@plitzi/plitzi-builder 0.33.1 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @plitzi/plitzi-builder
 
+## 0.34.0
+
+### Minor Changes
+
+- v0.34.0
+
+### Patch Changes
+
+- Updated dependencies [5aceda0]
+- Updated dependencies
+- Updated dependencies [5aceda0]
+- Updated dependencies [9c3292c]
+  - @plitzi/sdk-shared@0.34.0
+  - @plitzi/sdk-elements@0.34.0
+  - @plitzi/plitzi-sdk@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/plitzi-sdk@0.33.2
+  - @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/index.html

@@ -56,11 +56,10 @@
       render(
         'plitzi',
         {
-          webKey:
-            'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwib3JpZ2lucyI6WyJodHRwczovL3dlYnNpdGUucGxpdHppLmFwcCIsImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly9sb2NhbGhvc3Q6MzAwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6ODA4MCIsImh0dHA6Ly8xMjcuMC4wLjE6ODA4MCJdLCJpc3MiOiJodHRwczovL3NlcnZlci5wbGl0emkubG9jYWwiLCJhdWQiOlsiaHR0cHM6Ly9wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbDozMDAxIiwiaHR0cHM6Ly9hcGkucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zc3IucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9tY3AucGxpdHppLmxvY2FsIl0sInNjb3BlIjoic3BhY2U6cmVuZGVyIiwiaWF0IjoxNzg2NjU5NTg5LCJqdGkiOiJjMjRhZjMwN2Q1YTgzZmNjIiwibmJmIjoxNzg2NjU5NTg5fQ.q3-yIi5TmY8SLghX5q3jpN2qqsGJbDIF9dcVJvfLbfY',
+          webKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwib3JpZ2lucyI6WyJodHRwczovL3dlYnNpdGUucGxpdHppLmFwcCIsImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly9sb2NhbGhvc3Q6MzAwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6ODA4MCIsImh0dHA6Ly8xMjcuMC4wLjE6ODA4MCJdLCJpc3MiOiJodHRwczovL3NlcnZlci5wbGl0emkubG9jYWwiLCJhdWQiOlsiaHR0cHM6Ly9wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbDozMDAxIiwiaHR0cHM6Ly9hcGkucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zc3IucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9tY3AucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hdXRoLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly8xMjcuMC4wLjE6NTMwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6NTE4MCJdLCJzY29wZSI6InNwYWNlOnJlbmRlciIsImlhdCI6MTc4OTI0ODQ3NCwianRpIjoiZDAwNTkyYjNkYzc3ZGZjNSIsIm5iZiI6MTc4OTI0ODQ3NH0.1nXztIRTuKU016ZWahgXokFt8R8uQBnlB2m5oETBPYI',
           // The actor. Without it the builder loads and every write is refused, since authorization is
           // can(actor, space, permission). Both halves come from `yarn token 1 --user admin` in plitzi-sdk-server.
-          userKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwiaXNzIjoiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiYXVkIjpbImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vYXBpLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vbWNwLnBsaXR6aS5sb2NhbCJdLCJzY29wZSI6InVzZXIiLCJleHAiOjE3ODY3NDU5OTYsImlhdCI6MTc4NjY1OTU5NiwianRpIjoiNzYzOWUxNTAwN2RkMjE1OCIsIm5iZiI6MTc4NjY1OTU5Nn0.z4MIFGgjwsULzmWQx-ICM-R-GxovVYz8An4u2Vfcfms',
+          userKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwiaXNzIjoiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiYXVkIjpbImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vYXBpLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vbWNwLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vYXV0aC5wbGl0emkubG9jYWwiLCJodHRwOi8vMTI3LjAuMC4xOjUzMDAiLCJodHRwOi8vbG9jYWxob3N0OjUxODAiXSwic2NvcGUiOiJ1c2VyIiwiZXhwIjoxNzg5MzM0OTAzLCJpYXQiOjE3ODkyNDg1MDMsImp0aSI6Ijg3NjEyMDY1MGZiMWE5ZWEiLCJuYmYiOjE3ODkyNDg1MDN9.XTNR-ST5X6u-UIEnrGXGPQHRrT0Wnqz2ZgD-STWmMjI',
           environment: 'main',
           server: {
             basePath: '',

package/dist/modules/Actions/Actions.d.ts

@@ -0,0 +1,2 @@
+declare const Actions: () => import("react").JSX.Element;
+export default Actions;

package/dist/modules/Actions/ActionsContext.d.ts

@@ -0,0 +1,24 @@
+import { ActionDocument, ActionRunReport, ActionTaskDescriptor, ActionTriggerType, SpaceAction, SpaceCredential } from '@plitzi/sdk-shared';
+export type ActionsContextValue = {
+    actions: Record<string, SpaceAction>;
+    /** Served by this deployment's server, not hardcoded in the builder. */
+    tasks: ActionTaskDescriptor[];
+    /** Names and identifiers only — values never leave the server. */
+    credentials: SpaceCredential[];
+    isLoading: boolean;
+    error: string;
+    hasServerRendering: boolean;
+    /** One origin per deployment, for building webhook URLs. */
+    deployments: {
+        environment: string;
+        domain: string;
+        isDefault: boolean;
+    }[];
+    addAction: (name: string, document: ActionDocument) => Promise<SpaceAction | undefined>;
+    updateAction: (identifier: string, name: string, document: ActionDocument) => Promise<SpaceAction | undefined>;
+    removeAction: (identifier: string) => Promise<boolean>;
+    /** Runs the stored action through the same runner a visitor hits, under the trigger's own access rules. */
+    runAction: (identifier: string, input: Record<string, unknown>, trigger?: ActionTriggerType) => Promise<ActionRunReport | undefined>;
+};
+declare const ActionsContext: import('react').Context<ActionsContextValue>;
+export default ActionsContext;

package/dist/modules/Actions/ActionsContextProvider.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export type ActionsContextProviderProps = {
+    children: ReactNode;
+};
+declare const ActionsContextProvider: ({ children }: ActionsContextProviderProps) => import("react").JSX.Element;
+export default ActionsContextProvider;

package/dist/modules/Actions/components/ActionCheck/ActionCheck.d.ts

@@ -0,0 +1,5 @@
+export type ActionCheckProps = {
+    actionId?: string;
+};
+declare const ActionCheck: ({ actionId }: ActionCheckProps) => import("react").JSX.Element | null;
+export default ActionCheck;

package/dist/modules/Actions/components/ActionCheck/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ActionCheck } from './ActionCheck';
+export * from './ActionCheck';
+export default ActionCheck;

package/dist/modules/Actions/components/ActionEvents/ActionEvents.d.ts

@@ -0,0 +1,5 @@
+export type ActionEventsProps = {
+    actionId?: string;
+};
+declare const ActionEvents: ({ actionId }: ActionEventsProps) => import("react").JSX.Element | null;
+export default ActionEvents;

package/dist/modules/Actions/components/ActionEvents/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ActionEvents } from './ActionEvents';
+export * from './ActionEvents';
+export default ActionEvents;

package/dist/modules/Actions/components/ActionForm/ActionForm.d.ts

@@ -0,0 +1,16 @@
+import { ActionRunReport, ActionDocument, ActionTaskDescriptor, ActionTriggerType, SpaceAction, SpaceCredential } from '@plitzi/sdk-shared';
+export type ActionFormProps = {
+    action?: SpaceAction;
+    tasks: ActionTaskDescriptor[];
+    credentials: SpaceCredential[];
+    deployments: {
+        environment: string;
+        domain: string;
+        isDefault: boolean;
+    }[];
+    onRun: (identifier: string, input: Record<string, unknown>, trigger: ActionTriggerType) => Promise<ActionRunReport | undefined>;
+    onSubmit: (name: string, document: ActionDocument) => Promise<void> | void;
+    onCancel: () => void;
+};
+declare const ActionForm: ({ action, tasks, credentials, deployments, onRun, onSubmit, onCancel }: ActionFormProps) => import("react").JSX.Element;
+export default ActionForm;

package/dist/modules/Actions/components/ActionForm/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ActionForm } from './ActionForm';
+export * from './ActionForm';
+export default ActionForm;

