@plitzi/plitzi-sdk 0.33.1 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,110 @@
 # @plitzi/plitzi-sdk
 
+## 0.34.0
+
+### Minor Changes
+
+- v0.34.0
+- 9c3292c: `plitzi create` — a project that renders a space, with nothing to sign up for.
+
+  ```bash
+  npx @plitzi/cli create my-site
+  ```
+
+  Two decisions shape it: `--mode server|client` (a page server of your own, or the SDK in the browser with no
+  server at all) and `--source local|cloud` (the space travels in the project, or is read live out of Plitzi). It
+  installs the project and leaves it ready to start.
+
+  **`--package-manager npm|yarn|pnpm`** says which one the project is written for — what it installs with, and what
+  every command in its README and its Playwright config names. Omitted, it is taken from the one that invoked the
+  CLI, but that is a guess about the _invocation_: running `npx` once to scaffold a project you then work in with
+  Yarn is exactly the case it gets wrong. A Yarn project also gets a `.yarnrc.yml` pinning `nodeLinker:
+node-modules` — Yarn 4 installs Plug'n'Play by default and a server-mode project cannot start under it, since
+  `node --import tsx` dies resolving its own entry.
+
+  **The blank space moved into `@plitzi/sdk-authoring` as a declaration.** It was checked-in JSON inside the
+  platform's seeds, which meant anything else that wanted it kept a copy — and a copy of a fixture is a fixture
+  that is wrong six months later with nothing to say so. `blankSpaceSpec` is now the source both the platform's
+  `POST /spaces` and `plitzi create` author from; `blankSpace()` returns the documents, and `blankSpaceSource()`
+  returns the declaration as a file a project can own and edit.
+
+  A local project therefore gets `src/space.ts` — its own copy of that declaration, complete and self-contained —
+  rather than an import. It exports `space`, not `blankSpaceSpec`: whoever receives it is looking at their own site,
+  not at Plitzi's blank one.
+
+  `blankSpaceSource(name)` takes the name the copy should carry, so the scaffold no longer knows which literals the
+  declaration happens to contain — a rename that finds nothing to replace throws instead of quietly handing back a
+  space still called "New space", and `permanentUrl` is slugged, since it is a DNS label at the platform and what
+  every element id and style selector is derived from. The import rewrite reads the block one statement at a time
+  rather than by single-line regex (Prettier wraps a long import, and the old one read that as no import at all,
+  dropping names the copy uses), and refuses to return a file that still points at anything relative.
+
+  A browser-rendered project also serves the dev tools' stylesheet. They draw into a shadow root, which cannot see
+  the page's styles, so they fetch `/plitzi-sdk-devtools.css` — a path that exists on a server serving the SDK's
+  assets and nowhere else, which left the panel unstyled in a Vite app. The generated `vite.config.ts` serves it
+  from `node_modules` in development, so it cannot go stale and nothing is copied into the project.
+
+  **A plugin of the project's own.** `src/plugins/StatCard` is a React component the generated space renders
+  through a `custom` element — the one thing about Plitzi a page of built-in elements cannot show, and a project
+  with no example of it leaves people assuming the catalogue is the ceiling. A plugin's props ARE the hosting
+  element's attributes, so a data source pointed at that element later reaches the component with nothing in
+  between; it renders `RootElement`, so the element's id, classes and authored CSS land on what it draws. Server
+  mode registers it with `action: 'compile'` and activates it through the deployment's `pluginNames` — registering
+  a plugin says it exists, the deployment says which ones a space renders with, and leaving the second half out
+  renders "Custom Component … Not Found" with no error anywhere. The blank space in `@plitzi/sdk-authoring` is
+  unchanged: `blankSpaceSource({ plugin })` adds the host element only for callers that carry a component to fill
+  it, because the platform authors new spaces from the same declaration and hosts nobody's plugins.
+
+  **`render()`'s third argument takes a component, not a decorated one.** It asked for `ComponentPlugin` — the type
+  carrying `type`, `assets`, `origin` and `content`, all of which `App` stamps on itself from the keys of that very
+  object. Nobody registering a component of their own could satisfy it without a cast, which is also why
+  `<Sdk.Plugin component>` already declared the plain one.
+
+  **Prettier and ESLint in the generated project**, configured rather than mentioned: type-checked rules scoped to
+  the files a type checker can see, Prettier owning layout, and `eslint-config-prettier` last so the two do not
+  argue on save. `lint` and `format` are scripts from the first commit, which is the only moment a repository's
+  style is cheap to decide.
+
+  **`render()` now returns `{ unmount }`.** A second `render()` into the same element used to create a second React
+  root over the first: two live trees on one node, neither aware of the other. Anything that re-renders on its own
+  needs to take the first one down, and hot module replacement is the case that forced it — a generated client
+  project swaps the space module and remounts, so a save updates the page without reloading it.
+
+### Patch Changes
+
+- Updated dependencies [5aceda0]
+- Updated dependencies
+- Updated dependencies [5aceda0]
+  - @plitzi/sdk-shared@0.34.0
+  - @plitzi/sdk-elements@0.34.0
+  - @plitzi/sdk-auth@0.34.0
+  - @plitzi/sdk-dev-tools@0.34.0
+  - @plitzi/sdk-event-bridge@0.34.0
+  - @plitzi/sdk-interactions@0.34.0
+  - @plitzi/sdk-navigation@0.34.0
+  - @plitzi/sdk-plugins@0.34.0
+  - @plitzi/sdk-schema@0.34.0
+  - @plitzi/sdk-style@0.34.0
+  - @plitzi/sdk-variables@0.34.0
+
+## 0.33.2
+
+### Patch Changes
+
+- v0.33.2
+- Updated dependencies
+  - @plitzi/sdk-auth@0.33.2
+  - @plitzi/sdk-dev-tools@0.33.2
+  - @plitzi/sdk-elements@0.33.2
+  - @plitzi/sdk-event-bridge@0.33.2
+  - @plitzi/sdk-interactions@0.33.2
+  - @plitzi/sdk-navigation@0.33.2
+  - @plitzi/sdk-plugins@0.33.2
+  - @plitzi/sdk-schema@0.33.2
+  - @plitzi/sdk-shared@0.33.2
+  - @plitzi/sdk-style@0.33.2
+  - @plitzi/sdk-variables@0.33.2
+
 ## 0.33.1
 
 ### Patch Changes

