@plitzi/sdk-shared 0.38.4 → 0.38.5

package/dist/style/cssLayers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The cascade layers the SDK's stylesheets are written in, lowest first — declared once by `plitzi-sdk.css` and the
+ * builder's canvas, and again by the runtime stylesheet for a page that loads neither.
+ *
+ * A plugin's own stylesheet sits BELOW the space's: what the space writes about an element — its classes, `customCss`
+ * — wins over the defaults the element's author shipped, whatever their specificity, as it does for a built-in
+ * element. Above, a space's `customCss` hiding a marker inside a map lost to the plugin's `.marker { display: flex }`.
+ */
+export declare const PLUGIN_CSS_LAYER = "plitzi-sdk-plugin";
+export declare const RUNTIME_CSS_LAYER = "plitzi-sdk-runtime";
+/**
+ * A plugin's stylesheet, as it ships: everything in it in {@link PLUGIN_CSS_LAYER}. Written by whatever builds a
+ * plugin — a server compiling one, `plitzi pack plugin` — so every way the file later reaches a page (a `<link>` in the
+ * server's HTML, the SDK's assets, the builder's canvas) puts it in its place with no work of its own.
+ *
+ * Idempotent: a stylesheet already wrapped is returned as it is.
+ */
+export declare const inPluginLayer: (css: string, layer?: string) => string;

package/dist/style/cssLayers.mjs

@@ -0,0 +1,14 @@
+//#region src/style/cssLayers.ts
+var e = "plitzi-sdk-plugin", t = "plitzi-sdk-runtime", n = /^\s*(@charset\s[^;]*;|@import\s[^;]*;|\/\*[\s\S]*?\*\/)/, r = (e, t) => {
+	let n = /^@import\s+(url\([^)]*\)|"[^"]*"|'[^']*')([^;]*);$/.exec(e.trim());
+	return !n || /\blayer\b/.test(n[2]) ? e : `@import ${n[1]} layer(${t})${n[2]};`;
+}, i = (t, i = e) => {
+	let a = t, o = "";
+	for (let e = n.exec(a); e; e = n.exec(a)) {
+		let t = e[1];
+		o += t.startsWith("@import") ? r(t, i) : t, a = a.slice(e[0].length);
+	}
+	return a.trimStart().startsWith(`@layer ${i}`) ? t : a.trim() ? `${o}@layer ${i}{${a}}` : o;
+};
+//#endregion
+export { e as PLUGIN_CSS_LAYER, t as RUNTIME_CSS_LAYER, i as inPluginLayer };

package/dist/style/index.d.ts

@@ -1,5 +1,6 @@
 import { default as styleConstants } from './styleConstants';
 export * from './breakpoints';
+export * from './cssLayers';
 export * from './displayModes';
 export * from './fontAssets';
 export * from './fontValidation';

package/dist/style/index.mjs

@@ -1,12 +1,13 @@
 import e, { EMPTY_STYLE_SCHEMA as t, StyleBindingsAllowed as n, baseDefaultValue as r, inheritableAttributesBase as i } from "./styleConstants.mjs";
 import { DISPLAY_MODE_MIN_WIDTH as a, displayModeAt as o, displayModeWidthRem as s } from "./breakpoints.mjs";