package/dist/modules/Actions/components/ActionList/ActionList.d.ts

@@ -0,0 +1,9 @@
+import { SpaceAction } from '@plitzi/sdk-shared';
+export type ActionListProps = {
+    actions: SpaceAction[];
+    onSelect: (identifier: string) => void;
+    onRemove: (identifier: string) => void;
+    onCreate: () => void;
+};
+declare const ActionList: ({ actions, onSelect, onRemove, onCreate }: ActionListProps) => import("react").JSX.Element;
+export default ActionList;

package/dist/modules/Actions/components/ActionList/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ActionList } from './ActionList';
+export * from './ActionList';
+export default ActionList;

package/dist/modules/Actions/components/ActionTestRun/ActionTestRun.d.ts

@@ -0,0 +1,10 @@
+import { ActionDocument, ActionRunReport, ActionTriggerType } from '@plitzi/sdk-shared';
+export type ActionTestRunProps = {
+    /** The stored document — runs execute it, not unsaved form edits. */
+    document: ActionDocument;
+    disabled: boolean;
+    disabledReason?: string;
+    onRun: (input: Record<string, unknown>, trigger: ActionTriggerType) => Promise<ActionRunReport | undefined>;
+};
+declare const ActionTestRun: ({ document, disabled, disabledReason, onRun }: ActionTestRunProps) => import("react").JSX.Element;
+export default ActionTestRun;

