@plitzi/sdk-shared 0.38.4 → 0.38.5

package/dist/plugins/bundle.mjs

@@ -0,0 +1,62 @@
+import e from "node:fs/promises";
+import t from "node:path";
+//#region src/plugins/bundle.ts
+var n = [
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".svg",
+	".webp",
+	".avif",
+	".woff",
+	".woff2",
+	".ttf",
+	".otf"
+], r = () => Object.fromEntries(n.map((e) => [e, "dataurl"])), i = /\?(raw|inline)$/, a = {
+	".wasm": "application/wasm",
+	".js": "text/javascript",
+	".mjs": "text/javascript",
+	".json": "application/json",
+	".css": "text/css",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".woff2": "font/woff2"
+}, o = () => ({
+	name: "plitzi-import-queries",
+	setup: (n) => {
+		n.onResolve({ filter: i }, async (e) => {
+			let t = i.exec(e.path)?.[1] ?? "raw", r = await n.resolve(e.path.replace(i, ""), {
+				kind: e.kind,
+				importer: e.importer,
+				resolveDir: e.resolveDir
+			});
+			return r.errors.length > 0 ? { errors: r.errors } : {
+				path: r.path,
+				namespace: `plitzi-${t}`
+			};
+		}), n.onLoad({
+			filter: /.*/,
+			namespace: "plitzi-raw"
+		}, async (t) => ({
+			contents: await e.readFile(t.path),
+			loader: "text",
+			watchFiles: [t.path]
+		})), n.onLoad({
+			filter: /.*/,
+			namespace: "plitzi-inline"
+		}, async (n) => {
+			let r = a[t.extname(n.path).toLowerCase()] ?? "application/octet-stream", i = (await e.readFile(n.path)).toString("base64");
+			return {
+				contents: `export default ${JSON.stringify(`data:${r};base64,${i}`)};`,
+				loader: "js",
+				watchFiles: [n.path]
+			};
+		});
+	}
+});
+//#endregion
+export { n as PLUGIN_INLINED_ASSETS, r as pluginAssetLoaders, o as pluginImportQueries };

package/dist/plugins/declaration.d.ts

@@ -0,0 +1,12 @@
+import { ComponentDefinition, PluginDeclaration } from '../types';
+import { FC } from 'react';
+/** A plugin as its bundle exports it: the component, with the declaration its `index.ts` assigned onto it. */
+export type DeclaredPlugin = FC<never> & {
+    content?: ComponentDefinition;
+    version?: string;
+    initialItems?: string[];
+    plugins?: Record<string, DeclaredPlugin>;
+};
+export declare const pluginDeclarationOf: (plugin: DeclaredPlugin) => PluginDeclaration;
+/** The element types a plugin registered under `type` renders: its own and its sub-plugins', at any depth. */
+export declare const pluginTypesOf: (type: string, declaration: PluginDeclaration) => string[];

package/dist/plugins/declaration.mjs

@@ -0,0 +1,9 @@
+//#region src/plugins/declaration.ts
+var e = (e) => typeof e == "object" && !!e && "$$typeof" in e, t = (t) => JSON.parse(JSON.stringify(t, (t, n) => typeof n == "function" || e(n) ? void 0 : n)), n = (e) => ({
+	...e.content ? { content: t(e.content) } : {},
+	...e.version ? { version: e.version } : {},
+	...e.initialItems ? { initialItems: [...e.initialItems] } : {},
+	...e.plugins ? { plugins: Object.fromEntries(Object.entries(e.plugins).map(([e, t]) => [e, n(t)])) } : {}
+}), r = (e, t) => [e, ...Object.entries(t.plugins ?? {}).flatMap(([e, t]) => r(e, t))];
+//#endregion
+export { n as pluginDeclarationOf, r as pluginTypesOf };

package/dist/queries/queryCache.d.ts

