@plitzi/sdk-shared 0.37.9 → 0.38.1

package/dist/flags/resolveFlags.mjs

@@ -0,0 +1,38 @@
+import { evaluateRuleGroup as e } from "../helpers/ruleEvaluator.mjs";
+//#region src/flags/resolveFlags.ts
+var t = [
+	"space",
+	"server",
+	"sdk",
+	"qa"
+], n = (e) => e ? {
+	authenticated: !0,
+	email: e.email,
+	username: e.username,
+	roles: e.roles
+} : { authenticated: !1 }, r = [
+	"server",
+	"sdk",
+	"qa"
+], i = (e) => typeof e == "object" && !!e && "rules" in e && Array.isArray(e.rules) && e.rules.some((e) => typeof e == "object" && !!e && !("enabled" in e && e.enabled === !1)), a = (t, n) => Array.isArray(t.rules) ? t.rules.findIndex((t) => i(t.when) && e(t.when, n)) : -1, o = (e, t) => {
+	let n = a(e, t);
+	return n === -1 ? {
+		value: e.value,
+		layer: "space"
+	} : {
+		value: e.rules[n].value,
+		layer: "space",
+		rule: n
+	};
+}, s = (e, t = {}, n = {}) => Object.fromEntries(Object.entries(e ?? {}).map(([e, i]) => [e, r.reduce((t, r) => {
+	let i = n[r]?.[e];
+	return typeof i == "boolean" ? {
+		value: i,
+		layer: r
+	} : t;
+}, o(i, t))])), c = (e) => Object.fromEntries(Object.entries(e).map(([e, { value: t }]) => [e, t])), l = (e, t) => r.flatMap((n) => Object.keys(t[n] ?? {}).filter((t) => !Object.hasOwn(e ?? {}, t)).map((e) => ({
+	layer: n,
+	name: e
+}))), u = (e, t) => !e || (t[e.name] ?? !1) === e.is;
+//#endregion
+export { t as FLAG_LAYERS, n as flagUserFromSSR, c as flagValues, i as hasConditions, u as passesFlagGate, s as resolveFlags, l as undeclaredFlagOverrides };

package/dist/flags/schemaFlag.d.ts

@@ -0,0 +1,11 @@
+import { SchemaFlag } from '../types';
+/** A flag name: what `{{ flags.<name> }}` reads, so it has to be a valid key in a template path. */
+export declare const FLAG_NAME_PATTERN: RegExp;
+/** A gate as authoring and MCP write it: `name` while the flag is on, `!name` while it is off. */
+export declare const FLAG_GATE_PATTERN: RegExp;
+export declare const isFlagName: (name: string) => boolean;
+/**
+ * Whether a value is a flag as the resolver reads it — what every writer checks before storing one: a mutation, the
+ * live channel, the linter. A rule's `when` has to be a group; whether it says anything is the linter's to warn about.
+ */
+export declare const isSchemaFlag: (value: unknown) => value is SchemaFlag;

package/dist/flags/schemaFlag.mjs

@@ -0,0 +1,9 @@
+import { isRecord as e } from "../helpers/isRecord.mjs";
+//#region src/flags/schemaFlag.ts
+var t = "[A-Za-z_][A-Za-z0-9_]*", n = RegExp(`^${t}$`), r = RegExp(`^!?${t}$`), i = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]), a = (e) => n.test(e) && !i.has(e), o = (t) => e(t) && typeof t.value == "boolean" && (t.description === void 0 || typeof t.description == "string") && Array.isArray(t.rules) && t.rules.every((t) => e(t) && typeof t.value == "boolean" && e(t.when));
+//#endregion
+export { r as FLAG_GATE_PATTERN, n as FLAG_NAME_PATTERN, a as isFlagName, o as isSchemaFlag };

package/dist/flags/useFlagResolution.d.ts

