efficient-easel 0.0.0 → 0.96.0

package/dist/types-CEqUFH2j.d.ts

@@ -0,0 +1,129 @@
+import { ReactNode } from 'react';
+import { S as SettingsBucket } from './buckets-1vRlQceY.js';
+
+/** What every control shares: an id for its label, a name for screen readers, and a read-only switch. */
+interface ControlBase {
+    id?: string;
+    readOnly?: boolean;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+}
+interface FieldTextProps extends ControlBase {
+    value: string | undefined;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    /** Several lines (a `<textarea>`); one line otherwise. */
+    multiline?: boolean;
+    rows?: number;
+}
+interface FieldNumberProps extends ControlBase {
+    value: number | undefined;
+    /** `undefined` when the box is emptied: the setting goes back to the block's own. */
+    onChange: (value: number | undefined) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Shown after the box, e.g. `px`. */
+    unit?: string;
+    /** − and + beside the box. */
+    steppers?: boolean;
+    placeholder?: string;
+}
+interface FieldOption<V = unknown> {
+    label: string;
+    value: V;
+    disabled?: boolean;
+    icon?: ReactNode;
+}
+interface FieldSelectProps<V = unknown> extends ControlBase {
+    value: V | undefined;
+    options: readonly FieldOption<V>[];
+    onChange: (value: V) => void;
+    /** Shown when the value names no option. */
+    placeholder?: string;
+}
+interface FieldMeta {
+    label?: string;
+    /** The tab this field opens; inherited by the fields after it (see above). */
+    bucket?: SettingsBucket;
+    /** Only says where a bucket starts. Draws nothing. */
+    marker?: boolean;
+    visible?: boolean;
+    /** Drawn before the label. */
+    icon?: ReactNode;
+    /** One quiet line under the control. */
+    hint?: ReactNode;
+    /** Anything else an app keeps on its fields rides along untouched. */
+    [extra: string]: unknown;
+}
+interface TextFieldDef extends FieldMeta {
+    type: 'text';
+    placeholder?: string;
+}
+interface TextareaFieldDef extends FieldMeta {
+    type: 'textarea';
+    placeholder?: string;
+}
+interface NumberFieldDef extends FieldMeta {
+    type: 'number';
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: string;
+}
+interface SelectFieldDef extends FieldMeta {
+    type: 'select';
+    options: readonly FieldOption[];
+}
+interface RadioFieldDef extends FieldMeta {
+    type: 'radio';
+    options: readonly FieldOption[];
+}
+interface ObjectFieldDef extends FieldMeta {
+    type: 'object';
+    objectFields: Record<string, InspectorFieldDef>;
+}
+interface ArrayFieldDef extends FieldMeta {
+    type: 'array';
+    arrayFields: Record<string, InspectorFieldDef>;
+    defaultItemProps?: Record<string, unknown>;
+    getItemSummary?: (item: Record<string, unknown>, index?: number) => ReactNode;
+    min?: number;
+    max?: number;
+    /** One item's word, lower case ("slide"): its rows and buttons say it. Default "item". */
+    noun?: string;
+}
+interface SlotFieldDef extends FieldMeta {
+    type: 'slot';
+}
+interface CustomFieldDef extends FieldMeta {
+    type: 'custom';
+    render: (props: CustomFieldRenderProps) => ReactNode;
+}
+type InspectorFieldDef = TextFieldDef | TextareaFieldDef | NumberFieldDef | SelectFieldDef | RadioFieldDef | ObjectFieldDef | ArrayFieldDef | SlotFieldDef | CustomFieldDef;
+type InspectorFields = Record<string, InspectorFieldDef>;
+/**
+ * What a custom render is called with: Puck's own six props, so every custom
+ * field both apps wrote keeps working unchanged, plus what the host hands in as
+ * `context` (the node, the root, the device — blueprint §3.1).
+ */
+interface CustomFieldRenderProps<V = any> {
+    field: CustomFieldDef;
+    name: string;
+    id: string;
+    value: V;
+    onChange: (value: V) => void;
+    readOnly?: boolean;
+    [context: string]: unknown;
+}
+/** A field type's own drawing, swapped in by the host (e.g. Puck's array until 4.5). */
+type FieldRenderer = (props: {
+    field: InspectorFieldDef;
+    name: string;
+    id: string;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    readOnly?: boolean;
+}) => ReactNode;
+
+export type { ArrayFieldDef as A, CustomFieldDef as C, FieldRenderer as F, InspectorFields as I, NumberFieldDef as N, ObjectFieldDef as O, RadioFieldDef as R, SelectFieldDef as S, TextFieldDef as T, InspectorFieldDef as a, FieldTextProps as b, FieldNumberProps as c, FieldSelectProps as d, FieldOption as e, CustomFieldRenderProps as f, SlotFieldDef as g, TextareaFieldDef as h };

