@plitzi/plitzi-builder 0.37.8 → 0.37.10

package/dist/modules/Builder/Models/SnippetForm.d.ts

@@ -0,0 +1,16 @@
+import { MouseEvent } from 'react';
+/** What the form answers: the snippet, and the public bucket of which CDN it goes in. */
+export type SnippetFormValues = {
+    name: string;
+    description?: string;
+    cdnIdentifier: string;
+    bucketIdentifier: string;
+};
+export type SnippetFormProps = {
+    name?: string;
+    description?: string;
+    onClose?: (e?: MouseEvent) => void;
+    onSubmit?: (e: MouseEvent | undefined, values: SnippetFormValues) => void;
+};
+declare const SnippetForm: ({ name, description, onSubmit, onClose }: SnippetFormProps) => import('react').JSX.Element;
+export default SnippetForm;

package/dist/modules/Builder/components/BuilderContextMenu/BuilderContextMenuItem.d.ts

@@ -2,10 +2,15 @@ import { HTMLAttributes, MouseEvent, ReactNode } from 'react';
 export type BuilderContextMenuItemProps = {
     id?: string;
     title?: string;
+    /** What the item does beyond its name, shown on hover. */
+    hint?: string;
+    /** Only a shortcut that exists: a menu that shows one teaches it. */
     shortcut?: string;
+    /** `danger` for what removes. */
+    intent?: 'default' | 'danger';
     children?: ReactNode;
     className?: string;
     onClick?: (e: MouseEvent, id: string) => void;
 } & Omit<HTMLAttributes<HTMLDivElement>, 'onClick'>;
-declare const BuilderContextMenuItem: ({ id, title, shortcut, children, className, onClick, ...otherProps }: BuilderContextMenuItemProps) => import('react').JSX.Element;
+declare const BuilderContextMenuItem: ({ id, title, hint, shortcut, intent, children, className, onClick, ...otherProps }: BuilderContextMenuItemProps) => import('react').JSX.Element;
 export default BuilderContextMenuItem;

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

@@ -0,0 +1,11 @@
+export type ElementAnchorProps = {
+    anchor?: string;
+    /** `undefined` removes it: the element has no `id` in the DOM. */
+    onUpdate?: (key: string, value: string | undefined, isDefinition?: boolean) => void;
+};
+/**
+ * The `id` an element carries in the DOM, so a link to `/page#anchor` lands on it. Saved as soon as what is typed is
+ * one; while it is not, the field says why and the element keeps the one it had.
+ */
+declare const ElementAnchor: ({ anchor, onUpdate }: ElementAnchorProps) => import('react').JSX.Element;
+export default ElementAnchor;

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

