pagepilot-visual-editor 1.0.29 → 1.0.33

package/dist/editor-sample/documents/blocks/helpers/block-wrappers/saveAsTemplateUtils.d.ts

@@ -33,14 +33,16 @@ export type BlockTemplateConfiguration = {
  * type's own child-id layout) into a flat `{ id: block }` map.
  */
 export declare function collectBlockSubtree(document: BlockMap, rootBlockId: string): BlockMap;
+export declare function extractFormFieldsFromBlocks(blocks: BlockMap, rootBlockId: string): FormField[];
 /**
- * Parse `{{tokens}}` out of a block subtree's text and return field DEFINITIONS:
- *   - `{{#each id}}…{{this.sub}}…{{/each}}` → an array field with row sub-fields
- *   - `{{this.sub}}` (no explicit #each) → a synthetic `items` array field bound
- *     to `rootBlockId` (container-repeat)
- *   - `{{id}}` → a scalar text field
+ * Scalar `{{id}}` tokens present in the live document that have no matching
+ * root form field yet — returned as ready-to-append field objects. Lets the
+ * Variables panel surface a freshly-typed token immediately instead of only
+ * after "Save as template" runs `extractFormFieldsFromBlocks`.
+ * Repeat (array) fields are never auto-created here; they come from the
+ * explicit repeatable-container flow.
  */
-export declare function extractFormFieldsFromBlocks(blocks: BlockMap, rootBlockId: string): FormField[];
+export declare function detectMissingScalarFields(document: BlockMap, forms: FormField[]): FormField[];
 /**
  * Convert one live root field into an authoring field for the template dialog.
  * Only the DEFINITION is kept (id, name, type, itemFields, target blocks);
@@ -75,8 +77,15 @@ export declare function toAuthoringField(field: FormField, blockIds: Set<string>
  * templates, where any authored scalar is fair game) and for
  * `derivePageInitialFormFields` (which has no document to scan and passes
  * `detectedFields=[]`).
+ *
+ * `canvasDocument`/`canvasRootId` (opt-in) — when both are supplied, the
+ * merged result is sorted to match canvas top-to-bottom order (the same
+ * order the Variables panel displays), so a newly-detected field lands
+ * between the fields around it instead of always at the end. Omitted by the
+ * one caller with no live document to rank against, in which case the
+ * merged order is returned unchanged (today's behavior).
  */
-export declare function buildTemplateFormFields(rootFormFields: FormField[], detectedFields: FormField[], blockIds: Set<string>, prefillDefaults?: boolean, scopeScalarsToDetected?: boolean): FormField[];
+export declare function buildTemplateFormFields(rootFormFields: FormField[], detectedFields: FormField[], blockIds: Set<string>, prefillDefaults?: boolean, scopeScalarsToDetected?: boolean, canvasDocument?: BlockMap, canvasRootId?: string): FormField[];
 /** Pull color / font-size out of value HTML (`<font color>` or `style="font-size"`). */
 export declare function extractInlineStyle(html: string): {
     color?: string;
@@ -105,6 +114,27 @@ export declare function enrichTokenBlockStyleFromValue(block: AnyBlock, fields:
  *                        this false so authored templates stay default-empty.
  */
 export declare function buildBlockTemplateConfiguration(document: BlockMap, rootBlockId: string, liveFormFields: FormField[], prefillDefaults?: boolean): BlockTemplateConfiguration;
+/**
+ * Inverse of `buildBlockTemplateConfiguration`: wraps a saved block template's
+ * `{ isIndividualBlock, rootBlockId, blocks }` into a normal editable document
+ * (`{ root: EmailLayout, ...blocks }`) so the block can be opened on the
+ * regular canvas for editing, the same way a page document is.
+ *
+ * Used when editing an existing "block" type template — without this, the
+ * editor's document-loading effect (which requires `doc.root` to exist) has
+ * nothing to load and falls back to a blank canvas.
+ */
+export declare function wrapBlockConfigurationAsDocument(configuration: BlockTemplateConfiguration): BlockMap;
+/**
+ * Inverse of `wrapBlockConfigurationAsDocument`: given a document that was
+ * loaded via that wrapper and then edited on the canvas, collect the (single)
+ * root child's subtree back into the `isIndividualBlock` save shape.
+ *
+ * `formFields` are carried over as-is (not re-derived) so authored field
+ * definitions (custom names/types/defaults) aren't clobbered by a blind
+ * token re-detection on every save.
+ */
+export declare function unwrapDocumentToBlockConfiguration(document: BlockMap, formFields: FormField[]): BlockTemplateConfiguration | null;
 /**
  * True when the configuration has authored `formFields` embedded on one of its
  * document roots — meaning the record was already saved with the new

package/dist/editor-sample/documents/blocks/helpers/documentUtils.d.ts

@@ -36,6 +36,13 @@ export declare const addRepeatRow: (documentTree: Record<string, any>, sourceBlo
  * arrays. Used to delete a repeat row's cloned container subtree.
  */
 export declare function removeSubtree(documentTree: Record<string, any>, idsToRemove: Set<string>): Record<string, any>;
+/**
+ * removeSubtree for deleted repeat rows. Tabs are the exception to the
+ * "slot stays" rule: each repeat row owns a whole tab (label + panel), so
+ * deleting the row must drop the tab item itself — otherwise a blank-panel tab
+ * with a stale label is left behind. At least one tab is always kept.
+ */
+export declare function removeRepeatRowSubtrees(documentTree: Record<string, any>, cloneRootIds: string[], idsToRemove: Set<string>): Record<string, any>;
 export type RepeatableSlot = {
     childrenIds: string[];
 };
@@ -69,14 +76,24 @@ export type ItemsArrayInfo = {
 };
 /** True if the block's repeatable content is a flat `props.items` array (no child blocks). */
 export declare function isItemsArrayBlockType(type: string | undefined): boolean;
+/** The `data.props` key an items-array block keeps its items under. */
+export declare function getItemsArrayPropKey(type: string | undefined): string;
+/** A block's current items array (empty when missing). */
+export declare function readItemsArray(block: any): Record<string, any>[];
+type ItemSubField = {
+    id: string;
+    mapsTo?: string;
+};
+/** Items → field rows: row keys are sub-field ids, read from each sub's `mapsTo` item key. */
+export declare function itemsToRows(items: Record<string, any>[], itemFields: ItemSubField[] | null | undefined): Record<string, string>[];
+/** Field rows → items: writes each row value onto its sub's `mapsTo` key, keeping other item keys. */
+export declare function rowsToItems(rows: Record<string, any>[], existingItems: Record<string, any>[], itemFields: ItemSubField[] | null | undefined): Record<string, any>[];
 /**
  * Describe an items-array block's current items. Returns null when the block
  * isn't a supported items-array type. Used by the Variables tab to decide
  * whether to show the items data-source controls for the selected block.
  */
 export declare function getItemsArrayInfo(documentTree: Record<string, any>, blockId: string): ItemsArrayInfo | null;
-/** Write an items-array block's `items` back onto the block. */
-export declare function writeItemsArray(block: any, items: Record<string, any>[]): any;
 export type VariableGroupKind = 'container' | 'itemsArray' | 'block' | 'page';
 export type VariableGroup = {
     /** Stable identity for selection — the owning block id, or `page` for page-level. */
@@ -97,45 +114,52 @@ export type VariableGroup = {
      */
     fieldNames: string[];
     /**
-     * True when the block is a repeatable container the author has NOT set up
-     * yet — no field, no Repeat toggle, no row tokens. It owns nothing to edit,
+     * True when the block is a repeatable container that owns no variables —
+     * no field and no row tokens (the Repeat toggle alone doesn't count). It owns nothing to edit,
      * but its Repeat toggle is only reachable from its own screen, so it is
      * listed separately rather than dropped. See `isVariableBoundBlock`.
      */
     isCandidate?: boolean;
 };
+export declare function getFieldOwnerBlockId(documentTree: Record<string, any>, field: {
+    id?: string;
+    containerId?: string;
+    sourceBlockId?: string;
+    itemsBlockId?: string;
+}): string | null;
 /**
- * The block a field belongs to, or null when the field is page-level.
- *
- * `sourceBlockId` points at the template block sitting INSIDE a container slot,
- * not at the container itself — and in practice `containerId` is usually absent
- * (the repeat flow only ever writes `sourceBlockId`). So a source block is
- * walked UP to its owning repeatable container: that container is what the user
- * thinks of as "the group", and grouping by the raw `sourceBlockId` would both
- * split one grid into a row per slot and fail every `getRepeatableContainerInfo`
- * lookup downstream.
- *
- * A source block with no repeatable ancestor is a plain (non-repeatable) block
- * with variables — it stays its own group, keyed on itself.
+ * The block a field's `{{token}}` actually renders on — unlike
+ * `getFieldOwnerBlockId`, this resolves a plain scalar field (no explicit
+ * containerId/sourceBlockId/itemsBlockId) to the real block referencing its
+ * token instead of `null`. Used for canvas locate/highlight and row
+ * ordering, where the panel needs the field's true position even though it
+ * groups under the shared "General variables" bucket.
  */
-export declare function getFieldOwnerBlockId(documentTree: Record<string, any>, field: {
+export declare function getFieldCanvasBlockId(documentTree: Record<string, any>, field: {
+    id?: string;
     containerId?: string;
     sourceBlockId?: string;
     itemsBlockId?: string;
 }): string | null;
 /**
- * Cheap structural fingerprint of everything `collectVariableGroups` actually
- * reads: each block's `type` + every child-id array (the `collectSubtreeIds`
- * walk) + the slot-count props Grid/Pagination use, plus each field's owner ids
- * / name / type. Text edits, colour/style tweaks, `data.style`, block `props`
- * that aren't structural — none of it moves this string. Memo the group list on
- * this instead of the whole `document` so ~90% of editor keystrokes skip the
- * full tree re-scan.
- *
- * Must list the SAME shapes `collectSubtreeIds` + `readContainerSlots` walk —
- * if a new container child-array is added there, mirror it here or the list can
- * go stale until an unrelated structural edit flushes it.
+ * Where a field's row should sort within an opened Variables-panel group, so
+ * rows read in the same top-to-bottom order as their tokens appear on the
+ * canvas instead of whatever order `formFields` happens to be authored in.
+ * `blockIndex` is the owner block's position in `collectSubtreeIds` (canvas
+ * order); `tokenIndex` breaks ties between multiple tokens on the same block
+ * (e.g. a Button's `text` vs `url`) using their first-appearance order from
+ * `getBlockScalarTokenIds`. Unresolvable fields rank last via `Infinity`
+ * rather than throwing off the whole group's order.
  */
+export declare function getFieldCanvasRank(documentTree: Record<string, any>, field: {
+    id?: string;
+    containerId?: string;
+    sourceBlockId?: string;
+    itemsBlockId?: string;
+}): {
+    blockIndex: number;
+    tokenIndex: number;
+};
 export declare function variableGroupsStructuralKey(documentTree: Record<string, any>, fields: Array<{
     id?: string;
     name?: string;
@@ -153,6 +177,8 @@ export declare function collectVariableGroups(documentTree: Record<string, any>,
     sourceBlockId?: string;
     itemsBlockId?: string;
 }>): VariableGroup[];
+/** Write an items-array block's `items` back onto the block. */
+export declare function writeItemsArray(block: any, items: Record<string, any>[]): any;
 /**
  * Grow a repeatable container so it has at least `neededSlots` cells/columns/slides.
  *
@@ -307,3 +333,4 @@ export declare function sanitizeAgainstKnownTypes(doc: Record<string, any>, know
     removedTypes: string[];
     changed: boolean;
 };
+export {};

package/dist/editor-sample/documents/blocks/helpers/responsiveStyle.d.ts

@@ -31,7 +31,7 @@ export declare const RESPONSIVE_PROP_KEYS: readonly ["contentAlignment", "horizo
  * {@link nativeKeysForBlock} to get the right set for a block type — never test
  * against this flat list directly.
  */
-export declare const NATIVE_DEVICE_PROP_KEYS: readonly ["columnsCount", "columnsCountTablet", "columnsCountMobile", "rowsCount", "rowsCountTablet", "rowsCountMobile", "columnsGap", "columnsGapTablet", "columnsGapMobile", "rowsGap", "desktopLayout", "tabletLayout", "mobileLayout", "columnShrink", "columnShrinkTablet", "columnShrinkMobile", "columnsDirection", "columnsDirectionTablet", "columnsDirectionMobile", "widthType", "widthTypeTablet", "widthTypeMobile", "size", "sizeTablet", "sizeMobile", "fixedWidths", "fixedWidthsTablet", "fixedWidthsMobile", "contentAlignmentTablet", "contentAlignmentMobile", "slidesPerView", "slidesPerViewTablet", "slidesPerViewMobile", "width", "widthTablet", "widthMobile", "widthUnit", "widthUnitTablet", "widthUnitMobile", "height", "heightTablet", "heightMobile", "url", "urlTablet", "urlMobile", "iconName", "iconNameTablet", "iconNameMobile", "iconFillColor", "iconFillColorTablet", "iconFillColorMobile", "enableScroll", "enableScrollTablet", "enableScrollMobile", "orientation", "orientationTablet", "orientationMobile", "dropdown", "dropdownTablet", "dropdownMobile", "direction", "directionTablet", "directionMobile", "gapTablet", "gapMobile", "alignmentTablet", "alignmentMobile", "rotation", "rotationTablet", "rotationMobile", "burgerDropdownBackgroundColor", "stickyNavTablet", "stickyNavMobile"];
+export declare const NATIVE_DEVICE_PROP_KEYS: readonly ["columnsCount", "columnsCountTablet", "columnsCountMobile", "rowsCount", "rowsCountTablet", "rowsCountMobile", "columnsGap", "columnsGapTablet", "columnsGapMobile", "rowsGap", "desktopLayout", "tabletLayout", "mobileLayout", "columnShrink", "columnShrinkTablet", "columnShrinkMobile", "columnSpan", "columnSpanTablet", "columnSpanMobile", "columnsDirection", "columnsDirectionTablet", "columnsDirectionMobile", "widthType", "widthTypeTablet", "widthTypeMobile", "size", "sizeTablet", "sizeMobile", "fixedWidths", "fixedWidthsTablet", "fixedWidthsMobile", "contentAlignmentTablet", "contentAlignmentMobile", "slidesPerView", "slidesPerViewTablet", "slidesPerViewMobile", "width", "widthTablet", "widthMobile", "widthUnit", "widthUnitTablet", "widthUnitMobile", "height", "heightTablet", "heightMobile", "url", "urlTablet", "urlMobile", "iconName", "iconNameTablet", "iconNameMobile", "iconFillColor", "iconFillColorTablet", "iconFillColorMobile", "enableScroll", "enableScrollTablet", "enableScrollMobile", "orientation", "orientationTablet", "orientationMobile", "dropdown", "dropdownTablet", "dropdownMobile", "direction", "directionTablet", "directionMobile", "gapTablet", "gapMobile", "alignmentTablet", "alignmentMobile", "rotation", "rotationTablet", "rotationMobile", "burgerDropdownBackgroundColor", "stickyNavTablet", "stickyNavMobile"];
 /**
  * The native per-device prop keys that apply to `blockType`. Unambiguous keys
  * are always native; ambiguous ones only for the block types that actually

package/dist/editor-sample/documents/blocks/helpers/variableBinding.d.ts

@@ -1,5 +1,12 @@
+/**
+ * Scalar variable ids (`TemplateFormField.id`) referenced directly on this
+ * block's own props — the token shown by the tune menu's "highlight
+ * variable" icon. Distinct from `subtreeHasRowTokens`, which looks for
+ * `{{this.field}}` row tokens inside a repeatable container's subtree.
+ */
+export declare function getBlockScalarTokenIds(block: any): string[];
+/** Every token-bearing string on a single block. */
+export declare function blockTokenStrings(block: any): string[];
 export declare function subtreeHasRowTokens(documentTree: Record<string, any>, rootId: string): boolean;
-/** True if the author has switched the block's Repeat toggle on. */
-export declare function hasRepeatEnabled(block: any): boolean;
 export declare function isVariableBoundBlock(documentTree: Record<string, any>, blockId: string, fieldOwnerIds: Set<string>): boolean;
 export declare function classifyVariableBlock(documentTree: Record<string, any>, blockId: string, fieldOwnerIds: Set<string>): 'bound' | 'candidate' | 'none';

package/dist/editor-sample/documents/editor/EditorBlock.d.ts

@@ -4,13 +4,9 @@ type EditorBlockProps = {
     id: string;
 };
 /**
- * Loads a single block by id from the editor store and renders it. Subscribes
- * only to that block, so sibling edits don't re-render this subtree — the
- * per-block reference stays stable across setDocument calls that didn't
- * change this block (see _shallowBlockEqual in EditorContext).
  *
- * Memoized by id — React.memo + a stable id prop skips unchanged subtrees
- * entirely during diff.
+ * @param id - Block id
+ * @returns EditorBlock component that loads data from the EditorDocumentContext
  */
 declare function EditorBlock({ id }: EditorBlockProps): import("react/jsx-runtime").JSX.Element;
 declare const _default: React.MemoExoticComponent<typeof EditorBlock>;

package/dist/editor-sample/documents/editor/EditorContext.d.ts

@@ -1,20 +1,19 @@
 import { PageTypes } from '../../App/hooks/constants';
 import { TEditorConfiguration } from './core';
 import { TemplateFormField, TemplateArrayRow } from './templateVariables';
+export type PreviewHostTheme = 'light' | 'dark' | 'follow';
 type TValue = {
     document: TEditorConfiguration;
+    record: any | null;
     selectedBlockId: string | null;
     selectedSidebarTab: 'block-configuration' | 'styles' | 'behaviour' | 'layout' | 'settings' | 'background' | 'page-pilot-ai' | 'layers' | 'brand' | 'seo' | 'variables' | 'research';
     selectedMainTab: 'editor' | 'preview' | 'json' | 'html';
     selectedScreenSize: 'desktop' | 'mobile' | 'tablet';
+    previewHostTheme: PreviewHostTheme;
     zoomLevel: number;
     minimapVisible: boolean;
-    /**
-     * Which device the responsive sidebar tabs are currently authoring
-     * for. Independent of `selectedScreenSize` (the top-toolbar preview
-     * device) — flipping this must NOT resize the canvas.
-     */
     sidebarEditingDevice: 'desktop' | 'mobile' | 'tablet';
+    hasManualScreenSizeOverride: boolean;
     inspectorDrawerOpen: boolean;
     samplesDrawerOpen: boolean;
     activeStepIndex: number;
@@ -41,6 +40,7 @@ type TValue = {
     };
     inlineEditingEnabled: boolean;
     hoveredBlockId: string | null;
+    highlightedVariableId: string | null;
     copiedBlock: {
         rootBlockId: string;
         blocks: Record<string, any>;
@@ -98,13 +98,26 @@ export declare function useDocumentPruned(): TEditorConfiguration;
  * whenever a component only needs one block's data.
  */
 export declare function useEditorBlock(id: string): any;
+/**
+ * Subscribe to just the root block, for the id-not-found fallback path.
+ * Narrower than useDocument() — re-renders only when 'root' itself changes.
+ */
+export declare function useRootBlock(): any;
 /**
  * Non-reactive read of the current document. Use inside event handlers / callbacks
  * when you need the latest document but do NOT want the component to re-render
  * every time any block in the document changes.
  */
 export declare function getDocument(): TValue['document'];
-export declare function useRootFontFamily(): string;
+/**
+ * The page root's own font key, or null when the author never picked one.
+ *
+ * Deliberately does NOT resolve the workspace brand default here: this module
+ * is imported by nearly every editor component, and reaching into the redux
+ * store from it would create an import cycle. Callers pass the result through
+ * `resolveRootFontFamily` instead.
+ */
+export declare function useRootFontFamilyKey(): string | null;
 export declare function useSelectedBlockId(): string;
 /**
  * Boolean selector — returns true only when THIS block is the selected one.
@@ -112,7 +125,11 @@ export declare function useSelectedBlockId(): string;
  * re-renders A and B, not every other block on the canvas.
  */
 export declare function useIsBlockSelected(id: string): boolean;
+export declare function usePreviewHostTheme(): PreviewHostTheme;
+export declare function setPreviewHostTheme(previewHostTheme: PreviewHostTheme): void;
 export declare function useSelectedScreenSize(): "desktop" | "tablet" | "mobile";
+export declare const ZOOM_MIN = 25;
+export declare const ZOOM_MAX = 100;
 export declare function useZoomLevel(): number;
 /**
  * View-only state — deliberately does NOT go through pushToUndoStack, so
@@ -126,7 +143,6 @@ export declare function useMinimapVisible(): boolean;
 export declare function toggleMinimapVisible(): void;
 /** Which device's properties the sidebar is currently editing (see ResponsiveDeviceTabs). */
 export declare function useSidebarEditingDevice(): "desktop" | "tablet" | "mobile";
-export declare function setSidebarEditingDevice(sidebarEditingDevice: TValue['sidebarEditingDevice']): void;
 export declare function useSelectedMainTab(): "html" | "editor" | "preview" | "json";
 export declare function useActiveStepIndex(): number;
 export declare function useSelectors(): string[];
@@ -141,6 +157,7 @@ export declare function usePanelMeasurements(): {
     offsetTop?: number;
 };
 export declare function useCurrentRecordType(): string;
+export declare function setCurrentRecord(record: any | null): void;
 export declare function setCurrentRecordType(type: string | null): void;
 export declare function setPanelMeasurements(measurements: {
     panelWidth: number;
@@ -181,6 +198,12 @@ export declare function useInlineEditing(): {
     blockId: string | null;
     draft: string;
 };
+/**
+ * Boolean selector — true only while THIS block is the one being inline-edited.
+ * Prefer over useInlineEditing() in per-block components so starting/stopping
+ * an edit doesn't re-render every Text/Heading/Button on the canvas.
+ */
+export declare function useIsBlockInlineEditing(id: string): boolean;
 export declare function useHoveredBlockId(): string;
 /**
  * Boolean selector — returns true only when THIS block is the hovered one.
@@ -188,6 +211,8 @@ export declare function useHoveredBlockId(): string;
  */
 export declare function useIsBlockHovered(id: string): boolean;
 export declare function setHoveredBlockId(hoveredBlockId: string | null): void;
+export declare function useHighlightedVariableId(): string;
+export declare function setHighlightedVariableId(highlightedVariableId: string | null): void;
 export declare function getHoveredBlockId(): string | null;
 export declare function useCopiedBlock(): {
     rootBlockId: string;
@@ -231,23 +256,16 @@ export declare function resetDocument(document: TValue['document'], options?: {
     sideEffect?: UndoSideEffect;
     activeStepIndex?: number;
     /**
-     * Skip the undo-stack push *and* wipe both stacks. Use when seeding the
-     * editor from external state (host record on mount, hot reload, etc.) —
-     * the swap isn't a user action and the previous empty doc shouldn't
-     * become an Undo target. Without this, the Undo button is already
-     * enabled the moment the editor mounts because pushToUndoStack records
-     * the pre-seed empty state.
+     * pagepilot: skip the undo-stack push *and* wipe both stacks. Used by the
+     * Shell when seeding the editor from host props (not a user action), so
+     * the pre-seed empty doc never becomes an Undo target.
      */
     skipHistory?: boolean;
 }): void;
 /**
- * Wipe both history stacks without touching the document. Used by the Shell
- * after the initial seed has settled, to swallow any spurious pushes that
- * various block-level useEffects (ButtonGroup auto-seed, layout positioning
- * re-measure, sidebar panels echoing fetched data, etc.) emit between
- * "editor mounted" and "user has actually edited something". Without this
- * guard the Undo button is enabled on first paint and clicking it rolls
- * the canvas back to an empty document.
+ * pagepilot: wipe both history stacks without touching the document. Used by
+ * the Shell after the initial props-driven seed settles, to swallow spurious
+ * pushes from block-level effects before the user has edited anything.
  */
 export declare function clearEditorHistory(): void;
 export declare function resetDocumentKeepTab(document: TValue['document'], options?: {
@@ -263,6 +281,29 @@ export declare function resetDocumentKeepTab(document: TValue['document'], optio
  * the 200ms burst window with neighbouring words.
  */
 export declare function resetCoalesce(): void;
+/**
+ * Run a batch of setDocument / setTemplateForms calls as a SINGLE undoable
+ * step. Any entries the batch pushes onto undoStack are collapsed to one
+ * entry whose snapshot is the pre-batch state — so a single Ctrl+Z rewinds
+ * the whole logical action.
+ *
+ * Motivation: the "insert a section-library template" flow calls
+ *   1. `setDocument(newBlocks)`     — seed descendant blocks
+ *   2. `onInsert(rootBlock, id)`     — parent's handleChildrenChange writes
+ *      the root into its childrenIds AND calls `setSelectedBlockId` (which
+ *      resetCoalesces)
+ *   3. `appendTemplateFormFields`    — setDocument for root.data.formFields
+ *
+ * Step 2's `setSelectedBlockId` closes the coalesce window, so step 3 lands
+ * on its own undo entry. Users then need TWO Undos to remove the section,
+ * and after one Undo the section is still wired into the tree but its
+ * `{{tokens}}` render as "Add X" pills because formFields hasn't been
+ * restored yet.
+ *
+ * Any code path that combines several setDocument mutations into one
+ * user-visible action should wrap them here.
+ */
+export declare function withSingleUndoStep(action: () => void): void;
 export declare function undo(): void;
 export declare function redo(): void;
 /**
@@ -328,6 +369,15 @@ export declare function setDocument(document: TValue['document'], options?: SetD
 export declare function toggleInspectorDrawerOpen(): void;
 export declare function toggleSamplesDrawerOpen(): void;
 export declare function setSelectedScreenSize(selectedScreenSize: TValue['selectedScreenSize']): void;
+export declare function resetSelectedScreenSizeFromRecord(selectedScreenSize: TValue['selectedScreenSize']): void;
+export declare function useHasManualScreenSizeOverride(): boolean;
+export declare function resetManualScreenSizeOverride(): void;
+/**
+ * Switch which device's properties the sidebar edits. Deliberately separate
+ * from `setSelectedScreenSize` — this must NEVER resize the canvas preview;
+ * only the top toolbar's device toggle does that.
+ */
+export declare function setSidebarEditingDevice(sidebarEditingDevice: TValue['sidebarEditingDevice']): void;
 /** Reactive view of the template fields on root.data.formFields. */
 export declare function useTemplateForms(): TemplateFormField[];
 /** Non-reactive read for use inside event handlers / the save transform. */
@@ -337,8 +387,25 @@ export declare function getTemplateFormsState(): TemplateFormField[];
  * field (array field with a `sourceBlockId`). Recomputed when the document
  * changes. The canvas render path uses it to substitute a repeated container
  * copy's `{{this.subField}}` tokens with that copy's row values.
+ *
+ * Prefer `useRepeatRowForBlock(blockId)` in per-block components — this whole-
+ * map subscription re-renders on every document change and should only be used
+ * by callers that need the full map (ContainerRepeatSection, ItemsArrayRepeatSection,
+ * TabsBlockEditor's per-tab lookup).
  */
 export declare function useRepeatRowIndex(): Map<string, TemplateArrayRow>;
+/**
+ * Reactive per-block row lookup — the row (if any) that `blockId` currently
+ * belongs to inside a container-repeat copy. Unlike `useRepeatRowIndex()`, this
+ * subscribes to a single Map entry: zustand's `Object.is` equality check means
+ * the component only re-renders when ITS OWN row reference changes (row values
+ * come from `formFields[i].value[j]` and keep referential identity across
+ * unrelated edits), not on every keystroke anywhere in the document.
+ *
+ * This is what per-block components (Text/Heading/Button/Image/Avatar/Logo/
+ * Rating/Progress/Breadcrumb) should call — never a whole-document selector.
+ */
+export declare function useRepeatRowForBlock(blockId: string): TemplateArrayRow | null;
 /** Write the template-fields onto the document root (undoable, live). */
 export declare function setTemplateForms(fields: TemplateFormField[]): void;
 export declare function useElementIdError(): {

package/dist/editor-sample/documents/editor/LazyEditorBlock.d.ts

@@ -1,6 +1,7 @@
 type Props = {
     id: string;
 };
+export declare const blockHeightCache: Map<string, number>;
 /**
  * Virtualized wrapper around <EditorBlock>. While the placeholder div is
  * outside the viewport (plus a 600px margin), the real EditorBlock is NOT