package/dist/types-CuNiSnX6.d.ts

@@ -0,0 +1,204 @@
+import { a as EditorRailItem } from './types-DNrn_w4V.js';
+import { CSSProperties, ReactNode, Ref } from 'react';
+import { EditAccess, SaveConflict } from './edit-lock/index.js';
+
+/**
+ * The side-panel widths every editor opens on and drags between (px).
+ *
+ * Lifted from `efficient-shop/components/panel-widths.ts`, where the website
+ * editor measured them:
+ *
+ *   RIGHT is 320, not 308 (card 8810). At 308 the settings tab strip was left
+ *   269px once the inspector's 14px sides and its 11px scrollbar were off it —
+ *   one pixel under the 270 the strip's widest tier needs, so the tab words
+ *   turned into glyphs at the width every merchant opens on.
+ *
+ *   MIN_PANEL_W is load-bearing on the top bar: six 34px rail buttons are 204px,
+ *   and at 220 the rail column spreads them with nothing to spare.
+ *
+ * The campaign designer opened at 288 / 288 with a 520 ceiling until the
+ * 2026-09-17 redesign. One set of numbers now, here.
+ */
+declare const DEFAULT_PANEL_W: {
+    readonly left: 288;
+    readonly right: 320;
+};
+declare const MIN_PANEL_W = 220;
+declare const MAX_PANEL_W = 560;
+/** Which side panel a width belongs to. */
+type PanelSide = 'left' | 'right';
+type PanelWidths = {
+    left: number;
+    right: number;
+};
+/** Clamp a width into the panel band and round to a whole pixel. */
+declare function clampPanelWidth(width: number): number;
+/**
+ * The inline style that carries the widths, as `--es-left-w` / `--es-right-w`.
+ *
+ * ⚠️ PUT IT ON THE EDITOR ROOT, the nearest ancestor of EVERYTHING that reads
+ * it. The website editor learned this on 2026-09-04: the vars sat on the panel
+ * row, the top bar is that row's SIBLING, and the rail column read a width with
+ * no declaration in scope — which is not an error, it silently falls back to
+ * `auto` and the column shrinks to its buttons.
+ */
+declare function panelWidthVars(widths: PanelWidths): CSSProperties;
+
+type TopBarProps = {
+    children?: ReactNode;
+};
+type TopBarClusterProps = {
+    /**
+     * `rail`   — the LEFT column: exactly the left panel's width (`--es-left-w`),
+     *            carrying the panel's hairline up through the bar. Holds the
+     *            `EditorRail` in `orientation="row"` and nothing else.
+     * `right`  — the actions a person takes: save state, ghost buttons, the one
+     *            primary button.
+     * omitted  — the centre: undo / redo, a divider, the device switch, the panel
+     *            toggles.
+     */
+    kind?: 'rail' | 'right';
+    style?: CSSProperties;
+    children?: ReactNode;
+};
+type EditorIconButtonProps = {
+    /** Tooltip AND accessible name. An icon-only button has no other. */
+    label: string;
+    onClick?: () => void;
+    disabled?: boolean;
+    /**
+     * For a toggle (the panel toggles): `active` draws the glyph strong,
+     * `inactive` draws it in the disabled grey. Omit for a plain action.
+     */
+    state?: 'active' | 'inactive';
+    buttonRef?: Ref<HTMLButtonElement>;
+    children: ReactNode;
+};
+type DeviceOption<Id extends string = string> = {
+    id: Id;
+    /** Tooltip and accessible name — the strip itself shows only glyphs. */
+    label: string;
+    /** A 15px glyph. Decorative: the button carries the name. */
+    icon: ReactNode;
+};
+type DeviceSwitchProps<Id extends string = string> = {
+    /** The devices this editor previews, in order. The website has three; an email has two. */
+    devices: ReadonlyArray<DeviceOption<Id>>;
+    value: Id;
+    /** Asked for a different device. Never called for the current one. */
+    onChange: (next: Id) => void;
+    /** The strip's own name. Defaults to "Preview device" (`EditorStrings.chrome.device`). */
+    ariaLabel?: string;
+};
+/**
+ * What the save pill is saying.
+ *
+ *   idle        nothing changed yet — grey dot, no words
+ *   saved       a save landed — GREEN dot, no words (owner, 2026-09-09)
+ *   saving      a write is queued or going out — amber, with words
+ *   error       the last write failed — red, with words
+ *   off         autosave is paused by the person — boxed and muted
+ *   off-unsaved paused AND an edit is waiting — boxed and amber
+ */
+type SaveTone = 'idle' | 'saved' | 'saving' | 'error' | 'off' | 'off-unsaved';
+type SaveStateProps = {
+    tone: SaveTone;
+    /** The words. The editor owns them; an empty string draws the quiet dot alone. */
+    label: string;
+    /** Draw the emptying ring instead of the dot while a save waits. */
+    counting?: boolean;
+    /** How long the ring takes to empty — pass the editor's autosave debounce. */
+    waitMs?: number;
+    /**
+     * The ring node, so the host can restart the countdown on a keystroke
+     * without re-rendering (remove `is-counting`, read `offsetWidth`, add it back).
+     */
+    ringRef?: Ref<HTMLSpanElement>;
+    /** `status` where the pill is the only word on the save (a read-only view). */
+    role?: 'status';
+};
+type SaveStateToggleProps = {
+    /** True while autosave is OFF — the switch is "pressed" into the paused state. */
+    pressed: boolean;
+    title: string;
+    onToggle: () => void;
+    children: ReactNode;
+};
+type PanelResizeHandleProps = {
+    /** `left` = the left panel's right edge; `right` = the right panel's left edge. */
+    side: PanelSide;
+    width: number;
+    min: number;
+    max: number;
+    defaultWidth: number;
+    /** What this grip resizes, for a screen reader. Required: a default can only lie. */
+    label: string;
+    /** An absolute width (drag, reset) or an updater (keyboard nudge, so a burst accumulates). */
+    onResize: (width: number | ((prev: number) => number)) => void;
+};
+type InspectorHeadProps = {
+    /** A 15px glyph for the selected thing's type. */
+    icon: ReactNode;
+    /** The selected thing's name. Rendered as the panel's `h2`. */
+    name: ReactNode;
+    /** Its kind — Section, Block, Page, Email… */
+    kind: ReactNode;
+    /** `InspectorIconButton`s, right-aligned. Omit when the thing has no actions. */
+    actions?: ReactNode;
+};
+type InspectorUpLevelProps = {
+    /** What the level above is called — the section, the column, the group. */
+    name: string;
+    /** Select the level above. */
+    onSelect: () => void;
+    /** The glyph before the name. The host's own until the icon set carries one. */
+    icon?: ReactNode;
+    /**
+     * The tooltip, and the start of the accessible name ("… to ‹name›"). Default
+     * "Go up one level" (`EditorStrings.chrome.upLevel`); how the two are joined
+     * is `EditorStrings.chrome.upLevelTo`.
+     */
+    label?: string;
+};
+type InspectorIconButtonProps = {
+    /** Accessible name, and the tooltip unless `title` says something else. */
+    label: string;
+    /**
+     * A tooltip that differs from the name — the reason a disabled button is
+     * disabled ("Sections in the header cannot be duplicated"), while the name
+     * stays what the button is.
+     */
+    title?: string;
+    /** For a button that opens a menu: announced as a menu button. */
+    hasPopup?: 'menu';
+    onClick?: () => void;
+    disabled?: boolean;
+    /** Delete and the like: tints red on hover. */
+    danger?: boolean;
+    /** For a button that opens a menu: tinted while the menu is open. */
+    expanded?: boolean;
+    buttonRef?: Ref<HTMLButtonElement>;
+    children: ReactNode;
+};
+type TopBarRailProps = {
+    /** The rail's buttons (`EditorRail` items). */
+    items: EditorRailItem[];
+    /** The toolbar's own name, e.g. "Left panel views". */
+    ariaLabel?: string;
+};
+type EditNoticeProps = {
+    /** Who may write the document now (`efficient-easel/edit-lock`). */
+    access: EditAccess;
+    /** A refused save, or null. Outranks the lock. */
+    conflict: SaveConflict | null;
+    /** What the document is called in a sentence: `'email'`, `'page'` — in the host's language, as the sentences are. */
+    noun: string;
+    /** Take the document: from "someone is editing", from read-only, or back after a take-over. */
+    onTakeOver: () => void;
+    /** Look without touching. */
+    onViewReadOnly: () => void;
+    /** Throw this screen away and load what is saved — the only action that discards work. */
+    onReload: () => void;
+};
+
+export { type DeviceSwitchProps as D, type EditorIconButtonProps as E, type InspectorHeadProps as I, MAX_PANEL_W as M, type PanelResizeHandleProps as P, type SaveTone as S, type TopBarProps as T, type TopBarClusterProps as a, type TopBarRailProps as b, type SaveStateProps as c, type SaveStateToggleProps as d, type InspectorIconButtonProps as e, type InspectorUpLevelProps as f, type EditNoticeProps as g, DEFAULT_PANEL_W as h, type DeviceOption as i, MIN_PANEL_W as j, type PanelSide as k, type PanelWidths as l, clampPanelWidth as m, panelWidthVars as p };