-import { DISPLAY_MODES as c, isDisplayMode as l } from "./displayModes.mjs";
-import { fontLinkAssets as u } from "./fontAssets.mjs";
-import { SYSTEM_FONTS as d, availableFonts as f, familiesInCss as p, fontFamilyStack as m, fontUrlResolver as h, fontsToHead as g, googleCss2Url as _, googleTextSubsetUrl as v, isSafeFontUrl as y, primaryFamily as b } from "./fonts.mjs";
-import { FontValidationError as x, parseSpaceFont as S } from "./fontValidation.mjs";
-import { fallbackForFamily as C, fontsFromCss as w } from "./fontsFromCss.mjs";
-import { LAYOUT_GRIDS as T, layoutGridCss as E, layoutGridLook as D } from "./layoutGrid.mjs";
-import { RUNTIME_STYLE_ID as O, markStyleCache as k, styleCacheFromDocument as A, styleCacheTravelsInDocument as j } from "./runtimeStyle.mjs";
-import { mergeSnippetStyle as M, sameSelector as N, selectorsOf as P } from "./snippetStyle.mjs";
-import { CURRENT_PAGE_SELECTOR as F, HIDDEN_CLASS as I, STYLE_STATES as L, STYLE_STATE_LABELS as R, inCascadeOrder as z, isKnownState as B, isStartingState as V, stateSuffix as H } from "./styleStates.mjs";
-export { F as CURRENT_PAGE_SELECTOR, c as DISPLAY_MODES, a as DISPLAY_MODE_MIN_WIDTH, t as EMPTY_STYLE_SCHEMA, x as FontValidationError, I as HIDDEN_CLASS, T as LAYOUT_GRIDS, O as RUNTIME_STYLE_ID, L as STYLE_STATES, R as STYLE_STATE_LABELS, d as SYSTEM_FONTS, n as StyleBindingsAllowed, f as availableFonts, r as baseDefaultValue, o as displayModeAt, s as displayModeWidthRem, C as fallbackForFamily, p as familiesInCss, m as fontFamilyStack, u as fontLinkAssets, h as fontUrlResolver, w as fontsFromCss, g as fontsToHead, _ as googleCss2Url, v as googleTextSubsetUrl, z as inCascadeOrder, i as inheritableAttributesBase, l as isDisplayMode, B as isKnownState, y as isSafeFontUrl, V as isStartingState, E as layoutGridCss, D as layoutGridLook, k as markStyleCache, M as mergeSnippetStyle, S as parseSpaceFont, b as primaryFamily, N as sameSelector, P as selectorsOf, H as stateSuffix, A as styleCacheFromDocument, j as styleCacheTravelsInDocument, e as styleConstants };
+import { PLUGIN_CSS_LAYER as c, RUNTIME_CSS_LAYER as l, inPluginLayer as u } from "./cssLayers.mjs";
+import { DISPLAY_MODES as d, isDisplayMode as f } from "./displayModes.mjs";
+import { fontLinkAssets as p } from "./fontAssets.mjs";
+import { SYSTEM_FONTS as m, availableFonts as h, familiesInCss as g, fontFamilyStack as _, fontUrlResolver as v, fontsToHead as y, googleCss2Url as b, googleTextSubsetUrl as x, isSafeFontUrl as S, primaryFamily as C } from "./fonts.mjs";
+import { FontValidationError as w, parseSpaceFont as T } from "./fontValidation.mjs";
+import { fallbackForFamily as E, fontsFromCss as D } from "./fontsFromCss.mjs";
+import { LAYOUT_GRIDS as O, layoutGridCss as k, layoutGridLook as A } from "./layoutGrid.mjs";
+import { RUNTIME_STYLE_ID as j, markStyleCache as M, styleCacheFromDocument as N, styleCacheTravelsInDocument as P } from "./runtimeStyle.mjs";
+import { mergeSnippetStyle as F, sameSelector as I, selectorsOf as L } from "./snippetStyle.mjs";
+import { CURRENT_PAGE_SELECTOR as R, HIDDEN_CLASS as z, STYLE_STATES as B, STYLE_STATE_LABELS as V, inCascadeOrder as H, isKnownState as U, isStartingState as W, stateSuffix as G } from "./styleStates.mjs";
+export { R as CURRENT_PAGE_SELECTOR, d as DISPLAY_MODES, a as DISPLAY_MODE_MIN_WIDTH, t as EMPTY_STYLE_SCHEMA, w as FontValidationError, z as HIDDEN_CLASS, O as LAYOUT_GRIDS, c as PLUGIN_CSS_LAYER, l as RUNTIME_CSS_LAYER, j as RUNTIME_STYLE_ID, B as STYLE_STATES, V as STYLE_STATE_LABELS, m as SYSTEM_FONTS, n as StyleBindingsAllowed, h as availableFonts, r as baseDefaultValue, o as displayModeAt, s as displayModeWidthRem, E as fallbackForFamily, g as familiesInCss, _ as fontFamilyStack, p as fontLinkAssets, v as fontUrlResolver, D as fontsFromCss, y as fontsToHead, b as googleCss2Url, x as googleTextSubsetUrl, H as inCascadeOrder, u as inPluginLayer, i as inheritableAttributesBase, f as isDisplayMode, U as isKnownState, S as isSafeFontUrl, W as isStartingState, k as layoutGridCss, A as layoutGridLook, M as markStyleCache, F as mergeSnippetStyle, T as parseSpaceFont, C as primaryFamily, I as sameSelector, L as selectorsOf, G as stateSuffix, N as styleCacheFromDocument, P as styleCacheTravelsInDocument, e as styleConstants };