@@ -0,0 +1,13 @@
+import { AuthContextValue } from '../types';
+import { FlagResolution, FlagUser } from './resolveFlags';
+/** The visitor as a flag's rule sees them, from what auth knows. */
+export declare const flagUserFrom: ({ authenticated, user }: Partial<Pick<AuthContextValue, "authenticated" | "user">>) => FlagUser;
+/**
+ * Every declared flag, resolved for where this render is and who is looking.
+ *
+ * What the `flags` source every element reads is published from. The router cannot wait for that source — it decides
+ * whether the page is gated off before any child renders — so it calls `resolveFlags` itself, with the same inputs.
+ * Stable while nothing changed, so the source is not written again on every navigation.
+ */
+declare const useFlagResolution: (auth: Partial<Pick<AuthContextValue, "authenticated" | "user">>) => Record<string, FlagResolution>;
+export default useFlagResolution;

package/dist/flags/useFlagResolution.mjs

@@ -0,0 +1,43 @@
+import { resolveFlags as e } from "./resolveFlags.mjs";
+import t from "../hooks/useStableValue.mjs";
+import n from "../store/renderSettings.mjs";
+import { useCommonStore as r } from "../store/index.mjs";
+import { useMemo as i } from "react";
+//#region src/flags/useFlagResolution.ts
+var a = ({ authenticated: e, user: t }) => {
+	let n = t?.details, r = { authenticated: e === !0 };
+	return n ? {
+		...r,
+		email: n.email,
+		username: n.username,
+		roles: n.roles
+	} : r;
+}, o = (o) => {
+	let { environment: s } = n(), [[c, l, u, d, f]] = r([
+		"schema.flags",
+		"navigation.routeParams",
+		"navigation.queryParams",
+		"navigation.hostname",
+		"flags.overrides"
+	]), { authenticated: p, user: m } = o, h = i(() => a({
+		authenticated: p,
+		user: m
+	}), [p, m]);
+	return t(i(() => e(c, {
+		environment: s,
+		hostname: d,
+		routeParams: l,
+		queryParams: u,
+		user: h
+	}, f), [
+		c,
+		s,
+		d,
+		l,
+		u,
+		h,
+		f
+	]));
+};
+//#endregion
+export { o as default, a as flagUserFrom };

package/dist/helpers/eventTarget.d.ts

@@ -0,0 +1,10 @@
+/**
+ * An event's target read as a DOM node. `instanceof Node` answers false for a target inside an iframe — each window has
+ * its own `Node` — and the builder listens on its canvas iframe's document, so these test the node's own type instead.
+ */
+export declare const isNodeTarget: (target: EventTarget | null) => target is Node;
+/** An event's target as the node it is, for `contains`; null when it is not a node (a window, an XHR). */
+export declare const nodeOf: (target: EventTarget | null) => Node | null;
+export declare const isElementTarget: (target: EventTarget | null) => target is Element;
+/** An event's target as the element it is, for `closest`; null when it is a text node or no node at all. */
+export declare const elementOf: (target: EventTarget | null) => Element | null;

package/dist/helpers/eventTarget.mjs

@@ -0,0 +1,4 @@
+//#region src/helpers/eventTarget.ts
+var e = (e) => e !== null && "nodeType" in e && typeof e.nodeType == "number", t = (t) => e(t) ? t : null, n = (t) => e(t) && t.nodeType === Node.ELEMENT_NODE, r = (e) => n(e) ? e : null;
+//#endregion
+export { r as elementOf, n as isElementTarget, e as isNodeTarget, t as nodeOf };

package/dist/helpers/images.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A remote picture resized by the server that renders the page — the one vocabulary both ends speak.
+ *
+ * The widths are a closed set rather than whatever a page asks for: each one is a file the server makes and keeps,
+ * so a free width would let anybody fill its disk one request at a time.
+ */
+/** Where a page server that resizes images answers. */
+export declare const IMAGE_PATH = "/_plitzi/img";
+/** Every width a picture is offered at, narrowest first. */
+export declare const IMAGE_WIDTHS: readonly [320, 480, 640, 768, 960, 1280, 1600, 1920];
+export type ImageWidth = (typeof IMAGE_WIDTHS)[number];
+export declare const isImageWidth: (width: number) => width is ImageWidth;
+/** A picture another site serves — the only kind there is anything to resize; a path of this site is served as it is. */
+export declare const isRemoteImage: (src: string) => boolean;
+/** The address of `src` at `width` on the endpoint. */
+export declare const imageUrl: (endpoint: string, src: string, width: ImageWidth) => string;
+/** Every width as a `srcset`, for the browser to pick the one its layout needs. */
+export declare const imageSrcSet: (endpoint: string, src: string) => string;