@@ -100,6 +100,13 @@ export declare class QueryCache {
     fetchQuery<T>(key: string, options: QueryObserverOptions<T> & {
         gcTime?: number;
     }): Promise<T | undefined>;
+    /**
+     * Stops the request out for `key`: the answer it would have brought lands nowhere, and what is held stays on screen.
+     *
+     * What a STOP is — the visitor is done waiting. The query is left as it was before it asked, so the next reader, or
+     * the next `refetch`, asks again.
+     */
+    cancel(key: string): boolean;
     /** Asks again for `key` now, whatever the age of what is held — the explicit "reload this". */
     refetch(key: string): Promise<void>;
     /**

package/dist/queries/queryCache.mjs

@@ -67,6 +67,13 @@ var t = 3e5, n = (e) => {
 		let a = this.getEntry(e)?.data;
 		return this.scheduleGc(n), a;
 	}
+	cancel(e) {
+		let t = this.runtimes.get(n(e));
+		if (!t?.controller) return !1;
+		t.controller.abort(), t.controller = void 0, t.inFlight = void 0;
+		let i = r(e);
+		return this.getEntry(e) ? this.store.setState(`${i}.isFetching`, !1) : this.markUnasked(t), !0;
+	}
 	refetch(e) {
 		let t = this.runtimes.get(n(e));
 		return t ? this.invalidateOne(t) : Promise.resolve();
@@ -121,10 +128,10 @@ var t = 3e5, n = (e) => {
 			tags: o,
 			isFetching: !0
 		});
-		let c = this.epochValue, l = e.version, u = (r) => {
-			if (c !== this.epochValue || this.runtimes.get(n(i)) !== e) return Promise.resolve();
+		let c = this.epochValue, l = e.version, u = new AbortController(), d = (r) => {
+			if (c !== this.epochValue || this.runtimes.get(n(i)) !== e || e.controller !== u) return Promise.resolve();
 			e.inFlight = void 0, e.controller = void 0;
-			let u = l !== e.version;
+			let d = l !== e.version;
 			if ("error" in r) {
 				let e = this.getEntry(i);
 				this.store.setState(s, {
@@ -136,7 +143,7 @@ var t = 3e5, n = (e) => {
 					isFetching: !1
 				}, { ttl: 0 });
 			} else {
-				let n = !u && (t.isCacheable?.(r.data) ?? !0);
+				let n = !d && (t.isCacheable?.(r.data) ?? !0);
 				this.store.setState(s, {
 					key: i,
 					url: a,
@@ -145,9 +152,9 @@ var t = 3e5, n = (e) => {
 					isFetching: !1
 				}, { ttl: n ? this.ttlOf(e, t) : 0 });
 			}
-			return u ? this.fetchActive(e) : Promise.resolve();
-		}, d = new AbortController();
-		return e.controller = d, e.inFlight = t.fetcher(d.signal).then((e) => u({ data: e }), (e) => u({ error: e })), e.inFlight;
+			return d ? this.fetchActive(e) : Promise.resolve();
+		};
+		return e.controller = u, e.inFlight = t.fetcher(u.signal).then((e) => d({ data: e }), (e) => d({ error: e })), e.inFlight;
 	}
 	ttlOf(e, t) {
 		let n = e.observers.size > 0 ? Infinity : t.staleTime;

package/dist/queries/useQuery.d.ts

@@ -18,6 +18,8 @@ export type UseQueryResult<T> = {
     /** Nothing to render with yet — as opposed to a refresh of something already on screen. */
     isLoading: boolean;
     refetch: () => void;
+    /** Stops the request out, if there is one: what is held stays, and nothing is asked until the next reader or refetch. */
+    cancel: () => void;
 };
 declare const useQuery: <T>({ key, meta, fetcher, enabled, staleTime, gcTime, isCacheable }: UseQueryOptions<T>) => UseQueryResult<T>;
 export default useQuery;

package/dist/queries/useQuery.mjs

@@ -35,12 +35,15 @@ var { useStore: s } = o(), c = ({ key: o, meta: c, fetcher: l, enabled: u = !0,
 	};
 	let w = S ?? C.current?.data, T = (g?.isFetching ?? !1) || u && m && !_, E = r(() => {
 		u && o !== void 0 && e.refetch(o);
-	}, [u, o]);
+	}, [u, o]), D = r(() => {
+		o !== void 0 && e.cancel(o);
+	}, [o]);
 	return {
 		data: w,
 		isFetching: T,
 		isLoading: T && w === void 0,
-		refetch: E
+		refetch: E,
+		cancel: D
 	};
 };
 //#endregion

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.mjs