package/dist/style/useDisplayMode.d.ts

@@ -0,0 +1,11 @@
+import { DisplayMode } from '../types';
+/**
+ * Which of the space's breakpoints the page is showing — `desktop`, `tablet` or `mobile` — kept current as the window
+ * or the builder's canvas is resized. For a plugin that decides by layout (a dock only where there is room for one)
+ * with the space's own widths, rather than a number of its own that drifts from them. `compact`, in the space's
+ * styles, is `tablet` and `mobile` together.
+ *
+ * It listens to two media queries and nothing else — no resize handler, no store.
+ */
+declare const useDisplayMode: () => DisplayMode;
+export default useDisplayMode;

package/dist/style/useDisplayMode.mjs

@@ -0,0 +1,18 @@
+import { displayModeWidthRem as e } from "./breakpoints.mjs";
+import { useSyncExternalStore as t } from "react";
+//#region src/style/useDisplayMode.ts
+var n = {
+	mobile: `(max-width: ${e("tablet")})`,
+	tablet: `(max-width: ${e("desktop")})`
+}, r = (e) => typeof window > "u" || typeof window.matchMedia != "function" ? void 0 : window.matchMedia(e), i = () => r(n.mobile)?.matches ? "mobile" : r(n.tablet)?.matches ? "tablet" : "desktop", a = (e) => {
+	let t = [r(n.mobile), r(n.tablet)].filter((e) => e !== void 0);
+	return t.forEach((t) => {
+		t.addEventListener("change", e);
+	}), () => {
+		t.forEach((t) => {
+			t.removeEventListener("change", e);
+		});
+	};
+}, o = () => "desktop", s = () => t(a, i, o);
+//#endregion
+export { s as default };

package/dist/types/ActionTypes.d.ts