package/dist/helpers/images.mjs

@@ -0,0 +1,13 @@
+//#region src/helpers/images.ts
+var e = "/_plitzi/img", t = [
+	320,
+	480,
+	640,
+	768,
+	960,
+	1280,
+	1600,
+	1920
+], n = (e) => t.some((t) => t === e), r = (e) => /^https?:\/\//i.test(e), i = (e, t, n) => `${e}?url=${encodeURIComponent(t)}&w=${String(n)}`, a = (e, n) => t.map((t) => `${i(e, n, t)} ${String(t)}w`).join(", ");
+//#endregion
+export { e as IMAGE_PATH, t as IMAGE_WIDTHS, a as imageSrcSet, i as imageUrl, n as isImageWidth, r as isRemoteImage };

package/dist/helpers/index.d.ts

@@ -2,9 +2,12 @@ import { default as fetchManifest } from './fetchManifest';
 import { default as generateFacade } from './generateFacade';
 import { default as syntaxHighlight } from './syntaxHighlight';
 export * from './cookies';
+export * from './eventTarget';
 export * from './fetchManifest';
 export * from './formatDate';
+export * from './interval';
 export * from './isDate';
+export * from './isRecord';
 export * from './generateFacade';
 export * from './reducerOrigin';
 export * from './ruleEvaluator';

package/dist/helpers/index.mjs