package/dist/modules/Actions/components/ActionTestRun/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ActionTestRun } from './ActionTestRun';
+export * from './ActionTestRun';
+export default ActionTestRun;

package/dist/modules/Actions/components/ActionWebhookUrl/ActionWebhookUrl.d.ts

@@ -0,0 +1,11 @@
+export type ActionWebhookUrlProps = {
+    identifier: string;
+    deployments: {
+        environment: string;
+        domain: string;
+        isDefault: boolean;
+    }[];
+};
+/** The path mirrors sdk-server's webhook endpoint mount. */
+declare const ActionWebhookUrl: ({ identifier, deployments }: ActionWebhookUrlProps) => import("react").JSX.Element;
+export default ActionWebhookUrl;

package/dist/modules/Actions/components/ActionWebhookUrl/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ActionWebhookUrl } from './ActionWebhookUrl';
+export * from './ActionWebhookUrl';
+export default ActionWebhookUrl;

package/dist/modules/Actions/index.d.ts

@@ -0,0 +1,5 @@
+import { default as Actions } from './Actions';
+import { default as ActionsContext } from './ActionsContext';
+import { default as ActionsContextProvider } from './ActionsContextProvider';
+export * from './ActionsContext';
+export { Actions, ActionsContext, ActionsContextProvider };

package/dist/modules/App/AppContainer/containers/ContainerActions.d.ts

@@ -0,0 +1,2 @@
+declare const ContainerActions: () => import("react").JSX.Element;
+export default ContainerActions;

package/dist/modules/App/components/AppHeader/QuotaBreakdown.d.ts

