pagepilot-visual-editor 1.0.33 → 1.0.34

package/CHANGELOG.md

@@ -7,6 +7,25 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [Unreleased]
 
 ### Changed
+- Re-synced the vendored editor with ahd-fe `plugin-integration` (2aa96315d),
+  covering everything since the 67f2b933 sync. Upstream behaviour pulled in
+  includes:
+  - "Change design" in the block tune menu: swap a template section for
+    another design, carrying content over (`sectionScope`,
+    `changeSectionDesign`, `ChangeDesignFlow`, compare dialog + variables pane).
+  - "Edit variable" dialog: rename a `{{token}}` across the page or convert it
+    back to plain text, from the Variables tab, bound inputs or the canvas.
+  - MenuPicker: sub-menu text color / font size / font weight, header /
+    footer / navigation labels, page-link picker for site pages.
+  - Layers panel: section category in labels, copy/paste whole page buttons
+    disabled when there's nothing to copy/paste.
+  - Add-block keeps preassigned IDs, "Edit Content" in the add menu, Section
+    Library "View all" / "All sections", Video / Rating / Progress token fields.
+  - Inline text caret is restored correctly on undo/redo.
+- Host stubs: `modules/content/view/contentViewSelectors` (no record),
+  trimmed `view/page/form/dialog/PageVariablesPreview`, full
+  `view/template/form/fields/types` + `renameFieldTokens`; i18n defaults
+  regenerated with the new keys.
 - Re-synced the vendored editor with ahd-fe `master` (9661ba36b), on top of
   the 82ec6ec4b sync below. Upstream behaviour pulled in includes:
   - Host-application theme support (theme slots, surface lock, dark-host

package/dist/editor-sample/App/InspectorDrawer/ConfigurationPanel/input-panels/helpers/inputs/VariableLinkHint.d.ts

@@ -1,4 +1,16 @@
 import { default as React } from 'react';
+/** Inline "Edit variable" link — rename the token(s) behind `value` or convert them to text. */
+export declare function EditVariableLink({ value }: {
+    value: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Compact pencil (fits inside a locked input's end adornment) opening "Edit
+ * variable". Opts back into pointer events — VariableBoundClickArea switches
+ * them off on the input — and stops the click reaching that wrapper.
+ */
+export declare function EditVariableIcon({ value }: {
+    value: string;
+}): import("react/jsx-runtime").JSX.Element;
 /**
  * Wraps a locked, variable-bound input so clicking anywhere on it jumps to the
  * Variables tab (a disabled input swallows clicks itself, so its own pointer

package/dist/editor-sample/App/InspectorDrawer/LayoutPanel/ChangeDesignFlow.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+/**
+ * "Change design" for one section: pick a block template (the library opens
+ * on the section's category), review the section before/after, then swap it
+ * in place keeping the section's content. See changeSectionDesign.
+ */
+declare const ChangeDesignFlow: React.FC<{
+    blockId: string;
+    open: boolean;
+    onClose: () => void;
+}>;
+export default ChangeDesignFlow;

package/dist/editor-sample/App/InspectorDrawer/LayoutPanel/ChangeTemplateCompareDialog.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { FieldPatches } from './templateHelpers';
+interface ChangeTemplateCompareDialogProps {
+    open: boolean;
+    templateId?: string;
+    before: any;
+    after: any;
+    loading?: boolean;
+    onConfirm: (fieldPatches?: FieldPatches) => void;
+    onClose: () => void;
+    title?: string;
+    description?: string;
+    confirmLabel?: string;
+    notes?: string[];
+}
+/**
+ * "Change template" confirm: the current page on the left, the page as it
+ * will look after the change on the right — either rendered, or as each
+ * side's variables. The right side's variable values can be edited; the
+ * edits ride along with the confirm.
+ */
+declare const ChangeTemplateCompareDialog: React.FC<ChangeTemplateCompareDialogProps>;
+export default ChangeTemplateCompareDialog;

package/dist/editor-sample/App/InspectorDrawer/LayoutPanel/ChangeTemplateVariablesPane.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { TemplateFormField } from '../../../documents/editor/templateVariables';
+/**
+ * A page's variables (`root.data.formFields`), grouped the way the editor's
+ * Variables tab groups them. The "Change template" compare shows one per
+ * side, so the user sees which values the new template keeps; with
+ * `onPatch` the values can be edited before the change is applied, without
+ * it the same fields render disabled.
+ */
+declare const ChangeTemplateVariablesPane: React.FC<{
+    document: any;
+    onPatch?: (fieldId: string, patch: Partial<TemplateFormField>) => void;
+}>;
+export default ChangeTemplateVariablesPane;

package/dist/editor-sample/App/InspectorDrawer/LayoutPanel/SectionsModal.d.ts

@@ -2,6 +2,11 @@ interface SectionsModalProps {
     open: boolean;
     onClose: () => void;
     onInsert?: (block: any, preassignedId?: string) => void;
+    /** Category tab to open on (falls back to "Overall" when it has no templates). */
+    initialCategory?: string;
+    /** Pick mode ("Change design"): hand the fetched template back instead of inserting it. */
+    onPick?: (record: any) => void;
+    title?: string;
 }
 declare const SectionsModal: React.FC<SectionsModalProps>;
 export default SectionsModal;

package/dist/editor-sample/App/InspectorDrawer/LayoutPanel/templateCategory.d.ts

@@ -0,0 +1 @@
+export declare function humanizeCategory(category: string): string;

package/dist/editor-sample/App/InspectorDrawer/LayoutPanel/templateHelpers.d.ts

@@ -79,32 +79,12 @@ export declare function mergeTemplateFormFields(templateRecord: any, idMapping?:
     [oldId: string]: string;
 }): void;
 /**
- * Merge incoming formFields into the existing ones. Used by "Add this section"
- * so adding Template B that shares {{name}} with Template A keeps the typed
- * value and only appends B's new fields. Then jumps to Variables.
- *
- * Two dedupe rules — different because these fields mean different things:
- *
- *  - Scalar / plain-array fields are dedupe'd by `id`. A page-level `{{name}}`
- *    is a single slot; inserting Template B that also references `{{name}}`
- *    should reuse Template A's (possibly user-filled) value, not stomp it.
- *
- *  - Container-repeat fields (`type === 'array' && sourceBlockId`) are dedupe'd
- *    by `sourceBlockId`. Each such field is scoped to ONE container instance
- *    (a specific Grid / FlexColumns / Carousel), and its `sourceBlockId` gets
- *    remapped per insertion. Inserting a testimonial section twice produces
- *    two independent grid instances; BOTH need their own field or the second
- *    grid's `{{this.subField}}` tokens can't find their row in
- *    `buildRepeatRowIndex` (which keys off sourceBlockId/rowIds) and render as
- *    bare pills. Same-token-id but different sourceBlockId → different field.
- *
- * When a new container-repeat field's id collides with an already-registered
- * field (either a scalar sharing that name, or the same section inserted
- * before), we suffix the id with its sourceBlockId so `buildContext` doesn't
- * silently overwrite the earlier field. Sub-field tokens (`{{this.X}}`) are
- * resolved via the row index by block id, so they don't care about the outer
- * field's id.
+ * "Choose design" with a multi-section page template: replaces the page's
+ * sections with the template's (each carrying its own prefilled variables),
+ * loads the first internal section onto the canvas and returns its index so
+ * the caller can make it active.
  */
+export declare function applyPageSectionsTemplate(configuration: any, templateRecord: any, record: any, onUpdateRecord: (record: any) => void, resetDocument: (doc: any) => void): number;
 export declare function appendTemplateFormFields(templateRecord: any, idMapping?: {
     [oldId: string]: string;
 }): void;
@@ -119,7 +99,15 @@ export declare const buildChangeTemplateDocument: (configuration: any, document:
     fields: any[];
     current: any;
 } | null;
-export declare const applyChangeTemplate: (configuration: any, document: any, resetDocument: (doc: any) => void, templateRecord?: any) => void;
+export type FieldPatches = Record<string, Record<string, any>>;
+/**
+ * Apply field edits (field id → patch) made in the "Change template" compare
+ * to a document's `root.data.formFields`. An items-array field's rows are
+ * mirrored onto its block's items too — those blocks render from their own
+ * props, not from the field.
+ */
+export declare const applyFieldPatches: (doc: any, patches: FieldPatches) => any;
+export declare const applyChangeTemplate: (configuration: any, document: any, resetDocument: (doc: any) => void, templateRecord?: any, fieldPatches?: FieldPatches) => void;
 /**
  * "Use this Styles" for non-tour modules (pages, FAQ, app-banner, tooltip,
  * template). Applies the template's styling — the root canvas AND every

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/EditVariableDialog.d.ts

@@ -0,0 +1,9 @@
+/**
+ * "Edit variable" — rename a declared `{{token}}` / `{{this.token}}` (every
+ * use on the page is rewritten, the value is kept) or turn it back into plain
+ * text. Opened via `openEditVariable` from the Variables tab, a bound input in
+ * the block sidebar, or the canvas tune menu — the last two pass EVERY
+ * variable they use (a Button's label + link), so one "Convert to text" frees
+ * the whole block.
+ */
+export default function EditVariableDialog(): import("react/jsx-runtime").JSX.Element;

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/RowCard.d.ts

@@ -9,15 +9,19 @@ type RowCardProps = {
     onRemove: null | (() => void);
     updateCell: (rowIndex: number, key: string, value: string) => void;
     headerLabel: string;
+    /** Read-only: the row still expands, its inputs are disabled. */
+    disabled?: boolean;
+    /** Shows an "Edit variable" icon per sub-field (`{{this.subId}}` rename/unlink/delete). */
+    onEditSub?: (subId: string) => void;
 };
 /**
  * The bare list of sub-field inputs for one row — no card chrome. Used inside
  * RowCard (behind its collapse) and directly by the Template Modifier, which
  * doesn't need a second collapsible layer around its single template row.
  */
-export declare function RowFields({ rowIndex, row, itemFields, updateCell, sx, }: Pick<RowCardProps, 'rowIndex' | 'row' | 'itemFields' | 'updateCell'> & {
+export declare function RowFields({ rowIndex, row, itemFields, updateCell, sx, disabled, onEditSub, }: Pick<RowCardProps, 'rowIndex' | 'row' | 'itemFields' | 'updateCell' | 'disabled' | 'onEditSub'> & {
     sx?: object;
 }): import("react/jsx-runtime").JSX.Element;
 /** One collapsible copy/template card in the Variables array editor. */
-export default function RowCard({ rowIndex, row, itemFields, isExpanded, onToggle, onRemove, updateCell, headerLabel, }: RowCardProps): import("react/jsx-runtime").JSX.Element;
+export default function RowCard({ rowIndex, row, itemFields, isExpanded, onToggle, onRemove, updateCell, headerLabel, disabled, onEditSub, }: RowCardProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/ScalarFieldRow.d.ts

@@ -5,11 +5,13 @@ type Props = {
     onPatch: (patch: Partial<TemplateFormField>) => void;
     /** Optional control rendered at the right of the label row (e.g. "locate in canvas"). */
     headerAction?: ReactNode;
+    /** Read-only: shows the value and its controls, all disabled. */
+    disabled?: boolean;
 };
 /**
  * One scalar variable row: name, a type selector (Text / Number / Date / Time /
  * Image), the value input, and — for `date` / `time` — the format + timezone
  * controls.
  */
-export default function ScalarFieldRow({ field, onPatch, headerAction }: Props): import("react/jsx-runtime").JSX.Element;
+export default function ScalarFieldRow({ field, onPatch, headerAction, disabled }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/useAutoRegisterTokenFields.d.ts

@@ -4,5 +4,10 @@
  * token with no matching form field. Once added it's no longer "missing", so
  * this can't loop. Mounted from the always-present inspector drawer so the
  * variable already exists when the Variables tab is opened.
+ *
+ * A token edited away (present on the previous scan, gone now) drops its
+ * field. When exactly one token vanished and one new token appeared it's a
+ * rename (`{{old}}` → `{{new}}`): the field is re-keyed in place so its value
+ * and settings carry over instead of leaving both variables behind.
  */
 export default function useAutoRegisterTokenFields(): void;

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/variableEditActions.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A variable the "Edit variable" dialog acts on: a top-level `{{id}}` field,
+ * or a `{{this.subId}}` sub-field of a container-repeat field.
+ */
+export type VariableEditTarget = {
+    fieldId: string;
+    subId?: string;
+};
+export type VariableIdError = 'invalid' | 'duplicate';
+/** Opens the dialog for one variable, or every variable a block / input uses. */
+export declare const openEditVariable: (targets: VariableEditTarget | VariableEditTarget[]) => void;
+export declare const closeEditVariable: () => void;
+export declare const useEditVariableState: () => {
+    open: boolean;
+    targets: VariableEditTarget[];
+    openId: number;
+};
+export declare const VARIABLE_ID_RE: RegExp;
+/** All variables a block's own token-bearing props use (a Button: label + link). */
+export declare const getBlockVariableTargets: (blockId: string) => VariableEditTarget[];
+/** All variables behind one bound input value. */
+export declare const getValueVariableTargets: (value: string, blockId: string | null) => VariableEditTarget[];
+/**
+ * Per-target reason `nextIds[i]` can't be used, or null when it's fine (or
+ * unchanged). Keys must be unique against the page's other variables and
+ * against each other within the dialog.
+ */
+export declare function validateVariableIds(targets: VariableEditTarget[], nextIds: string[]): (VariableIdError | null)[];
+/** Renames every changed key, as ONE undo step. */
+export declare function renameVariables(targets: VariableEditTarget[], nextIds: string[]): void;
+/** Turns every target back into plain text, as ONE undo step. */
+export declare function unlinkVariables(targets: VariableEditTarget[]): void;

package/dist/editor-sample/App/InspectorDrawer/components/DateFieldControls.d.ts

@@ -2,11 +2,12 @@ import { TemplateFormField } from '../../../documents/editor/templateVariables';
 type Props = {
     field: TemplateFormField;
     onPatch: (patch: Partial<TemplateFormField>) => void;
+    disabled?: boolean;
 };
 /**
  * Format + timezone controls for a `date` scalar variable, shown under the
  * datetime input. `relative` recomputes in the reader's browser at view time;
  * every other preset is a fixed string baked in `dateTz` on publish.
  */
-export default function DateFieldControls({ field, onPatch }: Props): import("react/jsx-runtime").JSX.Element;
+export default function DateFieldControls({ field, onPatch, disabled }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/editor-sample/App/InspectorDrawer/components/DateTimeFieldControls.d.ts

@@ -2,6 +2,7 @@ import { TemplateFormField } from '../../../documents/editor/templateVariables';
 type Props = {
     field: TemplateFormField;
     onPatch: (patch: Partial<TemplateFormField>) => void;
+    disabled?: boolean;
 };
 /**
  * Controls for a `datetime` scalar variable: one ISO value, exposed as two
@@ -10,5 +11,5 @@ type Props = {
  * may be `relative` (recomputed in the reader's browser); the time part is
  * always a fixed string.
  */
-export default function DateTimeFieldControls({ field, onPatch }: Props): import("react/jsx-runtime").JSX.Element;
+export default function DateTimeFieldControls({ field, onPatch, disabled }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/editor-sample/App/InspectorDrawer/components/MiniRichTextInput.d.ts

@@ -3,6 +3,7 @@ type Props = {
     value: string;
     onChange: (value: string) => void;
     fieldId?: string;
+    disabled?: boolean;
 };
 declare const MiniRichTextInput: React.FC<Props>;
 export default MiniRichTextInput;

package/dist/editor-sample/App/InspectorDrawer/components/ScalarFieldInput.d.ts

@@ -6,6 +6,7 @@ type Props = {
     onChange: (value: string) => void;
     onPaperBackground?: boolean;
     fieldId?: string;
+    disabled?: boolean;
 };
-declare const ScalarFieldInput: ({ type, label, value, onChange, onPaperBackground, fieldId }: Props) => import("react/jsx-runtime").JSX.Element;
+declare const ScalarFieldInput: ({ type, label, value, onChange, onPaperBackground, fieldId, disabled, }: Props) => import("react/jsx-runtime").JSX.Element;
 export default ScalarFieldInput;

package/dist/editor-sample/App/InspectorDrawer/components/TimeFieldControls.d.ts

@@ -2,11 +2,12 @@ import { TemplateFormField } from '../../../documents/editor/templateVariables';
 type Props = {
     field: TemplateFormField;
     onPatch: (patch: Partial<TemplateFormField>) => void;
+    disabled?: boolean;
 };
 /**
  * Format + timezone controls for a `time` scalar variable, shown under the
  * datetime input. `time` always bakes to a fixed string (24h or AM/PM) rendered
  * in the chosen timezone — there's no view-time / relative mode.
  */
-export default function TimeFieldControls({ field, onPatch }: Props): import("react/jsx-runtime").JSX.Element;
+export default function TimeFieldControls({ field, onPatch, disabled }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/editor-sample/App/shared/SectionsDropdown.d.ts

@@ -3,8 +3,8 @@ type Props = {
     sections: PageSection[];
     activeSectionIndex: number;
     onSelectSection: (index: number) => void;
-    onDeleteSection: (index: number) => void;
-    onEditSection: (index: number) => void;
+    onDeleteSection?: (index: number) => void;
+    onEditSection?: (index: number) => void;
     onReorderSections?: (fromIndex: number, toIndex: number) => void;
 };
 declare const SectionsDropdown: ({ sections, activeSectionIndex, onSelectSection, onDeleteSection, onEditSection, onReorderSections, }: Props) => import("react/jsx-runtime").JSX.Element;

package/dist/editor-sample/App/shared/pageSections.d.ts

@@ -24,5 +24,12 @@ export declare const isExternalSection: (section: Partial<PageSection> | undefin
  * Identifier is auto-generated as `${sectionType}-${Date.now()}`.
  */
 export declare const createPageSectionFromDraft: (draft: SectionDraft, defaultDocument: TEditorConfiguration) => PageSection;
+/**
+ * Turns a multi-section page template's `sections` into page sections, giving
+ * each internal section's root the `formFields` tagged for it (`stepIndex` =
+ * section index, tag stripped). `existing` sections at the same index keep
+ * their `_id` / `identifier` so applying onto a saved page updates in place.
+ */
+export declare const buildSectionsFromTemplate: (templateSections: PageSection[], formFields?: any[], existing?: PageSection[]) => PageSection[];
 /** Writes the live editor document back into the active section before switching or saving. */
 export declare const mergeCurrentDocumentIntoSections: (sections: PageSection[], activeSectionIndex: number, document: TEditorConfiguration) => PageSection[];

package/dist/editor-sample/documents/blocks/MenuPicker/MenuPropsSchema.d.ts

@@ -34,6 +34,9 @@ declare const MenuPropsSchema: z.ZodObject<{
     submenuBackgroundColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     submenuRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
     submenuIconSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    submenuTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    submenuFontSize: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    submenuFontWeight: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     submenuPadding: z.ZodNullable<z.ZodOptional<z.ZodObject<{
         top: z.ZodNumber;
         right: z.ZodNumber;

package/dist/editor-sample/documents/blocks/MenuPicker/menuBlockLabel.d.ts

@@ -0,0 +1,4 @@
+export declare const menuBlockLabel: (props?: {
+    navRole?: string | null;
+    orientation?: string;
+} | null) => string;

package/dist/editor-sample/documents/blocks/helpers/EditorChildrenIds/AddBlockMenu/ScopePickerMenu.d.ts

@@ -7,8 +7,9 @@ export type ScopeOption = {
 };
 type Props = {
     anchorEl: HTMLElement | null;
-    options: [ScopeOption, ScopeOption];
+    options: ScopeOption[];
     onClose: () => void;
+    title?: string;
 };
-export default function ScopePickerMenu({ anchorEl, options, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export default function ScopePickerMenu({ anchorEl, options, onClose, title }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/editor-sample/documents/blocks/helpers/EditorChildrenIds/AddBlockMenu/index.d.ts

@@ -11,6 +11,7 @@ type Props = {
     containerNeighbors?: ContainerNeighbor[];
     onInsertIntoContainer?: (block: TEditorBlock, containerId: string, insertAt: 'start' | 'end') => void;
     insertAboveCallback?: (block: TEditorBlock) => void;
+    onEditContent?: () => void;
 };
-export default function AddBlockButton({ onSelect, onPaste, placeholder, suppressAdd, containerNeighbors, onInsertIntoContainer, insertAboveCallback, }: Props): import("react/jsx-runtime").JSX.Element;
+export default function AddBlockButton({ onSelect, onPaste, placeholder, suppressAdd, containerNeighbors, onInsertIntoContainer, insertAboveCallback, onEditContent, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -33,6 +33,8 @@ export type BlockTemplateConfiguration = {
  * type's own child-id layout) into a flat `{ id: block }` map.
  */
 export declare function collectBlockSubtree(document: BlockMap, rootBlockId: string): BlockMap;
+/** `firstName` → "First Name" for a human-readable field label. */
+export declare const humanize: (id: string) => string;
 export declare function extractFormFieldsFromBlocks(blocks: BlockMap, rootBlockId: string): FormField[];
 /**
  * Scalar `{{id}}` tokens present in the live document that have no matching
@@ -43,6 +45,14 @@ export declare function extractFormFieldsFromBlocks(blocks: BlockMap, rootBlockI
  * explicit repeatable-container flow.
  */
 export declare function detectMissingScalarFields(document: BlockMap, forms: FormField[]): FormField[];
+/**
+ * Add every `{{this.sub}}` token found inside a container-repeat field's own
+ * blocks (source + row subtrees) to that field's `itemFields`, so a row token
+ * typed after the repeat was set up shows in the Variables panel and survives
+ * save. Blocks belonging to a nested repeat are skipped — their tokens are
+ * that inner field's. Returns `forms` itself when nothing was added.
+ */
+export declare function mergeDetectedRowSubFields(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);

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

@@ -299,6 +299,12 @@ export declare const duplicateBlock: (documentTree: Record<string, any>, rootId:
     updatedDocument: Record<string, any>;
     newRootId: string;
 };
+/**
+ * Re-point a repeat field at its copied blocks. Items-array fields (MenuPicker
+ * custom menu) follow their block; container-repeat fields keep a row per
+ * copied row block. Null when the field's blocks weren't copied.
+ */
+export declare function cloneRepeatField(f: any, idMap: Record<string, string>): any | null;
 export declare const cloneCopiedBlocks: (copiedConfig: {
     rootBlockId: string;
     blocks: Record<string, any>;

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

@@ -0,0 +1,36 @@
+import { TemplateSource } from './sectionScope';
+/**
+ * "Change design": swap one section on the page for another block template
+ * while keeping the section's content.
+ *
+ * The new design takes the old section's place and its field scope (`__<n>`),
+ * and each of its fields takes the old value with the same plain id. A repeat
+ * list keeps all of its rows — the new design's row blocks are added/removed
+ * (growing its grid if needed) to match. Values the new design has no field
+ * for are dropped, so a section only ever carries its current design's data.
+ *
+ * Pure: returns the next document; the caller commits it.
+ */
+type Doc = Record<string, any>;
+type Field = Record<string, any>;
+export type ChangeSectionDesignResult = {
+    doc: Doc;
+    newRootIds: string[];
+    /** Plain ids of fields whose value came from the old design. */
+    carried: string[];
+    /** Plain ids of old values the new design has no field for (removed). */
+    dropped: string[];
+    /** Repeat fields that couldn't get a row block for every row. */
+    capacityLimited: string[];
+};
+export declare function changeSectionDesign({ doc, sectionRootId, configuration, templateFields, source, }: {
+    doc: Doc;
+    /** Top-level block of the section being replaced. */
+    sectionRootId: string;
+    /** The new block template's configuration ({ rootBlockId, blocks, childrenIds? }). */
+    configuration: any;
+    /** The new template's authored formFields. */
+    templateFields: Field[];
+    source: TemplateSource;
+}): ChangeSectionDesignResult | null;
+export {};

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

@@ -2284,6 +2284,9 @@ export declare const EditorBlock: ({ type, data }: import('@usewaypoint/document
         submenuBackgroundColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         submenuRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         submenuIconSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        submenuTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        submenuFontSize: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        submenuFontWeight: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         submenuPadding: z.ZodNullable<z.ZodOptional<z.ZodObject<{
             top: z.ZodNumber;
             right: z.ZodNumber;

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

@@ -0,0 +1,73 @@
+/**
+ * Section-scoped template fields.
+ *
+ * A block template placed on a page is a "section". Its top-level block(s) are
+ * stamped with `data.templateSource` so the editor knows which template and
+ * category the section came from (used by "Change design" to preselect the
+ * category, and below to tell sections of the same kind apart).
+ *
+ * Fields are page-wide by id: a header and a footer that both use
+ * `{{phoneNumber}}` show one value. A second section of the SAME kind must not
+ * share, though — two FAQ sections need their own title and Q&A list. So when
+ * a section's fields collide with another section of its kind, EVERY field of
+ * the new section gets the same `__<n>` suffix (n ≥ 2) and its `{{tokens}}` are
+ * rewritten to match. The suffix is digits only because bare `{{tokens}}` only
+ * allow `[a-zA-Z0-9_]`.
+ *
+ * Pure functions over the document tree; callers write the results.
+ */
+export type TemplateSource = {
+    templateId?: string;
+    name?: string;
+    category?: string;
+    /** The `__<n>` suffix this section's fields carry; absent for plain ids. */
+    scope?: number;
+};
+type Doc = Record<string, any>;
+type Field = Record<string, any>;
+export declare const baseFieldId: (id: string) => string;
+export declare const getTemplateSource: (block: any) => TemplateSource | undefined;
+export declare const withTemplateSource: (block: any, source: TemplateSource) => any;
+export declare function subtreeIdsOf(doc: Doc, rootId: string): string[];
+/** Top-level `{{token}}` ids used by the given blocks (`{{this.x}}` excluded). */
+export declare function tokenIdsIn(doc: Doc, ids: Iterable<string>): Set<string>;
+/** Repeat fields bound to one block instance (container-repeat or items-array). */
+export declare const isBlockScoped: (f: Field) => boolean;
+export declare const scopedFieldName: (name: string, scope?: number) => string;
+export declare const blockIdsOutside: (doc: Doc, exclude: Set<string>) => string[];
+/** The fields a section uses: tokens inside it plus repeat fields anchored inside it. */
+export declare function sectionFieldsOf(doc: Doc, rootId: string, fields: Field[]): Field[];
+/**
+ * Decide the field ids for a section that was just added to `doc` (its blocks,
+ * `sectionIds`, are already in `doc`).
+ *
+ * - Existing fields with an incoming id that nothing outside the section uses
+ *   any more are dropped, so a swapped-in design takes the plain ids back.
+ * - When an incoming id collides with a field owned by a section of the same
+ *   kind, every incoming field is suffixed `__<n>` and the section's tokens
+ *   are rewritten; `blocks` holds the rewritten blocks and `scope` is `n`.
+ * - Otherwise nothing is renamed: the caller keeps its normal dedupe (scalars
+ *   shared by id, colliding repeat fields suffixed).
+ */
+export declare function scopeSectionFields({ doc, existing, incoming, sectionIds, source, }: {
+    doc: Doc;
+    existing: Field[];
+    incoming: Field[];
+    sectionIds: Set<string>;
+    source?: TemplateSource;
+}): {
+    existing: Field[];
+    incoming: Field[];
+    blocks: Doc;
+    scope?: number;
+};
+/**
+ * After sections are removed: a scoped section whose plain ids are all free
+ * again (no field uses them) takes them back, lowest scope first. Returns null
+ * when nothing changes.
+ */
+export declare function unscopeSections(doc: Doc, fields: Field[]): {
+    blocks: Doc;
+    fields: Field[];
+} | null;
+export {};

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

@@ -4,13 +4,14 @@ import { DateFormatPreset, TimeFormatPreset } from '../../../host-stubs/utils/da
  * The kinds of single-value template field. `array` is repeatable and handled
  * separately. `text` / `textarea` substitute as plain strings, `number` as a
  * numeric string, `image` as an image URL (used in Image/Avatar/Logo blocks),
+ * `video` a video URL — media-library file or YouTube link (used in Video blocks),
  * `date` an ISO date string rendered through a display format (see `dateFormat`).
  * `time` an ISO date string rendered as just its time portion (see `timeFormat`).
  * `datetime` one ISO string exposing TWO sub-tokens — `{{id.date}}` (formatted
  *   via `dateFormat`) and `{{id.time}}` (via `timeFormat`) — so a single value /
  *   API mapping can print its date and time in separate blocks.
  */
-export type TemplateScalarType = 'text' | 'textarea' | 'number' | 'image' | 'date' | 'time' | 'datetime';
+export type TemplateScalarType = 'text' | 'textarea' | 'number' | 'image' | 'video' | 'date' | 'time' | 'datetime';
 export type TemplateFormType = TemplateScalarType | 'array';
 /** All scalar types — used by both top-level fields and array sub-fields. */
 export declare const TEMPLATE_SCALAR_TYPES: TemplateScalarType[];

package/dist/email-builder-core/blocks/MenuPicker/MenuColumns.d.ts

@@ -4,10 +4,12 @@ type Props = {
     menuItems: any[];
     menuKey: string;
     textColor: string;
+    submenuTextColor?: string | null;
+    submenuFontSize?: string | null;
     backgroundColor: string;
     fontFamily?: string;
     start?: React.ReactNode;
     end?: React.ReactNode;
 };
-declare const MenuColumns: ({ p, menuItems, menuKey, textColor, backgroundColor, fontFamily, start, end }: Props) => import("react/jsx-runtime").JSX.Element;
+declare const MenuColumns: ({ p, menuItems, menuKey, textColor, submenuTextColor, submenuFontSize, backgroundColor, fontFamily, start, end }: Props) => import("react/jsx-runtime").JSX.Element;
 export default MenuColumns;

package/dist/email-builder-core/blocks/MenuPicker/MenuPropsSchema.d.ts

@@ -34,6 +34,9 @@ declare const MenuPropsInnerSchema: z.ZodObject<{
     submenuBackgroundColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     submenuRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
     submenuIconSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    submenuTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    submenuFontSize: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    submenuFontWeight: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     submenuPadding: z.ZodNullable<z.ZodOptional<z.ZodObject<{
         top: z.ZodNumber;
         right: z.ZodNumber;
@@ -108,6 +111,9 @@ export declare const MenuPropsSchema: z.ZodObject<{
         submenuBackgroundColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         submenuRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         submenuIconSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        submenuTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        submenuFontSize: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        submenuFontWeight: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         submenuPadding: z.ZodNullable<z.ZodOptional<z.ZodObject<{
             top: z.ZodNumber;
             right: z.ZodNumber;

package/dist/host-stubs/modules/content/view/contentViewSelectors.d.ts

@@ -0,0 +1,4 @@
+declare const contentViewSelectors: {
+    selectRecord: any;
+};
+export default contentViewSelectors;

package/dist/host-stubs/view/page/form/dialog/PageVariablesPreview.d.ts

@@ -0,0 +1,5 @@
+type Props = {
+    document: any;
+};
+declare const PageVariablesPreview: ({ document }: Props) => import("react/jsx-runtime").JSX.Element;
+export default PageVariablesPreview;