@@ -1,18 +1,21 @@
-import { filters as e } from "./twigWrapper/filters/filters.mjs";
-import { processTwig as t, processTwigParam as n, processTwigValue as r } from "./twigWrapper/processTwig/processTwig.mjs";
-import { hasTemplateSyntax as i } from "./twigWrapper/tokens/hasTemplateSyntax.mjs";
-import { hasValidToken as a } from "./twigWrapper/tokens/hasValidToken.mjs";
-import { MAX_PARAM_PASSES as o, resolveStepParam as s } from "./twigWrapper/processTwig/resolveStepParam.mjs";
-import { inspectTemplate as c } from "./twigWrapper/inspectTemplate.mjs";
-import { templatePaths as l, templateRootNames as u } from "./twigWrapper/templateRoots.mjs";
-import d from "./fetchManifest.mjs";
-import f from "./generateFacade.mjs";
-import p from "./syntaxHighlight.mjs";
-import { cookieFromHeader as m, documentCookies as h } from "./cookies.mjs";
-import { formatDate as g, formatDateUTC as _, formatFromNow as v, formatUTCToLocal as y, getDurationMs as b, isValidFormat as x, parseDate as S, toUnixSeconds as C } from "./formatDate.mjs";
-import { isDate as w } from "./isDate.mjs";
-import { isUserEdit as T } from "./reducerOrigin.mjs";
-import { evaluateRuleGroup as E } from "./ruleEvaluator.mjs";
-import { ParamsFromURL as D, delay as O, emptyObject as k, getDisplayName as A, getKeyDecoded as j, getPathsFromObeject as M, hexToRGB as N, isInViewport as P, makeId as F } from "./utils.mjs";
-import { disableReactDevTools as I } from "./security.mjs";
-export { o as MAX_PARAM_PASSES, D as ParamsFromURL, m as cookieFromHeader, O as delay, I as disableReactDevTools, h as documentCookies, k as emptyObject, E as evaluateRuleGroup, d as fetchManifest, e as filters, g as formatDate, _ as formatDateUTC, v as formatFromNow, y as formatUTCToLocal, f as generateFacade, A as getDisplayName, b as getDurationMs, j as getKeyDecoded, M as getPathsFromObeject, i as hasTemplateSyntax, a as hasValidToken, N as hexToRGB, c as inspectTemplate, w as isDate, P as isInViewport, T as isUserEdit, x as isValidFormat, F as makeId, S as parseDate, t as processTwig, n as processTwigParam, r as processTwigValue, s as resolveStepParam, p as syntaxHighlight, l as templatePaths, u as templateRootNames, C as toUnixSeconds };
+import { isRecord as e } from "./isRecord.mjs";
+import { filters as t } from "./twigWrapper/filters/filters.mjs";
+import { processTwig as n, processTwigParam as r, processTwigValue as i } from "./twigWrapper/processTwig/processTwig.mjs";
+import { hasTemplateSyntax as a } from "./twigWrapper/tokens/hasTemplateSyntax.mjs";
+import { hasValidToken as o } from "./twigWrapper/tokens/hasValidToken.mjs";
+import { MAX_PARAM_PASSES as s, resolveStepParam as c } from "./twigWrapper/processTwig/resolveStepParam.mjs";
+import { inspectTemplate as l } from "./twigWrapper/inspectTemplate.mjs";
+import { templatePaths as u, templateRootNames as d } from "./twigWrapper/templateRoots.mjs";
+import f from "./fetchManifest.mjs";
+import p from "./generateFacade.mjs";
+import m from "./syntaxHighlight.mjs";
+import { cookieFromHeader as h, documentCookies as g } from "./cookies.mjs";
+import { elementOf as _, isElementTarget as v, isNodeTarget as y, nodeOf as b } from "./eventTarget.mjs";
+import { formatDate as x, formatDateUTC as S, formatFromNow as C, formatUTCToLocal as w, getDurationMs as T, isValidFormat as E, parseDate as D, toUnixSeconds as O } from "./formatDate.mjs";
+import { INTERVAL_TRIGGER as k, MIN_INTERVAL_MS as A, intervalOf as j } from "./interval.mjs";
+import { isDate as M } from "./isDate.mjs";
+import { isUserEdit as N } from "./reducerOrigin.mjs";
+import { evaluateRuleGroup as P } from "./ruleEvaluator.mjs";
+import { ParamsFromURL as F, delay as I, emptyObject as L, getDisplayName as R, getKeyDecoded as z, getPathsFromObeject as B, hexToRGB as V, isInViewport as H, makeId as U } from "./utils.mjs";
+import { disableReactDevTools as W } from "./security.mjs";
+export { k as INTERVAL_TRIGGER, s as MAX_PARAM_PASSES, A as MIN_INTERVAL_MS, F as ParamsFromURL, h as cookieFromHeader, I as delay, W as disableReactDevTools, g as documentCookies, _ as elementOf, L as emptyObject, P as evaluateRuleGroup, f as fetchManifest, t as filters, x as formatDate, S as formatDateUTC, C as formatFromNow, w as formatUTCToLocal, p as generateFacade, R as getDisplayName, T as getDurationMs, z as getKeyDecoded, B as getPathsFromObeject, a as hasTemplateSyntax, o as hasValidToken, V as hexToRGB, l as inspectTemplate, j as intervalOf, M as isDate, v as isElementTarget, H as isInViewport, y as isNodeTarget, e as isRecord, N as isUserEdit, E as isValidFormat, U as makeId, b as nodeOf, D as parseDate, n as processTwig, r as processTwigParam, i as processTwigValue, c as resolveStepParam, m as syntaxHighlight, u as templatePaths, d as templateRootNames, O as toUnixSeconds };

package/dist/helpers/interval.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Repeating a flow every so often — an autoplay, a clock, a poll of something on the page — with no plugin to write.
+ *
+ * The element listening, the interactions manager and authoring read this one module, so the trigger's name, its
+ * floor and what it carries cannot drift between them.
+ */
+/** The trigger a repeating flow starts on: fired once per tick of each interval its element's flows declare. */
+export declare const INTERVAL_TRIGGER = "onInterval";
+/** Below a quarter of a second, a flow that repeats is a busy loop that happens to wait. */
+export declare const MIN_INTERVAL_MS = 250;
+export type IntervalTriggerPayload = {
+    /** The interval that ticked, in milliseconds: the flows that run are the ones declared with it. */
+    interval: number;
+    /** How many times it has ticked since the element appeared — `{{ tick.count }}` with `named('tick', …)`. */
+    count: number;
+};
+/** An interval a flow declares, read as the trigger reads it: a whole number of milliseconds, at least the floor. */
+export declare const intervalOf: (value: unknown) => number | undefined;

package/dist/helpers/interval.mjs

