@plitzi/sdk-shared 0.33.1 → 0.34.0

package/dist/network/graphql/builder/Queries/Space/SpaceQuotaQuery.mjs

@@ -0,0 +1,40 @@
+import { gql as e } from "@apollo/client/core";
+//#region src/network/graphql/builder/Queries/Space/SpaceQuotaQuery.ts
+var t = e`
+  query SpaceQuotaQuery {
+    SpaceQuota {
+      planName
+      tier
+      isFree
+      periodStart
+      periodEnd
+      space {
+        views
+        viewsQuota
+        viewsUnlimited
+        viewsPercent
+        viewsRemaining
+        elements
+        elementsQuota
+        elementsUnlimited
+        elementsPercent
+        overLimit
+      }
+      account {
+        views
+        viewsQuota
+        viewsUnlimited
+        viewsPercent
+        viewsRemaining
+        elements
+        elementsQuota
+        elementsUnlimited
+        elementsPercent
+        overLimit
+      }
+      overLimit
+    }
+  }
+`;
+//#endregion
+export { t as default };

package/dist/network/graphql/builder/Queries/index.d.ts

@@ -2,18 +2,29 @@ import { TInitQuery } from './InitQuery';
 import { TPluginsQuery } from './PluginsQuery';
 import { TSegmentQuery } from './Segment/SegmentQuery';
 import { TSegmentsQuery } from './Segment/SegmentsQuery';
+import { TSpaceActionEventsQuery } from './Space/SpaceActionEventsQuery';
+import { TSpaceActionsQuery } from './Space/SpaceActionsQuery';
+import { TSpaceActionTasksQuery } from './Space/SpaceActionTasksQuery';
 import { TSpaceCdnsQuery } from './Space/SpaceCdnsQuery';
+import { TSpaceCheckActionQuery } from './Space/SpaceCheckActionQuery';
 import { TSpaceConnectorsQuery } from './Space/SpaceConnectorsQuery';
 import { TSpaceCredentialsQuery } from './Space/SpaceCredentialsQuery';
 import { TSpaceDeploymentsQuery } from './Space/SpaceDeploymentsQuery';
 import { TSpaceLatestRevisionQuery } from './Space/SpaceLatestRevisionQuery';
+import { TSpaceQuotaQuery } from './Space/SpaceQuotaQuery';
 import { TSpaceResourcesQuery } from './Space/SpaceResourcesQuery';