@@ -0,0 +1,19 @@
+import { QuotaReading } from '../../../Space/hooks/useSpaceQuota';
+export type QuotaBreakdownProps = {
+    readings: QuotaReading[];
+    /** The space being edited, so it is answered from the store rather than from the figure the server last saved. */
+    spaceId: number;
+    liveElements: number;
+};
+/**
+ * The number in the header, taken apart.
+ *
+ * The meter answers "how much room is left"; this answers what follows it — where the room went. Two breakdowns,
+ * because the two ceilings are spent by different things: elements sit in pages, and page views are spent by
+ * visitors on paths.
+ *
+ * The space being edited is answered entirely from the store, so it is on screen before any request is made, and it
+ * is there even for someone whose account owns none of this. The rest of the account is what the request is for.
+ */
+declare const QuotaBreakdown: ({ readings, spaceId, liveElements }: QuotaBreakdownProps) => import("react").JSX.Element;
+export default QuotaBreakdown;

package/dist/modules/App/components/AppHeader/QuotaMeter.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('react').MemoExoticComponent<() => import("react").JSX.Element | null>;
+export default _default;

package/dist/modules/App/models/PageForm.d.ts

@@ -4,17 +4,17 @@ import { MouseEvent } from 'react';
 declare const pageFormSchema: z.ZodObject<{
     name: z.ZodString;
     slug: z.ZodString;
-    idRef: z.ZodString;
+    id: z.ZodString;
     pageFolder: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type PageFormProps = {
     name?: string;
     slug?: string;
-    idRef?: string;
+    id?: string;
     pageFolder?: string;
     pageFolders?: PageFolder[];
     onClose?: (e: MouseEvent) => void;
     onSubmit?: (e: MouseEvent | undefined, values: z.infer<typeof pageFormSchema>) => void;
 };
-declare const PageForm: ({ name, slug, idRef, pageFolder, pageFolders, onClose, onSubmit }: PageFormProps) => import("react").JSX.Element;
+declare const PageForm: ({ name, slug, id, pageFolder, pageFolders, onClose, onSubmit }: PageFormProps) => import("react").JSX.Element;
 export default PageForm;

package/dist/modules/Builder/BuilderHelper.d.ts

@@ -27,7 +27,14 @@ export declare const getClipboardDataProcessed: (clipboardData?: DataTransfer) =
         };
     };
 } | undefined>;