@@ -209,10 +209,10 @@ export type ActionTaskDescriptor = {
     title: string;
     description?: string;
     /**
-     * Whose step it is: the deployment's (`http.request`, `kv.get`…) or one of the space's own functions. A run treats
-     * both alike; the editor lists them apart.
+     * Whose step it is: the deployment's (`http.request`, `kv.get`…), one of the space's own functions, or the server half
+     * of a plugin the space uses (`<type>.<action>`). A run treats them alike; the editor lists them apart.
      */
-    origin: 'deployment' | 'space';
+    origin: 'deployment' | 'space' | 'plugin';
     params: Record<string, unknown>;
 };
 /**

package/dist/types/ComponentTypes.d.ts

@@ -20,6 +20,19 @@ export type ComponentPlugin<T = unknown> = ComponentPluginFC<T> & {
     version?: string;
     initialItems?: string[];
 };
+/**
+ * What a plugin says about itself apart from its code — its definition, its sub-plugins' — as data a page can carry.
+ *
+ * A page is sent with the plugins it draws and only the declarations of the rest: the space knows every type it has
+ * (an element's defaults, a sub-plugin's name) from the start, and a plugin's code is fetched when a page that draws
+ * it is opened.
+ */
+export type PluginDeclaration = {
+    content?: ComponentDefinition;
+    version?: string;
+    initialItems?: string[];
+    plugins?: Record<string, PluginDeclaration>;
+};
 export type ComponentPluginWithHOC<T = unknown> = ComponentPluginFC<T & {
     internalProps: InternalPropsSTG1;
 }> & {

package/dist/types/DataTypes.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A space's own data, as everything outside the page server sees it — the builder, the CLI, the MCP and the platform
+ * that keeps it: JSON files a provider of the space reads on the server (`/data/<file>`), never served. What a project
+ * keeps in `src/data/`.
+ */
+/** One reason the data was not saved, by the file it is about — what an editor marks. */
+export type DataProblem = {
+    file: string;
+    message: string;
+};
+/** The draft's data: its files, and which copy of them this is. */
+export type DataDraft = {
+    /** `{ "products.json": "[…]", "shop/hours.json": "{…}" }`. */
+    files: Record<string, string>;
+    /** Hand it back as `base` when saving: data that moved on since is refused rather than overwritten. */
+    version: string;
+};
+/**
+ * Why nothing was saved: `version`, the data moved on since the copy this save started from; `storage`, the space has no
+ * private bucket to keep it in (the error says how to add one); `size`, it weighs more than a render reads.
+ */
+export type DataRefusal = {
+    status: number;
+    error: string;
+    limit: 'version' | 'storage' | 'size';
+};
+export type DataSaveResult = {
+    ok: true;
+    version: string;
+} | {
+    ok: false;
+    problems: DataProblem[];
+} | {
+    ok: false;
+    refusal: DataRefusal;
+};

package/dist/types/InteractionTypes.d.ts

@@ -19,7 +19,7 @@ export type InteractionNode = {
     endTime: number;
     whenParams?: Record<string, RuleValue>;
 };
-export type InteractionParamType = 'boolean' | 'select' | 'text' | 'textarea' | 'codemirror-text' | 'codemirror-json' | 'elements';
+export type InteractionParamType = 'boolean' | 'select' | 'text' | 'number' | 'textarea' | 'codemirror-text' | 'codemirror-json' | 'elements';
 export type InteractionCallbackParamValues<T extends Record<string, unknown> = Record<string, unknown>> = T;
 export type InteractionCallbackParam<T extends Record<string, unknown> = Record<string, unknown>> = {
     canBind?: boolean;
@@ -33,6 +33,11 @@ export type InteractionCallbackParam<T extends Record<string, unknown> = Record<
 } & ({
     type: 'text';
     defaultValue?: string | number;
+}
+/** Written as text — a number or a template — and handed to the callback as a number. */
+ | {
+    type: 'number';
+    defaultValue?: number;
 } | {
     type: 'textarea';
     defaultValue?: string | number;
@@ -74,7 +79,11 @@ export type InteractionCallbackParam<T extends Record<string, unknown> = Record<
         value: string;
     }[]);
 });
-export type InteractionCallbackPreview = string | Record<string, unknown>;
+/**
+ * What a field a step or a trigger hands its flow looks like — a sample, shown where a flow is written, never sent: `0`
+ * for a count, `false` for a flag, `[]` for a list, as well as the text `''`.
+ */
+export type InteractionCallbackPreview = string | number | boolean | null | unknown[] | Record<string, unknown>;
 export type InteractionCallbackPreviews = Record<string, InteractionCallbackPreview>;
 /**
  * What a callback learns about the flow running it.
@@ -86,6 +95,11 @@ export type InteractionCallbackPreviews = Record<string, InteractionCallbackPrev
 export type InteractionCallbackContext = {
     /** Id of the element this flow fired on. Absent for a flow with no host element. */
     hostElementId?: string;