package/dist/types-DNrn_w4V.d.ts

@@ -0,0 +1,88 @@
+import { W as WordFit } from './wordFit-9B9nqyf3.js';
+import { ReactNode } from 'react';
+
+/**
+ * One entry in the rail. A rail item is either a *view switch* (Pages, Layers,
+ * Styles, …) or an *action* (the quick-add "+"). The shape is the same for both;
+ * what tells them apart is `active`:
+ *
+ *   - a view item passes `active: true | false` → it renders as a toggle
+ *     (`aria-pressed`) and lights up when its surface is open;
+ *   - an action item omits `active` → it renders as a plain button with no
+ *     pressed state, because "Add" is a thing you *do*, not a thing you're *in*.
+ *
+ * The rail is purely presentational: it owns the LOOK, never the app state. The
+ * host decides which item is `active` and what each `onSelect` does.
+ */
+interface EditorRailItem {
+    /** Stable identity — used as the React key and to correlate selection. */
+    id: string;
+    /** Accessible name; becomes both the `aria-label` and the hover `title`. */
+    label: string;
+    /**
+     * The glyph. Pass one of the icons this package ships
+     * (`<PagesIcon />`, `<AddIcon />`, …) so every editor's rail draws the same
+     * set. Any 18×18, `currentColor`-stroked node works.
+     */
+    icon: ReactNode;
+    /** Present ⇒ this is a view toggle and this is whether its surface is open. */
+    active?: boolean;
+    /** Dim + non-interactive. */
+    disabled?: boolean;
+    /** Click handler. Skipped while `disabled`. */
+    onSelect?: () => void;
+}
+/**
+ * Which way the rail runs.
+ *
+ * `'column'` — the original, and the default: a slim fixed-width strip down the
+ * side of the editor, wearing its own card (a background, a 12px radius and a
+ * drop shadow).
+ *
+ * `'row'` — the same buttons laid left to right, with NO fixed width and NO
+ * card, so the rail can sit in the middle of a top bar that already has its own
+ * surface. It exists because the column costs a 1280px laptop 56px of preview
+ * (46px of rail plus the 10px gap) that the top bar has going spare.
+ *
+ * Only the CONTAINER changes. Button size, icon size, the gap, and the hover
+ * and active look are the same in both directions — the row re-points three
+ * existing `--es-rail-*` custom properties and touches nothing else.
+ */
+type EditorRailOrientation = 'column' | 'row';
+interface EditorRailProps {
+    /** The buttons, top to bottom, in render order (place the "+" where you want it). */
+    items: EditorRailItem[];
+    /** Names the toolbar for assistive tech. Defaults to `"Editor"` (`EditorStrings.rail.label`). */
+    ariaLabel?: string;
+    /** Extra class(es) merged onto the rail container. */
+    className?: string;
+    /**
+     * Which way the buttons run. Defaults to `'column'`, which renders exactly
+     * what every editor draws today — adding this prop changed no existing
+     * output. Pass `'row'` to lay the rail into a top bar.
+     */
+    orientation?: EditorRailOrientation;
+    /**
+     * A ROW rail's words, measured: the sum of every label's width and the widest
+     * one, in the rail's own type (`WordFit`). Given, every button carries its
+     * word in the markup and the stylesheet picks one of three states by the
+     * column's width — every word, the glyphs plus the active button's word, or
+     * glyphs only — the settings tabs' rule. The rail does not measure (it has
+     * no hooks, so a server component can render it); `TopBarRail`
+     * (efficient-easel/chrome) does, and passes this. Ignored on a column rail,
+     * which is one button wide. Omitted, the markup is exactly the icon-only rail.
+     */
+    wordFit?: WordFit;
+}
+interface EditorRailButtonProps {
+    label: string;
+    /** Put the label beside the icon, for the stylesheet to show or clip (see `EditorRail`). */
+    worded?: boolean;
+    icon: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    onSelect?: () => void;
+    className?: string;
+}
+
+export type { EditorRailButtonProps as E, EditorRailItem as a, EditorRailOrientation as b, EditorRailProps as c };

