@plitzi/sdk-shared 0.38.3 → 0.38.5

package/dist/schema/anchor.d.ts

@@ -6,3 +6,14 @@
  */
 export declare const ANCHOR_PATTERN: RegExp;
 export declare const isAnchor: (value: unknown) => value is string;
+/**
+ * The anchor a piece of text reads as: its words, accents dropped and lowercased, a hyphen for every run of anything
+ * else, and nothing before the first letter — `Server-resolved data` is `server-resolved-data`. What a Markdown
+ * heading's `id` is, and what authoring offers an element that needs an anchor.
+ */
+export declare const anchorOf: (text: string) => string;
+/**
+ * The anchor `text` takes on a page that already carries `taken` — `faq`, then `faq-2`, `faq-3` — recorded in `taken`,
+ * so the next heading of the same words gets the next one. A page renders its headings in order, and so numbers them.
+ */
+export declare const uniqueAnchor: (text: string, taken: Set<string>) => string;

package/dist/schema/anchor.mjs

@@ -1,4 +1,8 @@
 //#region src/schema/anchor.ts
-var e = /^[a-z][a-z0-9-]*$/, t = (t) => typeof t == "string" && e.test(t);
+var e = /^[a-z][a-z0-9-]*$/, t = (t) => typeof t == "string" && e.test(t), n = (e) => e.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^[^a-z]+|-+$/g, "") || "section", r = (e, t) => {
+	let r = n(e), i = r;
+	for (let e = 2; t.has(i); e += 1) i = `${r}-${String(e)}`;
+	return t.add(i), i;
+};
 //#endregion
-export { e as ANCHOR_PATTERN, t as isAnchor };
+export { e as ANCHOR_PATTERN, n as anchorOf, t as isAnchor, r as uniqueAnchor };

package/dist/schema/index.mjs

@@ -1,7 +1,7 @@
 import e from "./SchemaContext.mjs";
-import { ANCHOR_PATTERN as t, isAnchor as n } from "./anchor.mjs";
-import { COMPONENT_PROPS_SOURCE as r, EMPTY_SCHEMA as i, VARIABLE_REGEX as a } from "./schemaConstants.mjs";
-import { findLayoutCycle as o, resolveLayoutChain as s } from "./layoutChain.mjs";
-import { collectServerElements as c, hasServerElements as l } from "./serverElements.mjs";
-import { isSnippet as u } from "./snippet.mjs";
-export { t as ANCHOR_PATTERN, r as COMPONENT_PROPS_SOURCE, i as EMPTY_SCHEMA, e as SchemaContext, a as VARIABLE_REGEX, c as collectServerElements, o as findLayoutCycle, l as hasServerElements, n as isAnchor, u as isSnippet, s as resolveLayoutChain };
+import { ANCHOR_PATTERN as t, anchorOf as n, isAnchor as r, uniqueAnchor as i } from "./anchor.mjs";
+import { COMPONENT_PROPS_SOURCE as a, EMPTY_SCHEMA as o, VARIABLE_REGEX as s } from "./schemaConstants.mjs";
+import { findLayoutCycle as c, resolveLayoutChain as l } from "./layoutChain.mjs";
+import { collectServerElements as u, hasServerElements as d } from "./serverElements.mjs";
+import { isSnippet as f } from "./snippet.mjs";
+export { t as ANCHOR_PATTERN, a as COMPONENT_PROPS_SOURCE, o as EMPTY_SCHEMA, e as SchemaContext, s as VARIABLE_REGEX, n as anchorOf, u as collectServerElements, c as findLayoutCycle, d as hasServerElements, r as isAnchor, f as isSnippet, l as resolveLayoutChain, i as uniqueAnchor };

package/dist/schema/markdownHeadings.d.ts

@@ -0,0 +1,13 @@
+export type MarkdownHeading = {
+    level: number;
+    text: string;
+    anchor: string;
+};
+/** A heading's words as a reader sees them: the inline Markdown around them taken away, as the renderer takes it. */
+export declare const headingText: (source: string) => string;
+/**
+ * Every heading of a Markdown document, in order, with the anchor its `id` is when it renders — what a table of
+ * contents links to, and what a link's `hash` may name. ATX headings (`## Title`), outside fenced code; every level
+ * shares one set of anchors, as the rendered page does.
+ */
+export declare const markdownHeadings: (source: string) => MarkdownHeading[];

