@hy-bricks/canvas 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,1982 @@
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { DefineComponent } from 'vue';
+import { InjectionKey } from 'vue';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { ShallowRef } from 'vue';
+import { VNode } from 'vue';
+
+declare const __VLS_component: DefineComponent<__VLS_Props_2, {
+context: CanvasContext;
+handle: CanvasHandle & {
+dispose(): void;
+};
+canvasId: string;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"cannot-drag-slot-child": (payload: {
+instanceId: string;
+parentId: string | undefined;
+}) => any;
+"cannot-drag-layout-managed-child": (payload: {
+instanceId: string;
+parentId: string | undefined;
+parentLayoutMode: ContainerLayoutConfig["mode"];
+}) => any;
+"update:modelValue": (doc: PageDocument) => any;
+"context-ready": (ctx: CanvasContext) => any;
+"handle-ready": (handle: CanvasHandle) => any;
+}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{
+"onCannot-drag-slot-child"?: ((payload: {
+instanceId: string;
+parentId: string | undefined;
+}) => any) | undefined;
+"onCannot-drag-layout-managed-child"?: ((payload: {
+instanceId: string;
+parentId: string | undefined;
+parentLayoutMode: ContainerLayoutConfig["mode"];
+}) => any) | undefined;
+"onUpdate:modelValue"?: ((doc: PageDocument) => any) | undefined;
+"onContext-ready"?: ((ctx: CanvasContext) => any) | undefined;
+"onHandle-ready"?: ((handle: CanvasHandle) => any) | undefined;
+}>, {
+mode: CanvasMode;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+stageContainerEl: HTMLDivElement;
+}, any>;
+
+declare const __VLS_component_2: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+stageEl: HTMLDivElement;
+}, HTMLDivElement>;
+
+declare const __VLS_component_3: DefineComponent<__VLS_Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"cannot-drag-slot-child": (payload: {
+instanceId: string;
+parentId: string | undefined;
+}) => any;
+"cannot-drag-layout-managed-child": (payload: {
+instanceId: string;
+parentId: string | undefined;
+parentLayoutMode: ContainerLayoutConfig["mode"];
+}) => any;
+}, string, PublicProps, Readonly<__VLS_Props_4> & Readonly<{
+"onCannot-drag-slot-child"?: ((payload: {
+instanceId: string;
+parentId: string | undefined;
+}) => any) | undefined;
+"onCannot-drag-layout-managed-child"?: ((payload: {
+instanceId: string;
+parentId: string | undefined;
+parentLayoutMode: ContainerLayoutConfig["mode"];
+}) => any) | undefined;
+}>, {
+mode: CanvasMode;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+layerEl: HTMLDivElement;
+}, HTMLDivElement>;
+
+declare type __VLS_Props = {
+    payload?: PageRenderPayload;
+    document?: PageDocument;
+    componentSourceMap?: ComponentSourceMap;
+    schedulerOptions?: RenderSchedulerOptions;
+    canvasId?: string;
+    adapters?: CanvasAdapters;
+};
+
+declare type __VLS_Props_2 = {
+    modelValue?: PageDocument;
+    componentSourceMap?: ComponentSourceMap;
+    mode?: CanvasMode;
+    schedulerOptions?: RenderSchedulerOptions;
+    adapters?: CanvasAdapters;
+    canvasId?: string;
+};
+
+declare type __VLS_Props_3 = {
+    componentSourceMap?: ComponentSourceMap;
+    mode?: CanvasMode;
+    schedulerOptions?: RenderSchedulerOptions;
+    canvasId?: string;
+};
+
+declare type __VLS_Props_4 = {
+    mode?: CanvasMode;
+};
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => VNode[];
+        'canvas-overlay'?: (props: {
+            viewport: CanvasHandle["viewport"];
+            handle: CanvasHandle;
+        }) => VNode[];
+        'reparent-ghost'?: (props: {
+            state: {
+                rect: Rect;
+                target: DropTarget;
+                result: CanReparentResult;
+            };
+        }) => VNode[];
+        'split-divider'?: (props: {
+            state: {
+                parentId: string;
+                dividerIndex: number;
+                direction: "horizontal" | "vertical";
+                rect: Rect;
+                isDragging: boolean;
+            };
+        }) => VNode[];
+    }> & {
+        default?: () => VNode[];
+        'canvas-overlay'?: (props: {
+            viewport: CanvasHandle["viewport"];
+            handle: CanvasHandle;
+        }) => VNode[];
+        'reparent-ghost'?: (props: {
+            state: {
+                rect: Rect;
+                target: DropTarget;
+                result: CanReparentResult;
+            };
+        }) => VNode[];
+        'split-divider'?: (props: {
+            state: {
+                parentId: string;
+                dividerIndex: number;
+                direction: "horizontal" | "vertical";
+                rect: Rect;
+                isDragging: boolean;
+            };
+        }) => VNode[];
+    };
+    refs: {
+        stageContainerEl: HTMLDivElement;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_2(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        stageEl: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_3(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        'reparent-ghost'?: (props: {
+            state: {
+                rect: Rect;
+                target: DropTarget;
+                result: CanReparentResult;
+            };
+        }) => unknown;
+        'split-divider'?: (props: {
+            state: {
+                parentId: string;
+                dividerIndex: number;
+                direction: "horizontal" | "vertical";
+                rect: Rect;
+                isDragging: boolean;
+            };
+        }) => unknown;
+    }> & {
+        'reparent-ghost'?: (props: {
+            state: {
+                rect: Rect;
+                target: DropTarget;
+                result: CanReparentResult;
+            };
+        }) => unknown;
+        'split-divider'?: (props: {
+            state: {
+                parentId: string;
+                dividerIndex: number;
+                direction: "horizontal" | "vertical";
+                rect: Rect;
+                isDragging: boolean;
+            };
+        }) => unknown;
+    };
+    refs: {
+        layerEl: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
+
+declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_3<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare function applyEffectiveSplitRatiosToDocument(doc: PageDocument): PageDocument;
+
+export declare function applySplitDividerDrag(startRatios: readonly number[], dividerIndex: number, deltaPx: number, parentAxisPx: number, gap?: number): number[];
+
+export declare function assertNeverBindingSource(s: never): never;
+
+export declare function assertNeverBindingTarget(t: never): never;
+
+export declare interface AssetRef {
+    id: string;
+    type?: 'image' | 'video' | 'font' | 'json' | 'file';
+    url?: string;
+    name?: string;
+    meta?: Record<string, unknown>;
+}
+
+export declare interface AssetResolver {
+    resolve(ref: AssetRef): string | Promise<string>;
+    __clearCache(): void;
+}
+
+export declare interface AssetsAdapter {
+    resolve(ref: AssetRef): string | Promise<string>;
+}
+
+export declare type BindingErrorCode = 'target-not-mounted' | 'unsupported-cross-canvas' | 'unknown-target-data-input' | 'no-data-adapter' | 'data-query-failed' | 'cycle-detected' | 'invoke-failed';
+
+export declare interface BindingErrorEvent {
+    bindingId: string;
+    code: BindingErrorCode;
+    message?: string;
+    detail?: unknown;
+}
+
+export declare interface BindingErrorPolicy {
+    onError?: 'continue' | 'stop' | 'log';
+}
+
+export declare type BindingEventCb<E extends 'binding:fire' | 'binding:error' | 'binding:trace'> = E extends 'binding:fire' ? (event: BindingFireEvent) => void : E extends 'binding:error' ? (event: BindingErrorEvent) => void : (event: BindingTraceEvent) => void;
+
+export declare interface BindingFireEvent {
+    bindingId: string;
+    source: BindingSource;
+    target: BindingTarget;
+    payload: unknown;
+    args: unknown[];
+}
+
+export declare interface BindingInstanceRef {
+    canvasId?: string;
+    instanceId: string;
+}
+
+export declare type BindingIssue = BindingScopedIssue | InstanceDataInputMissingIssue;
+
+declare interface BindingIssueBase {
+    level: BindingIssueLevel;
+    message: string;
+}
+
+export declare type BindingIssueCode = BindingIssue['code'];
+
+export declare type BindingIssueLevel = 'error' | 'warn' | 'info';
+
+export declare type BindingMapping = {
+    kind: 'passthrough';
+} | {
+    kind: 'static';
+    args: unknown[];
+} | {
+    kind: 'pickPath';
+    paths: Array<{
+        from: string;
+        to?: number | string;
+    }>;
+};
+
+export declare function bindingModeForCanvasMode(canvasMode: CanvasMode): CanvasBindingMode;
+
+export declare function bindingReferencesInstance(binding: NormalizedPageBinding, instanceId: string, canvasId?: string): boolean;
+
+export declare interface BindingSchedule {
+    once?: boolean;
+    throttle?: {
+        windowMs: number;
+        leading?: boolean;
+        trailing?: boolean;
+    };
+    debounce?: {
+        windowMs: number;
+        leading?: boolean;
+        trailing?: boolean;
+    };
+}
+
+export declare interface BindingScopedIssue extends BindingIssueBase {
+    code: 'invalid-type-source-kind' | 'unknown-source-event' | 'unknown-target-method' | 'unknown-target-event' | 'unknown-target-data-input' | 'orphan-binding' | 'schedule-window-too-small' | 'unsupported-cross-canvas';
+    bindingId: string;
+    instanceId?: string;
+    canvasId?: string;
+}
+
+export declare type BindingSource = {
+    kind: 'instanceEvent';
+    canvasId?: string;
+    instanceId: string;
+    event: string;
+} | {
+    kind: 'lifecycle';
+    canvasId?: string;
+    instanceId: string;
+    hook: 'mounted' | 'unmounted';
+} | {
+    kind: 'page';
+    hook: 'pageInit' | 'pageBeforeUnmount';
+} | {
+    kind: 'dataSource';
+    sourceId: string;
+    watch?: 'change';
+};
+
+export declare type BindingTarget = {
+    kind: 'instanceMethod';
+    canvasId?: string;
+    instanceId: string;
+    method: string;
+} | {
+    kind: 'instanceDataInput';
+    canvasId?: string;
+    instanceId: string;
+    key: string;
+} | {
+    kind: 'instanceEmit';
+    canvasId?: string;
+    instanceId: string;
+    event: string;
+};
+
+export declare interface BindingTestTrace {
+    bindingId: string;
+    phase: 'mapping' | 'shouldFire' | 'calling-target' | 'done' | 'skipped' | 'error';
+    details: Record<string, unknown>;
+}
+
+export declare interface BindingTraceEvent {
+    kind: BindingTraceKind;
+    canvasId: string;
+    bindingId: string;
+    ts: number;
+    seq: number;
+    chainId?: string;
+    reason?: string;
+    payload?: unknown;
+    args?: unknown[];
+    code?: BindingErrorCode;
+    message?: string;
+    detail?: unknown;
+    schedule?: {
+        windowMs?: number;
+        leading?: boolean;
+        trailing?: boolean;
+        kind?: 'throttle' | 'debounce';
+    };
+    cacheKey?: string;
+    sourceId?: string;
+    writeSeq?: number;
+}
+
+export declare type BindingTraceKind = 'fire' | 'mapping-failed' | 'scheduled-skipped' | 'scheduled-deferred' | 'scheduled-flushed' | 'scheduled-dropped' | 'error' | 'cycle-detected' | 'stopped-skipped' | 'wire-skipped' | 'data-query-started' | 'data-source-update' | 'data-query-skipped';
+
+export declare function buildInstanceTree(instances: readonly PageInstance[]): PageInstanceTreeNode[];
+
+export declare interface CannotDragLayoutManagedChildEvent {
+    instanceId: string;
+    parentId: string | undefined;
+    parentLayoutMode: ContainerLayoutConfig['mode'];
+    token: number;
+}
+
+export declare interface CannotDragSlotChildEvent {
+    instanceId: string;
+    parentId: string | undefined;
+    token: number;
+}
+
+export declare interface CannotReparentEvent {
+    instanceId: string;
+    target: TreeMoveTarget;
+    reason: 'instance-not-exists' | 'parent-not-exists' | 'self-parent' | 'cycle' | 'parent-not-layout' | 'slot-not-exists' | 'accepts-violation' | 'slot-multiple-violated' | 'max-children-exceeded';
+    message: string;
+    token: number;
+}
+
+export declare type CannotReparentReason = 'instance-not-exists' | 'parent-not-exists' | 'self-parent' | 'cycle' | 'parent-not-layout' | 'slot-not-exists' | 'accepts-violation' | 'slot-multiple-violated' | 'max-children-exceeded';
+
+export declare function canReparent(instances: readonly PageInstance[], instanceId: string, target: TreeMoveTarget, opts?: CanReparentOptions): CanReparentResult;
+
+export declare interface CanReparentOptions {
+    resolveContract?: ReparentContractResolver;
+}
+
+export declare interface CanReparentResult {
+    ok: boolean;
+    reason?: CannotReparentReason;
+    message?: string;
+}
+
+export declare const CANVAS_CONTEXT_KEY: InjectionKey<CanvasContext>;
+
+export declare const CANVAS_REPARENT_BRIDGE_KEY: InjectionKey<ReparentBridge>;
+
+export declare type CanvasAction = CanvasDocumentAction | CanvasSelectionAction;
+
+export declare interface CanvasActionHooks {
+    onBeforeAction?: (action: CanvasAction) => boolean | void;
+    onAfterAction?: (action: CanvasAction) => void;
+    onAfterBatch?: (batchType?: string) => void;
+}
+
+export declare interface CanvasAdapters {
+    data?: DataAdapter;
+    assets?: AssetsAdapter;
+}
+
+export declare interface CanvasBackgroundConfig {
+    color?: string;
+    image?: AssetRef;
+    imageFit?: 'cover' | 'contain' | 'repeat' | 'stretch' | 'center';
+    imagePosition?: string;
+    opacity?: number;
+}
+
+export declare interface CanvasBehaviorConfig {
+    selectable?: boolean;
+    draggable?: boolean;
+    resizable?: boolean;
+    keyboardMove?: boolean;
+    snap?: boolean;
+    grid?: boolean;
+    allowOverflow?: boolean;
+    locked?: boolean;
+}
+
+export declare type CanvasBindingMode = 'off' | 'data-preview' | 'runtime';
+
+export declare type CanvasCommandId = 'undo' | 'redo' | 'deleteSelection' | 'duplicateSelection' | 'clearSelection' | 'cancelInteraction' | 'zoomIn' | 'zoomOut' | 'zoom100' | 'resetViewport' | 'fitToContent' | 'fitToSelection' | 'fitToSelectionOrContent' | 'nudgeSelection' | 'nudgeSelectionLarge' | 'lockSelection' | 'unlockSelection' | 'bringForward' | 'sendBackward' | 'bringToFront' | 'sendToBack' | 'toggleGrid' | 'toggleRuler' | (string & {});
+
+export declare interface CanvasContext {
+    document: DocumentStore;
+    selection: SelectionStore;
+    viewport: ViewportStore;
+    scheduler: RenderScheduler;
+    adapters: CanvasAdapters;
+    dataStore: DataSourceStore;
+    dispatch(action: CanvasAction): void;
+    dispose(): void;
+    readonly isBatching: ComputedRef<boolean>;
+    beginBatch(): void;
+    endBatch(batchType?: string): void;
+    registerHooks(hooks: CanvasActionHooks): () => void;
+    readonly isRecordingSuppressed: ComputedRef<boolean>;
+    suppressRecording<T>(fn: () => T): T;
+    readonly effectiveBehavior: ComputedRef<CanvasBehaviorConfig>;
+    readonly interactionOptions: ComputedRef<Readonly<Partial<InteractionOptions>>>;
+    setInteractionOptions(options: Partial<InteractionOptions>): void;
+    readonly toolMode: ComputedRef<CanvasToolMode>;
+    setToolMode(mode: CanvasToolMode): void;
+    setTemporaryToolMode(mode: CanvasToolMode | null): void;
+    readonly mouseCanvasPoint: ComputedRef<{
+        x: number;
+        y: number;
+    } | null>;
+    setMouseCanvasPoint(point: {
+        x: number;
+        y: number;
+    } | null): void;
+    readonly measuredStageSize: ComputedRef<MeasuredStageSize>;
+    readonly measuredCanvasSize: ComputedRef<MeasuredStageSize>;
+    setMeasuredStageSize(size: MeasuredStageSize): void;
+    readonly layoutIssues: ComputedRef<readonly LayoutIssue[]>;
+    setLayoutIssues(issues: readonly LayoutIssue[]): void;
+    readonly cannotDragLayoutManagedChildEvent: Readonly<Ref<CannotDragLayoutManagedChildEvent | null>>;
+    setCannotDragLayoutManagedChildEvent(ev: CannotDragLayoutManagedChildEvent | null): void;
+    resolveAsset(ref: AssetRef): string | Promise<string>;
+}
+
+export declare interface CanvasContextOptions {
+    initialDocument?: PageDocument;
+    scheduler?: RenderSchedulerOptions;
+    viewport?: ViewportStoreOptions;
+    adapters?: CanvasAdapters;
+    hooks?: CanvasActionHooks;
+    getMode?: () => CanvasMode;
+}
+
+export declare type CanvasDocumentAction = {
+    type: 'addInstance';
+    payload: {
+        instance: PageInstance;
+    };
+} | {
+    type: 'removeInstance';
+    payload: {
+        instanceId: string;
+    };
+} | {
+    type: 'updateInstance';
+    payload: {
+        instanceId: string;
+        patch: Partial<PageInstance>;
+    };
+} | {
+    type: 'moveInstance';
+    payload: {
+        instanceId: string;
+        x: number;
+        y: number;
+    };
+} | {
+    type: 'resizeInstance';
+    payload: {
+        instanceId: string;
+        w: number;
+        h: number;
+    };
+} | {
+    type: 'setInstanceProp';
+    payload: {
+        instanceId: string;
+        key: string;
+        value: unknown;
+    };
+} | {
+    type: 'addBinding';
+    payload: {
+        binding: PageBindingInput;
+    };
+} | {
+    type: 'removeBinding';
+    payload: {
+        bindingId: string;
+    };
+} | {
+    type: 'updateBinding';
+    payload: {
+        bindingId: string;
+        patch: PageBindingPatch;
+    };
+} | {
+    type: 'updateLayout';
+    payload: {
+        patch: Partial<CanvasLayoutConfig>;
+    };
+} | {
+    type: 'setRootLayout';
+    payload: {
+        rootLayout: ContainerLayoutConfig | null;
+    };
+} | {
+    type: 'replaceDocument';
+    payload: {
+        document: PageDocument;
+    };
+} | {
+    type: 'setComponentOverride';
+    payload: {
+        instanceId: string;
+        override: PageComponentOverride | null;
+    };
+} | {
+    type: 'setInstanceLocked';
+    payload: {
+        instanceId: string;
+        locked: boolean;
+    };
+} | {
+    type: 'duplicateInstance';
+    payload: {
+        instanceId: string;
+        newInstanceId: string;
+        offset?: {
+            x: number;
+            y: number;
+        };
+    };
+} | {
+    type: 'setInstanceSize';
+    payload: {
+        instanceId: string;
+        size: PageInstanceSize | null;
+    };
+} | {
+    type: 'setContainerLayout';
+    payload: {
+        instanceId: string;
+        containerLayout: ContainerLayoutConfig | null;
+    };
+} | {
+    type: 'updateLayoutBox';
+    payload: {
+        instanceId: string;
+        patch: Partial<LayoutBox>;
+    };
+} | {
+    type: 'updateLayoutItem';
+    payload: {
+        instanceId: string;
+        patch: Partial<LayoutItem> | null;
+    };
+} | {
+    type: 'updateRotation';
+    payload: {
+        instanceId: string;
+        value: number;
+    };
+};
+
+export declare interface CanvasFeatures {
+    showHistory?: boolean;
+    showDiff?: boolean;
+    enablePublish?: boolean;
+}
+
+export declare interface CanvasGridConfig {
+    visible?: boolean;
+    size?: number;
+    color?: string;
+    opacity?: number;
+    snap?: boolean;
+}
+
+export declare interface CanvasGuide {
+    id: string;
+    axis: 'x' | 'y';
+    position: number;
+    locked?: boolean;
+    label?: string;
+}
+
+export declare interface CanvasHandle {
+    dispatch(action: CanvasAction): void;
+    beginBatch(): void;
+    endBatch(batchType?: string): void;
+    readonly isBatching: Readonly<Ref<boolean>>;
+    getSnapshot(): PageDocument;
+    readonly selectedIds: Readonly<Ref<readonly string[]>>;
+    readonly selectedInstances: ComputedRef<readonly PageInstance[]>;
+    readonly viewport: ViewportStore;
+    clientToCanvasPoint(point: Point): Point;
+    getInstanceAtClientPoint(point: Point): PageInstance | null;
+    getDropTarget(point: Point, root?: ParentNode | null, options?: {
+        excludeInstanceId?: string;
+    }): DropTarget | null;
+    duplicateInstance(instanceId: string, options?: DuplicateInstanceOptions): string | null;
+    undo(): void;
+    redo(): void;
+    readonly canUndo: ComputedRef<boolean>;
+    readonly canRedo: ComputedRef<boolean>;
+    readonly undoStackSize: ComputedRef<number>;
+    readonly redoStackSize: ComputedRef<number>;
+    clearHistory(): void;
+    getLayoutConfig(): CanvasLayoutConfig;
+    updateCanvasSize(viewport: Partial<CanvasViewportConfig>): void;
+    updateCanvasBackground(bg: Partial<CanvasBackgroundConfig> | null): void;
+    updateBehavior(behavior: Partial<CanvasBehaviorConfig>): void;
+    setInteractionOptions(options: Partial<InteractionOptions>): void;
+    setRootLayout(mode: ContainerLayoutConfig | 'free' | 'split' | 'grid' | 'flex' | 'none' | null): void;
+    getEffectiveBehavior(): CanvasBehaviorConfig;
+    getInstanceTree(): PageInstanceTreeNode[];
+    getInstanceList(): PageInstance[];
+    getInstance(instanceId: string): PageInstance | null;
+    getSelectedPath(): PageInstanceTreeNode[];
+    getBreadcrumb(instanceId: string): PageInstance[];
+    focusInstance(instanceId: string): void;
+    scrollToInstance(instanceId: string): void;
+    resolveAsset(ref: AssetRef): string | Promise<string>;
+    moveInstanceInTree(instanceId: string, target: TreeMoveTarget): void;
+    canReparent(instanceId: string, target: TreeMoveTarget): CanReparentResult;
+    readonly cannotReparentEvent: Readonly<Ref<CannotReparentEvent | null>>;
+    readonly cannotDragLayoutManagedChildEvent: Readonly<Ref<CannotDragLayoutManagedChildEvent | null>>;
+    getViewportState(): ViewportState;
+    getVisibleBounds(): Rect_2;
+    getCanvasBounds(): Rect_2;
+    getContentBounds(): Rect_2 | null;
+    getSelectionBounds(): Rect_2 | null;
+    getInstanceBounds(instanceId: string): Rect_2 | null;
+    panBy(dx: number, dy: number): void;
+    panTo(panX: number, panY: number): void;
+    zoomTo(scale: number, options?: {
+        center?: Point;
+    }): void;
+    zoomBy(delta: number, options?: {
+        center?: Point;
+    }): void;
+    zoomToPoint(scale: number, clientPoint: Point): void;
+    resetViewport(): void;
+    fitToContent(options?: FitOptions): void;
+    fitToSelection(options?: FitOptions): void;
+    scrollToRect(rect: Rect_2, options?: FitOptions): void;
+    readonly toolMode: ComputedRef<CanvasToolMode>;
+    getToolMode(): CanvasToolMode;
+    setToolMode(mode: CanvasToolMode): void;
+    setTemporaryToolMode(mode: CanvasToolMode | null): void;
+    getDefaultShortcuts(): CanvasShortcutBinding[];
+    executeShortcut(event: KeyboardEvent): boolean;
+    executeCommand(id: CanvasCommandId, payload?: unknown): void;
+    canExecuteCommand(id: CanvasCommandId): boolean;
+    getStaleComponentOverrides(): StaleComponentOverride[];
+    setComponentOverride(instanceId: string, override: PageComponentOverride | null): void;
+    discardComponentOverride(instanceId: string): void;
+    getLayoutIssues(): readonly LayoutIssue[];
+    setRulerVisible(visible: boolean): void;
+    setGridVisible(visible: boolean): void;
+    updateRulerConfig(patch: Partial<CanvasRulerConfig>): void;
+    updateGridConfig(patch: Partial<CanvasGridConfig>): void;
+    addGuide(guide: Omit<CanvasGuide, 'id'> & {
+        id?: string;
+    }): string;
+    removeGuide(id: string): void;
+    updateGuide(id: string, patch: Partial<CanvasGuide>): void;
+    getGuides(): CanvasGuide[];
+    clearGuides(): void;
+    getMouseCanvasPoint(): {
+        x: number;
+        y: number;
+    } | null;
+    getInstanceSize(instanceId: string): PageInstanceSize | undefined;
+    updateInstanceSize(instanceId: string, size: PageInstanceSize | null): void;
+    getContainerLayout(instanceId: string): ContainerLayoutConfig | null;
+    updateContainerLayout(instanceId: string, containerLayout: ContainerLayoutConfig | null): void;
+    getLayoutBox(instanceId: string): LayoutBox | undefined;
+    updateLayoutBox(instanceId: string, patch: Partial<LayoutBox>): void;
+    getLayoutItem(instanceId: string): LayoutItem | undefined;
+    updateLayoutItem(instanceId: string, patch: Partial<LayoutItem> | null): void;
+    getRotation(instanceId: string): number;
+    updateRotation(instanceId: string, value: number): void;
+    getInstanceOutletRect(parentId: string, slot?: string): DOMRect | null;
+    setBindingMode(mode: CanvasBindingMode): void;
+    getBindingMode(): CanvasBindingMode;
+    testBinding(bindingId: string, mockPayload?: unknown): BindingTestTrace[];
+    on<E extends 'binding:fire' | 'binding:error' | 'binding:trace'>(event: E, cb: BindingEventCb<E>): () => void;
+    startTracing(opts?: TraceCollectorOptions): void;
+    stopTracing(): BindingTraceEvent[];
+    getTraceBuffer(): readonly BindingTraceEvent[];
+    invalidateDataSource(sourceId?: string): void;
+    getDataSourceSnapshot(): DataSourceSnapshot;
+    attachBindingDelegate(delegate: WirePageBindingsHandle | null, dataStore?: DataSourceStore | null): void;
+}
+
+export declare interface CanvasHandleOptions {
+    getStageEl: () => HTMLElement | null;
+    recorder?: {
+        maxSize?: number;
+    };
+    resolveContract?: ReparentContractResolver;
+}
+
+export declare interface CanvasInteraction {
+    marquee: Readonly<MarqueeState>;
+    marqueeRect: ComputedRef<Rect | null>;
+    drag: Readonly<DragState>;
+    isDragging: ComputedRef<boolean>;
+    resize: Readonly<ResizeState>;
+    isResizing: ComputedRef<boolean>;
+    snapLines: Readonly<Ref<readonly SnapLine[]>>;
+    cannotDragSlotChildEvent: Readonly<Ref<CannotDragSlotChildEvent | null>>;
+    cannotDragLayoutManagedChildEvent: Readonly<Ref<CannotDragLayoutManagedChildEvent | null>>;
+    handlePointerDown(canvasPt: Point, modifierKeys: ModifierKeys): {
+        startTracking: boolean;
+    };
+    handlePointerMove(canvasPt: Point): void;
+    handlePointerUp(): void;
+    cancelMarquee(): void;
+    cancelDrag(): void;
+    handleResizeStart(instanceId: string, handle: ResizeHandle, canvasPt: Point): {
+        startTracking: boolean;
+    };
+    cancelResize(): void;
+}
+
+export declare interface CanvasLayoutConfig {
+    type: 'free' | 'flow' | 'nested';
+    canvas: CanvasViewportConfig;
+    background?: CanvasBackgroundConfig;
+    behavior?: CanvasBehaviorConfig;
+    rootLayout?: ContainerLayoutConfig;
+    guides?: {
+        grid?: CanvasGridConfig;
+        ruler?: CanvasRulerConfig;
+        items?: CanvasGuide[];
+    };
+}
+
+export declare type CanvasMode = 'design' | 'preview' | 'runtime' | 'inspect';
+
+export declare interface CanvasRulerConfig {
+    visible?: boolean;
+    unit?: 'px';
+    size?: number;
+}
+
+export declare type CanvasSelectionAction = {
+    type: 'select';
+    payload: {
+        instanceId: string;
+    };
+} | {
+    type: 'toggleSelect';
+    payload: {
+        instanceId: string;
+    };
+} | {
+    type: 'addToSelection';
+    payload: {
+        instanceId: string;
+    };
+} | {
+    type: 'removeFromSelection';
+    payload: {
+        instanceId: string;
+    };
+} | {
+    type: 'clearSelection';
+    payload?: undefined;
+} | {
+    type: 'selectAll';
+    payload: {
+        instanceIds: string[];
+    };
+};
+
+export declare interface CanvasShortcutBinding {
+    id: string;
+    keys: string[];
+    command: CanvasCommandId;
+    when?: CanvasShortcutWhen;
+    preventDefault?: boolean;
+    payload?: unknown;
+}
+
+export declare type CanvasShortcutWhen = 'always' | 'design' | 'hasSelection' | 'notEditingText';
+
+export declare function canvasSizeToCss(size: CanvasSizeValue): string;
+
+export declare type CanvasSizeValue = {
+    mode: 'px';
+    value: number;
+} | {
+    mode: 'percent';
+    value: number;
+} | {
+    mode: 'vw';
+    value: number;
+} | {
+    mode: 'vh';
+    value: number;
+} | {
+    mode: 'auto';
+} | {
+    mode: 'fill';
+};
+
+export declare const CanvasStage: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
+
+export declare type CanvasToolMode = 'select' | 'hand' | 'marquee' | 'insert' | 'inspect' | 'comment' | 'connect' | 'measure';
+
+export declare interface CanvasVersionStatus {
+    currentVersionLabel?: string;
+    hasHistory?: boolean;
+    lastPublishedAt?: string;
+}
+
+export declare interface CanvasViewportConfig {
+    width: CanvasSizeValue;
+    height: CanvasSizeValue;
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    overflow?: 'visible' | 'hidden' | 'auto';
+    fit?: 'fixed' | 'contain' | 'cover' | 'width' | 'height';
+}
+
+export declare function cleanLayoutItem(item: LayoutItem | undefined): LayoutItem | null;
+
+export declare function clientToCanvas(clientPt: Point, stageEl: HTMLElement, viewport: CanvasContext['viewport']): Point;
+
+export declare interface CommandRecord {
+    type: string;
+    redo: CanvasAction[];
+    undo: CanvasAction[];
+    timestamp: number;
+}
+
+export declare interface CommandRecorder {
+    undo(): void;
+    redo(): void;
+    clear(): void;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    undoStackSize: ComputedRef<number>;
+    redoStackSize: ComputedRef<number>;
+    dispose(): void;
+}
+
+export declare interface CommandStackOptions {
+    maxSize?: number;
+}
+
+export declare interface ComponentCatalogItem {
+    componentId: string;
+    name: string;
+    currentVersion: string;
+    description?: string;
+    thumbnailUrl?: string;
+    tags?: string[];
+    kind?: ComponentKind;
+}
+
+export declare interface ComponentContract {
+    propsDecl: PropDecl[];
+    emitsDecl: EmitDecl[];
+    methodsDecl: MethodDecl[];
+    slotsDecl: SlotDecl[];
+    modelDecl: ModelDecl[];
+    dataInputsDecl: DataInputDecl[];
+    dataOutputsDecl: DataOutputDecl[];
+    layoutDecl?: ComponentLayoutDecl;
+}
+
+export declare type ComponentKind = 'visual' | 'layout' | 'data';
+
+export declare interface ComponentLayoutDecl {
+    role?: 'none' | 'container';
+    supportedLayouts?: Array<'split' | 'grid' | 'flow' | 'free'>;
+    defaultLayout?: ContainerLayoutConfig;
+    sizing?: {
+        defaultChildSize?: PageInstanceSize;
+        allowChildResize?: boolean;
+        allowChildDrag?: boolean;
+        allowChildReorder?: boolean;
+    };
+}
+
+export declare type ComponentSourceMap = Record<ComponentVersionKey, ComponentVersionAsset | DraftComponentVersionAsset>;
+
+export declare interface ComponentVersionAsset {
+    key: ComponentVersionKey;
+    componentId: string;
+    version: string;
+    status: ComponentVersionStatus;
+    invalidReason?: string;
+    name?: string;
+    source?: Source;
+    contract?: ComponentContract;
+    kind?: ComponentKind;
+    updatedAt?: string;
+}
+
+export declare type ComponentVersionKey = string;
+
+export declare type ComponentVersionStatus = 'ok' | 'unavailable' | 'missing' | 'broken';
+
+export declare function computeContentBounds(instances: readonly PageInstance[]): Rect_2 | null;
+
+export declare function computeEffectiveSplitRatios(rawRatios: readonly number[] | undefined, childrenRatios: readonly (number | undefined)[]): number[];
+
+export declare function computeFit(rect: Rect_2, container: {
+    w: number;
+    h: number;
+}, options?: FitOptions): FitResult;
+
+export declare function computeInverse(action: CanvasAction, ctx: CanvasContext): CanvasAction[] | null;
+
+export declare function computeNextAxisSize(startAxis: InstanceSizeAxis | undefined, newPxCanvas: number, outletPxCanvas: number | null): InstanceSizeAxis;
+
+export declare function computeNextLayoutBoxAxis(startMode: LayoutBoxAxisMode | undefined, newPxCanvas: number, outletPxCanvas: number | null): {
+    mode: LayoutBoxAxisMode;
+    value: number;
+};
+
+export declare function computeParentLayoutMode(layout: CanvasLayoutConfig | undefined | null, instances: readonly PageInstance[], instanceId: string): ContainerLayoutConfig['mode'] | undefined;
+
+export declare function computeSelectionBounds(instances: readonly PageInstance[], selectedIds: readonly string[]): Rect_2 | null;
+
+export declare function computeSlotChildCanvasRect(instanceId: string, stageEl: HTMLElement | null, viewport: CanvasContext['viewport']): Rect | null;
+
+export declare function computeSnap(input: SnapInput): SnapResult;
+
+export declare function computeSplitDividers(parentRect: Rect, ratios: readonly number[], direction: 'horizontal' | 'vertical', gap?: number): SplitDivider[];
+
+export declare function computeVisibleBounds(viewport: {
+    scale: number;
+    panX: number;
+    panY: number;
+}, container: {
+    w: number;
+    h: number;
+}): Rect_2;
+
+export declare type ContainerLayoutConfig = {
+    mode: 'none';
+} | FreeContainerLayout | FlexContainerLayout | SplitContainerLayout | GridContainerLayout;
+
+export declare type ContainerLayoutMode = 'none' | 'free' | 'flex' | 'split' | 'grid';
+
+export declare function containerLayoutToCss(cfg: ContainerLayoutConfig | undefined): Record<string, string> | null;
+
+export declare type ContractResolver = (versionKey: ComponentVersionKey) => ComponentContract | undefined;
+
+export declare function createAssetResolver(adapter?: AssetsAdapter): AssetResolver;
+
+export declare function createCanvasContext(opts?: CanvasContextOptions): CanvasContext;
+
+export declare function createCanvasHandle(ctx: CanvasContext, options: CanvasHandleOptions): CanvasHandle & {
+    dispose(): void;
+};
+
+export declare function createCanvasInteraction(ctx: CanvasContext, opts?: CreateCanvasInteractionOptions): CanvasInteraction;
+
+export declare interface CreateCanvasInteractionOptions {
+    getRoot?: () => ParentNode | null;
+    getDomBox?: (instanceId: string) => Rect | null;
+}
+
+export declare function createCommandRecorder(ctx: CanvasContext, options?: CommandStackOptions): CommandRecorder;
+
+export declare function createDocumentStore(initial?: PageDocumentInput): DocumentStore;
+
+export declare function createFreePageDocument(opts?: Omit<CreatePageDocumentOptions, 'rootLayout'>): PageDocument;
+
+export declare function createMinimalPageDocument(opts?: CreatePageDocumentOptions): PageDocument;
+
+export declare interface CreatePageDocumentOptions {
+    canvasWidth?: number;
+    canvasHeight?: number;
+    rootLayout?: ContainerLayoutMode | ContainerLayoutConfig;
+    instances?: PageInstance[];
+    bindings?: NormalizedPageBinding[];
+}
+
+export declare function createRenderScheduler(opts?: RenderSchedulerOptions): RenderScheduler;
+
+export declare function createSelectionStore(): SelectionStore;
+
+export declare function createSplitDividerInteraction(ctx: CanvasContext): SplitDividerInteraction;
+
+export declare function createViewportStore(opts?: ViewportStoreOptions): ViewportStore;
+
+export declare interface DataAdapter {
+    query(input: DataQueryInput): unknown | Promise<unknown>;
+    subscribe?(input: DataSubscribeInput, cb: (value: unknown) => void): () => void;
+}
+
+export declare interface DataInputDecl {
+    key: string;
+    type?: DeclValueType;
+    label?: string;
+    description?: string;
+    required?: boolean;
+}
+
+export declare interface DataOutputDecl {
+    key: string;
+    type?: DeclValueType;
+    label?: string;
+    description?: string;
+}
+
+export declare interface DataQueryInput {
+    sourceId: string;
+    params?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+
+export declare interface DataSourceEntry {
+    cacheKey: string;
+    sourceId: string;
+    status: DataSourceStatus;
+    value?: unknown;
+    error?: unknown;
+    lastFetchedAt?: number;
+}
+
+declare interface DataSourceRequestInput {
+    bindingId: string;
+    sourceId: string;
+    params?: Record<string, unknown>;
+    onUpdate: (value: unknown) => void;
+    onError?: (err: unknown) => void;
+}
+
+export declare interface DataSourceSnapshot {
+    readonly entries: ReadonlyArray<Readonly<DataSourceEntry>>;
+}
+
+export declare type DataSourceStatus = 'idle' | 'loading' | 'success' | 'error' | 'stale';
+
+declare interface DataSourceStore {
+    request(input: DataSourceRequestInput): void;
+    subscribe(input: DataSourceSubscribeInput): void;
+    removeBinding(bindingId: string, options?: {
+        preserveCache?: boolean;
+    }): void;
+    invalidate(sourceId?: string): void;
+    getSnapshot(): DataSourceSnapshot;
+    disposeAll(): void;
+    readonly isDisposed: boolean;
+    attachTraceBridge(cb: (ev: StoreTraceEvent) => void): () => void;
+    getBindingsForCacheKey(cacheKey: string): string[];
+}
+
+declare interface DataSourceSubscribeInput extends DataSourceRequestInput {
+}
+
+export declare interface DataSubscribeInput {
+    sourceId: string;
+    params?: Record<string, unknown>;
+}
+
+declare type DeclValueType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'any';
+
+export declare const DEFAULT_FIT_PADDING = 40;
+
+export declare const DIVIDER_HIT_THICKNESS = 8;
+
+export declare interface DocumentSource {
+    getDocument(): PageDocument | null;
+    onAction?(cb: (action: unknown) => void): () => void;
+    onDocumentChange?(cb: () => void): () => void;
+}
+
+export declare interface DocumentStore {
+    readonly document: Readonly<PageDocument>;
+    readonly instanceCount: ComputedRef<number>;
+    readonly bindingCount: ComputedRef<number>;
+    addInstance(instance: PageInstance): void;
+    removeInstance(instanceId: string): void;
+    updateInstance(instanceId: string, patch: Partial<PageInstance>): void;
+    moveInstance(instanceId: string, x: number, y: number): void;
+    resizeInstance(instanceId: string, w: number, h: number): void;
+    setInstanceProp(instanceId: string, key: string, value: unknown): void;
+    setInstanceLocked(instanceId: string, locked: boolean): void;
+    setInstanceSize(instanceId: string, size: PageInstanceSize | null): void;
+    setInstanceContainerLayout(instanceId: string, containerLayout: ContainerLayoutConfig | null): void;
+    updateInstanceLayoutBox(instanceId: string, patch: Partial<LayoutBox>): void;
+    updateInstanceLayoutItem(instanceId: string, patch: Partial<LayoutItem> | null): void;
+    setInstanceRotation(instanceId: string, value: number): void;
+    duplicateInstance(instanceId: string, newInstanceId: string, offset: {
+        x: number;
+        y: number;
+    }): void;
+    addBinding(binding: PageBindingInput): void;
+    removeBinding(bindingId: string): void;
+    updateBinding(bindingId: string, patch: PageBindingPatch): void;
+    setComponentOverride(instanceId: string, override: PageComponentOverride | null): void;
+    updateLayout(patch: Partial<CanvasLayoutConfig>): void;
+    replaceDocument(newDoc: PageDocumentInput): void;
+    getInstance(instanceId: string): PageInstance | undefined;
+    listInstancesByComponentVersionKey(key: string): PageInstance[];
+}
+
+export declare interface DraftComponentVersionAsset {
+    key: ComponentVersionKey;
+    baseVersionKey: ComponentVersionKey;
+    componentId: string;
+    isDraft: true;
+    status: 'ok';
+    source: Source;
+    contract: ComponentContract;
+    contractParseError?: {
+        message: string;
+        at: string;
+    };
+    lastGoodSource: Source;
+    lastGoodContract: ComponentContract;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare const DRAG_THRESHOLD_CANVAS_PX = 3;
+
+export declare interface DragState {
+    status: 'idle' | 'pending' | 'active';
+    startPt: Point | null;
+    startRects: Map<string, {
+        x: number;
+        y: number;
+    }>;
+    deferredClickSelect: string | null;
+}
+
+export declare interface DropTarget {
+    parentId: string;
+    slot: string;
+    outletEl: HTMLElement;
+}
+
+export declare interface DuplicateInstanceOptions {
+    newInstanceId?: string;
+    offset?: {
+        x: number;
+        y: number;
+    };
+}
+
+export declare const EFFECTIVE_DEFAULT_SLOT = "default";
+
+export declare function effectiveSlot(inst: PageInstance): string;
+
+export declare interface EmitDecl {
+    event: string;
+    label?: string;
+    description?: string;
+    highFrequency?: boolean;
+}
+
+export declare function emptyPageDocument(): PageDocument;
+
+export declare function filterExistingIds(ids: readonly string[], instances: readonly PageInstance[]): string[];
+
+export declare function filterInstancesInRect(rect: Rect, instances: readonly PageInstance[], domBoxLookup?: (instanceId: string) => Rect | null): string[];
+
+export declare function findInstanceBreadcrumb(instances: readonly PageInstance[], instanceId: string): PageInstance[];
+
+export declare function findInstancePath(tree: readonly PageInstanceTreeNode[], instanceId: string): PageInstanceTreeNode[];
+
+export declare interface FitOptions {
+    padding?: number;
+    maxScale?: number;
+    minScale?: number;
+    animate?: boolean;
+}
+
+export declare interface FitResult {
+    scale: number;
+    panX: number;
+    panY: number;
+}
+
+export declare interface FlexContainerLayout {
+    mode: 'flex';
+    direction: 'row' | 'column';
+    wrap?: boolean;
+    gap?: number;
+    justify?: 'start' | 'center' | 'end' | 'space-between' | 'space-around';
+    align?: 'start' | 'center' | 'end' | 'stretch';
+}
+
+export declare interface FreeContainerLayout {
+    mode: 'free';
+}
+
+export declare function getBindingInstanceRefs(binding: NormalizedPageBinding): BindingInstanceRef[];
+
+export declare function getDefaultShortcuts(): CanvasShortcutBinding[];
+
+export declare function getDesignerHandle(canvasId: string): CanvasHandle | null;
+
+export declare function getInstanceWrapperRectFromDom(instanceId: string, root?: ParentNode | null, canvasFallback?: boolean): DOMRect | null;
+
+export declare function getOutletRectFromDom(parentId: string, slot?: string, root?: ParentNode | null): DOMRect | null;
+
+export declare function getParentLayoutMode(ctx: CanvasContext, instanceId: string): ContainerLayoutConfig['mode'] | undefined;
+
+export declare function getSiblings(instances: readonly PageInstance[], parentId: string | null | undefined, slot: string | undefined): PageInstance[];
+
+export declare function getSlotChildRectFromDom(instanceId: string, root?: ParentNode | null): DOMRect | null;
+
+export declare interface GridContainerLayout {
+    mode: 'grid';
+    columns: Array<{
+        mode: 'fr' | 'px' | 'percent';
+        value: number;
+    }>;
+    rows: Array<{
+        mode: 'fr' | 'px' | 'percent' | 'auto';
+        value?: number;
+    }>;
+    gap?: number | {
+        row?: number;
+        column?: number;
+    };
+    cells?: Record<string, {
+        row: number;
+        column: number;
+        rowSpan?: number;
+        columnSpan?: number;
+    }>;
+}
+
+export declare function hitTestInstance(canvasPt: Point, instances: readonly PageInstance[], domBoxLookup?: (instanceId: string) => Rect | null): string | null;
+
+export declare const HyperCardCanvasDesigner: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+export declare const HyperCardPageRenderer: DefineComponent<__VLS_Props, {
+binding: ShallowRef<WirePageBindingsHandle | null, WirePageBindingsHandle | null>;
+data: {
+invalidateDataSource(sourceId?: string): void;
+getDataSourceSnapshot(): DataSourceSnapshot;
+} | null;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+rootEl: HTMLDivElement;
+}, any>;
+
+export declare interface InstanceDataInputMissingIssue extends BindingIssueBase {
+    code: 'required-data-input-missing';
+    instanceId: string;
+    key: string;
+    canvasId?: string;
+}
+
+export declare interface InstanceSizeAxis {
+    mode: InstanceSizeMode;
+    value?: number;
+    min?: number;
+    max?: number;
+}
+
+export declare type InstanceSizeMode = 'px' | 'percent' | 'fill' | 'hug' | 'auto';
+
+export declare const InteractionLayer: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
+
+export declare type InteractionOptions = CanvasBehaviorConfig;
+
+export declare function isAdditive(keys: ModifierKeys): boolean;
+
+export declare function isCanvasRootPlacement(placement: PageInstance['placement'] | undefined): boolean;
+
+export declare function isContainerChildPlacement(placement: PageInstance['placement'] | undefined): boolean;
+
+export declare function isDraftKey(key: ComponentVersionKey): boolean;
+
+export declare function isEditingText(target: EventTarget | null): boolean;
+
+export declare function isFreePositionLayoutMode(mode: ContainerLayoutConfig['mode'] | undefined): boolean;
+
+export declare function isInstanceEffectivelyLocked(inst: LockedSubset): boolean;
+
+export declare function isInstancePositionLocked(inst: LockedSubset): boolean;
+
+export declare function isInstanceSizeLocked(inst: LockedSubset): boolean;
+
+export declare function isV1Layout(layout: PageLayout | CanvasLayoutConfig | undefined): layout is CanvasLayoutConfig;
+
+export declare interface LayoutBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    widthMode: LayoutBoxAxisMode;
+    heightMode: LayoutBoxAxisMode;
+    overflow?: 'hidden' | 'visible' | 'auto';
+}
+
+export declare type LayoutBoxAxisMode = 'px' | 'percent' | 'fill' | 'auto';
+
+export declare interface LayoutIssue {
+    kind: LayoutIssueKind;
+    instanceId: string;
+    detail: string;
+}
+
+export declare type LayoutIssueKind = 'cycle' | 'missing-parent' | 'cross-page-parent' | 'orphan-slot' | 'invalid-slot' | 'parent-not-layout' | 'slot-not-allowed-component' | 'slot-multiple-violated' | 'absolute-child-rejected' | 'depth-exceeded';
+
+export declare interface LayoutItem {
+    order?: number;
+    grow?: number;
+    shrink?: number;
+    row?: number;
+    column?: number;
+    rowSpan?: number;
+    columnSpan?: number;
+    ratio?: number;
+}
+
+export declare function layoutItemToCss(item: LayoutItem | undefined, parentMode: ContainerLayoutConfig['mode'] | undefined): Record<string, string | number> | null;
+
+export declare interface LegacyPageBinding {
+    id: string;
+    type: 'event' | 'init';
+    disabled?: boolean;
+    source?: {
+        instanceId: string;
+        event: string;
+    };
+    target: {
+        instanceId: string;
+        method: string;
+        args?: unknown[];
+    };
+    options?: {
+        once?: boolean;
+        throttleMs?: number;
+        debounceMs?: number;
+    };
+}
+
+declare type Listener = (ids: readonly string[]) => void;
+
+export declare function listRegisteredCanvasIds(): readonly string[];
+
+declare type LockedSubset = {
+    locked?: boolean;
+    lockPosition?: boolean;
+    lockSize?: boolean;
+};
+
+export declare interface MarqueeState {
+    active: boolean;
+    start: Point | null;
+    end: Point | null;
+    additive: boolean;
+    priorSelection: string[];
+}
+
+export declare function matchBinding(binding: CanvasShortcutBinding, ev: KeyboardEvent): boolean;
+
+export declare const MAX_INSTANCE_TREE_DEPTH = 8;
+
+declare interface MeasuredStageSize {
+    w: number;
+    h: number;
+}
+
+export declare interface MethodDecl {
+    key: string;
+    params?: string[];
+    label?: string;
+    description?: string;
+    argsHint?: string;
+}
+
+export declare function migrateInstanceToLayoutBox(inst: PageInstance): PageInstance;
+
+export declare function migrateLayoutV0ToV1(raw: PageLayout | CanvasLayoutConfig | undefined): CanvasLayoutConfig;
+
+export declare function migratePlacementToCanvasContainer(inst: PageInstance): PageInstance;
+
+export declare function migrateRootLayout(layout: CanvasLayoutConfig): CanvasLayoutConfig;
+
+export declare const MIN_INSTANCE_SIZE = 8;
+
+export declare const MIN_RATIO_FRACTION = 0.05;
+
+export declare interface ModelDecl {
+    key: string;
+    prop?: string;
+    event?: string;
+    type?: DeclValueType;
+    defaultValue?: unknown;
+    label?: string;
+    description?: string;
+}
+
+export declare interface ModifierKeys {
+    shift: boolean;
+    ctrl: boolean;
+    meta: boolean;
+}
+
+export declare type MountState = 'idle' | 'pending' | 'mounting' | 'mounted' | 'disposing';
+
+export declare function normalizeComponentOverrides(raw: PageDocument['componentOverrides'], instances: readonly PageInstance[]): Record<string, PageComponentOverride>;
+
+export declare type NormalizedPageBinding = (PageBindingBase & {
+    type: 'event';
+}) | (PageBindingBase & {
+    type: 'init';
+}) | (PageBindingBase & {
+    type: 'data';
+});
+
+export declare function normalizeInstanceSlotFields(inst: PageInstance): PageInstance;
+
+export declare function normalizeKeyString(s: string): string;
+
+export declare function normalizeMarqueeRect(a: Point, b: Point): Rect;
+
+export declare function normalizePageBindings(raw: PageBindingInput[] | undefined | null): NormalizedPageBinding[];
+
+export declare function normalizePageDocument(raw: PageDocumentInput): PageDocument;
+
+export declare type PageBinding = PageBindingInput;
+
+export declare interface PageBindingBase {
+    id: string;
+    label?: string;
+    disabled?: boolean;
+    source: BindingSource;
+    target: BindingTarget;
+    mapping?: BindingMapping;
+    schedule?: BindingSchedule;
+    errorPolicy?: BindingErrorPolicy;
+}
+
+export declare type PageBindingInput = LegacyPageBinding | NormalizedPageBinding;
+
+export declare type PageBindingPatch = Partial<NormalizedPageBinding>;
+
+export declare interface PageComponentOverride {
+    instanceId: string;
+    baseVersionKey: ComponentVersionKey;
+    source: Source;
+    contract: ComponentContract;
+    contractParseError?: {
+        message: string;
+        line?: number;
+        column?: number;
+    };
+    createdAt?: string;
+    updatedAt?: string;
+}
+
+export declare interface PageDocument {
+    schemaVersion?: '1';
+    layout: PageLayout | CanvasLayoutConfig;
+    instances: PageInstance[];
+    bindings: NormalizedPageBinding[];
+    componentOverrides?: Record<string, PageComponentOverride>;
+}
+
+export declare interface PageDocumentInput {
+    schemaVersion?: '1';
+    layout: PageLayout | CanvasLayoutConfig;
+    instances: PageInstance[];
+    bindings: PageBindingInput[];
+    componentOverrides?: Record<string, PageComponentOverride>;
+}
+
+export declare interface PageInstance {
+    instanceId: string;
+    componentId: string;
+    componentVersionKey: ComponentVersionKey;
+    alias?: string;
+    rect: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    zIndex: number;
+    rotation?: number;
+    locked?: boolean;
+    lockPosition?: boolean;
+    lockSize?: boolean;
+    hidden?: boolean;
+    props: Record<string, unknown>;
+    layoutBox?: LayoutBox;
+    layoutItem?: LayoutItem;
+    slotPlacement?: {
+        parentInstanceId: string;
+        slotName: string;
+        order?: number;
+    };
+    parentId?: string;
+    slot?: string;
+    placement?: 'canvas' | 'container' | 'absolute' | 'slot';
+    sizing?: {
+        width?: {
+            mode: 'fixed' | 'fill' | 'hug' | 'percent';
+            value?: number;
+        };
+        height?: {
+            mode: 'fixed' | 'fill' | 'hug' | 'percent';
+            value?: number;
+        };
+        min?: {
+            w?: number;
+            h?: number;
+        };
+        max?: {
+            w?: number;
+            h?: number;
+        };
+    };
+    size?: PageInstanceSize;
+    containerLayout?: ContainerLayoutConfig;
+    position?: 'normal' | 'sticky' | 'pinned';
+}
+
+export declare interface PageInstanceSize {
+    width?: InstanceSizeAxis;
+    height?: InstanceSizeAxis;
+}
+
+export declare interface PageInstanceTreeNode {
+    instanceId: string;
+    componentId: string;
+    componentVersionKey: string;
+    label?: string;
+    kind: 'visual' | 'layout' | 'data' | string;
+    locked?: boolean;
+    lockPosition?: boolean;
+    lockSize?: boolean;
+    hidden?: boolean;
+    children?: PageInstanceTreeNode[];
+}
+
+export declare interface PageLayout {
+    type: 'free';
+    canvas: {
+        w: number;
+        h: number;
+        gridSize?: number;
+        background?: {
+            color?: string;
+            imageAssetId?: string;
+            fit?: 'cover' | 'contain' | 'original';
+        };
+    };
+}
+
+export declare interface PageRenderPayload {
+    page: {
+        id: string;
+        name: string;
+        targets: Array<'pc' | 'mobile' | 'screen'>;
+    };
+    version: {
+        version: string;
+        label: string;
+        publishedAt: string;
+    } | null;
+    document: PageDocument;
+    componentVersions: Record<ComponentVersionKey, ComponentVersionAsset | DraftComponentVersionAsset>;
+}
+
+export declare function parseComponentVersionKey(key: ComponentVersionKey): ParsedComponentVersionKey | null;
+
+export declare type ParsedComponentVersionKey = {
+    kind: 'published';
+    componentId: string;
+    version: string;
+} | {
+    kind: 'draft';
+    componentId: string;
+    pageId: string;
+    baseVersion: string;
+    baseVersionKey: string;
+};
+
+export declare function parseKeyEvent(ev: KeyboardEvent): string;
+
+export declare interface Point {
+    x: number;
+    y: number;
+}
+
+export declare interface PropDecl {
+    key: string;
+    type?: DeclValueType;
+    value?: unknown;
+    label?: string;
+    enum?: unknown[];
+    description?: string;
+    required?: boolean;
+}
+
+export declare function provideCanvasContext(ctx: CanvasContext): void;
+
+export declare interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+
+declare interface Rect_2 {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+
+export declare function registerDesignerHandle(canvasId: string, handle: CanvasHandle): void;
+
+export declare function renderLayoutBoxStyle(layoutBox: LayoutBox, zIndex: number, rotation: number | undefined, parentLayoutMode: ContainerLayoutConfig['mode'] | undefined): Record<string, string | number>;
+
+export declare interface RenderScheduler {
+    register(instanceId: string, el: Element): void;
+    unregister(instanceId: string): void;
+    isMounted(instanceId: string): boolean;
+    getState(instanceId: string): MountState;
+    readonly state: Readonly<Record<string, MountState>>;
+    dispose(): void;
+}
+
+export declare interface RenderSchedulerOptions {
+    rootMargin?: string;
+    disposeDelayMs?: number;
+    mountConcurrency?: number;
+    root?: Element | null;
+}
+
+export declare interface ReparentBridge {
+    getDropTarget(clientPoint: Point, options?: {
+        excludeInstanceId?: string;
+    }): DropTarget | null;
+    canReparent(instanceId: string, target: TreeMoveTarget): CanReparentResult;
+    moveInstanceInTree(instanceId: string, target: TreeMoveTarget): void;
+    cannotReparentEvent: Readonly<Ref<CannotReparentEvent | null>>;
+}
+
+export declare type ReparentContractResolver = (versionKey: ComponentVersionKey) => ComponentContract | undefined;
+
+export declare type ResizeHandle = 'nw' | 'n' | 'ne' | 'w' | 'e' | 'sw' | 's' | 'se';
+
+export declare interface ResizeState {
+    status: 'idle' | 'active';
+    handle: ResizeHandle | null;
+    startPt: Point | null;
+    startRect: Rect | null;
+    instanceId: string | null;
+    placement: 'absolute' | 'canvas' | 'slot' | 'container' | null;
+    parentLayoutMode: ContainerLayoutConfig['mode'] | undefined;
+    startSize: PageInstanceSize | null;
+    startLayoutBox: LayoutBox | null;
+    startOutletCanvasSize: {
+        w: number;
+        h: number;
+    } | null;
+}
+
+export declare function resolveCanvasSizePx(size: CanvasSizeValue, fallback?: number): number;
+
+export declare function resolveMeasuredCanvasSizePx(size: CanvasSizeValue, axisSize: number, fallback?: number): number;
+
+export declare const RuntimeLayer: DefineComponent<__VLS_Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_3> & Readonly<{}>, {
+mode: CanvasMode;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface SelectionStore {
+    readonly selectedIds: ComputedRef<string[]>;
+    readonly size: ComputedRef<number>;
+    readonly primaryId: ComputedRef<string | undefined>;
+    select(instanceId: string): void;
+    toggleSelect(instanceId: string): void;
+    addToSelection(instanceId: string): void;
+    removeFromSelection(instanceId: string): void;
+    clearSelection(): void;
+    selectAll(instanceIds: string[]): void;
+    purgeOrphans(validIds: string[]): void;
+    isSelected(instanceId: string): boolean;
+}
+
+export declare const SLOT_CHILD_RESIZE_HANDLES: readonly ["e", "s", "se"];
+
+export declare interface SlotDecl {
+    name: string;
+    label?: string;
+    accepts?: string[];
+    multiple?: boolean;
+    maxChildren?: number;
+    description?: string;
+}
+
+export declare type SnapAxis = 'x' | 'y';
+
+export declare interface SnapInput {
+    draggedRects: readonly Rect[];
+    otherRects: readonly Rect[];
+    canvasSize: {
+        w: number;
+        h: number;
+    };
+    threshold?: number;
+    manualGuides?: {
+        x?: readonly number[];
+        y?: readonly number[];
+    };
+}
+
+export declare type SnapKind = 'edge-left' | 'edge-right' | 'edge-top' | 'edge-bottom' | 'center-x' | 'center-y' | 'canvas-edge' | 'guide';
+
+export declare interface SnapLine {
+    axis: SnapAxis;
+    pos: number;
+    from: number;
+    to: number;
+    kind: SnapKind;
+}
+
+export declare interface SnapResult {
+    dx: number;
+    dy: number;
+    lines: SnapLine[];
+}
+
+export declare interface Source {
+    html: string;
+    js: string;
+    css: string;
+}
+
+export declare interface SplitContainerLayout {
+    mode: 'split';
+    direction: 'horizontal' | 'vertical';
+    ratios: number[];
+    gap?: number;
+}
+
+export declare interface SplitDivider {
+    index: number;
+    rect: Rect;
+    direction: 'horizontal' | 'vertical';
+}
+
+export declare interface SplitDividerDragState {
+    status: 'idle' | 'active';
+    parentId: string | null;
+    dividerIndex: number | null;
+    startRatios: number[] | null;
+    parentAxisPx: number;
+    startPt: Point | null;
+    direction: 'horizontal' | 'vertical' | null;
+    gap: number;
+}
+
+export declare interface SplitDividerInteraction {
+    drag: Readonly<SplitDividerDragState>;
+    isDragging: Readonly<Ref<boolean>>;
+    handleSplitDividerStart(args: {
+        parentId: string;
+        dividerIndex: number;
+        startRatios: number[];
+        parentAxisPx: number;
+        direction: 'horizontal' | 'vertical';
+        gap: number;
+        canvasPt: Point;
+    }): {
+        startTracking: boolean;
+    };
+    handleSplitDividerMove(canvasPt: Point): void;
+    handleSplitDividerEnd(): void;
+    cancelSplitDividerDrag(): void;
+}
+
+export declare interface StaleComponentOverride {
+    instanceId: string;
+    baseVersionKey: ComponentVersionKey;
+    currentVersionKey: ComponentVersionKey;
+}
+
+export declare interface StoreTraceEvent {
+    kind: StoreTraceKind;
+    cacheKey: string;
+    sourceId: string;
+    writeSeq?: number;
+    reason?: string;
+    value?: unknown;
+}
+
+export declare type StoreTraceKind = 'data-source-update' | 'data-query-skipped';
+
+export declare function subscribeDesignerRegistry(fn: Listener): () => void;
+
+export declare interface TraceCollectorOptions {
+    capacity?: number;
+    filterKinds?: BindingTraceKind[];
+}
+
+export declare interface TreeMoveTarget {
+    parentId: string | null;
+    slot?: string;
+    index?: number;
+}
+
+export declare function unionRects(rects: readonly Rect_2[]): Rect_2 | null;
+
+export declare function unregisterDesignerHandle(canvasId: string): void;
+
+export declare function useCanvasContext(): CanvasContext;
+
+export declare function validateBindings(doc: PageDocument, options?: ValidateBindingsOptions): BindingIssue[];
+
+export declare interface ValidateBindingsOptions {
+    resolveContract?: ContractResolver;
+    currentCanvasId?: string;
+}
+
+export declare function validateInstanceTree(doc: PageDocument, options: ValidateOptions): LayoutIssue[];
+
+export declare interface ValidateOptions {
+    resolveContract: ContractResolver;
+    maxDepth?: number;
+}
+
+export declare const VERSION = "0.0.0-d3.6c-stage";
+
+export declare interface ViewportState {
+    scale: number;
+    panX: number;
+    panY: number;
+}
+
+export declare interface ViewportStore {
+    readonly state: Readonly<ViewportState>;
+    readonly scale: ComputedRef<number>;
+    readonly panX: ComputedRef<number>;
+    readonly panY: ComputedRef<number>;
+    setScale(scale: number): void;
+    zoomAt(viewportPoint: Point, deltaScale: number): void;
+    setPan(panX: number, panY: number): void;
+    panBy(dx: number, dy: number): void;
+    resetView(): void;
+    fitToScreen(canvasSize: {
+        w: number;
+        h: number;
+    }, containerSize: {
+        w: number;
+        h: number;
+    }, padding?: number): void;
+    toCanvasPoint(viewportPoint: Point): Point;
+    toViewportPoint(canvasPoint: Point): Point;
+}
+
+export declare interface ViewportStoreOptions {
+    minScale?: number;
+    maxScale?: number;
+    initialScale?: number;
+}
+
+export declare function wirePageBindings(options: WirePageBindingsOptions): WirePageBindingsHandle;
+
+export declare interface WirePageBindingsHandle {
+    setMode(mode: CanvasBindingMode): void;
+    getMode(): CanvasBindingMode;
+    testBinding(bindingId: string, mockPayload?: unknown): BindingTestTrace[];
+    on<E extends 'binding:fire' | 'binding:error' | 'binding:trace'>(event: E, cb: BindingEventCb<E>): () => void;
+    startTracing(opts?: TraceCollectorOptions): void;
+    stopTracing(): BindingTraceEvent[];
+    getTraceBuffer(): readonly BindingTraceEvent[];
+    dispose(): void;
+}
+
+export declare interface WirePageBindingsOptions {
+    canvasId: string;
+    source: DocumentSource;
+    initialMode?: CanvasBindingMode;
+    dataStore?: DataSourceStore;
+}
+
+export { }