package/dist/types-DziKCwsN.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The document, and the smallest slice of a block config the data layer reads.
+ *
+ * THE DOCUMENT IS PUCK'S, BYTE FOR BYTE. Every campaign and every page already
+ * saved is a Puck 0.20 `Data` object, and the backend reads it too (campaign
+ * copy, coupon deadlines, the assistant's knowledge tool, the media and
+ * neutralization manifests). So the engine keeps that exact shape — no version
+ * key, no wrapper, no rename — and nothing saved needs to migrate when Puck goes.
+ *
+ *   { root: { props }, content: Node[], zones: {} }
+ *
+ * A node's children live INLINE in one of its props, under a field whose
+ * `type` is `"slot"`. `zones` is Puck's older DropZone store: neither editor
+ * writes it, so it is `{}` on every document, and it is kept that way on save.
+ */
+/** One block in the document. `props.id` is `<Type>-<uuid>`. */
+interface Node {
+    type: string;
+    props: NodeProps;
+    /** Puck's per-prop read-only map. Carried through untouched. */
+    readOnly?: Record<string, boolean>;
+}
+interface NodeProps {
+    id: string;
+    [key: string]: unknown;
+}
+interface RootData {
+    props: Record<string, unknown>;
+    readOnly?: Record<string, boolean>;
+    [key: string]: unknown;
+}
+interface Data {
+    root: RootData;
+    content: Node[];
+    zones?: Record<string, Node[]>;
+}
+/**
+ * Where a node sits: the parent that owns the list, the slot it is in, and its
+ * index in that list.
+ *
+ * The top-level list is `{ parentId: 'root', slot: 'default-zone' }`, and a
+ * slot is named by its PROP PATH (`col1`, `items[0].content`) — the same two
+ * halves as Puck's zone key `"<parentId>:<slot>"`, so an app that still speaks
+ * zone keys converts with `zoneKey` / `parseZoneKey`.
+ */
+interface SlotAddress {
+    parentId: string;
+    slot: string;
+}
+interface Place extends SlotAddress {
+    index: number;
+}
+/**
+ * The part of a field definition the data layer needs: which props are slots.
+ * A Puck `Field` satisfies it, so an app hands in the config it already has.
+ */
+interface FieldShape {
+    type: string;
+    objectFields?: Record<string, FieldShape>;
+    arrayFields?: Record<string, FieldShape>;
+}
+type FieldsShape = Record<string, FieldShape>;
+/**
+ * `fields` and `defaultProps` are typed as ANY OBJECT on purpose. A Puck config
+ * typed with its blocks' own props (`Config<{ Heading: HeadingProps }>`) carries
+ * `Fields<HeadingProps>` and `HeadingProps`, which no shared shape can name, and
+ * an app must be able to hand in the config it has. The data layer reads only
+ * each field's `type` (and `objectFields` / `arrayFields`), through
+ * `fieldsFrom` / `defaultsFrom` in ./slots.
+ */
+interface BlockShape {
+    fields?: object;
+    defaultProps?: object;
+}
+/**
+ * The config as the data layer sees it. A Puck `Config` satisfies it: only
+ * `components[type].fields` / `.defaultProps` and `root.fields` /
+ * `.defaultProps` are ever read. A type missing from `components` has no slots
+ * and is kept verbatim — never dropped — so content can land before its code.
+ */
+interface DataConfig {
+    root?: BlockShape;
+    components: Record<string, BlockShape | undefined>;
+}
+/** A node's slot, as found by `slotsOf`. */
+interface SlotEntry {
+    slot: string;
+    content: Node[];
+}
+interface Found {
+    node: Node;
+    place: Place;
+    /** The slots from the top-level list down to the one holding `node`. */
+    path: SlotAddress[];
+}
+interface WalkInfo {
+    place: Place;
+    path: SlotAddress[];
+    /** `null` for a top-level node. */
+    parent: Node | null;
+    /** 0 for a top-level node. */
+    depth: number;
+}
+
+export type { BlockShape as B, Data as D, Found as F, Node as N, Place as P, RootData as R, SlotAddress as S, WalkInfo as W, DataConfig as a, SlotEntry as b, FieldShape as c, FieldsShape as d, NodeProps as e };