-export declare const getElementDefinition: (componentDefinitions: Record<string, ComponentDefinition>, type: string, attributes?: Element["attributes"], styleSelectors?: Element["definition"]["styleSelectors"], parentId?: string) => {
+/**
+ * A pasted element, named on the spot.
+ *
+ * `mintId` is positional and local to the payload being assembled: what comes out of here is a throwaway template
+ * document that `SCHEMA_ADD_TEMPLATE` drops into the real space, and that is where a name colliding with the space
+ * is renamed. All this has to guarantee is that the paste does not collide with itself.
+ */
+export declare const getElementDefinition: (componentDefinitions: Record<string, ComponentDefinition>, mintId: (type: string) => string, type: string, attributes?: Element["attributes"], styleSelectors?: Element["definition"]["styleSelectors"], parentId?: string) => {
     definition: Element["definition"];
     attributes: Element["attributes"];
     id: string;

package/dist/modules/Builder/components/BuilderElementTools/ElementDefinitionSettings.d.ts

@@ -1,10 +1,12 @@
 import { Element } from '@plitzi/sdk-shared';
 export type ElementDefinitionSettingsProps = {
     definition: Element['definition'];
-    idRef?: string | null;
-    getIdRefConflict: (idRef: string) => string | null;
+    /** The one name this element answers to. Editing it renames the element across the whole document. */
+    id: string;
+    /** Why this id cannot be used here, or null when it is free. Given the slugified id, never the raw typing. */
+    getNameConflict: (id: string) => string | null;
     onUpdate?: (key: string, value: string | boolean | number | object, isDefinition?: boolean) => void;
-    onUpdateRef: (value: string) => void;
+    onRename: (id: string) => void;
 };
-declare const ElementDefinitionSettings: ({ definition, idRef, getIdRefConflict, onUpdate, onUpdateRef }: ElementDefinitionSettingsProps) => import("react").JSX.Element;
+declare const ElementDefinitionSettings: ({ definition, id, getNameConflict, onUpdate, onRename }: ElementDefinitionSettingsProps) => import("react").JSX.Element;
 export default ElementDefinitionSettings;

package/dist/modules/Builder/components/BuilderSearch/BuilderSearch.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+export type BuilderSearchProps = {
+    children?: ReactNode;
+};
+/**
+ * Finding an element from anywhere in the builder, whatever panel is open.
+ *
+ * The Layers panel has a search of its own, but it is only there while that panel is — and an author looking for
+ * an element across forty pages and a handful of layouts is rarely looking at Layers when they need it. This one
+ * opens with ⌘P / Ctrl+P or the header button, searches the whole space, and takes the author to the match.
+ *
+ * The canvas is an iframe, and keys pressed inside it never reach this document: the canvas forwards the shortcut
+ * through `openSearch` instead.
+ */
+declare const BuilderSearch: ({ children }: BuilderSearchProps) => import("react").JSX.Element;
+export default BuilderSearch;

package/dist/modules/Builder/components/BuilderSearch/BuilderSearchContext.d.ts

@@ -0,0 +1,5 @@
+export type BuilderSearchContextValue = {
+    openSearch: () => void;
+};
+declare const BuilderSearchContext: import('react').Context<BuilderSearchContextValue>;
+export default BuilderSearchContext;

package/dist/modules/Builder/components/BuilderSearch/components/BuilderSearchButton/BuilderSearchButton.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('react').MemoExoticComponent<() => import("react").JSX.Element>;
+export default _default;

package/dist/modules/Builder/components/BuilderSearch/components/BuilderSearchButton/index.d.ts

@@ -0,0 +1,3 @@
+import { default as BuilderSearchButton } from './BuilderSearchButton';
+export * from './BuilderSearchButton';
+export default BuilderSearchButton;

package/dist/modules/Builder/components/BuilderSearch/components/BuilderSearchPanel/BuilderSearchPanel.d.ts

@@ -0,0 +1,8 @@
+export type BuilderSearchPanelProps = {
+    onClose: () => void;
+};
+/**
+ * The input and its results. Mounted only while the search is open, so every opening starts from an empty query.
+ */
+declare const BuilderSearchPanel: ({ onClose }: BuilderSearchPanelProps) => import("react").JSX.Element;
+export default BuilderSearchPanel;

package/dist/modules/Builder/components/BuilderSearch/components/BuilderSearchPanel/index.d.ts

@@ -0,0 +1,3 @@
+import { default as BuilderSearchPanel } from './BuilderSearchPanel';
+export * from './BuilderSearchPanel';
+export default BuilderSearchPanel;

package/dist/modules/Builder/components/BuilderSearch/helpers.d.ts

@@ -0,0 +1,2 @@
+/** ⌘P / Ctrl+P — not ⌘K, which the AI panel already takes for its conversation list. */
+export declare const isSearchShortcut: (e: KeyboardEvent) => boolean;

package/dist/modules/Builder/components/BuilderSearch/index.d.ts

@@ -0,0 +1,3 @@
+import { default as BuilderSearch } from './BuilderSearch';
+export * from './BuilderSearch';
+export default BuilderSearch;

package/dist/modules/Builder/components/BuilderTree/BuilderTreeSearch/BuilderTreeSearch.d.ts

@@ -0,0 +1,13 @@
+export type BuilderTreeSearchProps = {
+    query: string;
+    baseElementId?: string;
+    onQueryChange: (query: string) => void;
+};
+/**
+ * The Layers panel's own way into the global search: the same space-wide results, inline, where the tree is.
+ *
+ * Picking one opens its page or layout, opens the tree down to it and selects it — then clears the query, which is
+ * what puts the tree back on screen to show it. The builder-wide search (⌘P) does the same from anywhere else.
+ */
+declare const BuilderTreeSearch: ({ query, baseElementId, onQueryChange }: BuilderTreeSearchProps) => import("react").JSX.Element;
+export default BuilderTreeSearch;

package/dist/modules/Builder/components/BuilderTree/BuilderTreeSearch/index.d.ts

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

package/dist/modules/Builder/components/ElementMatchItem/ElementMatchItem.d.ts

@@ -0,0 +1,12 @@
+import { ElementMatch } from '../../helpers/searchElements';
+export type ElementMatchItemProps = {
+    match: ElementMatch;
+    /** The page or layout the match lives in, when saying so helps: left out for the root already on screen. */
+    rootLabel?: string;
+    /** Highlighted by the keyboard, and kept scrolled into view. */
+    active?: boolean;
+    onSelect: (match: ElementMatch) => void;
+    onHover?: (match?: ElementMatch) => void;
+};
+declare const ElementMatchItem: ({ match, rootLabel, active, onSelect, onHover }: ElementMatchItemProps) => import("react").JSX.Element;
+export default ElementMatchItem;

package/dist/modules/Builder/components/ElementMatchItem/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ElementMatchItem } from './ElementMatchItem';
+export * from './ElementMatchItem';
+export default ElementMatchItem;

package/dist/modules/Builder/helpers/elementChain.d.ts

@@ -0,0 +1,23 @@
+import { Element } from '@plitzi/sdk-shared';
+/**
+ * The flat schema, typed as it actually behaves.
+ *
+ * `Record<string, Element>` promises an element for every string there is, so the compiler calls the miss checks
+ * below dead code — and a `parentId` naming an element the schema no longer has is exactly what this walk exists
+ * to survive. Callers hand over the store's own map, which is assignable to this.
+ */
+export type ElementLookup = Record<string, Element | undefined>;
+/**
+ * The chain from an element up to its root, outermost first.
+ *
+ * Walked through `parentId` rather than read off `rootId`, because the tree the panel opens is the chain of
+ * PARENTS: revealing a match six levels down means opening all six, and `rootId` names only the far end of it. The
+ * seen-set is not paranoia — a schema edited by two people at once can briefly describe a cycle, and without it
+ * this loops forever inside a render.
+ */
+export declare const chainOf: (flat: ElementLookup, id: string) => {
+    rootId: string;
+    ancestors: string[];
+};
+/** Whether an element lives in the page or layout `rootId` — the root itself included. */
+export declare const isInRoot: (flat: ElementLookup, id: string | undefined, rootId: string) => boolean;

package/dist/modules/Builder/helpers/elementChain.test.d.ts

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

package/dist/modules/Builder/helpers/searchElements.d.ts

@@ -0,0 +1,29 @@
+import { ElementLookup } from './elementChain';
+export type ElementMatch = {
+    id: string;
+    type: string;
+    /** Free display text, shown only when it says something the id does not. */
+    label?: string;
+    /** The page or layout this element lives in — where the search has to take you before it can select it. */
+    rootId: string;
+    /** The ids between the root and this element, outermost first: what the tree has to open to reveal it. */
+    ancestors: string[];
+    score: number;
+};
+export type SearchOptions = {
+    /** Answers past this are noise: nobody scrolls a thousand hits, they type another letter. */
+    limit?: number;
+    /** The page the author is on. Its matches sort first — that is where they were already looking. */
+    currentRootId?: string;
+};
+/**
+ * Every element in the SPACE whose id, label, page name or type matches — not only the ones on the page being
+ * edited.
+ *
+ * Across every page and layout on purpose: the tree can only ever show one root's elements, so an author with forty
+ * pages had no way to answer "where is the element called `cta-primary`" except by opening pages until one of them
+ * had it. Results carry the root they were found in, so the panel can say where each one is and take you there.
+ */
+export declare const searchElements: (flat: ElementLookup, query: string, { limit, currentRootId }?: SearchOptions) => ElementMatch[];
+/** What to call a root in the results: its page name if it has one, otherwise its label, otherwise its id. */
+export declare const rootName: (flat: ElementLookup, rootId: string) => string;

package/dist/modules/Builder/helpers/searchElements.test.d.ts

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

package/dist/modules/Builder/hooks/useRevealElement.d.ts

@@ -0,0 +1,15 @@
+import { ElementMatch } from '../helpers/searchElements';
+export type RevealTarget = Pick<ElementMatch, 'id' | 'rootId' | 'ancestors'>;
+/**
+ * Takes the author to an element anywhere in the space: its page or layout on screen, the tree opened down to it,
+ * and the element selected.
+ *
+ * The branches go into the same `openedCache` the tree reads, so revealing a match and expanding a node by hand are
+ * the same act — an element eight levels down is selected AND visible in the Layers panel, not selected somewhere
+ * the panel is not showing.
+ *
+ * The switch always goes out, even to the root already on screen: the builder may be showing a layout on top of
+ * the current page, and asking for the page is what brings it back. Asking for the root already open is a no-op.
+ */
+declare const useRevealElement: () => ({ id, rootId, ancestors }: RevealTarget) => void;
+export default useRevealElement;

package/dist/modules/Elements/ElementHelper.d.ts

@@ -1,5 +1,12 @@
-import { ComponentDefinition, Element } from '@plitzi/sdk-shared';
-export declare const getInitialItems: (parentId: string, items: string[] | undefined, definitions: Record<string, ComponentDefinition>, rootId?: string) => {
+import { ComponentDefinition, Element, Schema } from '@plitzi/sdk-shared';
+/** Mints names for a burst of new elements against one snapshot of the document.
+ *
+ *  A drop can insert a whole sub-tree at once, and each element of it needs a name that is free of the document AND
+ *  of its siblings in the same drop — which is why the taken set is carried across the burst rather than re-read
+ *  per element. The random minter, not the positional one: the builder and the MCP write the same document
+ *  concurrently, and a counter has both mint `heading-3`. */
+export declare const makeIdMinter: (flat: Schema["flat"]) => (type: string) => string;
+export declare const getInitialItems: (parentId: string, items: string[] | undefined, definitions: Record<string, ComponentDefinition>, mintId: (type: string) => string, rootId?: string) => {
     directItems: Record<string, Element>;
     items: Record<string, Element>;
 };

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

@@ -0,0 +1,17 @@
+/**
+ * Loads the space's families into the EDITOR's document, so a font can be chosen by looking at it.
+ *
+ * The canvas is an iframe with a document of its own: everything it loads is invisible to the panels around it,
+ * which is why the picker used to draw every family name in the same interface font. It was given a fixed Google
+ * stylesheet for exactly this, subsetted to the glyphs of eighteen hard-coded names — except the ampersand in that
+ * URL was HTML-escaped, so the subsetting was silently ignored and the browser fetched the families whole.
+ *
+ * Two different requests, because the two kinds of font are worth loading to different depths:
+ *
+ * - Google families are fetched for the LETTERS OF THEIR OWN NAMES (`text=`), a few hundred bytes for the whole
+ *   list. Enough to draw an option; deliberately useless for anything else.
+ * - What the space hosts or points at is loaded properly. There is no subsetting endpoint in front of somebody
+ *   else's CDN, and these are the space's own files.
+ */
+declare const FontPreviews: () => null;
+export default FontPreviews;

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * What this space loads, and where each family comes from.
+ *
+ * A space-level panel rather than something under an element's typography, because a font is a resource: it costs
+ * a request, it belongs to the space, and the element inspector only ever picks from what is declared here.
+ */
+declare const Fonts: () => import("react").JSX.Element;
+export default Fonts;

package/dist/modules/Fonts/components/AddGoogleFont/AddGoogleFont.d.ts

@@ -0,0 +1,7 @@
+import { SpaceFont } from '@plitzi/sdk-shared';
+export type AddGoogleFontProps = {
+    declared: string[];
+    onAdd: (font: SpaceFont) => void;
+};
+declare const AddGoogleFont: ({ declared, onAdd }: AddGoogleFontProps) => import("react").JSX.Element;
+export default AddGoogleFont;

package/dist/modules/Fonts/components/AddGoogleFont/index.d.ts

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

package/dist/modules/Fonts/components/AddHostedFont/AddHostedFont.d.ts

@@ -0,0 +1,17 @@
+import { SpaceFont } from '@plitzi/sdk-shared';
+export type AddHostedFontProps = {
+    /** Already declared, so a second face of the same family is added to it rather than refused as a duplicate. */
+    fonts: SpaceFont[];
+    onAdd: (font: SpaceFont) => void;
+    onUpdate: (family: string, font: SpaceFont) => void;
+};
+/**
+ * A face this deployment stores and serves itself.
+ *
+ * One file is one WEIGHT and one slant, which is why the two are asked for here rather than guessed: a family with
+ * a real bold is a second upload, and the weight select in the inspector offers exactly what has been declared.
+ * Uploading another face of a family that already exists extends it instead of starting a second entry, because
+ * `font-family` could not tell two entries of one name apart anyway.
+ */
+declare const AddHostedFont: ({ fonts, onAdd, onUpdate }: AddHostedFontProps) => import("react").JSX.Element;
+export default AddHostedFont;

package/dist/modules/Fonts/components/AddHostedFont/index.d.ts

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

package/dist/modules/Fonts/components/AddRemoteFont/AddRemoteFont.d.ts

@@ -0,0 +1,13 @@
+import { SpaceFont } from '@plitzi/sdk-shared';
+export type AddRemoteFontProps = {
+    onAdd: (font: SpaceFont) => void;
+};
+/**
+ * A family that lives on somebody else's origin: Adobe Fonts, Bunny, Fontshare, the customer's own CDN.
+ *
+ * The weights are typed rather than discovered, because nothing on our side can read them out of a foundry's kit —
+ * and they are not decoration: they are what the weight select offers, and what tells a bold apart from one the
+ * browser drew itself.
+ */
+declare const AddRemoteFont: ({ onAdd }: AddRemoteFontProps) => import("react").JSX.Element;
+export default AddRemoteFont;

package/dist/modules/Fonts/components/AddRemoteFont/index.d.ts

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

package/dist/modules/Fonts/components/AddSystemFont/AddSystemFont.d.ts

@@ -0,0 +1,13 @@
+import { SpaceFont } from '@plitzi/sdk-shared';
+export type AddSystemFontProps = {
+    onAdd: (font: SpaceFont) => void;
+};
+/**
+ * A stack the visitor's machine is expected to have already: a licensed face installed across a company, or a
+ * platform family the common stacks do not cover.
+ *
+ * Nothing is downloaded, which is the whole appeal — and the whole risk. Whoever does not have it installed reads
+ * the fallback, so the fallback is the field that matters here.
+ */
+declare const AddSystemFont: ({ onAdd }: AddSystemFontProps) => import("react").JSX.Element;
+export default AddSystemFont;

package/dist/modules/Fonts/components/AddSystemFont/index.d.ts

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

package/dist/modules/Fonts/components/FontRow/FontRow.d.ts

@@ -0,0 +1,13 @@
+import { SpaceFont } from '@plitzi/sdk-shared';
+export type FontRowProps = {
+    font: SpaceFont;
+    /** How many rules name this family. Removing one that is in use leaves those rules on their fallback. */
+    uses: number;
+    /** Whether this deployment has anywhere to copy a Google family INTO. */
+    canMirror?: boolean;
+    mirroring?: boolean;
+    onRemove?: (family: string) => void;
+    onMirror?: (family: string) => void;
+};
+declare const FontRow: ({ font, uses, canMirror, mirroring, onRemove, onMirror }: FontRowProps) => import("react").JSX.Element;
+export default FontRow;

package/dist/modules/Fonts/components/FontRow/index.d.ts

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