@@ -0,0 +1,7 @@
+//#region src/helpers/interval.ts
+var e = "onInterval", t = 250, n = (e) => {
+	let t = typeof e == "string" && e.trim() !== "" ? Number(e) : e;
+	return typeof t == "number" && Number.isInteger(t) && t >= 250 ? t : void 0;
+};
+//#endregion
+export { e as INTERVAL_TRIGGER, t as MIN_INTERVAL_MS, n as intervalOf };

package/dist/helpers/isRecord.d.ts

@@ -0,0 +1,2 @@
+/** A plain object read off untyped data — JSON, a message, a document — and not an array, which is an object too. */
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;

package/dist/helpers/isRecord.mjs

@@ -0,0 +1,4 @@
+//#region src/helpers/isRecord.ts
+var e = (e) => typeof e == "object" && !!e && !Array.isArray(e);
+//#endregion
+export { e as isRecord };

package/dist/helpers/scroll.d.ts

@@ -0,0 +1,42 @@
+/**
+ * What the scroll steps and the `onScroll` trigger read and write, as plain arithmetic over a box's sizes — so the
+ * meaning of `'80%'` or `'end'` is decided once, and tested without a browser.
+ */
+/** A box that scrolls, measured: what `Element` has, and all these functions read. */
+export type ScrollBox = {
+    scrollLeft: number;
+    scrollTop: number;
+    scrollWidth: number;
+    scrollHeight: number;
+    clientWidth: number;
+    clientHeight: number;
+};
+/** What `onScroll` hands its flow: where the box is, and whether it is at either end of the way it scrolls. */
+export type ScrollTriggerPayload = {
+    x: number;
+    y: number;
+    atStart: boolean;
+    atEnd: boolean;
+};
+export declare const SCROLL_BEHAVIORS: readonly ["smooth", "auto"];
+export type ScrollStepBehavior = (typeof SCROLL_BEHAVIORS)[number];
+/** Where `scrollIntoView` lands an element, on each axis. */
+export declare const SCROLL_POSITIONS: readonly ["start", "center", "end", "nearest"];
+export type ScrollStepPosition = (typeof SCROLL_POSITIONS)[number];
+/**
+ * A distance to move: pixels (`240`, `'240'`, `'240px'`) or a share of what the box shows (`'80%'` of its width) —
+ * negative goes back. `undefined` for nothing to move, or for text that is not a length.
+ */
+export declare const scrollDistance: (value: unknown, visible: number) => number | undefined;
+/**
+ * A place to go to on one axis: `'start'`, `'end'`, pixels from the start, or a share of the whole way (`'50%'` is
+ * half-way). `undefined` leaves that axis where it is.
+ */
+export declare const scrollPosition: (value: unknown, scrollSize: number, clientSize: number) => number | undefined;
+/**
+ * Where a box is, for `onScroll`. The ends are those of the way it scrolls — across for a row wider than its box,
+ * down otherwise — which is what an arrow that hides at the end of a carousel asks.
+ */
+export declare const scrollState: (box: ScrollBox) => ScrollTriggerPayload;
+/** The trigger a scroll fires, its action name in a flow. */
+export declare const SCROLL_TRIGGER = "onScroll";

package/dist/helpers/scroll.mjs

@@ -0,0 +1,30 @@
+//#region src/helpers/scroll.ts
+var e = ["smooth", "auto"], t = [
+	"start",
+	"center",
+	"end",
+	"nearest"
+], n = 1, r = /^(-?\d+(?:\.\d+)?)(px|%)?$/, i = (e, t) => {
+	if (typeof e == "number") return Number.isFinite(e) ? e : void 0;
+	if (typeof e != "string") return;
+	let n = r.exec(e.trim());
+	if (!n) return;
+	let i = Number(n[1]);
+	return n[2] === "%" ? i / 100 * t : i;
+}, a = (e, t, n) => {
+	let r = Math.max(t - n, 0);
+	if (e === "start") return 0;
+	if (e === "end") return r;
+	let a = i(e, r);
+	return a === void 0 ? void 0 : Math.min(Math.max(a, 0), r);
+}, o = (e) => {
+	let t = e.scrollWidth - e.clientWidth > n, r = t ? e.scrollLeft : e.scrollTop, i = t ? e.scrollWidth - e.clientWidth : e.scrollHeight - e.clientHeight;
+	return {
+		x: Math.round(e.scrollLeft),
+		y: Math.round(e.scrollTop),
+		atStart: r <= n,
+		atEnd: r >= i - n
+	};
+}, s = "onScroll";
+//#endregion
+export { e as SCROLL_BEHAVIORS, t as SCROLL_POSITIONS, s as SCROLL_TRIGGER, i as scrollDistance, a as scrollPosition, o as scrollState };