package/dist/types-_Vayx8ov.d.ts

@@ -0,0 +1,153 @@
+import { DataInput } from './data/index.js';
+import { I as ItemSelector, N as NodeSelection } from './plan-DtNw2VuI.js';
+import { D as Data, S as SlotAddress, a as DataConfig, N as Node } from './types-DziKCwsN.js';
+
+/**
+ * The editor's UI state, in Puck's shape so the apps' `appState.ui` reads move
+ * over unchanged. `itemSelector` and `selectedSlot` are DERIVED from the
+ * selection the store holds by id; every other key is the host's own and is
+ * kept as written.
+ */
+type EditorUi = Record<string, unknown> & {
+    itemSelector: ItemSelector | null;
+    /** The selected slot (a column), when a slot rather than a node is selected. */
+    selectedSlot: SlotAddress | null;
+    /** Puck's own UI keys, which a host's chrome reads and writes (`setUi`).
+     *  They start at Puck's defaults (`DEFAULT_UI`). */
+    leftSideBarVisible: boolean;
+    rightSideBarVisible: boolean;
+    previewMode: 'edit' | 'interactive';
+    isDragging: boolean;
+};
+/** Puck's public `appState`. */
+interface AppState {
+    data: Data;
+    ui: EditorUi;
+}
+type Recordable = {
+    recordHistory?: boolean;
+};
+/** What `setData` merges in: part of the document — in this package's shape,
+ *  or in Puck's looser one (`root.props` optional), which the apps' documents
+ *  are typed as and `<Puck>` accepted. */
+type SetDataPatch = Partial<Data> | DataInput;
+/**
+ * The actions the apps dispatch today — Puck 0.20's, with Puck's meaning. Zone
+ * keys are `"<parentId>:<slot>"`; `root:default-zone` is the page's own list.
+ */
+type EditorAction = ({
+    type: 'setData';
+    data: SetDataPatch | ((prev: Data) => SetDataPatch);
+} & Recordable) | ({
+    type: 'setUi';
+    ui: Partial<EditorUi> | ((prev: EditorUi) => Partial<EditorUi>);
+} & Recordable) | ({
+    type: 'set';
+    state: Partial<AppState> | ((prev: AppState) => Partial<AppState>);
+} & Recordable) | ({
+    type: 'insert';
+    componentType: string;
+    destinationIndex: number;
+    destinationZone: string;
+    id?: string;
+} & Recordable) | ({
+    type: 'replace';
+    destinationIndex: number;
+    destinationZone: string;
+    data: Node;
+} & Recordable) | ({
+    type: 'replaceRoot';
+    root: {
+        props?: Record<string, unknown>;
+        readOnly?: Record<string, boolean>;
+    };
+} & Recordable) | ({
+    type: 'duplicate';
+    sourceIndex: number;
+    sourceZone: string;
+} & Recordable) | ({
+    type: 'reorder';
+    sourceIndex: number;
+    destinationIndex: number;
+    destinationZone: string;
+} & Recordable) | ({
+    type: 'move';
+    sourceIndex: number;
+    sourceZone: string;
+    destinationIndex: number;
+    destinationZone: string;
+} & Recordable) | ({
+    type: 'remove';
+    index: number;
+    zone: string;
+} & Recordable);
+/** What a block, the root or the whole editor allows. Puck's five. */
+interface Permissions {
+    drag: boolean;
+    duplicate: boolean;
+    delete: boolean;
+    edit: boolean;
+    insert: boolean;
+    [key: string]: boolean;
+}
+/** The config the store needs: the data layer's shape, plus each block's own
+ *  `permissions` (Puck's per-component permissions). Rendering keys are the
+ *  renderer's business and pass through untouched. */
+interface EditorConfig extends DataConfig {
+    root?: DataConfig['root'] & {
+        permissions?: Partial<Permissions>;
+    };
+    components: Record<string, (NonNullable<DataConfig['components'][string]> & {
+        permissions?: Partial<Permissions>;
+    }) | undefined>;
+}
+/** The state the store holds. The selection is BY ID. */
+interface EditorCore {
+    data: Data;
+    selection: NodeSelection;
+    /** The host's own UI keys — everything but `itemSelector` / `selectedSlot`. */
+    ui: Record<string, unknown>;
+}
+/** One undo step: the whole state, as Puck's history holds the whole app state. */
+interface HistoryEntry {
+    id: string;
+    state: AppState;
+}
+/** Puck's PUBLIC `history` (what `usePuck` hands out): `hasPast` and
+ *  `hasFuture` are booleans there, read at the state they came with. */
+interface EditorHistory {
+    back: () => void;
+    forward: () => void;
+    hasPast: boolean;
+    hasFuture: boolean;
+    histories: HistoryEntry[];
+    index: number;
+    /** Go straight to one step (Puck's `setHistoryIndex`). */
+    setHistoryIndex: (index: number) => void;
+}
+/**
+ * What `useEditor` reads — Puck's `usePuck` state, so the apps' selectors move
+ * over by renaming the hook: `appState`, `selectedItem`, `dispatch`, `config`,
+ * `history`, `getPermissions`, `getItemById`, `getSelectorForId`. Plus the
+ * selection by id (`selection`), which Puck never had.
+ */
+interface EditorView<C extends EditorConfig = EditorConfig> {
+    appState: AppState;
+    selection: NodeSelection;
+    selectedItem: Node | null;
+    config: C;
+    dispatch: (action: EditorAction) => void;
+    history: EditorHistory;
+    getPermissions: (params?: {
+        item?: Node | null;
+        type?: string;
+        root?: boolean;
+    }) => Permissions;
+    getItemById: (id: string) => Node | undefined;
+    getItemBySelector: (selector: ItemSelector) => Node | undefined;
+    /** Puck's: the node's place, its zone always named. Never throws — Puck's
+     *  did, across a data swap, which the website editor wrapped. */
+    getSelectorForId: (id: string) => Required<ItemSelector> | undefined;
+}
+
+export type { AppState as A, EditorConfig as E, HistoryEntry as H, Permissions as P, SetDataPatch as S, EditorView as a, EditorAction as b, EditorCore as c, EditorUi as d, EditorHistory as e };