@pygmalionjs/pygmalion 0.5.14 → 0.5.16

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

@@ -0,0 +1,67 @@
+/**
+ * Which frame the pointer is over, computed from geometry rather than hit testing.
+ *
+ * The canvas camera layer turns off hit testing unless the select tool is active,
+ * so a canvas tool can drag across frame content. That also means a frame never
+ * sees a real pointer event in those modes — and hover is exactly when preparing
+ * the next frame pays off. The canvas surface still owns the pointer, so the frame
+ * under it is resolved from the camera transform and the frame boxes instead.
+ */
+export interface FrameBox {
+    frameId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface CanvasCamera {
+    panX: number;
+    panY: number;
+    zoom: number;
+}
+export interface ClientRectLike {
+    left: number;
+    top: number;
+}
+/** Converts a client point into canvas coordinates. Mirrors the marquee math in the canvas surface. */
+export declare function canvasPointFromClient(client: {
+    clientX: number;
+    clientY: number;
+}, rect: ClientRectLike, camera: CanvasCamera): {
+    x: number;
+    y: number;
+} | null;
+/**
+ * Returns the frame containing a canvas point, or null.
+ *
+ * Later frames win, matching paint order: a frame drawn on top of another is the
+ * one the designer is pointing at.
+ */
+export declare function frameAtCanvasPoint(frames: readonly FrameBox[], point: {
+    x: number;
+    y: number;
+} | null): string | null;
+export type FrameHoverTransition = {
+    action: 'idle';
+} | {
+    action: 'restart';
+    frameId: string;
+} | {
+    action: 'clear';
+};
+/**
+ * Decides what a pointer move does to the pending dwell.
+ *
+ * Leaving a frame forgets it, which is what makes returning to it start over. If
+ * the frame were remembered, a pointer that left before the dwell elapsed and came
+ * back would look like it had never moved, and that frame would never be prepared.
+ */
+export declare function resolveFrameHoverTransition(previousFrameId: string | null, frameId: string | null): FrameHoverTransition;
+/**
+ * Reports whether the canvas surface has to resolve hover itself.
+ *
+ * With the select tool the frames receive real pointer events, so the frame's own
+ * hover path already noted the intent; resolving it again from the surface would
+ * note the same frame twice.
+ */
+export declare function canvasOwnsFrameHover(editMode: boolean, tool: string): boolean;

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

@@ -0,0 +1,53 @@
+export type FramePointerIntent = 'select-frame' | 'delegate-to-layer' | 'delegate-to-canvas';
+export type ImportedRouteSurface = 'editable-layers' | 'responsive-preview';
+/**
+ * The first pointer press on an inactive frame selects the frame shell only.
+ * A later press may reach its editable DOM layers. Canvas tools always retain
+ * ownership of the pointer so panning and section operations remain available.
+ */
+export declare function resolveFramePointerIntent(active: boolean, tool: string): FramePointerIntent;
+/**
+ * Imported route layers stay interactive while the frame shell is selected.
+ * The frozen responsive preview covers every window in which the captured
+ * layer geometry cannot follow the frame's viewport: a resize gesture in
+ * progress, and a committed size change whose re-import has not landed yet.
+ */
+export declare function resolveImportedRouteSurface(snapshotAvailable: boolean, sizeTransitionActive: boolean): ImportedRouteSurface;
+/**
+ * True while a frame's viewport is moving or has moved away from the width
+ * its layers were imported at. Imported layer geometry is only valid at its
+ * import width — rendering it at another width overlaps and collides. A
+ * viewport preset click commits a resize with no drag gesture; the frozen
+ * replay covers the frame until the provisional re-import lands at the new
+ * width. An edited tree schedules no re-import (edits win), so it settles
+ * back to its editable layers immediately.
+ */
+export declare function frameSizeTransitionPending({ resizeDraftActive, importedAtCommittedWidth, reimportScheduled, }: {
+    /** A resize drag gesture is in progress. */
+    resizeDraftActive: boolean;
+    /** The committed width equals the width the layers were imported at. */
+    importedAtCommittedWidth: boolean;
+    /** A provisional re-import is scheduled for the committed size. */
+    reimportScheduled: boolean;
+}): boolean;
+/**
+ * The whole activating gesture belongs to frame selection, not just its
+ * mousedown. Activation imports the frozen preview synchronously (the D2
+ * contract in docs/perf-contracts.md), so by the time the browser dispatches
+ * the gesture's trailing `click`, an interactive imported tree already sits
+ * under the pointer — and a design-surface selection click must never reach
+ * application handlers (it navigated the host app's router when it did).
+ *
+ * The gate arms on the select-frame mousedown, consumes exactly one trailing
+ * click, and releases when the gesture is over — releasing also covers the
+ * click that never comes (press, drag off the frame, release elsewhere).
+ */
+export interface FrameActivationClickGate {
+    /** Arm on the select-frame mousedown that activates the frame. */
+    arm(): void;
+    /** The gesture ended without a suppressible click — disarm. */
+    release(): void;
+    /** True exactly once for the click belonging to the arming gesture. */
+    consume(): boolean;
+}
+export declare function createFrameActivationClickGate(): FrameActivationClickGate;

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

@@ -0,0 +1,26 @@
+/** Channels that stay global: they change rarely and invalidate every frame. */
+export declare function useGlobalPreviewChannels(): {
+    appOrigin: string;
+    previewRevision: string;
+    environmentControlRevision: number;
+};
+/**
+ * Channels scoped to one frame. Artifact events arrive under two key spaces —
+ * the recipe cache key and the frame identity — so both are subscribed; a
+ * whole-store event bumps an epoch inside every version getter. cacheHydrated
+ * composes the canvas-wide prehydration flag with this frame's own keys and is
+ * kept fresh by the per-key snapshot subscription.
+ */
+export declare function useFrameKeyChannels(keys: {
+    pageId: string;
+    routePreviewKey: string;
+    authoredRoutePreviewKey: string;
+    canonicalId: string;
+    fingerprint: string | null;
+    /** The batched prehydration flag; defaults to false until the caller threads it. */
+    batchHydrated?: boolean;
+}): {
+    artifactRevision: number;
+    previewIntended: boolean;
+    cacheHydrated: boolean;
+};

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

@@ -0,0 +1,21 @@
+import { type PageModel } from './store';
+/**
+ * The preview environment of one page: its own declared environment, plus the
+ * host's preview-environment override when the page is the active one.
+ *
+ * `active` matters for reactivity, not just for the merge. The default reads
+ * `editor.activePageId`, and inside a MobX observer render that read
+ * subscribes the component to every selection change — which is how a single
+ * click used to re-render all 79 frames. A caller that already knows whether
+ * its page is active (FrameView receives it as a prop) must pass `active`
+ * explicitly so its render never touches the selection observable.
+ */
+export declare function pagePreviewEnvironment(page: PageModel, active?: boolean): import("./designImport").StoryboardEnvironment | undefined;
+/**
+ * The recipe cache key of one page. `active` is forwarded to
+ * pagePreviewEnvironment — see its note on selection reactivity.
+ */
+export declare function routePreviewCacheKey(page: PageModel, previewRevision: string, viewport?: {
+    width: number;
+    height: number;
+}, active?: boolean): string;

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

@@ -0,0 +1,16 @@
+export type FrameWheelRoute = 'canvas' | 'native-preview' | 'programmatic-preview';
+export interface ScrollMetrics {
+    scrollLeft: number;
+    scrollTop: number;
+    scrollWidth: number;
+    scrollHeight: number;
+    clientWidth: number;
+    clientHeight: number;
+}
+export declare function canConsumeWheelDelta(metrics: ScrollMetrics, deltaX: number, deltaY: number): boolean;
+/**
+ * Keeps a wheel gesture inside an active frame while its rendered DOM can
+ * consume the requested delta. Once the inner scroller reaches its edge, the
+ * same gesture falls back to the infinite canvas.
+ */
+export declare function routeFrameWheel(event: WheelEvent): FrameWheelRoute;

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

@@ -0,0 +1,70 @@
+import type { DomImportOptions, DomImportResult } from './domImport';
+import type { InstanceResolver } from './fiberMap';
+import type { ShadowPreviewHandle } from './shadowPreview';
+/** Reads Track-D stamped attributes back into the fiberMap InstanceHit shape. */
+export declare function createStampedInstanceResolver(): InstanceResolver;
+/**
+ * `file#localName` CSS-module source of a frozen-preview element. The stamped
+ * attribute wins; the sourceTargetOf fallback reads __PYG_CSS_MODULES__ from
+ * the element's own window, which is usually absent in the editor realm — a
+ * harmless miss that yields ''.
+ */
+export declare function resolveStampedSourceStyle(el: Element): string;
+/** True when the document carries the Track-D body marker — unstamped frozen previews keep the boot path. */
+export declare function isStampedFrozenPreview(root: ParentNode): boolean;
+export type ShadowPreviewImportOptions = Omit<DomImportOptions, 'resolveInstance' | 'resolveSourceStyle'>;
+/**
+ * Whether a not-yet-mounted snapshot would support the D2 promotion once
+ * mounted — the string-level counterpart of `isStampedFrozenPreview`, used to
+ * decide surfaces before paying for the mount (a hover should not warm-boot
+ * the live pipeline when the frozen preview can deliver the editable tree).
+ */
+export declare function frozenSnapshotStamped(input: {
+    bodyAttributes?: string | null;
+    snapshotHtml?: string | null;
+}): boolean;
+/**
+ * Imports the mounted frozen preview under `handle` as a layer tree, or null
+ * when the promotion cannot produce a faithful result (torn-down handle,
+ * unstamped snapshot, skipped rendering, or no design-import controller). The
+ * controller supplies the same layer options the live captureIframeWhenStable
+ * import uses, so the provisional tree matches what the live swap delivers.
+ */
+/**
+ * The minimum plausible import size for a replay of `sourceElements`
+ * elements. An import far below the floor means the replay was measured in
+ * a broken state (styles missing, half torn down) — committing it would pin
+ * a near-empty tree as final, so the promotion refuses and retries when the
+ * next ready mount registers. Tiny sources import as-is: a floor there would
+ * only reject legitimate minimal screens.
+ */
+export declare function importCountFloor(sourceElements: number): number;
+/**
+ * Element-count magnitude of a serialized capture, for cross-source
+ * plausibility checks: a live import of a screen whose verified capture
+ * holds hundreds of elements cannot plausibly be a handful of divs — that is
+ * a half-booted app shell (dead backend, unfinished replay), not the screen.
+ * Counts opening tags; the floor only needs the order of magnitude.
+ */
+export declare function countMarkupElements(markup: string | null | undefined, limit?: number): number;
+export declare function importDomFromShadowPreview(handle: ShadowPreviewHandle, options?: ShadowPreviewImportOptions): DomImportResult | null;
+export interface LiveImportSwapInput {
+    /** True when the page tree changed after the provisional frozen import. */
+    editedSinceImport: boolean;
+}
+/**
+ * Decides whether an arriving live-import result may replace a provisional
+ * frozen import. Edits win: a user tree is never clobbered by the background
+ * boot — the existing stale affordance covers manual refresh instead.
+ */
+export declare function shouldSwapLiveImport(input: LiveImportSwapInput): boolean;
+/**
+ * Registers the live mount handle for a page. The returned cleanup removes
+ * exactly this registration, so a newer mount is never clobbered by a stale
+ * teardown.
+ */
+export declare function registerMountedShadowPreview(pageId: string, handle: ShadowPreviewHandle, options?: {
+    stale?: boolean;
+}): () => void;
+/** The mounted handle for a page, or null when none is mounted or the mounted preview is stale. */
+export declare function getMountedShadowPreviewHandle(pageId: string): ShadowPreviewHandle | null;

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

@@ -0,0 +1,133 @@
+import type { InspectApplyPayload } from './inspect';
+import type { DesignImportKind } from './designImport';
+import type { InspectQaResult } from './visualQa';
+export interface ApplyPayload {
+    tokens: {
+        name: string;
+        value: string;
+    }[];
+    pages: {
+        id: string;
+        name: string;
+        path: string;
+        width: number;
+        height: number;
+        canvas: string;
+        section?: string;
+        jsx: string;
+    }[];
+}
+/** Result returned after the host applies inspected source changes. */
+export interface InspectApplyResult {
+    applied: number;
+    /** Modification session branch created by the host. */
+    branch?: string;
+    /** Result of merging with latest development code. */
+    integration?: 'up_to_date' | 'auto_merged' | 'review_required' | 'conflict' | 'offline';
+    /** Text of application results to show to the designer. */
+    message?: string;
+    /** Comparison of DOM·PNG recapture of the impact screen immediately after application. */
+    qa?: InspectQaResult;
+}
+export interface InspectPreviewResult {
+    revision: number;
+    files: {
+        file: string;
+        diff: string;
+    }[];
+    affectedFiles: string[];
+    /** Based on comparison of impact screens captured in current revision. */
+    qa?: InspectQaResult;
+}
+export interface InspectImpactResult {
+    files: string[];
+}
+/**
+ * Unit of code edited on the canvas.
+ * The save UI is not divided according to asset type. icon/atom/component/screen are all
+ * It is the same JSX document, and the only difference is that the token is a value document, leaving the transport payload.
+ */
+export interface DesignCodeDocument {
+    type: 'document';
+    id: string;
+    kind: DesignImportKind;
+    name: string;
+    canvas: string;
+    section?: string;
+    path?: string;
+    route?: string;
+    width: number;
+    height: number;
+    assetIds: string[];
+    sourcePaths: string[];
+    jsx: string;
+}
+export interface DesignTokenDocument {
+    type: 'token';
+    id: string;
+    kind: 'design-tokens';
+    name: string;
+    value: string;
+}
+export type DesignElementDocument = DesignCodeDocument | DesignTokenDocument;
+export interface DesignElementChange {
+    operation: 'upsert' | 'delete';
+    element: DesignElementDocument;
+}
+/** Successive edits of one element are combined into one final state and delivered to the host. */
+export interface DesignChangePayload {
+    revision: number;
+    changes: DesignElementChange[];
+}
+export interface DesignChangeResult {
+    saved: number;
+    files?: string[];
+    message?: string;
+}
+export declare function setAppOrigin(origin: string): void;
+export declare function getAppOrigin(): string;
+export declare function subscribeAppOrigin(listener: () => void): () => void;
+export declare function setArtifactOrigin(origin: string): void;
+/**
+ * Origin a captured snapshot resolves its relative assets against.
+ *
+ * This is not the same question as "where does the live screen run". A capture is
+ * already rendered — it needs somewhere to fetch the images and fonts its markup
+ * still points at — while a live frame needs the checkout of a specific revision.
+ * Answering both with one value tied the catalog to a checkout that takes minutes
+ * to build, so opening the editor showed a spinner instead of the frames sitting
+ * on disk.
+ *
+ * The order is most-accurate-first: an origin the host declared, then the live
+ * one once a runtime exists, then the editor's own — which serves the same
+ * application and lets the catalog paint immediately. Assets it cannot resolve
+ * are the ones the working tree no longer has; the live origin replaces them the
+ * moment it comes up, because these readers re-run when it does.
+ */
+export declare function getArtifactOrigin(): string;
+export declare function subscribeArtifactOrigin(listener: () => void): () => void;
+/** Baseline code version of the preview (dev SHA, etc.). When a change is made, a new static screen cache of the same URL is also created. */
+export declare function setPreviewRevision(revision: string): void;
+export declare function getPreviewRevision(): string;
+export declare function subscribePreviewRevision(listener: () => void): () => void;
+export declare function setFlowCanvas(canvas: string): void;
+export declare function getFlowCanvas(): string;
+export declare function setStaticFrameSurface(surface: 'bitmap' | 'dom'): void;
+export declare function getStaticFrameSurface(): 'bitmap' | 'dom';
+export declare function setOnApply(cb: ((payload: ApplyPayload) => Promise<{
+    branch: string;
+} | void>) | null): void;
+export declare function getOnApply(): ((payload: ApplyPayload) => Promise<{
+    branch: string;
+} | void>) | null;
+export declare function setOnInspectApply(cb: ((payload: InspectApplyPayload) => Promise<InspectApplyResult | void>) | null): void;
+export declare function getOnInspectApply(): ((payload: InspectApplyPayload) => Promise<InspectApplyResult | void>) | null;
+export declare function setOnInspectPreview(cb: ((payload: InspectApplyPayload) => Promise<InspectPreviewResult>) | null): void;
+export declare function getOnInspectPreview(): ((payload: InspectApplyPayload) => Promise<InspectPreviewResult>) | null;
+export declare function setOnInspectImpact(cb: ((componentFiles: string[]) => Promise<InspectImpactResult>) | null): void;
+export declare function getOnInspectImpact(): ((componentFiles: string[]) => Promise<InspectImpactResult>) | null;
+export declare function setOnDesignChange(cb: ((payload: DesignChangePayload) => Promise<DesignChangeResult | void>) | null): void;
+export declare function getOnDesignChange(): ((payload: DesignChangePayload) => Promise<DesignChangeResult | void>) | null;
+/** ▶ Synchronize the preview open status with the host router. */
+export declare function setOnPreviewOpenChange(cb: ((open: boolean) => void) | null): void;
+export declare function getOnPreviewOpenChange(): ((open: boolean) => void) | null;

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

@@ -0,0 +1,225 @@
+/**
+ * css module source mapping — host vite plugin (pygmalion-inspect-plugin)
+ * window.__PYG_CSS_MODULES__ Derived from registration stacked in an array (scope class → scss file/local name).
+ */
+export interface SourceTarget {
+    /** .module.scss path (relative to host project root). */
+    file: string;
+    /** The component file that imported the scss (text write-back target). */
+    componentFile: string;
+    /** Local class name (e.g. row). */
+    localName: string;
+}
+/** Source mapping to the element's first css module class — null if not present (live-only editing). */
+export declare function sourceTargetOf(el: Element): SourceTarget | null;
+/** Target file for text write-back — componentFile of the first css module mapping class of itself/ancestor. */
+export declare function nearestComponentFile(el: Element): string | null;
+/** A safe structured representation of `componentFile|sourceStart|elementName` that the Vite transform injects into the DOM. */
+export interface SourceIdentity {
+    componentFile: string;
+    sourceStart: number;
+    elementName: string;
+}
+export interface SourceAffectedFrame {
+    id: string;
+    name: string;
+}
+export type SourceEditScope = 'instance' | 'shared-source';
+export type PrimitiveSourceValue = string | number | boolean;
+export type PrimitiveSourceValueType = 'string' | 'number' | 'boolean';
+export interface SourceInsertComponent {
+    name: string;
+    importPath: string;
+    importKind: 'named';
+    props: Record<string, PrimitiveSourceValue>;
+    children?: string;
+}
+export type SourceEditOperation = {
+    kind: 'prop';
+    identity: SourceIdentity;
+    prop: string;
+    from: PrimitiveSourceValue;
+    to: PrimitiveSourceValue;
+    valueType: PrimitiveSourceValueType;
+    scope: SourceEditScope;
+    affectedFrames: SourceAffectedFrame[];
+} | {
+    kind: 'text';
+    identity: SourceIdentity;
+    from: string;
+    to: string;
+    scope: SourceEditScope;
+    affectedFrames: SourceAffectedFrame[];
+} | {
+    kind: 'insert';
+    mode: 'clone';
+    identity: SourceIdentity;
+    fromIndex: number;
+    toIndex: number;
+    scope: SourceEditScope;
+    affectedFrames: SourceAffectedFrame[];
+} | {
+    kind: 'insert';
+    mode: 'component';
+    identity: SourceIdentity;
+    slot: 'children';
+    toIndex: number;
+    component: SourceInsertComponent;
+    scope: SourceEditScope;
+    affectedFrames: SourceAffectedFrame[];
+} | {
+    kind: 'remove';
+    identity: SourceIdentity;
+    fromIndex: number;
+    scope: SourceEditScope;
+    affectedFrames: SourceAffectedFrame[];
+} | {
+    kind: 'move';
+    identity: SourceIdentity;
+    fromIndex: number;
+    toIndex: number;
+    scope: SourceEditScope;
+    affectedFrames: SourceAffectedFrame[];
+};
+/** Parse strictly to avoid using untrustworthy DOM attributes as file paths/offsets. */
+export declare function parseSourceIdentity(raw: string | null | undefined): SourceIdentity | null;
+export declare function sourceIdentityOf(el: Element): SourceIdentity | null;
+/** The JSX opening that owns the rendered host element, independent of forwarded component props. */
+export declare function ownSourceIdentityOf(el: Element): SourceIdentity | null;
+/** Primitive literals authored on the owning JSX opening and safe for guarded AST replacement. */
+export declare function parsePrimitiveSourceProps(raw: string | null | undefined): Record<string, PrimitiveSourceValue>;
+/** Number of static direct JSX elements of the slot owner injected by instrumentation. The number of DOM children may differ from the slot, so it is not used. */
+export declare function sourceSlotChildCountOf(el: Element): number | null;
+/** The basic scope of influence for JSX component calls is the corresponding call-site instance, and for intrinsic DOM, the same source element. */
+export declare function sourceEditScopeFor(identity: SourceIdentity): SourceEditScope;
+/** Component props that do not correspond to the DOM, such as variants, are false — the actual results are visible after AST reflection/HMR. */
+export declare function canPreviewSourceProp(el: HTMLElement, prop: string): boolean;
+/** Relative paths whose meaning varies based on the target file are excluded. This slice supports only alias and bare package. */
+export declare function isSafeComponentImportPath(importPath: string): boolean;
+/** Normalize registry metadata only when it can be shared as is with AST payload and UI. */
+export declare function sourceInsertComponentFor(componentName: string): SourceInsertComponent | null;
+interface ComponentStructurePreview {
+    wrapper: HTMLElement;
+    mount: () => boolean;
+    unmount: () => void;
+    status: () => 'component' | 'placeholder';
+}
+export interface InspectEntry {
+    id: number;
+    kind: 'style' | 'text' | 'prop' | 'structure';
+    el: HTMLElement;
+    /** Display name — Registered component name or tag.localClass. */
+    label: string;
+    /** style: CSS property / text: 'text' / prop: JSX prop name. */
+    prop: string;
+    from: string;
+    to: string;
+    /** Whether the value is a var(--…) token (for log badges). */
+    token: boolean;
+    /** style write-back target (live only if none). */
+    source: SourceTarget | null;
+    /** text write-back destination file (live only if none). */
+    componentFile: string | null;
+    /** If not present, default rule; if present, responsive rule for the corresponding viewport scope. */
+    media: InspectMedia | null;
+    /** AST-based prop/text reflection target. If not, use the existing CSS/exact text replacement path. */
+    sourceIdentity: SourceIdentity | null;
+    sourceScope: SourceEditScope | null;
+    valueType: PrimitiveSourceValueType | null;
+    /** Whether the change is previewed immediately. Otherwise it appears after source apply and HMR. */
+    previewApplied: boolean;
+    affectedFrames: SourceAffectedFrame[];
+    /** DOM staging metadata for structure entries only. */
+    structureKind?: 'insert' | 'remove' | 'move';
+    structureInsertMode?: 'clone' | 'component';
+    structureParent?: HTMLElement;
+    structureClone?: HTMLElement;
+    structureComponent?: SourceInsertComponent;
+    structurePreview?: ComponentStructurePreview;
+}
+export interface InspectMedia {
+    minWidth?: number;
+    maxWidth?: number;
+}
+/** Source edit payload posted through a host-provided write-back endpoint. */
+export interface InspectApplyPayload {
+    /** Final bundle of declarations per (scss file, local class). */
+    styles: {
+        file: string;
+        className: string;
+        componentFile: string;
+        declarations: Record<string, string>;
+        affectedFrames: SourceAffectedFrame[];
+        media?: InspectMedia;
+    }[];
+    /** Initial text for each element → Final text (assuming one-time exact matching substitution in the source). */
+    texts: {
+        componentFile: string;
+        oldText: string;
+        newText: string;
+        affectedFrames: SourceAffectedFrame[];
+    }[];
+    /** AST-based prop/text editing using injected JSX source locations. */
+    operations: SourceEditOperation[];
+}
+export declare class InspectSession {
+    /** Final commit candidate. Only one combination of the same element, attribute, and breakpoint is always maintained. */
+    entries: InspectEntry[];
+    toastMsg: string;
+    toastSeq: number;
+    private seq;
+    /** Undo/Redo is a session memory cache separate from the final patch. */
+    private undoHistory;
+    private redoHistory;
+    /** Original value before editing for each (element, property, breakpoint). */
+    private originals;
+    private listeners;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    subscribe(fn: () => void): () => void;
+    private notify;
+    reset(): void;
+    toast(msg: string): void;
+    private scopeKey;
+    private originalValue;
+    private setOriginalValue;
+    private sameTarget;
+    private pendingFor;
+    /** Fold 1 manipulation into the final patch. When it returns to its original value, it is removed from the commit candidates. */
+    private updatePending;
+    private pushOperation;
+    /** Commit style edits — apply DOM immediately + record history + merge final patches. */
+    recordStyle(el: HTMLElement, prop: string, value: string, label: string, media?: InspectMedia | null, affectedFrames?: readonly SourceAffectedFrame[]): void;
+    hasPendingValueEdit(el: HTMLElement): boolean;
+    hasPendingStructuralEdit(el: HTMLElement): boolean;
+    structuralEditKind(el: HTMLElement): InspectEntry['structureKind'] | null;
+    /** A source element stages only one value or structure, and a DOM parent stages only one structure change. */
+    structuralBlockReason(el: HTMLElement, requested: 'insert' | 'remove' | 'move'): string | null;
+    /** Check whether the registry component can be placed in the children slot of the selection element. */
+    componentInsertBlockReason(el: HTMLElement, targetComponentName?: string | null): string | null;
+    /** Text edit commit — Only one final text per element is kept as a commit candidate. */
+    recordText(el: HTMLElement, newText: string, label: string, affectedFrames?: readonly SourceAffectedFrame[]): boolean;
+    /** Editing primitive component props — Possible DOM properties are reflected immediately, variants, etc. are reflected after application/HMR. */
+    recordProp(el: HTMLElement, prop: string, originalValue: PrimitiveSourceValue, newValue: PrimitiveSourceValue, label: string, identity?: SourceIdentity | null, affectedFrames?: readonly SourceAffectedFrame[]): boolean;
+    recordDuplicate(el: HTMLElement, label: string, affectedFrames?: readonly SourceAffectedFrame[]): boolean;
+    /** Inserts the registry component directly into the children slot of the selected element. */
+    recordComponentInsert(slotOwner: HTMLElement, componentName: string, toIndex: number, label: string, targetComponentName?: string | null, affectedFrames?: readonly SourceAffectedFrame[]): boolean;
+    recordRemove(el: HTMLElement, label: string, affectedFrames?: readonly SourceAffectedFrame[]): boolean;
+    recordMove(el: HTMLElement, direction: -1 | 1, label: string, affectedFrames?: readonly SourceAffectedFrame[]): boolean;
+    private applyValue;
+    undo(): void;
+    redo(): void;
+    /** Returns all unapplied operations to their original values. Redo cache is preserved. */
+    restoreOriginal(): void;
+    /** Restore every unapplied change and clear undo and redo history. */
+    discardPending(): void;
+    /** Build the apply payload using AST operations or the legacy CSS and exact-text path. */
+    buildApplyPayload(): InspectApplyPayload;
+    /** Impact graph results are reflected in the current source operation. If they are the same, they are not re-rendered. */
+    updateAffectedFrames(frames: readonly SourceAffectedFrame[]): void;
+    /** After successful reflection — only the mapped and reflected entries are emptied from the log (leaving live-only entries). */
+    clearApplied(): void;
+}
+export declare function isSourceBackedEntry(entry: InspectEntry): boolean;
+export declare const inspectSession: InspectSession;
+export {};