@pygmalionjs/pygmalion 0.5.13 → 0.5.15

package/dist-lib/types/editor/store.d.ts

@@ -0,0 +1,838 @@
+import { type InteractiveStateDef } from './interactiveStates';
+import { type ScreenDimensionDef } from './screenDimensions';
+import { type CardBadgeOption, type CardSlotDef, type ScreenCardDef } from './screenCards';
+import { type ScreenListDef } from './screenLists';
+import { type DesignImportAsset, type DesignImportKind, type DesignFrameSizeMode, type DesignScreenAssertion, type DesignScreenInteraction, type DesignScreenPreset, type StoryboardEnvironment } from './designImport';
+import { type DomImportDiagnostic, type DomImportResult } from './domImport';
+import { type DesignFrameHeightMode } from './frameHeight';
+import { type RegistryPropValue } from './registry';
+import { type PrimitiveSourceValue } from './inspect';
+import { type SourceJournalSnapshot } from './sourceJournal';
+import { type SharedSourceEditScope, type SharedSourceImpact } from './sharedSource';
+export type NodeType = 'rows' | 'columns' | 'text' | 'component';
+/** Autolayout container type (with direction, gap, and alignment). */
+export declare const isContainerType: (t: NodeType) => t is "rows" | "columns";
+/** Can contain child nodes — container + children:'nodes' components (Card, etc.). */
+export declare const canHaveChildren: (n: NodeModel) => boolean;
+export type SizeMode = 'fill' | 'fit' | 'fixed';
+export type TextAlign = 'left' | 'center' | 'right';
+export type JustifyMode = 'start' | 'center' | 'end' | 'between';
+export type AlignMode = 'start' | 'center' | 'end';
+export declare class NodeModel {
+    id: string;
+    type: NodeType;
+    name: string;
+    children: NodeModel[];
+    widthMode: SizeMode;
+    width: number;
+    heightMode: SizeMode;
+    height: number;
+    gap: number;
+    padding: number;
+    justify: JustifyMode;
+    alignItems: AlignMode;
+    fill: string;
+    radius: number;
+    borderWidth: number;
+    borderColor: string;
+    opacity: number;
+    hidden: boolean;
+    locked: boolean;
+    text: string;
+    fontSize: number;
+    fontWeight: number;
+    color: string;
+    textAlign: TextAlign;
+    componentName: string;
+    componentProps: Record<string, RegistryPropValue>;
+    childrenText: string;
+    domTag: string;
+    domAttributes: Record<string, string>;
+    domStyle: Record<string, string>;
+    /** registry importPath/component file boundary. Connects sub-DOMs of the same implementation between frames. */
+    sourceComponent: string;
+    /** CSS module source (file#localClass). The strongest shared identifier for style editing. */
+    sourceStyle: string;
+    /** Stable shared key calculated from the sourceComponent/sourceStyle/route structure. */
+    sourceKey: string;
+    /** Primitive literals authored on this rendered element's owning JSX opening. */
+    sourceProps: Record<string, PrimitiveSourceValue>;
+    linkTo: string;
+    constructor(type: NodeType, patch?: Partial<NodeModel>);
+}
+export interface NodeJSON {
+    id: string;
+    type: NodeType;
+    name: string;
+    widthMode: SizeMode;
+    width: number;
+    heightMode: SizeMode;
+    height: number;
+    gap: number;
+    padding: number;
+    justify: JustifyMode;
+    alignItems: AlignMode;
+    fill: string;
+    radius: number;
+    borderWidth: number;
+    borderColor: string;
+    opacity: number;
+    hidden: boolean;
+    locked: boolean;
+    text: string;
+    fontSize: number;
+    fontWeight: number;
+    color: string;
+    textAlign: TextAlign;
+    componentName: string;
+    componentProps: Record<string, RegistryPropValue>;
+    childrenText: string;
+    domTag: string;
+    domAttributes: Record<string, string>;
+    domStyle: Record<string, string>;
+    sourceComponent?: string;
+    sourceStyle?: string;
+    sourceKey?: string;
+    sourceProps?: Record<string, PrimitiveSourceValue>;
+    linkTo: string;
+    children: NodeJSON[];
+}
+export interface FrozenPreviewMutation {
+    key: string;
+    selector: string;
+    text?: string;
+    textNodeOrdinal?: number;
+    hidden?: boolean;
+    attributes?: Record<string, string | null>;
+    replaceChildrenHtml?: string;
+    /** A serialization descriptor to re-execute the registry component within the ownerDocument of the frozen iframe. */
+    component?: {
+        name: string;
+        props: Record<string, RegistryPropValue>;
+        childrenText: string;
+    };
+    /** Changes that cannot be expressed accurately without rerunning React. Specifies on the screen where the selector exists. */
+    staleReason?: string;
+}
+export interface FrozenPreviewCssRule {
+    key: string;
+    selector: string;
+    css: string;
+}
+export declare function serializeNode(n: NodeModel): NodeJSON;
+export declare function deserializeNode(j: NodeJSON, freshIds?: boolean): NodeModel;
+export interface DropHint {
+    parentId: string;
+    index: number;
+    /** Drop indicator line — viewport(fixed) coordinates. */
+    indicator: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+}
+export interface PageModel {
+    /** Frame size (px). Default 390×600 (mobile). */
+    width?: number;
+    height?: number;
+    /** Immutable manifest-authored viewport used by the reset action and responsive preview source. */
+    authoredFrameSize?: {
+        width: number;
+        height: number;
+        frameSizeMode?: DesignFrameSizeMode;
+        heightMode?: DesignFrameHeightMode;
+        maxHeight?: number;
+    };
+    /** Generated catalog pages may replace their measurement seed with actual rendered DOM bounds. */
+    frameSizeMode?: DesignFrameSizeMode;
+    /** Transient guard that prevents content measurement from overwriting a manual frame layout. */
+    contentAutoLayout?: boolean;
+    /** Manifest-owned frame sizing policy. Runtime document measurements never replace the configured viewport height. */
+    heightMode?: DesignFrameHeightMode;
+    maxHeight?: number;
+    /** Transient rendered document height shared by live, frozen, and detailed preview states. */
+    resolvedDocumentHeight?: number;
+    /** Canvas deformation and appearance of the frame itself. */
+    rotation?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+    clipContent?: boolean;
+    fill?: string;
+    opacity?: number;
+    radius?: number;
+    /** Screen path to use when publishing. route is for actual app reference, and path is the output path of the creation screen. */
+    path?: string;
+    /** If false, it is excluded from reflection/publishing output. */
+    publish?: boolean;
+    /** Owning canvas. Switching canvases replaces the visible frame set. */
+    canvas?: string;
+    /** Page list section headers (line breaks within the canvas — "Design System"/"Screen", etc.). */
+    section?: string;
+    /** Actual app routes running (iframe referencing page — not editable, actual routing in preview). */
+    route?: string;
+    /** Whether the design importer replaces the first actual DOM render with the entire layer tree and the processing status. */
+    importLayers?: boolean;
+    layersImported?: boolean;
+    importPageId?: string;
+    importKind?: string;
+    /** Link to actual assets/source files in your code inventory. It is passed as is to the auto-save payload. */
+    assetIds?: string[];
+    sourcePaths?: string[];
+    /** User flow-based screen capture metadata. */
+    flow?: string;
+    scenario?: string;
+    state?: string;
+    /** Host-declared kind of the state branch (overlay, badge, layout, ...). Drives the Screen states control's presentation only. */
+    stateKind?: string;
+    /** Host-declared situation group the frame is arranged into (see frameLanes). */
+    lane?: string;
+    scenarioId?: string;
+    /** Every scenario the screen demonstrates; coverage counts this set. */
+    scenarioIds?: readonly string[];
+    interactions?: DesignScreenInteraction[];
+    /** Captured recipe, kept while a declared interactive state extends it. */
+    baseInteractions?: DesignScreenInteraction[];
+    /** Declared interactive axis the frame is currently held in, if any. */
+    interactiveStateId?: string;
+    interactiveOptionId?: string;
+    /**
+     * The case's own environment, kept so clearing an interactive option can put
+     * `environment` back without reconstructing what the case declared. Same shape
+     * as authoredFrameSize: the live field is what everything reads, the authored
+     * one is what restores it.
+     *
+     * A selected option's boot condition is merged INTO `environment` rather than
+     * held beside it, because every consumer already reads that field — the boot
+     * URL, the flow-session environment, the artifact fingerprint, the cache key.
+     * Holding it apart would mean finding and updating each of them, and missing
+     * one is silent: the frame re-keys and re-supplies, but boots without the
+     * condition, so the axis looks dead for a reason nothing reports.
+     */
+    authoredEnvironment?: StoryboardEnvironment;
+    environment?: StoryboardEnvironment;
+    preset?: DesignScreenPreset;
+    assertions?: DesignScreenAssertion[];
+    /** Host-declared warm instance group. Set when the screen state is declared, not replayed. */
+    session?: string;
+    layerImportCount?: number;
+    layerImportTruncated?: boolean;
+    layerImportDiagnostics?: readonly DomImportDiagnostic[];
+    layerImportError?: string;
+    /** Page edit revision recorded when the layers were imported. */
+    layerImportRevision?: number;
+    /** Frame width the layers were imported at — their geometry is only valid there. */
+    layerImportViewportWidth?: number;
+    /** Infinite canvas coordinates (multi-frame placement). */
+    x?: number;
+    y?: number;
+    id: string;
+    name: string;
+    root: NodeModel;
+}
+export interface FrameResizeOptions {
+    /** Records a history checkpoint before applying the resize. */
+    recordHistory?: boolean;
+    /** Applies the horizontal viewport change. */
+    resizeWidth?: boolean;
+    /** Applies the vertical viewport change and converts document-height frames to a fixed viewport. */
+    resizeHeight?: boolean;
+}
+/** A first-class organizational section that can exist without a frame. */
+export interface SectionRect {
+    canvas: string;
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface CanvasFrameLayout {
+    key: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    section?: string;
+    /**
+     * Content-fit frames stay in deterministic catalog layout until a user
+     * explicitly moves them. Optional for backward compatibility with snapshots
+     * written before this state was persisted.
+     */
+    contentAutoLayout?: boolean;
+}
+interface CanvasLayoutSnapshotV5 {
+    version: 5;
+    scope: string;
+    frames: CanvasFrameLayout[];
+    sections: SectionRect[];
+}
+export declare const CANVAS_LAYOUT_VERSION = 5;
+export declare function isCanvasLayoutSnapshot(value: unknown, scope: string): value is CanvasLayoutSnapshotV5;
+export type CanvasObjectSelection = {
+    kind: 'frame';
+    id: string;
+} | {
+    kind: 'section';
+    name: string;
+} | null;
+export declare class EditorStore {
+    /** Multi-page — each page has an independent tree. */
+    pages: PageModel[];
+    activePageId: string;
+    /** Multiple selection — Last element is primary (targeted in the Properties panel). */
+    selectedIds: string[];
+    /** Frames and sections are selected as canvas objects separate from internal nodes. */
+    selectedCanvasObject: CanvasObjectSelection;
+    hoveredId: string | null;
+    showRenderCount: boolean;
+    /** Canvas zoom from 0.25 to 3, controlled by Command/Ctrl-scroll or keyboard shortcuts. */
+    zoom: number;
+    /** Infinite canvas pan (viewport px, no limit — negative numbers allowed). The initial value is an offset that avoids the left panel. */
+    panX: number;
+    panY: number;
+    /** Active canvas. Each canvas preserves its pan and zoom in canvasViews. */
+    activeCanvas: string;
+    private canvasViews;
+    /**
+     * Canvas names in the order a designer navigates them.
+     *
+     * Appearance order alone made this list inherit however the host happened to
+     * order its case array, so one misplaced case reordered the whole panel. A
+     * declared section carries the order its author intended, so canvases are
+     * ordered by that — within each import kind, since the kinds themselves keep
+     * the order they appear in. That is what holds the catalog canvases where
+     * they sit relative to the screens while the screens sort themselves.
+     *
+     * A canvas whose sections are undeclared keeps its appearance position, so a
+     * host that declares no section headers sees no change.
+     */
+    get canvasNames(): string[];
+    /** Frames belonging to the active canvas. */
+    get canvasPages(): PageModel[];
+    /** canvas + scenario -> the group member currently holding the canvas slot. */
+    private screenStateSelections;
+    private screenStateSlotKey;
+    /**
+     * Declared state variants sharing a scenario on one canvas, in declaration
+     * order. Folding never crosses canvases: a scenario that also names a
+     * screen on another canvas (a flow's entry point, say) keeps that screen
+     * as a normal frame there — otherwise a canvas could fold down to nothing.
+     */
+    screenStateGroup(scenario: string, canvas: string): PageModel[];
+    /** The group member holding the group's canvas slot, or null for non-groups. */
+    shownScreenStateId(scenario: string, canvas: string): string | null;
+    /** False only for state variants folded into the Screen states control. */
+    isScreenStateShown(page: PageModel): boolean;
+    /** Swaps a folded variant into its group's canvas slot; the camera stays. */
+    private revealScreenState;
+    /** Switch canvases, restore their view, and activate the first frame. */
+    switchCanvas(name: string): void;
+    setPan(x: number, y: number): void;
+    setCameraView(view: {
+        panX: number;
+        panY: number;
+        zoom: number;
+    }): void;
+    /**
+     * Selects a frame and commits its camera destination in one observable action.
+     * Observers never render the newly active frame at the previous camera view.
+     */
+    focusFrame(id: string, view: {
+        panX: number;
+        panY: number;
+        zoom: number;
+    }): boolean;
+    panBy(dx: number, dy: number): void;
+    /** Cursor anchor zoom — Pan correction to anchor the world point below local (container coordinates). */
+    zoomAt(localX: number, localY: number, factor: number): void;
+    /** Shows the docked source code drawer. */
+    codeOpen: boolean;
+    /** Collapsed node id in the layer tree. */
+    collapsed: Set<string>;
+    /** The node id being dragged (displayed semi-transparently on the canvas). */
+    dragNodeId: string | null;
+    /** Preview drop location while dragging. */
+    dropHint: DropHint | null;
+    /** Right-click context menu location (viewport). */
+    ctxMenu: {
+        x: number;
+        y: number;
+    } | null;
+    /** Layer tree inline rename target (⌘R·double-click). */
+    renamingId: string | null;
+    /** Canvas inline text editing target (double click, Enter). */
+    editingTextId: string | null;
+    /** Internal clipboard (⌘C/X/V — OS clipboard integration is on the roadmap). */
+    private clipboardJSON;
+    private undoStack;
+    private redoStack;
+    private lastCheckpointTag;
+    private lastCheckpointTime;
+    /** Final shared style patch that will also be applied to the same source frame that has not yet been rendered/fetched. */
+    private sharedSourceOverrides;
+    /** Child structures of the same source container. It is applied immediately after import to frames that have not yet been captured. */
+    private sharedSourceStructureOverrides;
+    /** Common CSS to be immediately injected into route snapshots that have not yet created a detailed layer. */
+    private sharedFrozenCssRules;
+    /** A script-free DOM patch with text and display states that cannot be expressed in CSS. */
+    private sharedFrozenDomMutations;
+    /** sourceSha + Canvas layout repository with fixed scope as a page catalog. */
+    private canvasLayoutScope;
+    private canvasLayoutStorageKey;
+    private canvasLayoutDisposer;
+    /** Explicit edit scope by sourceKey. Unspecified is shared like the existing operation. */
+    private sharedSourceEditScopes;
+    /** The final change that can be safely reflected to the original source during a regular canvas NodeModel patch. */
+    private sourcePatchJournal;
+    /** Asset-list edit intent waiting for the catalog page's DOM layer import. */
+    private pendingDesignAssetEdit;
+    /** Page DOM as of last load/reflection. Asynchronous screens register upon completion of each capture. */
+    private pageRootBaselines;
+    /** Monotonic per-page edit revision derived from the checkpoint funnel every mutation passes through. */
+    private pageEditRevisions;
+    /** pageId → edit revision at the moment a frozen preview was promoted without a boot (D2). */
+    private provisionalLayerImports;
+    private contentLayoutScheduled;
+    private contentLayoutCanvases;
+    constructor();
+    get activePage(): PageModel;
+    get selectedFrame(): PageModel | null;
+    get selectedSection(): SectionRect | null;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    get canAddFrame(): boolean;
+    designAssetPage(kind: DesignImportKind, asset: DesignImportAsset): PageModel | null;
+    /** Open an inventory asset as an editable implementation layer. */
+    beginDesignAssetEdit(kind: DesignImportKind, asset: DesignImportAsset): PageModel | null;
+    private resolvePendingDesignAssetEdit;
+    sharedSourceImpactFor(node: NodeModel): SharedSourceImpact;
+    /**
+   * Common source CSS to put into script-free DOM previews on inactive screens.
+   * Component-level changes are immediately visible even without mounting the entire React layer tree.
+   */
+    frozenPreviewOverrideCss(_page: PageModel): string;
+    frozenPreviewCssRules(): FrozenPreviewCssRule[];
+    frozenPreviewMutations(): FrozenPreviewMutation[];
+    /** Only frames with common props/structure that cannot be expressed as a snapshot patch are promoted to a live model. */
+    pageRequiresLiveSharedPreview(page: PageModel): boolean;
+    sharedSourceEditScopeFor(node: NodeModel): SharedSourceEditScope;
+    /** source-backed revision + InspectApplyPayload compatible final state of generic canvas changes. */
+    getPendingSourceChanges(): SourceJournalSnapshot;
+    /** During asynchronous apply, the revision is acked only when there is no new patch/undo. */
+    ackPendingSourceChanges(expectedRevision: number): boolean;
+    /**
+   * Unreflected style and text edits are discarded based on the last load/reflection criteria.
+   * Pan/zoom and frame placement are maintained as they are in the workspace state.
+   */
+    resetCurrentEdits(): boolean;
+    private sourceEditScopeForNode;
+    setSharedSourceEditScope(node: NodeModel, scope: SharedSourceEditScope): void;
+    private pagesInitialized;
+    /**
+   * Host injects “real screen components” into editor pages — 1 component node per page (root fill).
+   * StrictMode applies only once even to dual mounts (idempotent).
+   */
+    initPagesFromComponents(defs: {
+        name: string;
+        componentName?: string;
+        /** Registry Name List — Created as a vertical gallery page (listing component nodes). */
+        gallery?: string[];
+        canvas?: string;
+        section?: string;
+        route?: string;
+        width?: number;
+        height?: number;
+        frameSizeMode?: DesignFrameSizeMode;
+        heightMode?: DesignFrameHeightMode;
+        maxHeight?: number;
+        path?: string;
+        publish?: boolean;
+        importLayers?: boolean;
+        importPageId?: string;
+        importKind?: string;
+        assetIds?: string[];
+        sourcePaths?: string[];
+        flow?: string;
+        scenario?: string;
+        state?: string;
+        stateKind?: string;
+        lane?: string;
+        scenarioId?: string;
+        scenarioIds?: readonly string[];
+        interactions?: DesignScreenInteraction[];
+        environment?: StoryboardEnvironment;
+        preset?: DesignScreenPreset;
+        assertions?: DesignScreenAssertion[];
+        session?: string;
+    }[], options?: {
+        initialCanvas?: string;
+    }): void;
+    /** Tree root of the active page — getter(computed) for compatibility with existing code. */
+    get root(): NodeModel;
+    addPage(): boolean;
+    switchPage(id: string, opts?: {
+        fromHistory?: boolean;
+    }): void;
+    renamePage(id: string, name: string): void;
+    patchPage(id: string, partial: Partial<Pick<PageModel, 'name' | 'path' | 'publish' | 'x' | 'y' | 'width' | 'height' | 'rotation' | 'flipX' | 'flipY' | 'clipContent' | 'fill' | 'opacity' | 'radius'>>): void;
+    setPagePath(id: string, rawPath: string): void;
+    /** Change section name — applies to section rectangles and member frames on the same canvas. It is only a classification for canvas organization and has no effect on code calculation. */
+    renameSection(canvas: string | undefined, oldName: string, newName: string): void;
+    /** Section title drag — Absolute movement of the member frame/section rectangle based on the drag start coordinate (no cumulative error). */
+    moveSectionTo(name: string, base: {
+        frames: {
+            id: string;
+            x: number;
+            y: number;
+        }[];
+        rect: {
+            x: number;
+            y: number;
+        } | null;
+    }, dx: number, dy: number, recordHistory?: boolean): void;
+    /** Relocate a frame to another section — when dropped into a section pane box on the canvas. */
+    setPageSection(id: string, section: string): void;
+    /** Canvas coordinates for a newly inserted frame within its ordered story section. */
+    private nextFramePos;
+    /**
+     * Records asynchronous document measurements without changing canvas camera state
+     * or the configured capture viewport used by route cache identity.
+     */
+    setPageDocumentHeight(id: string, measuredHeight: number): boolean;
+    resetPageDocumentHeight(id: string): boolean;
+    /**
+     * Automatically places authored frames by canvas and story section. Section
+     * order and frame order remain manifest-owned; only wrapping is adaptive.
+     */
+    private layoutFrames;
+    private scheduleContentFrameLayout;
+    private flushContentFrameLayout;
+    /**
+     * Replaces a generated catalog page's 1×1 measurement seed with its actual
+     * rendered DOM bounds. The update is transient and never changes camera state.
+     */
+    setPageContentBounds(id: string, bounds: {
+        width: number;
+        height: number;
+    }): boolean;
+    private canvasLayoutSnapshot;
+    private restoreCanvasLayout;
+    /**
+   * Canvas geometry is owned by Pygmalion, separate from the code documentation.
+   * Embeds without source revision do not enable persistence because projects cannot be safely distinguished.
+   */
+    private startCanvasLayoutPersistence;
+    /** Called once when a direct-manipulation gesture starts. Subsequent pointer updates skip history. */
+    beginFrameTransform(id: string, kind: 'move' | 'resize'): boolean;
+    moveFrame(id: string, x: number, y: number, recordHistory?: boolean): void;
+    resizeFrame(id: string, rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, options?: FrameResizeOptions): void;
+    /** True when the imported tree carries no user edits since its import. */
+    private layersUneditedSinceImport;
+    /**
+     * Imported layer geometry is only valid at the width it was captured at.
+     * A committed width change on an unedited tree schedules a provisional
+     * re-import: the live pipeline boots at the new width and swaps its
+     * capture in, while the frozen replay covers the wait. An edited tree is
+     * never volunteered for replacement — edits win, as everywhere else.
+     * `uneditedSinceImport` is judged by the caller before its checkpoint
+     * bumps the edit revision.
+     */
+    private scheduleLayerReimportForWidthChange;
+    frameSizeDiffersFromAuthored(id: string): boolean;
+    /**
+     * Restores only the viewport contract supplied by the host manifest.
+     * Canvas position and camera state intentionally remain untouched.
+     */
+    resetFrameSize(id: string): boolean;
+    /** Called once when the pointer gesture starts — Afterwards, the move is updated with recordHistory=false. */
+    beginSectionTransform(name: string, kind: 'move' | 'resize'): boolean;
+    resizeSection(name: string, rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, recordHistory?: boolean): void;
+    removeFrame(id: string): boolean;
+    removeSection(name: string): void;
+    /** DOM snapshot of the route page into the page for editing — "Import as Layer". */
+    importDomAsPage(rootJson: NodeJSON, opts: {
+        name: string;
+        section?: string;
+        width?: number;
+        height?: number;
+    }): void;
+    /**
+     * D2 bootless edit promotion: when the page being activated still needs its
+     * layer import and a stamped, non-stale frozen preview is mounted for it,
+     * that preview is imported synchronously — no boot, no scheduling.
+     *
+     * The promotion is final. A mounted non-stale preview replays an
+     * assertion-verified capture of the same source revision, so a background
+     * live boot could only re-measure identical content — and it measures
+     * worse: a live app is mid-animation, so stacked title variants import as
+     * overlapping text, and its capture then replaced this verified tree.
+     * Stale or unstamped previews never reach this path and keep the boot
+     * pipeline; committed size changes schedule their own provisional
+     * re-import (resizeFrame/resetFrameSize).
+     */
+    private promoteFrozenLayerImport;
+    /**
+     * Applies a screen dimension value: adopts the matched raw captured node
+     * into the declared adapter instance (an undoable tree edit that keeps the
+     * captured layout box), or re-props an already adopted instance. Returns
+     * false when the page has no matching node.
+     */
+    /**
+     * Puts one captured piece into a declared state.
+     *
+     * `nodeId` targets a specific match, which is what a list needs: five
+     * repeated rows each own their badge, and without it every control on the
+     * panel would fight over the first one.
+     */
+    applyScreenDimension(pageId: string, dimension: ScreenDimensionDef, value: string, nodeId?: string): boolean;
+    /**
+     * Sets how many rows a declared list shows.
+     *
+     * Growth clones the last row — identical on purpose, because the core has
+     * no idea what a second row would say, and the per-row dimension
+     * controls are how a designer makes them differ. Shrinking drops trailing
+     * rows. One checkpoint covers the whole change, so it is a single undo,
+     * and because this only edits the captured tree the frame never waits on
+     * a walk.
+     */
+    applyScreenListLength(pageId: string, def: ScreenListDef, count: number): boolean;
+    /**
+     * Adds or removes one badge in one slot of one card.
+     *
+     * Adding clones a captured instance from another card when the screen has
+     * one, so the result is the product's own markup; only a badge nothing on
+     * screen shows is built from the declared adapter. The badge lands where
+     * the component would put it (the anchor), and a slot the product renders
+     * conditionally is created from a donor and removed again when it empties.
+     */
+    applyCardBadge(pageId: string, def: ScreenCardDef, cardNodeId: string, slot: CardSlotDef, option: CardBadgeOption, present: boolean): boolean;
+    /**
+     * Puts a frame into a declared interactive state by extending its recipe.
+     *
+     * The steps become part of `page.interactions`, which is what the preview
+     * cache key, the live replay and the session walk all read — so the frame
+     * asks for the variant through the ordinary supply instead of a parallel
+     * path. Returning to the base option restores the captured recipe.
+     */
+    applyInteractiveState(pageId: string, def: InteractiveStateDef, optionId: string): boolean;
+    /** Pages whose mounted frozen preview was refused at the import boundary. */
+    private frozenPromotionRefusals;
+    /** True when the page's frozen capture was refused and activation should boot live instead. */
+    frozenPromotionRefused(pageId: string): boolean;
+    /**
+     * Retries the bootless promotion for the active page once its frozen
+     * preview finishes mounting. An activation click without a hover dwell has
+     * no mounted preview to import from at switchPage time; the activated frame
+     * then renders its stamped frozen preview instead of booting live, and the
+     * mount registration calls back here — so every activation of a frame with
+     * a fresh stamped capture promotes within the mount, not a boot.
+     */
+    promoteFrozenLayerImportIfPending(pageId: string): void;
+    /** Monotonic revision of the page's content — bumps on every checkpointed mutation, restore, and DOM import. */
+    pageEditRevision(pageId: string): number;
+    private bumpPageEditRevision;
+    /** Edit revision recorded when the page was provisionally imported from a frozen preview, or null. */
+    provisionalLayerImportRevision(pageId: string): number | null;
+    /** Keeps the current (user-edited) tree and stops further live re-import attempts for the page. */
+    discardProvisionalLayerImport(pageId: string): void;
+    /** Design importer automatically inserts the capture results into the existing frame. The route is maintained for live preview. */
+    replacePageRootFromDom(pageId: string, rootJson: NodeJSON, result?: Pick<DomImportResult, 'count' | 'truncated'> & Partial<Pick<DomImportResult, 'diagnostics' | 'metrics'>>): void;
+    setPageLayerImportError(pageId: string, message: string): void;
+    /** Switch pages by name — Path used by the host fixture's actual button handler (pygmalionNavigate). */
+    navigateToPageByName(name: string): void;
+    /** Show preview overlay — page navigation with Scyllender, linkTo/host navigation without editor chrome. */
+    previewOpen: boolean;
+    /** Preview navigation history (back) — Stack of page ids. */
+    previewHistory: string[];
+    /** Edit Mode (top right toggle) — If false, block manipulation of canvas (view only). */
+    editMode: boolean;
+    /** Shows the Reflect (Change Summary) panel. */
+    applyOpen: boolean;
+    private editModeInitialized;
+    /**
+     * Applies the host's declared starting mode, once.
+     *
+     * Initial rather than controlled: the mode is a toggle the designer owns, and
+     * a prop that re-asserted itself on every render would snap them back out of
+     * whichever mode they chose. Once means once for the life of the store, so a
+     * canvas switch or a re-render does not reset it either. Nothing is persisted
+     * — a reload returns to the declared mode, which is a place a designer can
+     * find, unlike a remembered state with no visible home.
+     */
+    initEditMode(editMode: boolean): void;
+    toggleEditMode(): void;
+    setApplyOpen(v: boolean): void;
+    tool: 'select' | 'hand' | 'zoom' | 'section';
+    /** A section is a first-class object. Its display bounds include its rectangle and member frames. */
+    sections: SectionRect[];
+    /** Section name whose name is entered immediately after creation/double-clicking — SectionBoxes are rendered as input. */
+    sectionRenameTarget: string | null;
+    setTool(tool: 'select' | 'hand' | 'zoom' | 'section'): void;
+    setSectionRenameTarget(name: string | null): void;
+    /**
+   * Completing a section drag creates the rectangle immediately and includes intersecting frames.
+   * Immediately after creation, the state switches to name input, and the tool returns to select.
+   */
+    createSectionFromRect(x0: number, y0: number, x1: number, y1: number): void;
+    /**
+     * Enters the app screen for one frame, whichever frame is asked for.
+     *
+     * ▶ plays from the *current* frame, which is right for a toolbar button but
+     * makes "see this one for real" a two-step gesture: select the frame, then
+     * find the button. Double-clicking the frame's own label is the direct form of
+     * the same intent, so it names the frame instead of relying on selection.
+     */
+    openFramePreview(pageId: string): void;
+    openPreview(options?: {
+        notifyHost?: boolean;
+    }): void;
+    closePreview(options?: {
+        notifyHost?: boolean;
+    }): void;
+    previewBack(): void;
+    get selectedId(): string | null;
+    get selected(): NodeModel | null;
+    /** Select nodes — tree DFS order (preserve visual order when grouping/copying). */
+    get selectedNodes(): NodeModel[];
+    isSelected(id: string): boolean;
+    select(id: string | null): void;
+    setSelection(ids: string[]): void;
+    selectFrame(id: string): void;
+    /**
+   * An implicit section with only page.section promotes the currently displayed bbox to a first-class SectionRect at the moment of selection.
+   * Since this is a normalization step where the visible geometry does not change, no undo items are created, and only the actual move/resize is recorded thereafter.
+   */
+    selectSection(name: string, implicitRect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    toggleInSelection(id: string): void;
+    hover(id: string | null): void;
+    /** "Only the top" during selection — exclude nodes whose ancestors are also selected (group/copy/delete target calculations). */
+    private topLevelSelected;
+    toggleRenderCount(): void;
+    setZoom(z: number): void;
+    toggleCode(): void;
+    toggleCollapsed(id: string): void;
+    setDrag(id: string | null): void;
+    setDropHint(hint: DropHint | null): void;
+    openCtxMenu(x: number, y: number): void;
+    closeCtxMenu(): void;
+    requestRename(): void;
+    setRenaming(id: string | null): void;
+    startTextEdit(id: string): void;
+    stopTextEdit(): void;
+    private currentSnapshot;
+    /** Called just before mutation. Consecutive changes (resizing, dragging, typing) within 600ms of the same tag are grouped into one entry. */
+    checkpoint(tag: string, force?: boolean): void;
+    undo(): void;
+    redo(): void;
+    private restore;
+    /**
+   * The DOM import node preserves and renders the computed style. Only semantic fields in the properties panel
+   * If you change it, it may be hidden by the computed style, so the actual DOM style in the same patch is also
+   * Update. This is a key path that ensures that the active/inactive renderer only reads the same model.
+   */
+    private withImportedDomStyle;
+    private escapeFrozenSelectorValue;
+    private frozenStyleSelector;
+    private frozenSemanticSelector;
+    private escapeFrozenHtml;
+    private serializeFrozenNode;
+    private recordFrozenPreviewStructure;
+    private recordFrozenPreviewPatch;
+    /**
+   * Reapplies common structural edits previously performed to frames whose capture ended late.
+   * The structured JSON materializes into a new NodeModel each frame without sharing ids.
+   */
+    private applySharedSourceStructureOverrides;
+    /**
+   * Instantly replicates the structure of the common source container to all already captured frames,
+   * A final structure override is also left for frames that have not yet been captured.
+   */
+    private syncSharedSourceStructure;
+    /** A single action through which all changes pass through the properties panel, resize, and rename. */
+    patch(node: NodeModel, partial: Partial<NodeModel>): void;
+    /** Update one source-authored primitive JSX prop and keep the imported DOM preview in sync. */
+    patchSourceProp(node: NodeModel, prop: string, value: PrimitiveSourceValue): boolean;
+    /**
+     * Flips one registry-typed prop on a component instance through the regular
+     * patch spine: a single patch call means one undo step, shared-source
+     * propagation to peer instances, and frozen-preview replay. When the prop is
+     * literal-authored (present in sourceProps with a matching primitive type)
+     * the same sourceProps/domAttributes/own-props mirror patchSourceProp
+     * records is applied so Apply writes it back to source; otherwise the flip
+     * is preview-only.
+     */
+    patchComponentInstanceProp(node: NodeModel, prop: string, value: RegistryPropValue): {
+        applied: boolean;
+        sourceWritable: boolean;
+    };
+    /** Selection criteria Insert target — If it is a child-accepting node, it is inside it, if it is a leaf, it is the parent, and if it is not, it is the root. */
+    private insertTarget;
+    addNode(type: NodeType): void;
+    /** Insert a registry component into the canvas — an “actual React component” node. */
+    addComponentNode(name: string): void;
+    removeSelected(): void;
+    /** ⌘D · Alt+drag — Duplicate the top selections into their siblings (issue new IDs). */
+    duplicateSelected(): void;
+    copySelection(): void;
+    cutSelection(): void;
+    paste(): void;
+    /** Command/Ctrl-G groups selected siblings into a Rows container. */
+    groupSelected(): void;
+    /** ⌘⇧G — Unpacks the selected container and spreads its children into the parent's place. */
+    ungroupSelected(): void;
+    /**
+   * Decomposes the entire component node into the entire actual DOM layer.
+   * Internal registry component boundaries maintain their names, but sub-DOMs also continue to recurse.
+   */
+    decomposeSelectedComponent(): void;
+    /** Brackets move to the first or last position; modified brackets move one position. */
+    reorderSelected(dir: -1 | 1 | 'front' | 'back'): void;
+    toggleHiddenSelected(): void;
+    toggleLockedSelected(): void;
+    /** Number keys 1–9 set 10–90% opacity; 0 sets 100%. */
+    setOpacitySelected(v: number): void;
+    /** Drag drop commit — reorder/reparent. index is based on the child list “excluding the drag node”. */
+    moveNode(id: string, parentId: string, index: number): void;
+    /** root → corresponding node path. If not, []. */
+    pathTo(id: string): NodeModel[];
+    /** Is id in the rootId subtree (including itself)? */
+    isInSubtree(rootId: string, id: string): boolean;
+    /**
+   * Selection rules:
+   * · Click: Top level (immediate root). If you are already in the depth, you are the brother of that depth.
+   * · Double click (drill): Enter one step. · ⌘click (deep): Deepest part. · Shift(additive): Toggle.
+   */
+    selectFromHit(deepestId: string, opts?: {
+        deep?: boolean;
+        drill?: boolean;
+        additive?: boolean;
+    }): void;
+    /** ⌘A — All siblings of the current depth (directly at the root if none exist). */
+    selectAllSiblings(): void;
+    /** Tab/⇧Tab — Sibling cycle. */
+    selectSibling(delta: -1 | 1): void;
+    /** Enter — First child entry. */
+    selectFirstChild(): void;
+    /** ⇧Enter — To Parent. */
+    selectParent(): void;
+}
+export declare function findNode(from: NodeModel, id: string): NodeModel | null;
+export declare function findParent(from: NodeModel, id: string): NodeModel | null;
+export declare const editor: EditorStore;
+export {};