+export type { TQuotaPlane, TSpaceQuota } from './Space/SpaceQuotaQuery';
 export type BuilderQueriesMap = {
     Init: TInitQuery;
     SpaceLatestRevision: TSpaceLatestRevisionQuery;
+    SpaceQuota: TSpaceQuotaQuery;
     SpaceResources: TSpaceResourcesQuery;
     SpaceDeployments: TSpaceDeploymentsQuery;
     SpaceCdns: TSpaceCdnsQuery;
+    SpaceActions: TSpaceActionsQuery;
+    SpaceActionEvents: TSpaceActionEventsQuery;
+    SpaceCheckAction: TSpaceCheckActionQuery;
+    SpaceActionTasks: TSpaceActionTasksQuery;
     SpaceConnectors: TSpaceConnectorsQuery;
     SpaceCredentials: TSpaceCredentialsQuery;
     Plugins: TPluginsQuery;
@@ -23,9 +34,14 @@ export type BuilderQueriesMap = {
 declare const BuilderQueries: {
     Init: import('graphql').DocumentNode;
     SpaceLatestRevision: import('graphql').DocumentNode;
+    SpaceQuota: import('graphql').DocumentNode;
     SpaceResources: import('graphql').DocumentNode;
     SpaceDeployments: import('graphql').DocumentNode;
     SpaceCdns: import('graphql').DocumentNode;
+    SpaceActions: import('graphql').DocumentNode;
+    SpaceActionEvents: import('graphql').DocumentNode;
+    SpaceCheckAction: import('graphql').DocumentNode;
+    SpaceActionTasks: import('graphql').DocumentNode;
     SpaceConnectors: import('graphql').DocumentNode;
     SpaceCredentials: import('graphql').DocumentNode;
     Plugins: import('graphql').DocumentNode;

package/dist/network/graphql/builder/Queries/index.mjs

@@ -2,24 +2,34 @@ import e from "./InitQuery.mjs";
 import t from "./PluginsQuery.mjs";
 import n from "./Segment/SegmentQuery.mjs";
 import r from "./Segment/SegmentsQuery.mjs";
-import i from "./Space/SpaceCdnsQuery.mjs";
-import a from "./Space/SpaceConnectorsQuery.mjs";
-import o from "./Space/SpaceCredentialsQuery.mjs";
-import s from "./Space/SpaceDeploymentsQuery.mjs";
-import c from "./Space/SpaceLatestRevisionQuery.mjs";
-import l from "./Space/SpaceResourcesQuery.mjs";
+import i from "./Space/SpaceActionEventsQuery.mjs";
+import a from "./Space/SpaceActionsQuery.mjs";
+import o from "./Space/SpaceActionTasksQuery.mjs";
+import s from "./Space/SpaceCdnsQuery.mjs";
+import c from "./Space/SpaceCheckActionQuery.mjs";
+import l from "./Space/SpaceConnectorsQuery.mjs";
+import u from "./Space/SpaceCredentialsQuery.mjs";
+import d from "./Space/SpaceDeploymentsQuery.mjs";
+import f from "./Space/SpaceLatestRevisionQuery.mjs";
+import p from "./Space/SpaceQuotaQuery.mjs";
+import m from "./Space/SpaceResourcesQuery.mjs";
 //#region src/network/graphql/builder/Queries/index.ts
-var u = {
+var h = {
 	Init: e,
-	SpaceLatestRevision: c,
-	SpaceResources: l,
-	SpaceDeployments: s,
-	SpaceCdns: i,
-	SpaceConnectors: a,
-	SpaceCredentials: o,
+	SpaceLatestRevision: f,
+	SpaceQuota: p,
+	SpaceResources: m,
+	SpaceDeployments: d,
+	SpaceCdns: s,
+	SpaceActions: a,
+	SpaceActionEvents: i,
+	SpaceCheckAction: c,
+	SpaceActionTasks: o,
+	SpaceConnectors: l,
+	SpaceCredentials: u,
 	Plugins: t,
 	Segment: n,
 	Segments: r
 };
 //#endregion
-export { u as default };
+export { h as default };

package/dist/network/graphql/sdk/Queries/InitQuery.d.ts

@@ -5,6 +5,10 @@ export type TInitQuery = {
         schema: SchemaRaw;
         style: Style;
         segments?: SegmentRaw[];
+        /** What the server decided about this render. Server-side facts the space cannot author away. */
+        render?: {
+            overQuota: boolean;
+        };
     };
 };
 declare const InitQuery: import('graphql').DocumentNode;

package/dist/network/graphql/sdk/Queries/InitQuery.mjs

@@ -7,7 +7,6 @@ var t = e`
         settings
         flat {
           id
-          idRef
           definition {
             label
             type
@@ -55,7 +54,6 @@ var t = e`
           }
           flat {
             id
-            idRef
             definition {
               label
               type
@@ -83,6 +81,11 @@ var t = e`
         variables
         cache
       }
+      # The schema fetch is the one moment a client-side render hears from the server at all, so the decision it
+      # would have been handed in an SSR bootstrap travels here instead.
+      render {
+        overQuota
+      }
     }
   }
 `;

package/dist/network/graphql/sdk/Queries/Segment/SegmentQuery.mjs

@@ -19,7 +19,6 @@ var t = e`
         }
         flat {
           id
-          idRef
           definition {
             label
             type

package/dist/network/graphql/sdk/Queries/Segment/SegmentsQuery.mjs

@@ -20,7 +20,6 @@ var t = e`
           }
           flat {
             id
-            idRef
             definition {
               label
               type

package/dist/network/spaceEvents.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { StyleVariableCategory } from '../types/StyleTypes';
-import { DropPosition, Element, PageFolder, SchemaRaw, SchemaVariable, Style, StyleCategory, StyleItem, StyleVariableValue } from '../types';
+import { DropPosition, Element, PageFolder, SchemaRaw, SchemaVariable, SpaceFont, Style, StyleCategory, StyleItem, StyleVariableValue } from '../types';
 export declare const spaceEventSchemas: {
     readonly SPACE_UPDATED: z.ZodObject<{
         schema: z.ZodCustom<SchemaRaw, SchemaRaw>;
@@ -50,6 +50,10 @@ export declare const spaceEventSchemas: {
     readonly SPACE_UPDATE_ELEMENT: z.ZodObject<{
         element: z.ZodCustom<Element, Element>;
     }, z.core.$strip>;
+    readonly SPACE_RENAME_ELEMENT: z.ZodObject<{
+        elementId: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>;
     readonly SPACE_UPDATE_ELEMENTS: z.ZodObject<{
         elements: z.ZodArray<z.ZodCustom<Element, Element>>;
     }, z.core.$strip>;
@@ -197,6 +201,16 @@ export declare const spaceEventSchemas: {
         path: z.ZodString;
         value: z.ZodString;
     }, z.core.$strip>;
+    readonly STYLE_ADD_FONT: z.ZodObject<{
+        font: z.ZodCustom<SpaceFont, SpaceFont>;
+    }, z.core.$strip>;
+    readonly STYLE_UPDATE_FONT: z.ZodObject<{
+        family: z.ZodString;
+        font: z.ZodCustom<SpaceFont, SpaceFont>;
+    }, z.core.$strip>;
+    readonly STYLE_REMOVE_FONT: z.ZodObject<{
+        family: z.ZodString;
+    }, z.core.$strip>;
     readonly SEGMENT_ADD_ELEMENT: z.ZodObject<{
         element: z.ZodCustom<Element, Element>;
         dropPosition: z.ZodCustom<DropPosition, DropPosition>;
@@ -209,6 +223,11 @@ export declare const spaceEventSchemas: {
         element: z.ZodCustom<Element, Element>;
         contextId: z.ZodString;
     }, z.core.$strip>;
+    readonly SEGMENT_RENAME_ELEMENT: z.ZodObject<{
+        elementId: z.ZodString;
+        id: z.ZodString;
+        contextId: z.ZodString;
+    }, z.core.$strip>;
     readonly SEGMENT_UPDATE_ELEMENTS: z.ZodObject<{
         elements: z.ZodArray<z.ZodCustom<Element, Element>>;
         contextId: z.ZodString;

package/dist/network/spaceEvents.mjs

@@ -1,42 +1,42 @@
 import { StyleVariableCategory as e } from "../types/StyleTypes.mjs";
 import { z as t } from "zod";
 //#region src/network/spaceEvents.ts
-var n = (e) => typeof e == "object" && !!e && !Array.isArray(e), r = t.custom((e) => n(e) && typeof e.id == "string", { message: "expected an element with an id" }), i = t.array(r), a = t.custom((e) => n(e) && Array.isArray(e.flat), { message: "expected a schema whose `flat` is a list of elements" }), o = t.custom((e) => n(e) && typeof e.id == "string", { message: "expected a page folder with an id" }), s = t.custom((e) => n(e) && typeof e.name == "string", { message: "expected a variable with a name" }), c = t.custom(n, { message: "expected a style attributes object" }), l = t.custom((e) => typeof e == "string" || typeof e == "number" || n(e), { message: "expected a style variable value" }), u = t.enum([
+var n = (e) => typeof e == "object" && !!e && !Array.isArray(e), r = t.custom((e) => n(e) && typeof e.id == "string", { message: "expected an element with an id" }), i = t.array(r), a = t.custom((e) => n(e) && Array.isArray(e.flat), { message: "expected a schema whose `flat` is a list of elements" }), o = t.custom((e) => n(e) && typeof e.id == "string", { message: "expected a page folder with an id" }), s = t.custom((e) => n(e) && typeof e.name == "string", { message: "expected a variable with a name" }), c = t.custom(n, { message: "expected a style attributes object" }), l = t.custom((e) => n(e) && typeof e.family == "string" && typeof e.source == "string", { message: "expected a font with a family and a source" }), u = t.custom((e) => typeof e == "string" || typeof e == "number" || n(e), { message: "expected a style variable value" }), d = t.enum([
 	"desktop",
 	"tablet",
 	"mobile"
-]), d = t.custom((e) => typeof e == "string", { message: "expected a drop position" }), f = t.custom((e) => typeof e == "string", { message: "expected a style category" }), p = t.enum([
+]), f = t.custom((e) => typeof e == "string", { message: "expected a drop position" }), p = t.custom((e) => typeof e == "string", { message: "expected a style category" }), m = t.enum([
 	"class",
 	"element",
 	"id"
-]), m = t.enum([
+]), h = t.enum([
 	"hover",
 	"active",
 	"focus",
 	"disabled",
 	"checked",
 	"visited"
-]), h = t.enum(e), g = t.object({
+]), g = t.enum(e), _ = t.object({
 	componentType: t.string().optional(),
 	styleSelector: t.string().optional(),
-	styleState: m.optional(),
+	styleState: h.optional(),
 	styleVariant: t.string().optional()
-}), _ = g.extend({ styleSelector: t.string() }), v = { contextId: t.string() }, y = t.object({ variable: s }), b = t.object({
-	displayMode: u,
+}), v = _.extend({ styleSelector: t.string() }), y = { contextId: t.string() }, b = t.object({ variable: s }), x = t.object({
+	displayMode: d,
 	selector: t.string(),
-	category: h,
+	category: g,
 	name: t.string(),
-	value: l
-}), x = t.object({
-	displayMode: u,
+	value: u
+}), S = t.object({
+	displayMode: d,
 	selector: t.string(),
-	category: h,
+	category: g,
 	name: t.string()
-}), S = t.object({
-	category: h,
+}), C = t.object({
+	category: g,
 	name: t.string(),
-	value: l
-}), C = {
+	value: u
+}), w = {
 	SPACE_UPDATED: t.object({ schema: a }),
 	STYLE_UPDATED: t.object({
 		platform: t.custom(n),
@@ -50,36 +50,40 @@ var n = (e) => typeof e == "object" && !!e && !Array.isArray(e), r = t.custom((e
 	SPACE_ADD_PAGE_FOLDER: t.object({ pageFolder: o }),
 	SPACE_UPDATE_PAGE_FOLDER: t.object({ pageFolder: o }),
 	SPACE_REMOVE_PAGE_FOLDER: t.object({ pageFolderId: t.string() }),
-	SPACE_ADD_VARIABLE: y,
-	SPACE_UPDATE_VARIABLE: y,
+	SPACE_ADD_VARIABLE: b,
+	SPACE_UPDATE_VARIABLE: b,
 	SPACE_REMOVE_VARIABLE: t.object({ name: t.string() }),
 	SPACE_ADD_ELEMENT: t.object({
 		element: r,
-		dropPosition: d,
+		dropPosition: f,
 		to: t.string(),
 		initialItems: i.optional(),
 		variables: t.array(s).optional()
 	}),
 	SPACE_UPDATE_ELEMENT: t.object({ element: r }),
+	SPACE_RENAME_ELEMENT: t.object({
+		elementId: t.string(),
+		id: t.string()
+	}),
 	SPACE_UPDATE_ELEMENTS: t.object({ elements: i }),
 	SPACE_REMOVE_ELEMENT: t.object({ elementId: t.string() }),
 	SPACE_MOVE_ELEMENT: t.object({
 		from: t.string(),
 		to: t.string(),
 		elementId: t.string(),
-		dropPosition: d
+		dropPosition: f
 	}),
 	SPACE_CLONE_ELEMENT: t.object({
 		to: t.string(),
 		element: r,
-		dropPosition: d,
+		dropPosition: f,
 		initialItems: i
 	}),
 	SPACE_ADD_TEMPLATE: t.object({
 		element: r,
 		style: t.custom(n),
 		to: t.string(),
-		dropPosition: d,
+		dropPosition: f,
 		initialItems: i.optional(),
 		variables: t.array(s).optional()
 	}),
@@ -92,135 +96,146 @@ var n = (e) => typeof e == "object" && !!e && !Array.isArray(e), r = t.custom((e
 		])
 	}),
 	STYLE_ADD_SELECTOR: t.object({
-		displayMode: u,
+		displayMode: d,
 		selector: t.string(),
-		path: f.optional(),
-		type: p,
+		path: p.optional(),
+		type: m,
 		style: c.optional(),
-		params: g
+		params: _
 	}),
 	STYLE_UPDATE_SELECTOR: t.object({
-		displayMode: u,
+		displayMode: d,
 		selector: t.string(),
-		path: f.optional(),
+		path: p.optional(),
 		style: c.optional(),
-		params: _
+		params: v
 	}),
 	STYLE_REMOVE_SELECTOR: t.object({
-		displayMode: u,
+		displayMode: d,
 		selector: t.string()
 	}),
 	STYLE_REMOVE_SELECTORS: t.object({
-		displayMode: u,
+		displayMode: d,
 		selectors: t.array(t.string())
 	}),
-	STYLE_ADD_SELECTOR_VARIABLE: b,
-	STYLE_UPDATE_SELECTOR_VARIABLE: b,
-	STYLE_REMOVE_SELECTOR_VARIABLE: x,
-	STYLE_ADD_VARIABLE: S,
-	STYLE_UPDATE_VARIABLE: S,
+	STYLE_ADD_SELECTOR_VARIABLE: x,
+	STYLE_UPDATE_SELECTOR_VARIABLE: x,
+	STYLE_REMOVE_SELECTOR_VARIABLE: S,
+	STYLE_ADD_VARIABLE: C,
+	STYLE_UPDATE_VARIABLE: C,
 	STYLE_REMOVE_VARIABLE: t.object({
-		category: h,
+		category: g,
 		name: t.string()
 	}),
 	STYLE_UPDATE_SETTINGS: t.object({
 		path: t.string(),
 		value: t.string()
 	}),
+	STYLE_ADD_FONT: t.object({ font: l }),
+	STYLE_UPDATE_FONT: t.object({
+		family: t.string(),
+		font: l
+	}),
+	STYLE_REMOVE_FONT: t.object({ family: t.string() }),
 	SEGMENT_ADD_ELEMENT: t.object({
-		...v,
+		...y,
 		element: r,
-		dropPosition: d,
+		dropPosition: f,
 		to: t.string(),
 		initialItems: i.optional(),
 		variables: t.array(s).optional()
 	}),
 	SEGMENT_UPDATE_ELEMENT: t.object({
-		...v,
+		...y,
 		element: r
 	}),
+	SEGMENT_RENAME_ELEMENT: t.object({
+		...y,
+		elementId: t.string(),
+		id: t.string()
+	}),
 	SEGMENT_UPDATE_ELEMENTS: t.object({
-		...v,
+		...y,
 		elements: i
 	}),
 	SEGMENT_REMOVE_ELEMENT: t.object({
-		...v,
+		...y,
 		elementId: t.string()
 	}),
 	SEGMENT_MOVE_ELEMENT: t.object({
-		...v,
+		...y,
 		elementId: t.string(),
 		from: t.string(),
 		to: t.string(),
-		dropPosition: d
+		dropPosition: f
 	}),
 	SEGMENT_CLONE_ELEMENT: t.object({
-		...v,
+		...y,
 		element: r,
-		dropPosition: d,
+		dropPosition: f,
 		to: t.string(),
 		initialItems: i.optional()
 	}),
 	SEGMENT_ADD_TEMPLATE: t.object({
-		...v,
+		...y,
 		element: r,
 		style: t.custom(n),
 		to: t.string(),
-		dropPosition: d,
+		dropPosition: f,
 		initialItems: i.optional(),
 		variables: t.array(s).optional()
 	}),
 	SEGMENT_SPACE_ADD_VARIABLE: t.object({
-		...v,
+		...y,
 		variable: s
 	}),
 	SEGMENT_SPACE_UPDATE_VARIABLE: t.object({
-		...v,
+		...y,
 		variable: s
 	}),
 	SEGMENT_SPACE_REMOVE_VARIABLE: t.object({
-		...v,
+		...y,
 		variable: t.object({ name: t.string() })
 	}),
 	SEGMENT_STYLE_ADD_SELECTOR: t.object({
-		...v,
-		displayMode: u,
+		...y,
+		displayMode: d,
 		selector: t.string(),
-		type: p,
-		path: f.optional(),
+		type: m,
+		path: p.optional(),
 		style: c.optional(),
-		params: g
+		params: _
 	}),
 	SEGMENT_STYLE_UPDATE_SELECTOR: t.object({
-		...v,
-		displayMode: u,
+		...y,
+		displayMode: d,
 		selector: t.string(),
-		path: f.optional(),
+		path: p.optional(),
 		style: c.optional(),
-		params: _
+		params: v
 	}),
 	SEGMENT_STYLE_REMOVE_SELECTOR: t.object({
-		...v,
-		displayMode: u,
+		...y,
+		displayMode: d,
 		selector: t.string()
 	}),
 	SEGMENT_STYLE_REMOVE_SELECTORS: t.object({
-		...v,
-		displayMode: u,
+		...y,
+		displayMode: d,
 		selectors: t.array(t.string())
 	}),
-	SEGMENT_STYLE_ADD_SELECTOR_VARIABLE: b.extend(v),
-	SEGMENT_STYLE_UPDATE_SELECTOR_VARIABLE: b.extend(v),
-	SEGMENT_STYLE_REMOVE_SELECTOR_VARIABLE: x.extend(v),
-	SEGMENT_STYLE_ADD_VARIABLE: S.extend(v),
-	SEGMENT_STYLE_UPDATE_VARIABLE: S.extend(v),
+	SEGMENT_STYLE_ADD_SELECTOR_VARIABLE: x.extend(y),
+	SEGMENT_STYLE_UPDATE_SELECTOR_VARIABLE: x.extend(y),
+	SEGMENT_STYLE_REMOVE_SELECTOR_VARIABLE: S.extend(y),
+	SEGMENT_STYLE_ADD_VARIABLE: C.extend(y),
+	SEGMENT_STYLE_UPDATE_VARIABLE: C.extend(y),
 	SEGMENT_STYLE_REMOVE_VARIABLE: t.object({
-		...v,
-		category: h,
+		...y,
+		category: g,
 		name: t.string()
 	})
-}, w = Object.fromEntries(Object.keys(C).map((e) => [e, e])), T = (e, t) => {
-	let n = C[e];
+}, T = Object.fromEntries(Object.keys(w).map((e) => [e, e])), E = (e, t) => {
+	let n = w[e];
 	if (!n) return {
 		ok: !1,
 		issues: [{
@@ -241,4 +256,4 @@ var n = (e) => typeof e == "object" && !!e && !Array.isArray(e), r = t.custom((e
 	};
 };
 //#endregion
-export { w as SpaceEvents, w as default, C as spaceEventSchemas, T as validateSpaceEvent };
+export { T as SpaceEvents, T as default, w as spaceEventSchemas, E as validateSpaceEvent };

package/dist/schema/index.d.ts

@@ -1,4 +1,5 @@
 import { default as SchemaContext } from './SchemaContext';
 export * from './schemaConstants';
 export * from './SchemaContext';
+export * from './serverElements';
 export { SchemaContext };

package/dist/schema/index.mjs

@@ -1,3 +1,4 @@
 import e from "./SchemaContext.mjs";
 import { EMPTY_SCHEMA as t, VARIABLE_REGEX as n } from "./schemaConstants.mjs";
-export { t as EMPTY_SCHEMA, e as SchemaContext, n as VARIABLE_REGEX };
+import { collectServerElements as r, hasServerElements as i } from "./serverElements.mjs";
+export { t as EMPTY_SCHEMA, e as SchemaContext, n as VARIABLE_REGEX, r as collectServerElements, i as hasServerElements };

package/dist/schema/serverElements.d.ts

@@ -0,0 +1,16 @@
+import { Element, Schema } from '../types';
+/**
+ * Which elements of a page want data from the server — the one definition of it, because both sides of RSC have to
+ * agree on the answer. The rendering server asks before calling its `getRscData` adapter, and the client asks before
+ * spending a request on `/_rsc`: a page whose subtree holds no `runtime: 'server'` element has nobody to give a
+ * payload to, so resolving one costs an API call, a connector read or a round trip that nothing will ever read.
+ *
+ * Page-scoped and not schema-scoped on purpose. A space is normally a mix — one page backed by a CMS, the next one
+ * static — and the whole point is that rendering the static one must not pay for the other one's providers.
+ *
+ * The walk is iterative to stay safe on deeply nested schemas, and follows `definition.items`, so a server element
+ * nested under any number of plain containers is still found.
+ */
+export declare const collectServerElements: (schema: Schema, pageId: string | undefined, ids?: string[]) => Element[];
+/** Whether anything on this page consumes server data at all — the question both RSC gates actually ask. */
+export declare const hasServerElements: (schema: Schema, pageId: string | undefined) => boolean;

package/dist/schema/serverElements.mjs

@@ -0,0 +1,18 @@
+//#region src/schema/serverElements.ts
+var e = (e, t, n) => {
+	if (t === void 0) return [];
+	let r = n ? new Set(n) : void 0, i = [], a = /* @__PURE__ */ new Set(), o = [t];
+	for (; o.length > 0;) {
+		let t = o.pop();
+		if (t === void 0 || a.has(t)) continue;
+		a.add(t);
+		let n = e.flat[t];
+		if (!n) continue;
+		n.definition.runtime === "server" && (!r || r.has(n.id)) && i.push(n);
+		let { items: s } = n.definition;
+		s && o.push(...s);
+	}
+	return i;
+}, t = (t, n) => e(t, n).length > 0;
+//#endregion
+export { e as collectServerElements, t as hasServerElements };

package/dist/server/actions/useActionsSync.d.ts

@@ -0,0 +1,10 @@
+import { ServerSSR } from '../../types';
+/**
+ * Seeds where this origin runs server actions, once, at the SDK root.
+ *
+ * The same shape as `useRscSync` and for the same reason: only a server that mounts the endpoint publishes the
+ * path, so a client-only render — an embed, the builder, an offline widget — leaves every `serverAction` step
+ * inert rather than posting to a guaranteed 404 against whatever origin the page happens to live on.
+ */
+declare const useActionsSync: (ssr?: ServerSSR) => void;
+export default useActionsSync;

package/dist/server/actions/useActionsSync.mjs

@@ -0,0 +1,7 @@
+import { useCommonStoreSync as e } from "../../store/index.mjs";
+//#region src/server/actions/useActionsSync.ts
+var t = (t) => {
+	e(["actions.endpoint"], [t?.actionPath]);
+};
+//#endregion
+export { t as default };

package/dist/server/index.d.ts

@@ -1,5 +1,6 @@
+import { default as useActionsSync } from './actions/useActionsSync';
 import { default as refreshRsc } from './rsc/refreshRsc';
 import { default as useRscRefresh } from './rsc/useRscRefresh';
 import { default as useRscSync } from './rsc/useRscSync';
 export * from './rsc/refreshRsc';
-export { refreshRsc, useRscRefresh, useRscSync };
+export { refreshRsc, useActionsSync, useRscRefresh, useRscSync };

package/dist/server/index.mjs

@@ -1,4 +1,5 @@
-import e, { rscDataPath as t } from "./rsc/refreshRsc.mjs";
-import n from "./rsc/useRscRefresh.mjs";
-import r from "./rsc/useRscSync.mjs";
-export { e as refreshRsc, t as rscDataPath, n as useRscRefresh, r as useRscSync };
+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 };

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

@@ -12,5 +12,15 @@ export declare const rscDataPath: (id: string) => PathOf<CommonState>;
  * refresh, which replaces it. `params` ride along on the query string; that is how a provider asks for a different
  * page window.
  */
-export declare const refreshRsc: (store: StoreApi<CommonState>, ids?: string[], params?: Record<string, string>) => Promise<void>;
+/** 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.
+ *
+ * A route change that renders first and fetches after paints a page whose sections have no answer, so the
+ * 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) => Promise<void>;
 export default refreshRsc;