@@ -5,6 +5,8 @@ export type ElementDefinitionSettingsProps = {
     canHoldItems?: boolean;
     /** What the element's type declares, which is what an instance with no strategy of its own follows. */
     declaredLoadStrategy?: ElementLoadStrategy;
+    /** The feature flags the space declares — what the element's gate may name. */
+    flagNames?: string[];
     /** 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. */
@@ -13,5 +15,5 @@ export type ElementDefinitionSettingsProps = {
     onUpdate?: (key: string, value: string | boolean | number | object | undefined, isDefinition?: boolean) => void;
     onRename: (id: string) => void;
 };
-declare const ElementDefinitionSettings: ({ definition, canHoldItems, declaredLoadStrategy, id, getNameConflict, onUpdate, onRename }: ElementDefinitionSettingsProps) => import('react').JSX.Element;
+declare const ElementDefinitionSettings: ({ definition, canHoldItems, declaredLoadStrategy, flagNames, id, getNameConflict, onUpdate, onRename }: ElementDefinitionSettingsProps) => import('react').JSX.Element;
 export default ElementDefinitionSettings;

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

@@ -0,0 +1,16 @@
+import { ElementFlagGate as TElementFlagGate } from '@plitzi/sdk-shared';
+export type ElementFlagGateProps = {
+    gate?: TElementFlagGate;
+    /** The flags the space declares, which are the ones a gate may name. */
+    flagNames: string[];
+    isPage?: boolean;
+    /** `undefined` removes the gate: the element is rendered whatever the flags say. */
+    onUpdate?: (key: string, value: TElementFlagGate | undefined, isDefinition?: boolean) => void;
+};
+/**
+ * The feature flag an element exists under — not a visibility: gated off, it is not rendered at all, on the server or
+ * in the browser, and none of its markup is in the page. Offered only once the space declares a flag,
+ * and kept on screen for an element still naming one the space removed, so the author can see why it is gone.
+ */
+declare const ElementFlagGate: ({ gate, flagNames: names, isPage, onUpdate }: ElementFlagGateProps) => import('react').JSX.Element | null;
+export default ElementFlagGate;

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

@@ -0,0 +1,6 @@
+/**
+ * What the tools say before anything is chosen: how to choose, and the keys that work on what is chosen — the place
+ * an author looks while learning the canvas, so the place the shortcuts are taught.
+ */
+declare const NothingSelected: () => import('react').JSX.Element;
+export default NothingSelected;

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

@@ -0,0 +1,16 @@
+/**
+ * The two ways part of a page is reused, as the builder shows them wherever it offers them — the canvas overlay, the
+ * context menu, the Components panel: one icon and one line each, said once, so the two never end up looking alike.
+ *
+ * What tells them apart is what happens after: a component stays linked, a snippet is a copy.
+ */
+export declare const REUSE: {
+    readonly component: {
+        readonly icon: "fa-solid fa-cube";
+        readonly hint: "reusable, and editing it updates every instance";
+    };
+    readonly snippet: {
+        readonly icon: "fa-solid fa-object-group";
+        readonly hint: "a copy to drop anywhere, not linked to where it came from";
+    };
+};

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

@@ -0,0 +1,8 @@
+import { Element } from '@plitzi/sdk-shared';
+/**
+ * Saves an element on the canvas as a snippet: asks for its name and the bucket it goes in, uploads it, and says how
+ * that went — saved only once the upload answered, so a failed one is never announced as done. Returns whether it was
+ * saved.
+ */
+declare const useSaveAsSnippet: () => (element: Element) => Promise<boolean>;
+export default useSaveAsSnippet;

package/dist/modules/Components/Components.d.ts

@@ -0,0 +1,11 @@
+export type ComponentsProps = {
+    /** What the catalog is searched for: the elements above and these alike. */
+    filter: string;
+};
+/**
+ * The space's components, at the foot of the element catalog: placed the way an element is, by dragging it onto a
+ * page — with what each is called and how many places render it. Edited by opening it in the canvas, where its tree is
+ * edited like a page's.
+ */
+declare const Components: ({ filter }: ComponentsProps) => import('react').JSX.Element;
+export default Components;

package/dist/modules/Components/components/ComponentBanner/ComponentBanner.d.ts

@@ -0,0 +1,7 @@
+import { SpaceComponent } from '@plitzi/sdk-shared';
+export type ComponentBannerProps = {
+    component: SpaceComponent;
+};
+/** Says the canvas is a component, not a page — every instance of it changes with what is edited here. */
+declare const ComponentBanner: ({ component }: ComponentBannerProps) => import('react').JSX.Element;
+export default ComponentBanner;

package/dist/modules/Components/components/ComponentBanner/index.d.ts

@@ -0,0 +1 @@
+export { default } from './ComponentBanner';

package/dist/modules/Components/components/ComponentForm/ComponentForm.d.ts

@@ -0,0 +1,19 @@
+import { PageFolder, SpaceComponentDeclaration } from '@plitzi/sdk-shared';
+import { MouseEvent } from 'react';
+export type ComponentFormProps = {
+    declaration?: SpaceComponentDeclaration;
+    /** The elements of the component's tree that can be a slot: those that hold children. */
+    slotChoices?: {
+        id: string;
+        label: string;
+    }[];
+    pageFolders?: PageFolder[];
+    onClose?: (e?: MouseEvent) => void;
+    onSubmit?: (e: MouseEvent | undefined, values: SpaceComponentDeclaration) => void;
+};
+/**
+ * What a component declares: what it is called, where the builder files it, the props an instance hands in and the
+ * elements of its tree an instance fills.
+ */
+declare const ComponentForm: ({ declaration, slotChoices, pageFolders, onClose, onSubmit }: ComponentFormProps) => import('react').JSX.Element;
+export default ComponentForm;

package/dist/modules/Components/components/ComponentForm/SlotChoice.d.ts

@@ -0,0 +1,8 @@
+export type SlotChoiceProps = {
+    id: string;
+    label: string;
+    checked: boolean;
+    onToggle: (id: string, checked: boolean) => void;
+};
+declare const SlotChoice: ({ id, label, checked, onToggle }: SlotChoiceProps) => import('react').JSX.Element;
+export default SlotChoice;

package/dist/modules/Components/components/ComponentForm/index.d.ts

@@ -0,0 +1 @@
+export { default } from './ComponentForm';

package/dist/modules/Components/components/ComponentItem/ComponentItem.d.ts

@@ -0,0 +1,12 @@
+import { PageFolder, SpaceComponent } from '@plitzi/sdk-shared';
+export type ComponentItemProps = {
+    component: SpaceComponent;
+    /** How many places in the space render it. */
+    instances: number;
+    /** Whether it is the one open in the canvas. */
+    open: boolean;
+    pageFolders: PageFolder[];
+};
+/** One component of the space: dragged onto a page to place it, opened to edit its tree, renamed, removed. */
+declare const ComponentItem: ({ component, instances, open, pageFolders }: ComponentItemProps) => import('react').JSX.Element;
+export default ComponentItem;

package/dist/modules/Components/components/ComponentItem/index.d.ts

@@ -0,0 +1 @@
+export { default } from './ComponentItem';

package/dist/modules/Components/components/InstanceTools/InstanceTools.d.ts

@@ -0,0 +1,10 @@
+export type InstanceToolsProps = {
+    instanceId: string;
+    componentId: string;
+};
+/**
+ * What only the builder can do with an instance, beside the settings of the element itself: open the component it
+ * places, put each of its children in a slot, and detach it — a copy of the component that is then this page's own.
+ */
+declare const InstanceTools: ({ instanceId, componentId }: InstanceToolsProps) => import('react').JSX.Element | null;
+export default InstanceTools;

package/dist/modules/Components/components/InstanceTools/SlotRow.d.ts

@@ -0,0 +1,13 @@
+import { Element } from '@plitzi/sdk-shared';
+export type SlotRowProps = {
+    child: Element;
+    slots: {
+        value: string;
+        label: string;
+    }[];
+    /** The slot a child naming none goes in: the component's first. */
+    fallback?: string;
+};
+/** One child of an instance, and the slot of the component it fills. */
+declare const SlotRow: ({ child, slots, fallback }: SlotRowProps) => import('react').JSX.Element;
+export default SlotRow;

package/dist/modules/Components/components/InstanceTools/index.d.ts

@@ -0,0 +1 @@
+export { default } from './InstanceTools';

package/dist/modules/Components/components/PropsEditor/PropRow.d.ts

@@ -0,0 +1,14 @@
+import { ComponentProp } from '@plitzi/sdk-shared';
+export type PropEntry = {
+    name: string;
+    prop: ComponentProp;
+};
+export type PropRowProps = {
+    index: number;
+    entry: PropEntry;
+    problem?: string;
+    onChange: (index: number, entry: PropEntry) => void;
+    onRemove: (index: number) => void;
+};
+declare const PropRow: ({ index, entry, problem, onChange, onRemove }: PropRowProps) => import('react').JSX.Element;
+export default PropRow;

package/dist/modules/Components/components/PropsEditor/PropsEditor.d.ts

@@ -0,0 +1,11 @@
+import { PropEntry } from './PropRow';
+export type PropsEditorProps = {
+    value: PropEntry[];
+    onChange: (value: PropEntry[]) => void;
+};
+/**
+ * The props a component declares, one row each: the name it is read by (`{{ props.<name> }}`), its kind, what it is
+ * for and whether an instance must hand it in.
+ */
+declare const PropsEditor: ({ value, onChange }: PropsEditorProps) => import('react').JSX.Element;
+export default PropsEditor;

package/dist/modules/Components/components/PropsEditor/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './PropsEditor';
+export type { PropEntry } from './PropRow';

package/dist/modules/Components/helpers.d.ts

@@ -0,0 +1,17 @@
+import { ComponentDefinition, Schema, SpaceComponent } from '@plitzi/sdk-shared';
+/** A name for a new component, from what the author called it and free among the space's components. */
+export declare const componentIdFor: (label: string, components: Schema["components"]) => string;
+/**
+ * A new component with nothing in it yet: the one container it is built in, made the way a drop makes one — from the
+ * element's own declaration — and named free of every tree of the document.
+ */
+export declare const emptyComponent: (label: string, schema: Pick<Schema, "flat" | "components">, container: ComponentDefinition) => SpaceComponent;
+/** What the builder shows a component as: the name the author gave it, else its id. */
+export declare const componentLabel: (component: SpaceComponent) => string;
+/**
+ * How many places render each component.
+ *
+ * Counted tree by tree. While a component is open, the builder reads `schema.flat` with its tree laid over the pages',
+ * so an element is counted from that flat only when no component holds it — and from its component's tree otherwise.
+ */
+export declare const instanceCounts: (schema: Pick<Schema, "flat" | "components">) => Record<string, number>;

package/dist/modules/Components/helpers.test.d.ts

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

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

@@ -0,0 +1,2 @@
+export { default } from './Components';
+export { default as useOpenComponent } from './useOpenComponent';

package/dist/modules/Components/slotChoices.d.ts

@@ -0,0 +1,9 @@
+import { ComponentDefinition, Element, Schema } from '@plitzi/sdk-shared';
+/**
+ * The elements of a tree hung off `rootId` that can be a slot: those whose TYPE holds children, as its declaration
+ * says. Not the element's own `items`, which an authored document gives every element, a text included.
+ */
+export declare const slotChoicesOf: (flat: Schema["flat"], rootId: Element["id"], definitions: Record<string, ComponentDefinition>) => {
+    id: string;
+    label: string;
+}[];

package/dist/modules/Components/useOpenComponent.d.ts

@@ -0,0 +1,13 @@
+import { SpaceComponent } from '@plitzi/sdk-shared';
+/**
+ * The component open in the canvas, and the scope the builder is drawn in while it is.
+ *
+ * The scope lays the component's tree over the pages' — ids are one namespace, so every tool that finds an element by
+ * id finds the component's — and hands its props their defaults. With nothing open it is empty, and a scope with
+ * nothing of its own reads straight through to the store.
+ */
+declare const useOpenComponent: () => {
+    component?: SpaceComponent;
+    scope: Record<string, unknown>;
+};
+export default useOpenComponent;

package/dist/modules/Components/useSaveAsComponent.d.ts

@@ -0,0 +1,7 @@
+import { Element } from '@plitzi/sdk-shared';
+/**
+ * Makes a component of an element on the canvas: the element and everything inside it become the component's tree,
+ * and an instance of it takes the element's place, so the page renders what it did. Returns whether it was made.
+ */
+declare const useSaveAsComponent: () => (element: Element) => Promise<boolean>;
+export default useSaveAsComponent;

package/dist/modules/Connectors/ConnectorsContext.d.ts

@@ -3,8 +3,6 @@ export type ConnectorsContextValue = {
     connectors: Record<string, SpaceConnector>;
     isLoading: boolean;
     error: string;
-    /** True when the space has at least one deployment that can run server code, which is what resolves connectors. */
-    hasServerRendering: boolean;
     addConnector: (name: string, manifest: ConnectorManifestDraft) => Promise<SpaceConnector | undefined>;
     updateConnector: (identifier: string, name: string, manifest: ConnectorManifestDraft) => Promise<SpaceConnector | undefined>;
     removeConnector: (identifier: string) => Promise<boolean>;

package/dist/modules/Connectors/helpers/manifestDoc.d.ts

@@ -38,4 +38,3 @@ export declare const fieldDocs: {
     readonly mediaBaseUrl: "Host to prepend to relative image and file URLs the CMS returns. Only values under keys ending in url, src or href are rewritten.";
     readonly writeBodyPath: "Key to wrap the submitted values in, e.g. data. Leave empty to send them at the root.";
 };
-export declare const CONNECTOR_SERVER_ONLY_NOTE = "Connectors resolve on the server before the page reaches the browser. A space published without server rendering has no server to resolve them.";

package/dist/modules/Credentials/Credentials.d.ts

@@ -1,9 +1,2 @@
-/**
- * Manages the space's secrets in one place.
- *
- * Credentials were only reachable from the modals that consume them — a deployment form, a CDN row — so a secret
- * could not be prepared before the thing that needs it existed. A connector needs exactly that ordering: the CMS
- * token has to exist before there is a manifest to reference it from.
- */
 declare const Credentials: () => import('react').JSX.Element;
 export default Credentials;

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

@@ -4,8 +4,9 @@ import { ComponentDefinition, Element, Schema } from '@plitzi/sdk-shared';
  *  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;
+ *  concurrently, and a counter has both mint `heading-3`. Free of every tree — the pages' and each component's — since
+ *  ids are one namespace across them. */
+export declare const makeIdMinter: (schema: Pick<Schema, "flat" | "components">) => (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/Elements/hooks/useDragElement.d.ts

@@ -1,13 +1,14 @@
-import { Template } from '@plitzi/sdk-shared';
+import { Snippet } from '@plitzi/sdk-shared';
 import { DragEvent } from 'react';
 export type UseDragElementProps = {
     attributes?: Record<string, unknown>;
     type: string;
     variables?: object[];
-    manifest?: Template;
-    onParentRefresh?: (identifier: string, segment: object) => void;
+    manifest?: Snippet;
+    /** What the dropped element is called in the builder's tree, instead of its type's default label. */
+    label?: string;
 };
-declare const useDragElement: ({ attributes, type, variables, manifest }: UseDragElementProps) => {
+declare const useDragElement: ({ attributes, type, variables, manifest, label }: UseDragElementProps) => {
     onDragStart: (e: DragEvent) => void;
 };
 export default useDragElement;

package/dist/modules/Flags/Flags.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The space's feature flags: declared and ruled here, previewed in the canvas, and published on their own.
+ *
+ * Forcing one here is the canvas's `qa` layer — what the author looks at, never saved. Flags are not part of a
+ * snapshot: each environment has one set, shared by every revision it serves, and publishing them switches what the
+ * environment serves now without shipping whatever else the draft holds.
+ */
+declare const Flags: () => import('react').JSX.Element;
+export default Flags;

package/dist/modules/Flags/components/FlagForm/FlagForm.d.ts

@@ -0,0 +1,15 @@
+import { Field } from '@plitzi/plitzi-ui/QueryBuilder';
+import { SchemaFlag } from '@plitzi/sdk-shared';
+import { MouseEvent } from 'react';
+export type FlagFormProps = {
+    name?: string;
+    flag?: SchemaFlag;
+    isNewRecord?: boolean;
+    /** The names already declared, so a new flag cannot take one. */
+    takenNames?: string[];
+    fields: Record<string, Field>;
+    onSubmit: (name: string, flag: SchemaFlag) => void;
+    onClose: (e?: MouseEvent) => void;
+};
+declare const FlagForm: ({ name, flag, isNewRecord, takenNames, fields, onSubmit, onClose }: FlagFormProps) => import('react').JSX.Element;
+export default FlagForm;

package/dist/modules/Flags/components/FlagForm/FlagRule.d.ts

@@ -0,0 +1,11 @@
+import { Field } from '@plitzi/plitzi-ui/QueryBuilder';
+export type FlagRuleProps = {
+    index: number;
+    last: boolean;
+    fields: Record<string, Field>;
+    onRemove: (index: number) => void;
+    onMove: (from: number, to: number) => void;
+};
+/** One rule of a flag: the value it gives, and when. Rules are read top to bottom and the first that matches wins. */
+declare const FlagRule: ({ index, last, fields, onRemove, onMove }: FlagRuleProps) => import('react').JSX.Element;
+export default FlagRule;

package/dist/modules/Flags/components/FlagForm/index.d.ts

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

package/dist/modules/Flags/components/FlagForm/ruleGroup.d.ts

@@ -0,0 +1,5 @@
+import { RuleGroup } from '@plitzi/plitzi-ui/QueryBuilder';
+/** What a new rule starts as: no conditions yet. */
+export declare const EMPTY_WHEN: RuleGroup;
+/** A rule's `when` as the query builder edits it: `and` or `or` over a list of conditions and groups. */
+export declare const isRuleGroup: (value: unknown) => value is RuleGroup;

package/dist/modules/Flags/components/FlagForm/ruleGroup.test.d.ts

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

package/dist/modules/Flags/components/FlagItem/FlagItem.d.ts

@@ -0,0 +1,14 @@
+import { Field } from '@plitzi/plitzi-ui/QueryBuilder';
+import { FlagResolution, SchemaFlag } from '@plitzi/sdk-shared';
+export type FlagItemProps = {
+    name: string;
+    flag: SchemaFlag;
+    resolution?: FlagResolution;
+    forced?: boolean;
+    fields: Record<string, Field>;
+    onUpdate: (name: string, flag: SchemaFlag) => void;
+    onRemove: (name: string) => void;
+    onForce: (name: string, value: boolean | undefined) => void;
+};
+declare const FlagItem: ({ name, flag, resolution, forced, fields, onUpdate, onRemove, onForce }: FlagItemProps) => import('react').JSX.Element;
+export default FlagItem;

package/dist/modules/Flags/components/FlagItem/FlagPreviewOption.d.ts

@@ -0,0 +1,13 @@
+export type FlagPreviewOptionValue = {
+    label: string;
+    value: boolean | undefined;
+    title: string;
+};
+export type FlagPreviewOptionProps = {
+    name: string;
+    option: FlagPreviewOptionValue;
+    active: boolean;
+    onForce: (name: string, value: boolean | undefined) => void;
+};
+declare const FlagPreviewOption: ({ name, option, active, onForce }: FlagPreviewOptionProps) => import('react').JSX.Element;
+export default FlagPreviewOption;

package/dist/modules/Flags/components/FlagItem/FlagPreviewToggle.d.ts

@@ -0,0 +1,9 @@
+export type FlagPreviewToggleProps = {
+    name: string;
+    /** What the canvas is forced to, if anything. */
+    forced?: boolean;
+    onForce: (name: string, value: boolean | undefined) => void;
+};
+/** Forces a flag in the canvas only — what an author looks at, never what is saved or published. */
+declare const FlagPreviewToggle: ({ name, forced, onForce }: FlagPreviewToggleProps) => import('react').JSX.Element;
+export default FlagPreviewToggle;

package/dist/modules/Flags/components/FlagItem/index.d.ts

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

package/dist/modules/Flags/components/PublishFlagsForm/PublishFlagsForm.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { MouseEvent } from 'react';
+declare const publishFlagsSchema: z.ZodObject<{
+    environment: z.ZodEnum<{
+        production: "production";
+        staging: "staging";
+        development: "development";
+    }>;
+    description: z.ZodString;
+}, z.core.$strip>;
+export type PublishFlagsValues = z.infer<typeof publishFlagsSchema>;
+export type PublishFlagsFormProps = {
+    onClose?: (e?: MouseEvent) => void;
+    onSubmit?: (e: MouseEvent | undefined, values: PublishFlagsValues) => void;
+};
+/**
+ * Where the draft's flags go, and why. Not the snapshot form: flags are no part of a snapshot, and saying so is the
+ * point — an author turning a flag in production must know the half-finished page they are also editing stays.
+ */
+declare const PublishFlagsForm: ({ onClose, onSubmit }: PublishFlagsFormProps) => import('react').JSX.Element;
+export default PublishFlagsForm;

package/dist/modules/Flags/components/PublishFlagsForm/index.d.ts

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

package/dist/modules/Flags/helpers/flagRuleFields.d.ts

@@ -0,0 +1,11 @@
+import { Field } from '@plitzi/plitzi-ui/QueryBuilder';
+import { QueryParams, RouteParams } from '@plitzi/sdk-shared';
+/**
+ * What a flag's rule may be written over: everything a variable's `when` sees — the environment, the host, the URL the
+ * builder is previewing — and the visitor, whose roles are offered from the ones this space declares.
+ */
+export declare const flagRuleFields: ({ routeParams, queryParams, visitorRoles }: {
+    routeParams: RouteParams;
+    queryParams: QueryParams;
+    visitorRoles: string[];
+}) => Record<string, Field>;

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

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

package/dist/modules/Functions/Functions.d.ts

@@ -1,7 +1,8 @@
 /**
- * The space's own server code: its files, edited with TypeScript that knows the contract, saved as the draft
- * — built and checked on the platform, problems shown where they are — and tried in the sandbox. The live site runs
- * what the space was last published with. A project's `plitzi functions pull` edits the same files.
+ * The space's own server code: its tasks and routes as the code declares them — listed as it is typed — its files,
+ * edited with TypeScript that knows the contract, and the selected task's time limit and test run beside them. Saved as
+ * the draft, built and checked on the platform; the live site runs what the space was last published with. A
+ * project's `plitzi functions pull` edits the same files.
  */
 declare const Functions: () => import('react').JSX.Element;
 export default Functions;

package/dist/modules/Functions/components/FunctionInspector/FunctionInspector.d.ts

@@ -0,0 +1,20 @@
+import { ListedTask } from '../../helpers';
+import { ActionRunReport, FunctionTimeLimits } from '@plitzi/sdk-shared';
+export type FunctionInspectorProps = {
+    task: ListedTask;
+    /** What every task gets unless it asks for its own, from `defineFunctions`. */
+    sharedLimits?: FunctionTimeLimits;
+    hosts: string[];
+    /** Why its limits cannot be written for you right now — the code is still being read, say — or nothing. */
+    limitsDisabledReason: string;
+    /** The code differs from the saved draft. */
+    modified: boolean;
+    onLimitsChange: (task: ListedTask, cpuMs: number | undefined) => void;
+    onRun: (task: string, params: Record<string, unknown>) => Promise<ActionRunReport | undefined>;
+};
+/**
+ * The selected task: what it is as a step, how much CPU a run of it may use — written into its code — and a run of it
+ * in the sandbox, saving first when the code changed.
+ */
+declare const FunctionInspector: ({ task, sharedLimits, hosts, limitsDisabledReason, modified, onLimitsChange, onRun }: FunctionInspectorProps) => import('react').JSX.Element;
+export default FunctionInspector;

package/dist/modules/Functions/components/FunctionInspector/components/InspectorSection/InspectorSection.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+export type InspectorSectionProps = {
+    title: string;
+    /** One line under the title, saying what the section is for. */
+    hint?: string;
+    children: ReactNode;
+};
+/** One part of the inspector: its title, what it is for, and what it holds. */
+declare const InspectorSection: ({ title, hint, children }: InspectorSectionProps) => import('react').JSX.Element;
+export default InspectorSection;

package/dist/modules/Functions/components/FunctionInspector/components/InspectorSection/index.d.ts

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

package/dist/modules/Functions/components/FunctionInspector/components/TaskTest/TaskTest.d.ts

@@ -0,0 +1,16 @@
+import { ListedTask } from '../../../../helpers';
+import { ActionRunReport } from '@plitzi/sdk-shared';
+export type TaskTestProps = {
+    /** The task under test. The form starts again from its defaults whenever it changes: give it a `key` of it. */
+    task: ListedTask;
+    /** The code differs from the saved draft — or the task is not in it yet — so a run saves first. */
+    needsSave: boolean;
+    /** Runs it in the sandbox as you, saving first when it has to; throws why it could not. */
+    onRun: (task: string, params: Record<string, unknown>) => Promise<ActionRunReport | undefined>;
+};
+/**
+ * The task run in the sandbox as you — its params filled in as its step would fill them, or as JSON — and what it
+ * answered: the value, what it logged, how long it took and why it failed. Its fetches and its writes are real.
+ */
+declare const TaskTest: ({ task, needsSave, onRun }: TaskTestProps) => import('react').JSX.Element;
+export default TaskTest;

package/dist/modules/Functions/components/FunctionInspector/components/TaskTest/index.d.ts

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