package/dist/helpers/twigWrapper/TemplateCache/TemplateCache.mjs

@@ -2,7 +2,7 @@ import { isDottedPath as e } from "../charClass.mjs";
 import { lex as t } from "../Lexer/Lexer.mjs";
 import { parse as n } from "../Parser/Parser.mjs";
 //#region src/helpers/twigWrapper/TemplateCache/TemplateCache.ts
-var r = /* @__PURE__ */ new Map(), i = 256, a = {
+var r = /* @__PURE__ */ new Map(), i = 1024, a = {
 	hits: 0,
 	misses: 0
 }, o = () => ({

package/dist/helpers/twigWrapper/filters/filters.mjs

@@ -151,7 +151,20 @@ var e = Symbol("twigArrowParams"), t = (e) => e == null || e === "", n = (e, t)
 		seconds: Number(i("second")),
 		weekday: f.indexOf(i("weekday"))
 	};
-}, _ = {
+}, _ = (e) => {
+	if (typeof e == "number") return Number.isFinite(e) ? e : void 0;
+	if (typeof e == "string" && e.trim() !== "") {
+		let t = Number(e);
+		return Number.isFinite(t) ? t : void 0;
+	}
+}, v = (e, t, n) => {
+	for (let r of [t == null ? "en" : i(t), "en"]) try {
+		return new Intl.NumberFormat(r, n).format(e);
+	} catch {
+		continue;
+	}
+	return String(e);
+}, y = {
 	raw: (e) => u(e),
 	to_json: (e) => r(e),
 	json_encode: (e) => r(e),
@@ -220,6 +233,29 @@ var e = Symbol("twigArrowParams"), t = (e) => e == null || e === "", n = (e, t)
 		let s = o.split(".");
 		return s[0] = s[0].replace(/\B(?=(\d{3})+(?!\d))/g, a), s.join(r);
 	},
+	currency: (e, t) => {
+		let n = _(e);
+		if (n === void 0 || t.length === 0) return e;
+		let r = t[2], a = typeof r == "object" && !!r && "trimZeros" in r && r.trimZeros === !0 && Number.isInteger(n);
+		return v(n, t[1], {
+			style: "currency",
+			currency: i(t[0]),
+			...a ? {
+				minimumFractionDigits: 0,
+				maximumFractionDigits: 0
+			} : {}
+		});
+	},
+	percent: (e, t) => {
+		let n = _(e);
+		if (n === void 0) return e;
+		let r = Number(t[0]) || 0;
+		return v(n, t[1], {
+			style: "percent",
+			minimumFractionDigits: 0,
+			maximumFractionDigits: r
+		});
+	},
 	sort: (t, r) => {
 		if (!Array.isArray(t)) return t;
 		let i = [...t], a = r[0];
@@ -447,4 +483,4 @@ var e = Symbol("twigArrowParams"), t = (e) => e == null || e === "", n = (e, t)
 	}
 };
 //#endregion
-export { e as ARROW_PARAMS, c as RAW_MARKER, _ as filters, l as isRawMarker, d as unwrapRaw, u as wrapRaw };
+export { e as ARROW_PARAMS, c as RAW_MARKER, y as filters, l as isRawMarker, d as unwrapRaw, u as wrapRaw };

package/dist/history/describe.mjs

@@ -1,5 +1,6 @@
+import { isRecord as e } from "../helpers/isRecord.mjs";
 //#region src/history/describe.ts