+    /**
+     * Aborted when the flow running this step is superseded — its trigger fired again under `whileRunning: 'latest'`. A
+     * step waiting on something it can stop (a request, a server run) stops it; the flow starts no further step.
+     */
+    signal?: AbortSignal;
 };
 export type InteractionCallback<T extends Record<string, unknown> = Record<string, unknown>> = {
     elementId?: string;

package/dist/types/SchemaTypes.d.ts

@@ -53,8 +53,10 @@ export type ElementBinding = {
  * - `skip` (the default): the new firing is ignored — what keeps a double click from submitting twice.
  * - `parallel`: every firing runs its own flow, at the same time.
  * - `queue`: every firing runs, one after another, in the order they came — none lost, none overlapping.
+ * - `latest`: every firing runs, and the run before it stops — it starts no further step, and the step it is waiting
+ *   on stops if it can (a server action, a request). A search as you type: only the last question is answered.
  */
-export type WhileRunning = 'skip' | 'parallel' | 'queue';
+export type WhileRunning = 'skip' | 'parallel' | 'queue' | 'latest';
 export declare const WHILE_RUNNING_MODES: readonly WhileRunning[];
 export type ElementInteraction<T extends Record<string, unknown> = Record<string, unknown>> = {
     id: string;

package/dist/types/SchemaTypes.mjs

@@ -2,7 +2,8 @@
 var e = [
 	"skip",
 	"parallel",
-	"queue"
+	"queue",
+	"latest"
 ];
 //#endregion
 export { e as WHILE_RUNNING_MODES };

package/dist/types/ServerTypes.d.ts

@@ -1,6 +1,8 @@
 import { ActionEmailConfig, ActionEntry, ActionJobQueue, ActionLimits, ActionRejectReason, ActionRunSummary, ActionRejectRecord, ActionRunRecord, ActionRunReport, ActionRunStatus, ActionTaskDescriptor, ActionTriggerType } from './ActionTypes';
 import { Environment } from './CommonTypes';
+import { PluginDeclaration } from './ComponentTypes';
 import { ConnectorEntry } from './ConnectorTypes';
+import { DataDraft, DataSaveResult } from './DataTypes';
 import { FunctionsDraft, FunctionsSaveResult } from './FunctionTypes';
 import { SSRRealtimeConfig } from './RealtimeTypes';
 import { Schema } from './SchemaTypes';
@@ -119,6 +121,11 @@ export type PluginEntry = {
      * against, and the mismatch throws away the whole tree it happens in.
      */
     ssr?: boolean;
+    /**
+     * What the plugin declares, when this page draws none of its types: its code and stylesheet are left out of the
+     * document and loaded when a page that draws it is opened. Absent, the page loads it up front.
+     */
+    deferred?: PluginDeclaration;
 };
 export type SSRTemplateProps = {
     title?: string;
@@ -126,6 +133,13 @@ export type SSRTemplateProps = {
     description?: string;
     jsPath?: string;
     cssPath?: string;
+    /** Font Awesome's rules, after `cssPath`; its fonts are files beside it, fetched only for a style the page uses. */
+    iconsCssPath?: string;
+    /**
+     * Where the page fetches the space from, when it travels beside the document rather than in its payload: the
+     * page preloads it, and the bootstrap reads it before hydrating.
+     */
+    spaceDocumentPath?: string;
     builderJsPath?: string;
     builderCssPath?: string;
     plugins?: PluginEntry[];
@@ -348,10 +362,6 @@ export type SSRAdapters = {
     /** Which space, environment and revision a request resolves to. Optional here for the same reason as
      *  `getOfflineData`: MCP resolves its space from the request token (`getGrant`), never from the host. */
     getSpaceDeployment?: (req: SSRRequest) => Promise<SSRSpaceDeployment>;
-    /** Persist a space mutated by the mcp-ai `apply` tool — store it as given; derived caches (notably `style.cache`)
-     *  arrive already compiled. When omitted, mcp-ai runs read/preview/validate only and `apply` reports
-     *  `persisted: false`. */
-    saveOfflineData?: (spaceId: number, environment: string, data: OfflineDataRaw) => Promise<void>;
     /** Resolve the grant the MCP request operates under, from the verified `Authorization` bearer. The consumer
      *  owns the JWT secret and the authorization model, so it decides here; the MCP service stays stateless.
      *  Returns undefined when the token is missing or invalid. Required for the `mcp` service to serve any
@@ -399,6 +409,12 @@ export type SSRAdapters = {
     saveFunctions?: (spaceId: number, files: Record<string, string>, base: string, write: SSRWriteContext) => Promise<FunctionsSaveResult>;
     /** Run one task of the draft's functions in the sandbox for the person behind the agent — the builder's Try. */
     tryFunction?: (spaceId: number, task: string, params: Record<string, unknown>, write: SSRWriteContext) => Promise<ActionRunReport>;
+    /** The space's own data: the draft's JSON files its server providers read (`/data/<file>`), and which copy they are.
+     *  When omitted, the MCP offers no data resource and refuses the data ops. */
+    getData?: (spaceId: number) => Promise<DataDraft | undefined>;
+    /** Save the draft's data, whole: every file JSON at a plain path. `base` is the version the agent read, and data that
+     *  moved on since is refused rather than overwritten. */
+    saveData?: (spaceId: number, files: Record<string, string>, base: string, write: SSRWriteContext) => Promise<DataSaveResult>;
     /** Persist the element schema mutated by the MCP `apply` tool. When omitted, `apply` reports `persisted: false`. */
     saveSchema?: (spaceId: number, environment: Environment, schema: Schema, write: SSRWriteContext) => Promise<void>;
     /** Persist the style document mutated by the MCP `apply` tool — store it as given. `style.cache` arrives already
@@ -523,6 +539,11 @@ export interface SSRRscContext {
      * against the page it matched and skips it — so a feature that is off puts nothing in the payload.
      */
     flagOverrides?: FlagOverrides;
+    /**
+     * Aborted when whoever asked stops waiting — a browser that hung up, a refresh superseded by a newer one, a STOP — so
+     * what it asked for stops being worked on, here and in the runs it started.
+     */
+    signal?: AbortSignal;
 }
 /**
  * Which published version of a space is asking.
@@ -554,6 +575,14 @@ export type ActionLookupsConfig = {
     getConnector?: (spaceId: number, connectorId: string, at?: SpaceRevision) => Promise<unknown>;
     /** The space's own functions as of that revision — `SpaceFunctions` in `@plitzi/sdk-server/functions`. */
     getFunctions?: (spaceId: number, at?: SpaceRevision) => Promise<unknown>;
+    /** The server halves of the plugins the space uses, by plugin type — a `SpaceFunctions` each. */
+    getPluginFunctions?: (spaceId: number, at?: SpaceRevision) => Promise<unknown>;
+    /**
+     * The space's own data as of that revision — what a project keeps in `src/data/`, kept privately and frozen with each
+     * publish — as its files' text by path (`products.json`). A provider resolved on the server whose `query` is
+     * `/data/<file>` reads it, as `dataDir` reads a folder; no browser is answered it.
+     */
+    getData?: (spaceId: number, at?: SpaceRevision) => Promise<unknown>;
     /** The feature flags the space declares as of that revision — what a flow reads as `{{ flags.<name> }}`. */
     getFlags?: (spaceId: number, at?: SpaceRevision) => Promise<Schema['flags']>;
 };
@@ -903,7 +932,15 @@ export type SSRServerConfig = {
         minVersion?: 'TLSv1' | 'TLSv1.1' | 'TLSv1.2' | 'TLSv1.3';
     };
     environment?: ServerEnvironment;
+    /** Served to anyone who asks, as it is: pictures, a favicon, what a page fetches in the browser. */
     publicDir?: string;
+    /**
+     * The project's own data, never served as files: a provider resolved on the server (`runtime: 'server'`) whose
+     * `query` is `/data/<file>` reads `<dataDir>/<file>`, and the page arrives with it. Nobody downloads the folder; what
+     * a provider reads goes into the page it renders, though — data a page must not carry is a server action's to read,
+     * answering only what is shown.
+     */
+    dataDir?: string;
     static?: Record<string, string>;
     devMode?: boolean;
     /**
@@ -976,12 +1013,13 @@ export type SSRServerConfig = {
     /** Write endpoint for server-driven providers. Absent means the server serves reads only. */
     action?: SSRActionConfig;
     /**
-     * Code of this server's own, and the sandbox for the spaces' — shaped as `FunctionsConfig` in
-     * `@plitzi/sdk-server/functions`. `native` is trusted code loaded in the process (a self-hosted server's tasks, or a
-     * platform's own); `runner` runs each space's functions, isolated.
+     * The server's code: its own (`native`), the server halves of the plugins it ships (`plugins`, by plugin type), the
+     * runner the spaces' code runs on, and the ceilings. Built by `@plitzi/sdk-server/functions` (`loadFunctions`), and
+     * checked as the server starts.
      */
     functions?: {
         native?: unknown[];
+        plugins?: Record<string, unknown>;
         runner?: unknown;
         limits?: Record<string, number>;
     };
@@ -1131,6 +1169,12 @@ export type SSRContext = {
      * refresh is done, and handed on only to a page whose debugging is authorized.
      */
     actionRuns?: ActionRunSummary[];
+    /**
+     * What a refresh of server data asked for beside the page's own address (`/_rsc?location=…&q=…`): a provider's
+     * `input`, a page window. What the provider asks for this time, so it wins over the `input` the element was saved
+     * with — the query string of the page does not.
+     */
+    rscParams?: Record<string, string>;
 };
 export type SSRServer = {
     listen: (port: number, host?: string) => void;
@@ -1142,6 +1186,13 @@ export type SSRServer = {
      * calls once it wrote the new documents, instead of restarting the server. Nothing otherwise.
      */
     reloadPages: () => void;
+    /**
+     * The server halves of the plugins this server ships (`functions.plugins`), replaced while it runs: what a development
+     * server does when a plugin's `functions/` change. `definition` is what `loadFunctions` loads; none takes it away.
+     */
+    readonly functions: {
+        setPlugin: (plugin: string, definition: unknown) => void;
+    };
 };
 /** A key/value store with per-entry expiry, backing the OAuth layer's short-lived protocol state (registered
  *  clients, authorization codes, refresh grants). Values are opaque strings the SDK serialises itself. A

package/dist/types/StoreTypes.d.ts

@@ -101,6 +101,12 @@ export type CommonState = {
         href: string;
         currentPageId: string;
         navigate: (url: string, isExternal?: boolean) => void;
+        /**
+         * Where a navigation is going while it waits for the destination's server data — `''` when none is. A link to a
+         * page resolved on the server asks for that page's data before it goes, and the page on screen stays until then:
+         * this is what a loading bar for it reads.
+         */
+        pendingLocation?: string;
     };
 };
 /** Not document state and not server data: the surface the schema is being rendered on. `previewMode` and
@@ -209,6 +215,19 @@ export type RscState = {
      * compare this against where the visitor actually is, and a mismatch means "not mine yet" rather than "gone".
      */
     location?: string;
+    /**
+     * The elements a refresh in flight is asking about for the page on screen, by id — `*` for the whole payload.
+     *
+     * What makes a server provider's `isLoading` true while it is asked again (`performQuery`, `refreshSeconds`, a page
+     * of a pager), as a browser provider's is while it refetches. A navigation's prefetch is for another page, and
+     * marks nothing on this one.
+     */
+    refreshing?: Record<string, boolean>;
+    /**
+     * Names this SDK root, so the refreshes asked through any store under it — each element writes through a scoped store
+     * of its own — are known to each other: one request per question, the newest question winning.
+     */
+    instance?: string;
 };
 export type BuilderState = CommonState & {
     collaboration: {
@@ -233,12 +252,6 @@ export type BuilderState = CommonState & {
         queryParams: QueryParams;
         hostname: string;
     };
-    /**
-     * The builder's OWN feature flags — Plitzi's, not the space's: which parts of the editor this person is shown, as the
-     * platform resolved them for them when the editor opened (`PlatformFlags` in the builder's first query). Never
-     * authored, never published.
-     */
-    platformFlags?: Record<string, boolean>;
     displayMode: DisplayMode;
     selector?: string;
     styleSelector?: string;

package/dist/types/index.d.ts

@@ -11,6 +11,7 @@ export * from './NavigationTypes';
 export * from './CollectionTypes';
 export * from './ConnectorTypes';
 export * from './ActionTypes';
+export * from './DataTypes';
 export * from './FunctionTypes';
 export * from './RealtimeTypes';
 export * from './ComponentTypes';
@@ -23,6 +24,4 @@ export * from './SpaceTypes';
 export * from './DevToolsTypes';
 export * from './StoreTypes';
 export * from './ThemeTypes';
-export * from './McpTypes';
 export * from './ServerTypes';
-export * from './AITypes';