@@ -239,7 +239,7 @@ var t = [
 	"stagger",
 	"loop"
 ]), p = (i) => {
-	if (!e(i)) return ["motion is an object: `{ enter: 'fade-up', on: 'view' }`"];
+	if (!e(i)) return ["motion is an object: `{ enter: \"fade-up\", on: \"view\" }`"];
 	let a = [];
 	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(", ")}`);

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/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 };

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

@@ -1,6 +1,18 @@
 import { CommonState } from '../../types';
 import { PathOf, StoreApi } from '@plitzi/nexus';
 export declare const rscDataPath: (id: string) => PathOf<CommonState>;
+/** Where the visitor is, spelled the way the server reads it back. */
+export declare const currentRscLocation: () => string;
+/**
+ * Stops what a refresh in flight is asking the server for — the request, and the work behind it on the server — and
+ * leaves the payload as it is.
+ *
+ * `ids` cancels the refreshes of those elements; nothing cancels every refresh in flight, a navigation's included.
+ * What a STOP button is: the visitor is done waiting, and what is on screen stays.
+ */
+export declare const cancelRsc: (store: StoreApi<CommonState>, ids?: readonly string[]) => void;
+/** Every refresh of this root aborted and forgotten — the SDK root that owned them is going away. */
+export declare const releaseRscRequests: (instance: string) => void;
 /**
  * Re-fetches RSC data into the store.
  *
@@ -11,9 +23,12 @@ export declare const rscDataPath: (id: string) => PathOf<CommonState>;
  * Pass `ids` to refresh only those elements — the response is merged over the existing payload. Omit them for a full
  * refresh, which replaces it. `params` ride along on the query string; that is how a provider asks for a different
  * page window.
+ *
+ * One request per question, and the newest question wins: asking again for what is already in flight is answered by
+ * the request in flight, and a request whose answer a newer one would overwrite anyway — a whole payload asked for
+ * again, an element asked for again — is aborted, here and on the server. Before this a click on a link asked twice
+ * (its prefetch, then the route change), and a slow answer could land over a newer one.
  */
-/** Where the visitor is, spelled the way the server reads it back. */
-export declare const currentRscLocation: () => string;
 export declare const refreshRsc: (store: StoreApi<CommonState>, ids?: string[], params?: Record<string, string>, 
 /**
  * Resolve for somewhere the visitor is not yet.
@@ -22,7 +37,5 @@ export declare const refreshRsc: (store: StoreApi<CommonState>, ids?: string[],
  * navigation asks for the destination BEFORE it commits. Absent means where the visitor already is, which is
  * every other caller: the initial load, a pager, an element refreshing itself.
  */
-location?: string, 
-/** Whether this is the one second asking, after a refusal that renewed the session. */
-retried?: boolean) => Promise<void>;
+location?: string) => Promise<void>;
 export default refreshRsc;

package/dist/server/rsc/refreshRsc.mjs

@@ -7,30 +7,90 @@ var o = (e, t, n) => {
 	if (!e) return;
 	let r = e.pages.reduce((t, n) => (n in e.flat && (t[n] = e.flat[n]), t), {});
 	return a(i(r, e.pageFolders, n), t.split("?")[0], n).pageId;
-}, s = (e) => `rsc.data.${e}`, c = () => typeof window > "u" ? "" : `${window.location.pathname}${window.location.search}`, l = async (i, a, u, d, f = !1) => {
-	let { enabled: p, endpoint: m } = i.get("rsc") ?? {};
-	if (!p || !m || typeof window > "u") return;
-	let h = d ?? c(), g = i.get("schema"), _ = i.get("runtime.sources.auth"), v = d ? o(g, d, !!_?.details) : i.get("navigation.currentPageId"), y = d ? void 0 : i.get("runtime.sources.flags");
-	if (g && r(g, v, y)) try {
-		let r = new URLSearchParams({ location: h });
-		a?.length && r.set("ids", a.join(",")), Object.entries(u ?? {}).forEach(([e, t]) => r.set(e, t));
-		let o = await fetch(`${m}?${r.toString()}`, { headers: { Accept: "application/json" } });
-		if (!o.ok) {
-			let n = e(o.status, await o.json().catch(() => void 0));
+}, s = (e) => `rsc.data.${e}`, c = () => typeof window > "u" ? "" : `${window.location.pathname}${window.location.search}`, l = "*", u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new WeakMap(), f = () => ({
+	seq: 0,
+	inFlight: /* @__PURE__ */ new Set(),
+	asked: /* @__PURE__ */ new Map()
+}), p = (e) => {
+	let t = e.get("rsc.instance");
+	if (typeof t == "string" && t) {
+		let e = u.get(t);
+		if (e) return e;
+		let n = f();
+		return u.set(t, n), n;
+	}
+	let n = d.get(e);
+	if (n) return n;
+	let r = f();
+	return d.set(e, r), r;
+}, m = (e, t) => {
+	let n = {};
+	t.inFlight.forEach((e) => {
+		e.here && (e.ids ?? [l]).forEach((e) => {
+			n[e] = !0;
+		});
+	}), e.set("rsc.refreshing", n);
+}, h = (e, t) => !e || !!t && t.every((t) => e.includes(t)), g = (e, t) => {
+	p(e).inFlight.forEach((e) => {
+		(!t || e.ids?.some((e) => t.includes(e))) && e.controller.abort();
+	});
+}, _ = (e) => {
+	u.get(e)?.inFlight.forEach((e) => e.controller.abort()), u.delete(e);
+}, v = (e, t, n, r, i) => {
+	let { ids: a, seq: o } = n;
+	e.batch(() => {
+		if (a?.length) Object.entries(r).forEach(([n, r]) => {
+			(t.asked.get(n) ?? 0) <= o && (t.asked.get(l) ?? 0) <= o && e.set(s(n), r);
+		});
+		else {
+			let n = e.get("rsc.data") ?? {}, i = (e) => e !== l && (t.asked.get(e) ?? 0) > o, a = Object.fromEntries([...Object.entries(r).filter(([e]) => !i(e)), ...Object.entries(n).filter(([e]) => i(e))]);
+			e.set("rsc.data", a);
+		}
+		e.set("rsc.loaded", !0), e.set("rsc.stale", !1), e.set("rsc.location", i);
+	});
+}, y = async (i, a, s, u) => {
+	let { enabled: d, endpoint: f } = i.get("rsc") ?? {};
+	if (!d || !f || typeof window > "u") return;
+	let g = u ?? c(), _ = i.get("schema"), y = i.get("runtime.sources.auth"), b = u ? o(_, u, !!y?.details) : i.get("navigation.currentPageId"), x = u ? void 0 : i.get("runtime.sources.flags");
+	if (!_ || !r(_, b, x)) return;
+	let S = new URLSearchParams({ location: g });
+	a?.length && S.set("ids", a.join(",")), Object.entries(s ?? {}).forEach(([e, t]) => S.set(e, t));
+	let C = `${f}?${S.toString()}`, w = p(i), T = [...w.inFlight].find((e) => e.url === C);
+	if (T) return T.promise;
+	w.inFlight.forEach((e) => {
+		h(a, e.ids) && e.controller.abort();
+	});
+	let E = ++w.seq;
+	a?.length ? a.forEach((e) => w.asked.set(e, E)) : (w.asked.clear(), w.asked.set(l, E));
+	let D = new AbortController(), O = {
+		url: C,
+		...a?.length ? { ids: a } : {},
+		here: g === c(),
+		seq: E,
+		controller: D,
+		promise: Promise.resolve()
+	}, k = async (r) => {
+		let a = await fetch(C, {
+			headers: { Accept: "application/json" },
+			signal: D.signal
+		});
+		if (!a.ok) {
+			let n = e(a.status, await a.json().catch(() => void 0));
 			if (n && await t({
 				reason: n,
-				url: m
-			}) && !f) return await l(i, a, u, d, !0);
+				url: f
+			}) && !r) return k(!0);
 			i.set("rsc.stale", !0);
 			return;
 		}
-		let { serverData: c, actionRuns: p } = await o.json();
-		p?.length && n(p), i.batch(() => {
-			a?.length ? Object.entries(c ?? {}).forEach(([e, t]) => i.set(s(e), t)) : i.set("rsc.data", c ?? {}), i.set("rsc.loaded", !0), i.set("rsc.stale", !1), i.set("rsc.location", h);
-		});
-	} catch {
-		i.set("rsc.stale", !0);
-	}
+		let { serverData: o, actionRuns: s } = await a.json();
+		s?.length && n(s), v(i, w, O, o ?? {}, g);
+	};
+	return O.promise = k(!1).catch(() => {
+		D.signal.aborted || i.set("rsc.stale", !0);
+	}).finally(() => {
+		w.inFlight.delete(O), m(i, w);
+	}), w.inFlight.add(O), m(i, w), O.promise;
 };
 //#endregion
-export { c as currentRscLocation, l as default, l as refreshRsc, s as rscDataPath };
+export { g as cancelRsc, c as currentRscLocation, y as default, y as refreshRsc, _ as releaseRscRequests, s as rscDataPath };

package/dist/server/rsc/useRscSync.mjs

@@ -1,27 +1,38 @@
 import { useCommonStore as e, useCommonStoreSync as t } from "../../store/index.mjs";
-import n, { currentRscLocation as r } from "./refreshRsc.mjs";
-import { useEffect as i, useRef as a } from "react";
-import { useStoreById as o } from "@plitzi/nexus/react";
+import n, { currentRscLocation as r, releaseRscRequests as i } from "./refreshRsc.mjs";
+import { useEffect as a, useId as o } from "react";
+import { useStoreById as s } from "@plitzi/nexus/react";
 //#region src/server/rsc/useRscSync.ts
-var s = (s) => {
-	let c = o(), [l] = e("schema.rsc", { mode: "mount" }), [u] = e("runtime.sources.navigation"), { rscData: d, rscPath: f } = s ?? {}, p = (l?.enabled ?? !1) && !!f;
-	t(["rsc.enabled", "rsc.endpoint"], [p, f]), t([
+var c = (c) => {
+	let l = s(), u = o(), [d] = e("schema.rsc", { mode: "mount" }), [f] = e([
+		"navigation.routeParams",
+		"navigation.queryParams",
+		"navigation.currentPageId",
+		"navigation.href"
+	]), p = JSON.stringify(f), { rscData: m, rscPath: h } = c ?? {}, g = (d?.enabled ?? !1) && !!h;
+	t([
+		"rsc.enabled",
+		"rsc.endpoint",
+		"rsc.instance"
+	], [
+		g,
+		h,
+		u
+	]), t([
 		"rsc.data",
 		"rsc.loaded",
 		"rsc.location"
 	], [
-		d?.serverData ?? {},
-		d !== void 0,
+		m?.serverData ?? {},
+		m !== void 0,
 		r()
-	], { mode: "mount" });
-	let m = JSON.stringify(u ?? {}), h = a(d === void 0 ? void 0 : m);
-	i(() => {
-		p && m !== h.current && (h.current = m, n(c));
+	], { mode: "mount" }), a(() => () => i(u), [u]), a(() => {
+		!g || l.get("rsc.loaded") && l.get("rsc.location") === r() && !l.get("rsc.stale") || n(l);
 	}, [
+		g,
 		p,
-		m,
-		c
+		l
 	]);
 };
 //#endregion
-export { s as default };
+export { c as default };

package/dist/server/usePluginRoute.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Where a plugin's own server half answers, for its component: `route('/layout')` is the URL of the plugin's
+ * `GET /layout`, served under `/fn/plugins/<type>/` by the server this page came from — with no flow, no server action
+ * and nothing for the space to wire.
+ *
+ * ```tsx
+ * const route = usePluginRoute('board');
+ * const url = route('/layout');
+ * if (url) {
+ *   await fetch(url, { method: 'POST', body: JSON.stringify(layout), credentials: 'same-origin' });
+ * }
+ * ```
+ *
+ * `undefined` while the page is served without a server that runs code — the builder's canvas, an embed, an offline
+ * render — the same answer that leaves a `runServerAction` step inert there, rather than a request to a guaranteed 404.
+ */
+declare const usePluginRoute: (plugin: string) => (path?: string) => string | undefined;
+export default usePluginRoute;

package/dist/server/usePluginRoute.mjs

@@ -0,0 +1,14 @@
+import { pluginRoutePath as e } from "../actions/functions.mjs";
+import { useCommonStore as t } from "../store/index.mjs";
+import { useCallback as n } from "react";
+//#region src/server/usePluginRoute.ts
+var r = (r) => {
+	let [i] = t("actions.endpoint");
+	return n((t = "/") => {
+		if (!i) return;
+		let n = e(r, t);
+		return typeof window > "u" ? n : new URL(n, new URL(i, window.location.href)).href;
+	}, [i, r]);
+};
+//#endregion
+export { r as default };

package/dist/source/export.d.ts

@@ -60,6 +60,14 @@ export type SpaceExport = {
         version: string;
         files: Record<string, string>;
     };
+    /**
+     * The space's own data, by path in `src/data/` (JSON its providers read on the server, never served), and the version
+     * of it this is — what `plitzi push` checks the space's copy has not moved on from.
+     */
+    data: {
+        version: string;
+        files: Record<string, string>;
+    };
     /**
      * The source its plugins and runtime were built from, merged: every file by its path in the project (bytes in
      * base64), the packages they need, and where each build starts.
@@ -77,9 +85,14 @@ export type SpaceExport = {
     };
     /** What there is no source of: kept built, so the project runs it as it is and cannot change it. */
     builtOnly: {
+        /**
+         * Each plugin's built files, and its server half's source when it brings one (by path in its `functions/`): the
+         * platform keeps that privately, so it travels here rather than as a file on the CDN.
+         */
         plugins: {
             type: string;
             files: SpaceExportFile[];
+            functions?: Record<string, string>;
         }[];
         /** The packed runtime, in base64 — what `@plitzi/sdk-server/runtime` loads. */
         runtime: string | null;