-var e = (e) => typeof e == "object" && !!e && !Array.isArray(e), t = (n, r, i = "") => e(n) && e(r) ? [.../* @__PURE__ */ new Set([...Object.keys(n), ...Object.keys(r)])].flatMap((e) => t(n[e], r[e], i ? `${i}.${e}` : e)) : JSON.stringify(n) === JSON.stringify(r) ? [] : [{
+var t = (n, r, i = "") => e(n) && e(r) ? [.../* @__PURE__ */ new Set([...Object.keys(n), ...Object.keys(r)])].flatMap((e) => t(n[e], r[e], i ? `${i}.${e}` : e)) : JSON.stringify(n) === JSON.stringify(r) ? [] : [{
 	path: i,
 	...n === void 0 ? {} : { before: n },
 	...r === void 0 ? {} : { after: r }
@@ -28,6 +29,7 @@ var e = (e) => typeof e == "object" && !!e && !Array.isArray(e), t = (n, r, i =
 	component: "component",
 	folder: "folder",
 	variable: "variable",
+	flag: "feature flag",
 	setting: "setting",
 	selector: "class",
 	globalStyle: "global style for",

package/dist/history/diff.d.ts

@@ -16,7 +16,7 @@ export declare const sameValue: (a: unknown, b: unknown) => boolean;
  */
 export declare const jsonCopy: <T>(value: T) => T;
 /** The part of a schema a history reads: what is stored, never what the runtime derives from it. */
-export type HistorySchema = Pick<Schema, 'flat' | 'pages' | 'pageFolders' | 'variables' | 'settings' | 'definition' | 'components'>;
+export type HistorySchema = Pick<Schema, 'flat' | 'pages' | 'pageFolders' | 'variables' | 'flags' | 'settings' | 'definition' | 'components'>;
 /**
  * What changed between two versions of a schema, entity by entity.
  *

package/dist/history/diff.mjs

@@ -31,6 +31,7 @@ var e = (t, n) => {
 	...n("component", o(e), o(t)),
 	...n("folder", r(e.pageFolders, (e) => e.id), r(t.pageFolders, (e) => e.id)),
 	...n("variable", r(e.variables, (e) => e.name), r(t.variables, (e) => e.name)),
+	...n("flag", e.flags ?? {}, t.flags ?? {}),
 	...n("setting", {
 		...i("settings", e.settings),
 		...i("definition", e.definition),

package/dist/history/types.d.ts

@@ -11,7 +11,7 @@ export type ChangeOrigin = 'builder' | 'mcp' | 'coworker' | 'autofix' | 'api' |
  * (a bare element selector), an id style, a design token (`<category>/<name>`), a font family, a style setting
  * (`theme`, `mode`). Functions: a file of their source, by its path (`index.ts`, `lib/feed.ts`).
  */
-export type ChangeKind = 'element' | 'component' | 'folder' | 'variable' | 'setting' | 'selector' | 'globalStyle' | 'idStyle' | 'token' | 'font' | 'file';
+export type ChangeKind = 'element' | 'component' | 'folder' | 'variable' | 'flag' | 'setting' | 'selector' | 'globalStyle' | 'idStyle' | 'token' | 'font' | 'file';
 /** One entity that changed, whole, before and after: the field-level difference is derived from the two. */
 export type ChangeEntry = {
     kind: ChangeKind;

package/dist/hooks/index.mjs

@@ -1,5 +1,5 @@
-import e from "./useFontHead.mjs";
-import t from "./useNetwork.mjs";
-import n, { PlitziServiceContext as r, PlitziServiceProvider as i } from "./usePlitziServiceContext.mjs";
-import a from "./useStableValue.mjs";
-export { r as PlitziServiceContext, i as PlitziServiceProvider, e as useFontHead, t as useNetwork, n as usePlitziServiceContext, a as useStableValue };
+import e from "./useStableValue.mjs";
+import t from "./useFontHead.mjs";
+import n from "./useNetwork.mjs";
+import r, { PlitziServiceContext as i, PlitziServiceProvider as a } from "./usePlitziServiceContext.mjs";
+export { i as PlitziServiceContext, a as PlitziServiceProvider, t as useFontHead, n as useNetwork, r as usePlitziServiceContext, e as useStableValue };

package/dist/index.d.ts

@@ -16,3 +16,4 @@ export * from './theme';
 export * from './server';
 export * from './state';
 export * from './history';
+export * from './flags';