package/dist/schema/markdownHeadings.mjs

@@ -0,0 +1,24 @@
+import { uniqueAnchor as e } from "./anchor.mjs";
+//#region src/schema/markdownHeadings.ts
+var t = /^ {0,3}(`{3,}|~{3,})/, n = /^ {0,3}(#{1,6})[ \t]+(.*?)(?:[ \t]+#+)?[ \t]*$/, r = (e) => e.replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/<[^>]+>/g, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/`+([^`]*?)`+/g, "$1").replace(/(\*\*|~~)(.+?)\1/g, "$2").replace(/\*(.+?)\*/g, "$1").replace(/\b__(.+?)__\b/g, "$1").replace(/\b_(.+?)_\b/g, "$1").replace(/\\([\\`*_{}[\]()#+\-.!|~>])/g, "$1").trim(), i = (i) => {
+	let a = /* @__PURE__ */ new Set(), o = [], s;
+	for (let c of i.split("\n")) {
+		let i = t.exec(c)?.[1];
+		if (i) {
+			s ? i[0] === s[0] && i.length >= s.length && (s = void 0) : s = i;
+			continue;
+		}
+		let l = s ? null : n.exec(c);
+		if (l) {
+			let t = r(l[2]);
+			o.push({
+				level: l[1].length,
+				text: t,
+				anchor: e(t, a)
+			});
+		}
+	}
+	return o;
+};
+//#endregion
+export { r as headingText, i as markdownHeadings };

package/dist/schema/motion.d.ts

@@ -7,20 +7,27 @@
  * The one description the authoring package, the builder's Motion tab, the MCP and the validator all read; the
  * stylesheet mirrors its presets and frames, and a test in `apps/sdk` holds the two together.
  */
-export declare const MOTION_ENTERS: readonly ["fade", "fade-up", "fade-down", "slide-left", "slide-right", "scale"];
+export declare const MOTION_ENTERS: readonly ["fade", "fade-up", "fade-down", "slide-left", "slide-right", "slide-up", "scale", "zoom-in", "zoom-out", "pop", "bounce-in", "tilt", "spin-in"];
 export type MotionEnter = (typeof MOTION_ENTERS)[number];
-/** As the page loads, or as the element scrolls into view — tied to the scroll, so it plays at the reader's pace. */
-export declare const MOTION_TRIGGERS: readonly ["load", "view"];
+/**
+ * When an arrival plays: as the page loads (`load`); once, as the element first comes into view, and then it stays
+ * (`view`); or with the scroll itself, at the reader's pace — played backwards when the reader scrolls back up past it
+ * (`scroll`).
+ */
+export declare const MOTION_TRIGGERS: readonly ["load", "view", "scroll"];
 export type MotionTrigger = (typeof MOTION_TRIGGERS)[number];
-/** A motion that repeats: a gentle rise and fall, a breath, a turn, a sway. Held until the page is live. */
-export declare const MOTION_LOOPS: readonly ["float", "pulse", "spin", "sway"];
+/**
+ * A motion that repeats: a gentle rise and fall, a breath, a turn, a sway — a bounce, a wobble, a small orbit, a
+ * heartbeat, a drift. Held until the page is live.
+ */
+export declare const MOTION_LOOPS: readonly ["float", "pulse", "spin", "sway", "bounce", "wobble", "orbit", "heartbeat", "drift"];
 export type MotionLoop = (typeof MOTION_LOOPS)[number];
 export interface ElementMotion {
     /** How it arrives. */
     enter?: MotionEnter;
-    /** When it arrives: `load` (the default) or `view`. */
+    /** When it arrives: `load` (the default), `view` (once, as it comes into view) or `scroll` (with the scroll). */
     on?: MotionTrigger;
-    /** How long it takes to arrive, in ms (600 by default). Ignored under `view`, which follows the scroll. */
+    /** How long it takes to arrive, in ms (600 by default). Ignored under `scroll`, which follows the scroll. */
     duration?: number;
     /** How long it waits before it does, in ms. */
     delay?: number;
@@ -35,19 +42,35 @@ export interface ElementMotion {
 /** How long an arrival takes when it does not say, and the curve every arrival follows: quick out, gentle in. */
 export declare const MOTION_DEFAULT_DURATION = 600;
 export declare const MOTION_ENTER_EASING = "cubic-bezier(0.2, 0.7, 0.2, 1)";
-/** Where each arrival starts from; it ends where the element is. */
-export declare const MOTION_ENTER_FROM: Record<MotionEnter, {
-    opacity: number;
+/**
+ * One frame of an arrival, `at` a percentage of its duration. It moves the individual `translate`, `scale` and `rotate`
+ * properties — never `transform` — so it composes with a `transform` the element has of its own and with a loop.
+ */
+export interface MotionEnterFrame {
+    at: number;
+    opacity?: number;
     translate?: string;
     scale?: string;
-}>;
+    rotate?: string;
+}
 /**
- * Each loop's one moving frame — its `transform` halfway through the period and back (`middle`), or at the end of
- * one that keeps turning (`end`) — and its period and curve.
+ * Each arrival's frames, from where it starts (`at: 0`) through any it passes on the way — an overshoot, a bounce. It
+ * always ends where the element is, which is why no frame says so.
  */
-export declare const MOTION_LOOP_FRAMES: Record<MotionLoop, {
+export declare const MOTION_ENTER_FRAMES: Record<MotionEnter, MotionEnterFrame[]>;
+/** Where each arrival starts from — its first frame. */
+export declare const MOTION_ENTER_FROM: Record<MotionEnter, Omit<MotionEnterFrame, "at">>;
+/** One frame of a loop: its `transform` at a percentage of its period. A frame no loop names is the element at rest. */
+export interface MotionLoopFrame {
+    at: number;
     transform: string;
-    at: 'middle' | 'end';
+}
+/**
+ * Each loop's frames, its period and its curve. A loop that swings starts and ends at rest; one that keeps turning
+ * (`spin`) ends a full turn on, which is the same place.
+ */
+export declare const MOTION_LOOP_FRAMES: Record<MotionLoop, {
+    frames: MotionLoopFrame[];
     periodMs: number;
     easing: string;
 }>;
@@ -72,6 +95,15 @@ export declare const MOVING_SELECTOR = "[data-motion-enter], [data-motion-stagge
  * never is.
  */
 export declare const MOTION_STILL_CSS = "[data-motion-enter], [data-motion-stagger] > *, [data-motion-loop] { animation: none !important; }";
+/** The attribute an arrival waiting to be seen (`on: 'view'`) gets once it has been, and then keeps (`revealOnView`). */
+export declare const MOTION_SEEN_ATTRIBUTE = "data-motion-seen";
+/** Every element whose arrival waits to be seen: what `revealOnView` watches. */
+export declare const MOTION_VIEW_SELECTOR = "[data-motion-on=\"view\"]";
+/**
+ * Every arrival waiting to be seen, played as if it had been: a surface with nobody scrolling it and no SDK root to
+ * watch it — a preview of an element, a thumbnail — would hold it at its start, unseen.
+ */
+export declare const MOTION_SEEN_CSS = "[data-motion-on=\"view\"][data-motion-enter], [data-motion-on=\"view\"][data-motion-stagger] > * { animation-play-state: running, running !important; }";
 export declare const MOTION_PLAY_CSS: string;
 /** Whether an animation is one of the declared motion's — what replaying the canvas restarts, and nothing else. */
 export declare const isMotionAnimation: (animation: object) => boolean;

package/dist/schema/motion.mjs

@@ -6,81 +6,253 @@ var t = [
 	"fade-down",
 	"slide-left",
 	"slide-right",
-	"scale"
-], n = ["load", "view"], r = [
+	"slide-up",
+	"scale",
+	"zoom-in",
+	"zoom-out",
+	"pop",
+	"bounce-in",
+	"tilt",
+	"spin-in"
+], n = [
+	"load",
+	"view",
+	"scroll"
+], r = [
 	"float",
 	"pulse",
 	"spin",
-	"sway"
+	"sway",
+	"bounce",
+	"wobble",
+	"orbit",
+	"heartbeat",
+	"drift"
 ], i = 600, a = "cubic-bezier(0.2, 0.7, 0.2, 1)", o = {
-	fade: { opacity: 0 },
-	"fade-up": {
+	fade: [{
+		at: 0,
+		opacity: 0
+	}],
+	"fade-up": [{
+		at: 0,
 		opacity: 0,
 		translate: "0 24px"
-	},
-	"fade-down": {
+	}],
+	"fade-down": [{
+		at: 0,
 		opacity: 0,
 		translate: "0 -24px"
-	},
-	"slide-left": {
+	}],
+	"slide-left": [{
+		at: 0,
 		opacity: 0,
 		translate: "32px 0"
-	},
-	"slide-right": {
+	}],
+	"slide-right": [{
+		at: 0,
 		opacity: 0,
 		translate: "-32px 0"
-	},
-	scale: {
+	}],
+	"slide-up": [{
+		at: 0,
+		opacity: 0,
+		translate: "0 72px"
+	}],
+	scale: [{
+		at: 0,
 		opacity: 0,
 		scale: "0.94"
-	}
-}, s = {
+	}],
+	"zoom-in": [{
+		at: 0,
+		opacity: 0,
+		scale: "0.6"
+	}],
+	"zoom-out": [{
+		at: 0,
+		opacity: 0,
+		scale: "1.25"
+	}],
+	pop: [
+		{
+			at: 0,
+			opacity: 0,
+			scale: "0.5"
+		},
+		{
+			at: 55,
+			opacity: 1,
+			scale: "1.08"
+		},
+		{
+			at: 78,
+			scale: "0.97"
+		}
+	],
+	"bounce-in": [
+		{
+			at: 0,
+			opacity: 0,
+			translate: "0 -64px"
+		},
+		{
+			at: 55,
+			opacity: 1,
+			translate: "0 10px"
+		},
+		{
+			at: 75,
+			translate: "0 -5px"
+		},
+		{
+			at: 90,
+			translate: "0 2px"
+		}
+	],
+	tilt: [{
+		at: 0,
+		opacity: 0,
+		translate: "0 32px",
+		rotate: "-6deg"
+	}],
+	"spin-in": [{
+		at: 0,
+		opacity: 0,
+		scale: "0.4",
+		rotate: "-180deg"
+	}]
+}, s = Object.fromEntries(t.map((e) => {
+	let [{ at: t, ...n }] = o[e];
+	return [e, n];
+})), c = (e, t) => {
+	let n = t * 2 * Math.PI, r = Math.round(Math.sin(n) * e * 10) / 10, i = Math.round(-Math.cos(n) * e * 10) / 10;
+	return `translate(${String(r)}px, ${String(i)}px)`;
+}, l = {
 	float: {
-		transform: "translateY(-8px)",
-		at: "middle",
+		frames: [{
+			at: 50,
+			transform: "translateY(-8px)"
+		}],
 		periodMs: 6e3,
 		easing: "ease-in-out"
 	},
 	pulse: {
-		transform: "scale(1.04)",
-		at: "middle",
+		frames: [{
+			at: 50,
+			transform: "scale(1.04)"
+		}],
 		periodMs: 3e3,
 		easing: "ease-in-out"
 	},
 	spin: {
-		transform: "rotate(360deg)",
-		at: "end",
+		frames: [{
+			at: 100,
+			transform: "rotate(360deg)"
+		}],
 		periodMs: 12e3,
 		easing: "linear"
 	},
 	sway: {
-		transform: "rotate(2deg)",
-		at: "middle",
+		frames: [{
+			at: 50,
+			transform: "rotate(2deg)"
+		}],
 		periodMs: 5e3,
 		easing: "ease-in-out"
+	},
+	bounce: {
+		frames: [
+			{
+				at: 0,
+				transform: "translateY(0) scale(1.03, 0.97)"
+			},
+			{
+				at: 45,
+				transform: "translateY(-14px) scale(0.98, 1.02)"
+			},
+			{
+				at: 55,
+				transform: "translateY(-14px) scale(0.98, 1.02)"
+			},
+			{
+				at: 100,
+				transform: "translateY(0) scale(1.03, 0.97)"
+			}
+		],
+		periodMs: 1400,
+		easing: "ease-in-out"
+	},
+	wobble: {
+		frames: [{
+			at: 25,
+			transform: "rotate(-5deg)"
+		}, {
+			at: 75,
+			transform: "rotate(5deg)"
+		}],
+		periodMs: 2400,
+		easing: "ease-in-out"
+	},
+	orbit: {
+		frames: Array.from({ length: 9 }, (e, t) => ({
+			at: t * 100 / 8,
+			transform: c(6, t / 8)
+		})),
+		periodMs: 8e3,
+		easing: "linear"
+	},
+	heartbeat: {
+		frames: [
+			{
+				at: 14,
+				transform: "scale(1.1)"
+			},
+			{
+				at: 28,
+				transform: "scale(1)"
+			},
+			{
+				at: 42,
+				transform: "scale(1.07)"
+			},
+			{
+				at: 70,
+				transform: "scale(1)"
+			}
+		],
+		periodMs: 1600,
+		easing: "ease-in-out"
+	},
+	drift: {
+		frames: [{
+			at: 50,
+			transform: "translateX(12px)"
+		}],
+		periodMs: 7e3,
+		easing: "ease-in-out"
 	}
-}, c = 1e4, l = (e, t) => typeof t == "string" && e.includes(t), u = /* @__PURE__ */ new Set([
+}, u = 1e4, d = (e, t) => typeof t == "string" && e.includes(t), f = /* @__PURE__ */ new Set([
 	"enter",
 	"on",
 	"duration",
 	"delay",
 	"stagger",
 	"loop"
-]), d = (i) => {
-	if (!e(i)) return ["motion is an object: `{ enter: 'fade-up', on: 'view' }`"];
+]), p = (i) => {
+	if (!e(i)) return ["motion is an object: `{ enter: \"fade-up\", on: \"view\" }`"];
 	let a = [];
-	for (let e of Object.keys(i)) u.has(e) || a.push(`motion has no "${e}" — it takes enter, on, duration, delay, stagger and loop`);
-	i.enter !== void 0 && !l(t, i.enter) && a.push(`motion.enter is one of ${t.join(", ")}`), i.on !== void 0 && !l(n, i.on) && a.push(`motion.on is ${n.join(" or ")}`), i.loop !== void 0 && !l(r, i.loop) && a.push(`motion.loop is one of ${r.join(", ")}`);
+	for (let e of Object.keys(i)) f.has(e) || a.push(`motion has no "${e}" — it takes enter, on, duration, delay, stagger and loop`);
+	i.enter !== void 0 && !d(t, i.enter) && a.push(`motion.enter is one of ${t.join(", ")}`), i.on !== void 0 && !d(n, i.on) && a.push(`motion.on is ${n.slice(0, -1).join(", ")} or ${String(n.at(-1))}`), i.loop !== void 0 && !d(r, i.loop) && a.push(`motion.loop is one of ${r.join(", ")}`);
 	for (let e of [
 		"duration",
 		"delay",
 		"stagger"
 	]) {
 		let t = i[e];
-		t !== void 0 && (typeof t != "number" || !Number.isFinite(t) || t < 0 || t > 1e4) && a.push(`motion.${e} is a number of ms from 0 to ${String(c)}`);
+		t !== void 0 && (typeof t != "number" || !Number.isFinite(t) || t < 0 || t > 1e4) && a.push(`motion.${e} is a number of ms from 0 to ${String(u)}`);
 	}
 	return i.enter === void 0 && i.loop === void 0 && a.push("motion says nothing to play: give it an `enter`, a `loop`, or both"), i.stagger !== void 0 && i.enter === void 0 && a.push("motion.stagger staggers the children’s `enter`: give it one"), a;
-}, f = (e) => d(e).length === 0, p = (e) => {
+}, m = (e) => p(e).length === 0, h = (e) => {
 	if (!e) return {
 		attributes: {},
 		style: {}
@@ -90,6 +262,10 @@ var t = [
 		attributes: t,
 		style: n
 	};
-}, m = "[data-motion-enter], [data-motion-stagger] > *, [data-motion-loop]", h = `${m} { animation: none !important; }`, g = ["[data-motion-loop] { animation-play-state: running, running !important; }", "[data-motion-on=\"view\"][data-motion-enter], [data-motion-on=\"view\"][data-motion-stagger] > * { animation-timeline: auto, auto !important; }"].join("\n"), _ = (e) => "animationName" in e && typeof e.animationName == "string" && e.animationName.startsWith("plitzi-motion-");
+}, g = "[data-motion-enter], [data-motion-stagger] > *, [data-motion-loop]", _ = `${g} { animation: none !important; }`, v = "data-motion-seen", y = "[data-motion-on=\"view\"]", b = "[data-motion-on=\"view\"][data-motion-enter], [data-motion-on=\"view\"][data-motion-stagger] > * { animation-play-state: running, running !important; }", x = [
+	"[data-motion-loop] { animation-play-state: running, running !important; }",
+	b,
+	"[data-motion-on=\"scroll\"][data-motion-enter], [data-motion-on=\"scroll\"][data-motion-stagger] > * { animation-timeline: auto, auto !important; }"
+].join("\n"), S = (e) => "animationName" in e && typeof e.animationName == "string" && e.animationName.startsWith("plitzi-motion-");
 //#endregion
-export { i as MOTION_DEFAULT_DURATION, t as MOTION_ENTERS, a as MOTION_ENTER_EASING, o as MOTION_ENTER_FROM, r as MOTION_LOOPS, s as MOTION_LOOP_FRAMES, c as MOTION_MAX_MS, g as MOTION_PLAY_CSS, h as MOTION_STILL_CSS, n as MOTION_TRIGGERS, m as MOVING_SELECTOR, f as isMotion, _ as isMotionAnimation, p as motionAttributes, d as motionProblems };
+export { i as MOTION_DEFAULT_DURATION, t as MOTION_ENTERS, a as MOTION_ENTER_EASING, o as MOTION_ENTER_FRAMES, s as MOTION_ENTER_FROM, r as MOTION_LOOPS, l as MOTION_LOOP_FRAMES, u as MOTION_MAX_MS, x as MOTION_PLAY_CSS, v as MOTION_SEEN_ATTRIBUTE, b as MOTION_SEEN_CSS, _ as MOTION_STILL_CSS, n as MOTION_TRIGGERS, y as MOTION_VIEW_SELECTOR, g as MOVING_SELECTOR, m as isMotion, S as isMotionAnimation, h as motionAttributes, p as motionProblems };

package/dist/schema/motionReveal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Plays every arrival under `root` that waits to be seen (`motion: { on: 'view' }`) the first time it comes into view,
+ * and never again: the stylesheet holds it at its start until the element carries `data-motion-seen`, which this sets
+ * and nothing takes off. Elements added later — a page navigated to, a list's new rows — are watched as they arrive.
+ * Answers the function that stops watching.
+ *
+ * One observer for the whole tree rather than one per element: a page of cards is hundreds of them. A browser without
+ * `IntersectionObserver` shows each arrival at once, as one that cannot know what is on screen.
+ */
+export declare const revealOnView: (root: Element) => (() => void);

package/dist/schema/motionReveal.mjs

@@ -0,0 +1,23 @@
+import { MOTION_SEEN_ATTRIBUTE as e, MOTION_VIEW_SELECTOR as t } from "./motion.mjs";
+//#region src/schema/motionReveal.ts
+var n = `${t}:not([${e}])`, r = (t) => {
+	let r = (t) => t.setAttribute(e, ""), i = (e) => [...e.matches(n) ? [e] : [], ...Array.from(e.querySelectorAll(n))];
+	if (typeof Reflect.get(globalThis, "IntersectionObserver") != "function") return i(t).forEach(r), () => void 0;
+	let a = new IntersectionObserver((e) => {
+		for (let t of e) t.isIntersecting && (r(t.target), a.unobserve(t.target));
+	}), o = (e) => i(e).forEach((e) => a.observe(e)), s = new MutationObserver((e) => {
+		for (let t of e) t.type === "attributes" && t.target instanceof Element && o(t.target), t.addedNodes.forEach((e) => {
+			e instanceof Element && o(e);
+		});
+	});
+	return o(t), s.observe(t, {
+		childList: !0,
+		subtree: !0,
+		attributes: !0,
+		attributeFilter: ["data-motion-on"]
+	}), () => {
+		a.disconnect(), s.disconnect();
+	};
+};
+//#endregion
+export { r as revealOnView };

package/dist/schema/pageElements.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from '../types';
+/**
+ * The element types a page can draw — what decides which plugins a page has to have before it hydrates, and which can
+ * wait until a page that draws them is opened.
+ *
+ * Generous on purpose, because the two mistakes do not cost the same: a type counted that is never drawn only loads a
+ * plugin early, while one missed hydrates a page without the component the server drew. So it walks the page and
+ * every shell around it, into every component an instance names and every element a reference copies, and it counts
+ * what a flag or a visibility binding might hide: those are decided as the page renders, and may change while it is
+ * open. A `custom` element counts as the plugin it names (`renderType`), which is what it renders.
+ */
+export declare const pageElementTypes: (schema: Schema, pageId: string) => Set<string>;

package/dist/schema/pageElements.mjs

@@ -0,0 +1,41 @@
+import { resolveLayoutChain as e } from "./layoutChain.mjs";
+//#region src/schema/pageElements.ts
+var t = (e) => typeof e == "string" ? e : "", n = (n, r) => {
+	let i = /* @__PURE__ */ new Set(), a = n.flat[r];
+	if (!a) return i;
+	let o = [r, ...e((e) => n.flat[e], t(a.attributes.layout), t(a.attributes.layoutContainer)).map((e) => e.layout)].map((e) => ({
+		flat: n.flat,
+		id: e
+	})), s = /* @__PURE__ */ new Map();
+	for (; o.length > 0;) {
+		let e = o.pop();
+		if (!e) break;
+		let { flat: r, id: a } = e, c = s.get(r) ?? /* @__PURE__ */ new Set();
+		s.set(r, c);
+		let l = r[a];
+		if (!l || c.has(a)) continue;
+		c.add(a);
+		let { type: u, items: d } = l.definition;
+		i.add(u);
+		let f = t(l.attributes.renderType);
+		u === "custom" && f && i.add(f);
+		let p = t(l.attributes.referenceId);
+		if (u === "reference" && p) {
+			let e = l.attributes.referenceType === "component" ? n.components[p] : void 0;
+			o.push(e ? {
+				flat: e.flat,
+				id: e.rootId
+			} : {
+				flat: n.flat,
+				id: p
+			});
+		}
+		d && o.push(...d.map((e) => ({
+			flat: r,
+			id: e
+		})));
+	}
+	return i;
+};
+//#endregion
+export { n as pageElementTypes };

package/dist/schema/wire.mjs

@@ -10,11 +10,11 @@ var e = (e) => ({
 	...typeof e.stagger == "number" ? { stagger: e.stagger } : {},
 	...e.loop ? { loop: e.loop } : {}
 }), n = ({ definition: e, ...n }) => {
-	let { parentId: r, items: i, bindings: a, interactions: o, initialState: s, runtime: c, loadStrategy: l, flag: u, anchor: d, motion: f, ...p } = e;
+	let { parentId: r, items: i, bindings: a, interactions: o, initialState: s, runtime: c, loadStrategy: l, flag: u, anchor: d, motion: f, quiet: p, ...m } = e;
 	return {
 		...n,
 		definition: {
-			...p,
+			...m,
 			...r == null ? {} : { parentId: r },
 			...i == null ? {} : { items: i },
 			...a == null ? {} : { bindings: a },
@@ -24,7 +24,8 @@ var e = (e) => ({
 			...l == null ? {} : { loadStrategy: l },
 			...u == null ? {} : { flag: u },
 			...d == null ? {} : { anchor: d },
-			...f == null ? {} : { motion: t(f) }
+			...f == null ? {} : { motion: t(f) },
+			...p == null ? {} : { quiet: p }
 		}
 	};
 }, r = (e) => ({

package/dist/server/index.mjs

@@ -1,5 +1,5 @@
 import e from "./actions/useActionsSync.mjs";
-import t, { currentRscLocation as n, rscDataPath as r } from "./rsc/refreshRsc.mjs";
-import i from "./rsc/useRscRefresh.mjs";
-import a from "./rsc/useRscSync.mjs";
-export { n as currentRscLocation, t as refreshRsc, r as rscDataPath, e as useActionsSync, i as useRscRefresh, a as useRscSync };
+import t, { cancelRsc as n, currentRscLocation as r, releaseRscRequests as i, rscDataPath as a } from "./rsc/refreshRsc.mjs";
+import o from "./rsc/useRscRefresh.mjs";
+import s from "./rsc/useRscSync.mjs";
+export { n as cancelRsc, r as currentRscLocation, t as refreshRsc, i as releaseRscRequests, a as rscDataPath, e as useActionsSync, o as useRscRefresh, s as useRscSync };

package/dist/server/rsc/projectData.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Where a project's own data answers: a provider whose `query` is `/data/<file>` reads `<file>` from the folder the
+ * server keeps it in (`dataDir`), which is never served — so only a provider resolved on the server reads it. The
+ * server's resolver and the authoring check that refuses a browser read hold the same prefix.
+ */
+export declare const PROJECT_DATA_PREFIX = "/data/";

package/dist/server/rsc/projectData.mjs

@@ -0,0 +1,4 @@
+//#region src/server/rsc/projectData.ts
+var e = "/data/";
+//#endregion
+export { e as PROJECT_DATA_PREFIX };