package/dist/App.d.ts

@@ -1,4 +1,4 @@
-import { AnalyticsConfig, Environment, EventBridgeContextValue, OfflineDataRaw, RenderMode, Server, RuntimeStateInstance } from '@plitzi/sdk-shared';
+import { AnalyticsConfig, Theme, ThemeScope, Environment, EventBridgeContextValue, OfflineDataRaw, RenderMode, Server, RuntimeStateInstance } from '@plitzi/sdk-shared';
 import { ReactNode } from 'react';
 export type AppProps = {
     className?: string;
@@ -12,18 +12,42 @@ export type AppProps = {
     offlineData?: OfflineDataRaw;
     offlineDataType?: 'json' | 'yaml';
     renderMode?: RenderMode;
+    /**
+     * Whether this space owns the browser's address bar.
+     *
+     * `browser` is right for a space that IS the page — it is the site, so its pages are the window's URLs. `memory`
+     * is for a space EMBEDDED in an application that has a router of its own: the desktop app, a component mounted
+     * in a host. Without it the space's own navigation rewrites the host's location — the desktop window went from
+     * `#/spaces/view/day-plan` to `/tasks#/spaces` on the first link followed inside a space, and a reload then
+     * landed on the shell's index with the space gone.
+     */
+    routing?: 'browser' | 'memory';
     debugMode?: boolean;
     isHydrating?: boolean;
     previewMode?: boolean;
     /** Shows the "Made in Plitzi" link over the rendered space; off for embeds that are not a Plitzi site of their
      *  own (an MCP widget rendered inside a chat, a component mounted in a host app). */
     branding?: boolean;
+    /** Set by the server that metered this render: the account behind this space is over its quota, so the page says
+     *  so. Never authored — a space cannot turn it off from its own settings. */
+    overQuota?: boolean;
     externalStyle?: string;
     /** Reporting channel for this render — see {@link AnalyticsConfig}. Absent means report nothing. */
     analytics?: AnalyticsConfig;
+    /**
+     * Whose theme this space follows and repaints.
+     *
+     * `document` — the default — is a space that IS the page. `container` is a space EMBEDDED in an application with
+     * a theme of its own (the desktop window, a component mounted in a host): it wears the class on its own root and
+     * keeps a theme store of its own, so toggling it never reaches the application around it, and two spaces in one
+     * document do not answer for each other.
+     */
+    themeScope?: ThemeScope;
+    /** The theme the host already settled — from the cookie a server read before it rendered the document. */
+    theme?: Theme;
     state?: Record<string, unknown>;
     onInitStateManager?: (instance: RuntimeStateInstance) => void;
     onInitEventBridge?: (instance: EventBridgeContextValue) => void;
 };
-declare const App: ({ className, children, webKey, server, renderMode, debugMode: debugModeProp, state, ...sdkProps }: AppProps) => import("react").JSX.Element;
+declare const App: ({ className, children, webKey, server, renderMode, routing, debugMode: debugModeProp, themeScope, theme, state, ...sdkProps }: AppProps) => import("react").JSX.Element;
 export default App;

package/dist/index.d.ts

@@ -10,17 +10,36 @@ import { default as ReplicaProvider } from '@plitzi/sdk-elements/Element/Replica
 import { default as RootElement } from '@plitzi/sdk-elements/Element/RootElement';
 import { default as ComponentContext } from '@plitzi/sdk-shared/elements/ComponentContext';
 import { PlitziServiceProvider } from '@plitzi/sdk-shared/hooks/usePlitziServiceContext';
+import { default as useRscRefresh } from '@plitzi/sdk-shared/server/rsc/useRscRefresh';
 import { useSdkStore } from '@plitzi/sdk-shared/store';
 import { track } from './modules/Analytics';
 import { ElementContextValue } from '@plitzi/sdk-elements/Element/ElementContext';
 import { default as EventBridge } from '@plitzi/sdk-event-bridge';
 import { default as InteractionsManager } from '@plitzi/sdk-interactions/InteractionsManager';
-import { AnalyticsConfig, Element, Schema, Style, ComponentPluginFC, ComponentPlugin, InteractionCallback, InteractionCallbackParamValues, Environment, EventBridgeContextValue, OfflineDataRaw, RenderMode, Server, RuntimeStateInstance, PlitziServiceContextValue as BasePlitziServiceContextValue } from '@plitzi/sdk-shared';
+import { AnalyticsConfig, Element, Schema, Style, ComponentPluginFC, ComponentPlugin, InteractionCallback, InteractionCallbackParamValues, Environment, EventBridgeContextValue, HostActions, OfflineDataRaw, RenderMode, Server, RuntimeStateInstance, Theme, ThemeScope, PlitziServiceContextValue as BasePlitziServiceContextValue } from '@plitzi/sdk-shared';
 import { ReactNode } from 'react';
-export declare function render(widgetContainer: string, params?: PlitziSdkProps, plugins?: Record<string, {
-    component: ComponentPlugin;
+/**
+ * A registered plugin is a COMPONENT, not a decorated one.
+ *
+ * `ComponentPluginFC` and not `ComponentPlugin`, because the metadata the latter carries — `type`, `assets`,
+ * `origin`, `content` — is stamped on by `App` when it reads these, from the very keys given here. Asking a
+ * caller for it made the parameter impossible to satisfy without a cast: everybody registering a component of
+ * their own has a React component and nothing else, which is also exactly what `<Sdk.Plugin component>` declares.
+ */
+export type RenderPlugins = Record<string, {
+    /**
+     * A plugin's props ARE the hosting element's attributes, which this package cannot know — so the parameter is
+     * left open. Narrowed to `ComponentPluginFC` with its default `unknown`, it refuses every component anybody
+     * actually writes: a component declaring `{ label?: string }` has nothing in common with the runtime-supplied
+     * props alone, and TypeScript reads that as a mistake rather than as the intended widening.
+     */
+    component: ComponentPluginFC<any>;
     props?: Record<string, unknown>;
-}>, debugMode?: boolean, ssrMode?: boolean): void;
+    clientOnly?: boolean;
+}>;
+export declare function render(widgetContainer: string, params?: PlitziSdkProps, plugins?: RenderPlugins, debugMode?: boolean, ssrMode?: boolean): {
+    unmount: () => void;
+} | undefined;
 declare global {
     interface Window {
         plitziCache?: PlitziSdkProps;
@@ -38,18 +57,54 @@ export type PlitziSdkProps = {
     offlineData?: OfflineDataRaw;
     offlineDataType?: 'json' | 'yaml';
     renderMode?: RenderMode;
+    /**
+     * Whether this space owns the browser's address bar. `browser` (the default) is right when the space IS the page.
+     *
+     * `memory` is for a space EMBEDDED in an application that has a router of its own — the desktop app, a component
+     * mounted in a host: without it the space's own navigation rewrites the host's location, and a reload then opens
+     * the host's index with the space gone.
+     */
+    routing?: 'browser' | 'memory';
     debugMode?: boolean;
     isHydrating?: boolean;
     previewMode?: boolean;
     /** Shows the "Made in Plitzi" link over the rendered space; off for embeds that are not a Plitzi site of their
      *  own (an MCP widget rendered inside a chat, a component mounted in a host app). */
     branding?: boolean;
+    /** Set by the server that metered this render: the account behind this space is over its quota, so the page says
+     *  so. Never authored — a space cannot turn it off from its own settings. */
+    overQuota?: boolean;
     externalStyle?: string;
     sdkDevToolsStylePath?: string;
     /** Where this render reports SPA navigations and interactions, and with what key. Injected by a server that
      *  renders the page; derived from `server` + `webKey` for a client-side render; absent means report nothing. */
     analytics?: AnalyticsConfig;
     state?: Record<string, unknown>;
+    /**
+     * What the application EMBEDDING this space hands it, published as the `host` data source.
+     *
+     * The half that makes an application SHELL authorable: a sidebar cannot list the host's screens unless the host
+     * can give it the list. Kept current while the space is on screen — unlike `state`, which the space owns from
+     * the moment it mounts.
+     */
+    hostData?: Record<string, unknown>;
+    /**
+     * What that application is willing to be asked to do, reached from a flow with the `hostAction` step.
+     *
+     * The only way out of a space and into its host: opening one of the host's screens, signing out of its keyring,
+     * quitting. A name the host does not register does nothing.
+     */
+    hostActions?: HostActions;
+    /**
+     * Whose theme this space follows and repaints. `document` (the default) is a space that IS the page.
+     *
+     * `container` is a space EMBEDDED in an application with a theme of its own: it wears the class on its own root
+     * and keeps a theme store of its own, so toggling it never reaches the application around it, and two spaces in
+     * one document do not answer for each other.
+     */
+    themeScope?: ThemeScope;
+    /** The theme the host already settled — from the cookie a server read before it rendered the document. */
+    theme?: Theme;
 };
 declare const PlitziSdk: {
     ({ debugMode, isHydrating, children, webKey, environment, renderMode, ...otherProps }: PlitziSdkProps): import("react").JSX.Element;
@@ -57,7 +112,7 @@ declare const PlitziSdk: {
 };
 type PlitziServiceContextValue = BasePlitziServiceContextValue<InstanceType<typeof EventBridge>, InstanceType<typeof InteractionsManager>>;
 declare const usePlitziServiceContext: () => PlitziServiceContextValue;
-export { track, useSdkStore as useStore, ComponentProvider, ComponentContext, usePlitziServiceContext, PlitziServiceProvider, RootElement, withElement, JsxManager, PluginManager, sdkComponents, PluginRemote, ReplicaProvider, useElement, useRscData };
+export { track, useSdkStore as useStore, ComponentProvider, ComponentContext, usePlitziServiceContext, PlitziServiceProvider, RootElement, withElement, JsxManager, PluginManager, sdkComponents, PluginRemote, ReplicaProvider, useElement, useRscData, useRscRefresh };
 export type { AnalyticsConfig, ElementContextValue, Element, Schema, Style, ComponentPlugin, ComponentPluginFC, PlitziServiceContextValue, OfflineDataRaw, InteractionCallback, InteractionCallbackParamValues };
 export declare const version: string;
 export declare const getStateManager: () => RuntimeStateInstance;

package/dist/index.html

@@ -57,8 +57,7 @@
       render(
         'plitzi',
         {
-          webKey:
-            'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwib3JpZ2lucyI6WyJodHRwczovL3dlYnNpdGUucGxpdHppLmFwcCIsImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly9sb2NhbGhvc3Q6MzAwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6ODA4MCIsImh0dHA6Ly8xMjcuMC4wLjE6ODA4MCJdLCJpc3MiOiJodHRwczovL3NlcnZlci5wbGl0emkubG9jYWwiLCJhdWQiOlsiaHR0cHM6Ly9wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbDozMDAxIiwiaHR0cHM6Ly9hcGkucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zc3IucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9tY3AucGxpdHppLmxvY2FsIl0sInNjb3BlIjoic3BhY2U6cmVuZGVyIiwiaWF0IjoxNzg2NjU5NTg5LCJqdGkiOiJjMjRhZjMwN2Q1YTgzZmNjIiwibmJmIjoxNzg2NjU5NTg5fQ.q3-yIi5TmY8SLghX5q3jpN2qqsGJbDIF9dcVJvfLbfY',
+          webKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwib3JpZ2lucyI6WyJodHRwczovL3dlYnNpdGUucGxpdHppLmFwcCIsImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly9sb2NhbGhvc3Q6MzAwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6ODA4MCIsImh0dHA6Ly8xMjcuMC4wLjE6ODA4MCJdLCJpc3MiOiJodHRwczovL3NlcnZlci5wbGl0emkubG9jYWwiLCJhdWQiOlsiaHR0cHM6Ly9wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbDozMDAxIiwiaHR0cHM6Ly9hcGkucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zc3IucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9tY3AucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hdXRoLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly8xMjcuMC4wLjE6NTMwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6NTE4MCJdLCJzY29wZSI6InNwYWNlOnJlbmRlciIsImlhdCI6MTc4OTI0ODQ3NCwianRpIjoiZDAwNTkyYjNkYzc3ZGZjNSIsIm5iZiI6MTc4OTI0ODQ3NH0.1nXztIRTuKU016ZWahgXokFt8R8uQBnlB2m5oETBPYI',
           environment: 'main',
           revision: 0,
           renderMode: 'raw',

package/dist/modules/App/AppMain.d.ts

@@ -1,4 +1,4 @@
-import { AnalyticsConfig, Environment, Server, RenderMode, RuntimeStateInstance, EventBridgeContextValue, OfflineDataRaw } from '@plitzi/sdk-shared';
+import { HostActions, AnalyticsConfig, Environment, Server, RenderMode, RuntimeStateInstance, EventBridgeContextValue, OfflineDataRaw } from '@plitzi/sdk-shared';
 export type AppMainProps = {
     revision?: number;
     webKey?: string;
@@ -17,10 +17,16 @@ export type AppMainProps = {
     previewMode?: boolean;
     debugMode?: boolean;
     branding?: boolean;
+    /** Set by the server that metered this render: the account behind this space is over its quota. */
+    overQuota?: boolean;
     analytics?: AnalyticsConfig;
     state?: Record<string, unknown>;
+    /** What the embedding application hands this space — see `PlitziSdkProps`. */
+    hostData?: Record<string, unknown>;
+    /** What it is willing to be asked to do — see `PlitziSdkProps`. */
+    hostActions?: HostActions;
     onInitStateManager?: (instance: RuntimeStateInstance) => void;
     onInitEventBridge?: (instance: EventBridgeContextValue) => void;
 };
-declare const AppMain: ({ revision, webKey, webId, environment, currentPageId, server, isHydrating, offlineMode, offlineData, offlineDataType, instanceId, renderMode, sdkStylePath, sdkDevToolsStylePath, previewMode, debugMode, analytics, onInitEventBridge, onInitStateManager, ...sdkProps }: AppMainProps) => import("react").JSX.Element;
+declare const AppMain: ({ revision, webKey, webId, environment, currentPageId, server, isHydrating, offlineMode, offlineData, offlineDataType, instanceId, renderMode, sdkStylePath, sdkDevToolsStylePath, previewMode, debugMode, overQuota, analytics, onInitEventBridge, hostData, hostActions, onInitStateManager, ...sdkProps }: AppMainProps) => import("react").JSX.Element;
 export default AppMain;

package/dist/modules/App/ThemedRoot.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+export type ThemedRootProps = {
+    className?: string;
+    /** True when this space is embedded in an application with a theme of its own — see `ThemeProvider`'s `scope`. */
+    scoped?: boolean;
+    children?: ReactNode;
+};
+/**
+ * The SDK's own root, wearing the theme when the document is not this space's to write on.
+ *
+ * An embedded space cannot stamp `<html>` — the desktop window's chrome reads that class, and repainting the
+ * application around a space is not what toggling the space's theme means. So the class lands here instead, on the
+ * element the space actually occupies, which is all its own styles ever needed: `.dark` and `.light` declare
+ * `color-scheme` wherever they sit, and Tailwind's `dark:` variant matches any ancestor.
+ *
+ * `system` writes nothing, here as everywhere else: with no class the space inherits whatever the host document
+ * settled on, which for an embedded surface is the right default.
+ */
+declare const ThemedRoot: ({ className, scoped, children }: ThemedRootProps) => import("react").JSX.Element;
+export default ThemedRoot;

package/dist/modules/App/debugPreference/debugPreference.d.ts

@@ -0,0 +1,5 @@
+/** Shown unless the visitor hid them. Absent means no preference, and no preference means show. */
+export declare const readDebugPreference: (name: string) => boolean;
+/** JSON, because that is the shape `useStorage` wrote for as long as this was a `useStorage` value, and a cookie
+ *  written before this change still has to read back the same. */
+export declare const writeDebugPreference: (name: string, shown: boolean) => void;

package/dist/modules/App/debugPreference/debugPreference.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/App/debugPreference/index.d.ts

@@ -0,0 +1 @@
+export * from './debugPreference';

package/dist/modules/App/useDebugShortcut.d.ts

@@ -4,10 +4,14 @@ export type UseDebugShortcutProps = {
     onToggle: () => void;
 };
 /**
- * shift+F12 shows or hides the dev tools on a page that was already allowed to show them; it cannot grant that
- * permission. The environment is deliberately not part of the rule — whoever mounts the SDK may well want to debug a
+ * Shows or hides the dev tools on a page that was already allowed to show them; it cannot grant that permission.
+ * The environment is deliberately not part of the rule — whoever mounts the SDK may well want to debug a
  * production space — but a visitor of a site that never asked for debugging must not reach the panel, the element
  * ids or the store by knowing the shortcut.
+ *
+ * **Two chords, and the second is not a convenience.** On a Mac the top row is media keys unless the visitor
+ * holds `fn` or has changed a system setting, so `shift+F12` is a shortcut a good half of the people reading this
+ * cannot press. `shift+alt+D` is typeable on every keyboard, which is what makes the panel actually reachable.
  */
 declare const useDebugShortcut: ({ authorized, onToggle }: UseDebugShortcutProps) => void;
 export default useDebugShortcut;

package/dist/modules/Element/elements/PlitziSdk/index.d.ts

@@ -43,10 +43,7 @@ declare const PlitziSdk: {
             displayMode: string;
             style: {
                 base: {
-                    default: {
-                        'min-width': string;
-                        'min-height': string;
-                    };
+                    default: {};
                 };
             };
         };

package/dist/modules/Fonts/FontFaces/FontFaces.d.ts

@@ -0,0 +1,14 @@
+import { FontHead } from '@plitzi/sdk-shared';
+export type FontFacesProps = {
+    /** What the space's manifest resolves to — `fontsToHead(style.fonts, ...)`. */
+    head: FontHead;
+};
+/**
+ * The space's web fonts, in the document, for a render that has no server to have put them there.
+ *
+ * A component rather than a call inside `Sdk` because the render modes decide who needs it: everything that paints
+ * into THIS document, shadow included — where a `@font-face` would be ignored — and not the iframe, whose head is
+ * fed through the asset rail instead.
+ */
+declare const FontFaces: ({ head }: FontFacesProps) => null;
+export default FontFaces;

package/dist/modules/Fonts/FontFaces/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './FontFaces';
+export * from './FontFaces';

package/dist/modules/Sdk/components/OverQuotaNotice.d.ts

@@ -0,0 +1,12 @@
+/**
+ * What a site says while it is over its plan's quota.
+ *
+ * The server decides this, not the page: `render.overQuota` is set from what metering answered for THIS render, so
+ * a space cannot turn it off from its own settings — the same reason the "Made in Plitzi" badge is forced on while
+ * degraded. It renders nothing at all the rest of the time, which is every render of every paid or in-quota space.
+ *
+ * Deliberately a line and a link rather than a modal or an interstitial: the site still works, its visitors are not
+ * the ones who can fix this, and the person who can is the one who recognises their own site.
+ */
+declare const OverQuotaNotice: () => import("react").JSX.Element | null;
+export default OverQuotaNotice;

package/dist/modules/Sdk/components/index.d.ts

@@ -1,3 +1,4 @@
 import { default as MadeInPlitzi } from './MadeInPlitzi';
+import { default as OverQuotaNotice } from './OverQuotaNotice';
 export * from './MadeInPlitzi';
-export { MadeInPlitzi };
+export { MadeInPlitzi, OverQuotaNotice };