@dragcraft/renderer 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,1419 @@
+import { Command, CommandExecutionResult, ContainerRegionDefinition, ContainerRegionId, ContainerVariantId, CoreWidgetMeta, CreationBlockReason, DeepReadonly as DeepReadonly$1, DesignerEngine, DesignerSchema, LayoutPlan, NodeDestination, NodeOwner, NodeStyle, PlacementDecision, ResolvedNodeLayout, SchemaIndexResult, SchemaNode, StyleValueMap } from "@dragcraft/core";
+import { Component, ComputedRef, InjectionKey, PropType, Ref, VNode } from "vue";
+import { MessageTree } from "@dragcraft/i18n";
+//#region src/event-hooks.d.ts
+/**
+ * A value that is either T or a Promise resolving to T.
+ * Used to allow event hooks to be either synchronous or asynchronous.
+ */
+type MaybePromise<T> = T | Promise<T>;
+interface PendingGuard {
+  value: boolean;
+}
+/**
+ * Payload for selection hooks.
+ */
+interface SelectHookPayload {
+  nodeId: string;
+  event?: MouseEvent;
+}
+/**
+ * Payload for drag hooks.
+ */
+interface DragHookPayload {
+  nodeId: string;
+  event?: DragEvent;
+}
+/**
+ * Payload for hover hooks.
+ */
+interface HoverHookPayload {
+  nodeId: string | null;
+}
+/**
+ * Interceptable event hooks for non-action renderer events.
+ *
+ * "onBefore*" hooks are called BEFORE the action. Returning `false`
+ * cancels the event (e.g., prevents selection).
+ * Returning `undefined` or `true` allows the action to proceed.
+ * Hooks may return a Promise for async operations (e.g., confirmation dialogs, API validation).
+ *
+ * "onAfter*" hooks are called AFTER the action completed.
+ * They are informational and cannot cancel. May return a Promise (fire-and-forget).
+ *
+ * Exceptions:
+ * - `onBeforeDrag` stays synchronous — browser DragEvent requires synchronous `preventDefault()`.
+ * - `onHoverChange` stays synchronous — high-frequency informational event.
+ */
+interface RendererEventHooks {
+  onBeforeSelect?: (payload: SelectHookPayload) => MaybePromise<boolean | void>;
+  onAfterSelect?: (payload: SelectHookPayload) => MaybePromise<void>;
+  onBeforeDrag?: (payload: DragHookPayload) => boolean | void;
+  onAfterDrag?: (payload: DragHookPayload) => MaybePromise<void>;
+  onHoverChange?: (payload: HoverHookPayload) => void;
+}
+/**
+ * Returns empty event hooks (no-op). Used as the default.
+ */
+declare function createDefaultEventHooks(): RendererEventHooks;
+/**
+ * Resolves a before-hook result that may be sync or async.
+ * Returns `true` if the action should proceed, `false` if cancelled.
+ *
+ * Error handling: if the hook throws or the promise rejects,
+ * the action is CANCELLED (returns false) and the error is logged.
+ * Rationale: a gating hook that crashes should fail closed, not open.
+ */
+declare function resolveBeforeHook(result: Promise<boolean | void>): Promise<boolean>;
+/**
+ * Fires an after-hook (fire-and-forget).
+ * If the hook returns a promise, any rejection is caught and logged.
+ * Errors never propagate to the caller.
+ */
+declare function fireAfterHook<P>(hook: ((payload: P) => MaybePromise<void>) | undefined, payload: P): void;
+//#endregion
+//#region src/action-runtime.d.ts
+type ActionRisk = 'normal' | 'destructive';
+interface ActionDecision {
+  allowed: boolean;
+  reason?: string;
+}
+interface ActionInvocation {
+  key: string;
+  label: string;
+  ctx: NodeActionContext;
+  event: MouseEvent;
+  risk: ActionRisk;
+  command?: Command;
+  metadata?: Record<string, unknown>;
+}
+interface ActionInterceptor {
+  beforeAction?: (invocation: ActionInvocation) => MaybePromise<boolean | ActionDecision | void>;
+  afterAction?: (invocation: ActionInvocation) => MaybePromise<void>;
+  onActionError?: (invocation: ActionInvocation, error: unknown) => void;
+}
+interface ActionConfirmRequest {
+  invocation: ActionInvocation;
+  title?: string;
+  message?: string;
+}
+interface ConfirmActionInterceptorOptions {
+  confirm: (request: ActionConfirmRequest) => MaybePromise<boolean>;
+  shouldConfirm?: (invocation: ActionInvocation) => boolean;
+  title?: string | ((invocation: ActionInvocation) => string);
+  message?: string | ((invocation: ActionInvocation) => string);
+}
+declare function runActionPipeline(invocation: ActionInvocation, execute: () => MaybePromise<void>, interceptors?: ActionInterceptor[], pendingGuard?: PendingGuard): void | Promise<void>;
+declare function createConfirmActionInterceptor(options: ConfirmActionInterceptorOptions): ActionInterceptor;
+//#endregion
+//#region src/selection-presentation.d.ts
+type NodeSelectionPlane = 'root' | 'content' | 'viewport';
+type NodeSelectionProjectionKind = 'root-segment' | 'material-bounds';
+interface NodeSelectionRect {
+  top: number;
+  left: number;
+  width: number;
+  height: number;
+}
+interface NodeSelectionProjection {
+  kind: NodeSelectionProjectionKind;
+  plane: NodeSelectionPlane;
+  /** Material border box relative to the registered plane. */
+  materialBounds: NodeSelectionRect;
+  /** Renderer-owned semantic selection range relative to the registered plane. */
+  bounds: NodeSelectionRect;
+}
+interface NodeSelectionPresentationHost {
+  registerPlane: (plane: NodeSelectionPlane, element: HTMLElement | null) => void;
+}
+interface NodeSelectionPresentation extends NodeSelectionPresentationHost {
+  registerFallback: (element: HTMLElement | null) => void;
+  getPlane: (plane: NodeSelectionPlane) => ComputedRef<HTMLElement | null>;
+}
+declare const NODE_SELECTION_PRESENTATION_KEY: InjectionKey<NodeSelectionPresentation>;
+declare const NODE_SELECTION_PLANE_KEY: InjectionKey<Readonly<Ref<NodeSelectionPlane>>>;
+declare function createNodeSelectionPresentation(): NodeSelectionPresentation;
+declare function useNodeSelectionPresentation(): NodeSelectionPresentation;
+//#endregion
+//#region src/node-interaction.d.ts
+type NodeInteractionGeometryMode = 'root-band' | 'node-box';
+type NodeToolbarPlacement = 'left-start' | 'top-end';
+type NodeToolbarOrientation = 'vertical' | 'horizontal';
+interface NodeInteractionPresentation {
+  geometryMode: NodeInteractionGeometryMode;
+  selectionKind: NodeSelectionProjectionKind;
+  toolbarPlacement: NodeToolbarPlacement;
+  toolbarOrientation: NodeToolbarOrientation;
+}
+declare function resolveNodeInteractionPresentation(owner: NodeOwner): NodeInteractionPresentation;
+//#endregion
+//#region src/types.d.ts
+type DeepReadonly<T> = T extends ((...args: infer Args) => infer Result) ? (...args: Args) => Result : T extends readonly unknown[] ? { readonly [Key in keyof T]: DeepReadonly<T[Key]>; } : T extends object ? { readonly [Key in keyof T]: DeepReadonly<T[Key]>; } : T;
+/**
+ * Maps a node's `type` string to a Vue component.
+ *
+ * Example: { button: ButtonWidget, text: TextWidget }
+ */
+type ComponentMap = Record<string, Component>;
+interface WidgetRendererProps {
+  node: SchemaNode;
+  owner?: NodeOwner;
+  /** Internal coordinate plane inherited by nested container nodes. */
+  selectionPlane?: NodeSelectionPlane;
+}
+interface ContainerRegionOutletProps {
+  regionId: ContainerRegionId;
+  as?: string | Component;
+}
+interface ResolveContainerDropIndexContext {
+  event: DragEvent;
+  regionElement: HTMLElement;
+  itemElements: readonly HTMLElement[];
+  nodes: DeepReadonly<SchemaNode[]>;
+}
+type ResolveContainerDropIndex = (ctx: ResolveContainerDropIndexContext) => number | null;
+interface ContainerRegionOutletDropProps extends ContainerRegionOutletProps {
+  resolveDropIndex?: ResolveContainerDropIndex;
+}
+interface ContainerDropTarget {
+  event: DragEvent;
+  destination: Extract<NodeDestination, {
+    kind: 'container';
+  }>;
+}
+interface ContainerDropRejection {
+  event: DragEvent;
+  containerId: string;
+  regionId: string;
+  allowed: false;
+  code: 'CONTAINER_DROP_ADAPTER_MISSING' | 'CONTAINER_DROP_ADAPTER_FAILED' | 'CONTAINER_DROP_ADAPTER_INVALID' | 'CONTAINER_DROP_NO_TARGET';
+  message?: string;
+}
+/**
+ * Props received by a custom nodeWrapper component.
+ * Must render a default slot containing the widget content.
+ */
+interface NodeWrapperProps {
+  /** The schema node ID being wrapped */
+  nodeId: string;
+  /** The widget type string */
+  nodeType: string;
+  /** Structural owner that determines the default interaction presentation. */
+  owner: NodeOwner;
+  /** Reactive interaction state */
+  state: NodeInteractionState;
+  /** The resolved widget meta, if available */
+  meta: RendererWidgetMeta | undefined;
+}
+interface RendererWidgetActionExtra {
+  key: string;
+  label: string;
+  icon?: string | Component;
+  type: 'button' | 'drag-handle';
+  order: number;
+  risk?: ActionRisk;
+  metadata?: Record<string, unknown>;
+  visible?: (ctx: NodeActionContext) => boolean;
+  available?: (ctx: NodeActionContext) => boolean;
+  disabled?: (ctx: NodeActionContext) => boolean;
+  command?: (ctx: NodeActionContext, event: MouseEvent) => Command | null | undefined;
+  handler?: (ctx: NodeActionContext, event: MouseEvent) => MaybePromise<void>;
+  className?: string;
+}
+interface WidgetActionConfig {
+  only?: string[];
+  exclude?: string[];
+  extra?: RendererWidgetActionExtra[];
+}
+interface RendererContainerAdapter {
+  resolveDropIndex?: ResolveContainerDropIndex;
+}
+interface RendererWidgetMeta extends CoreWidgetMeta {
+  actions?: WidgetActionConfig;
+  wrapper?: Component;
+  containerAdapter?: RendererContainerAdapter;
+}
+/**
+ * Viewport-relative position coordinates for floating toolbar.
+ * When provided, the toolbar uses position: fixed to escape overflow clipping.
+ */
+interface ToolbarPositionData {
+  /** CSS x coordinate in pixels (viewport-relative). */
+  x: number;
+  /** CSS y coordinate in pixels (viewport-relative). */
+  y: number;
+  /** Resolved placement after collision handling. */
+  placement: 'left-start' | 'top-end' | 'bottom-end';
+  /** Action layout direction for the resolved owner presentation. */
+  orientation: NodeToolbarOrientation;
+  /** Positioning strategy used by the interaction layer. */
+  strategy: 'fixed';
+  /** Whether the toolbar should be visible (widget is at least partially in viewport) */
+  visible: boolean;
+}
+/**
+ * Props received by a custom nodeToolbar component.
+ */
+interface NodeToolbarProps {
+  /** The schema node ID */
+  nodeId: string;
+  /** The widget type string */
+  nodeType: string;
+  /** Structural owner that determines the default interaction presentation. */
+  owner: NodeOwner;
+  /** Pre-resolved actions for this node */
+  actions: ResolvedNodeAction[];
+  /** Reactive interaction state */
+  state: NodeInteractionState;
+  /** Drag start handler for drag-handle type actions */
+  onDragStart: (e: DragEvent) => void;
+  /** Drag end handler for drag-handle type actions */
+  onDragEnd: (e: DragEvent) => void;
+  /**
+   * Viewport-relative position for fixed positioning.
+   * When provided, the toolbar escapes overflow clipping by using position: fixed.
+   * If not provided, falls back to position: absolute behavior.
+   */
+  toolbarPosition?: ToolbarPositionData;
+}
+/**
+ * Props received by a custom nodeMask component.
+ */
+interface NodeMaskProps {
+  /** The schema node ID */
+  nodeId: string;
+  /** The widget type string */
+  nodeType: string;
+  /** Structural owner that determines the default interaction presentation. */
+  owner: NodeOwner;
+  /** Select handler to call on click */
+  onSelect: (e: MouseEvent) => void;
+}
+/**
+ * Props received by a custom nodeHandle component.
+ */
+interface NodeHandleProps {
+  /** The schema node ID */
+  nodeId: string;
+  /** The widget type string */
+  nodeType: string;
+  /** Structural owner that determines the default interaction presentation. */
+  owner: NodeOwner;
+  /** Select handler to call on click */
+  onSelect: (e: MouseEvent) => void;
+}
+/**
+ * Props received by a custom nodeSelection component.
+ * Renderer and the shell own geometry, plane routing, and clipping; the
+ * component only owns the visual presentation.
+ */
+interface NodeSelectionProps {
+  /** The schema node ID */
+  nodeId: string;
+  /** The widget type string */
+  nodeType: string;
+  /** Structural owner that determines the projection kind. */
+  owner: NodeOwner;
+  /** Renderer-owned material and semantic selection bounds in a coordinate plane. */
+  projection: NodeSelectionProjection;
+}
+/**
+ * Props received by a custom emptyState component.
+ */
+interface EmptyStateProps {
+  /** Whether a drag operation is currently over the canvas */
+  isDragOver: boolean;
+}
+/**
+ * Props received by a custom forbiddenOverlay component.
+ */
+interface ForbiddenOverlayProps {
+  /** The widget type that was blocked */
+  widgetType: string;
+  /** User-facing reason for the blocked creation attempt */
+  reason: CreationBlockReason | null;
+}
+/**
+ * Props received by a custom widgetFallback component.
+ */
+interface WidgetFallbackProps {
+  /** The schema node ID */
+  nodeId: string;
+  /** The unresolved widget type string */
+  nodeType: string;
+}
+interface RendererExtensions {
+  /**
+   * Replaces the default root canvas wrapper.
+   * E.g., a phone frame, tablet frame, or custom viewport shell.
+   * Receives ContainerShellProps and region slot functions.
+   */
+  containerShell?: Component;
+  /**
+   * Replaces the default drop indicator shown inside containers
+   * during drag-over state.
+   */
+  dropIndicator?: Component;
+  /**
+   * Wraps each rendered widget node. Receives NodeWrapperProps.
+   * Must render a default slot containing the widget content.
+   * Use this to add custom chrome, annotations, badges, etc.
+   */
+  nodeWrapper?: Component;
+  /**
+   * Replaces the default per-node floating toolbar.
+   * Receives NodeToolbarProps with pre-resolved actions.
+   */
+  nodeToolbar?: Component;
+  /**
+   * Replaces the default mask overlay for mask=true widgets.
+   * Receives NodeMaskProps.
+   */
+  nodeMask?: Component;
+  /**
+   * Replaces the default selection handle for mask=false widgets.
+   * Receives NodeHandleProps.
+   */
+  nodeHandle?: Component;
+  /**
+   * Replaces the visual presentation of the Renderer-owned selected projection.
+   * Geometry, plane routing, and clipping remain owned by Renderer and the shell.
+   */
+  nodeSelection?: Component;
+  /**
+   * Replaces the default "drag components here" empty state.
+   * Receives EmptyStateProps.
+   */
+  emptyState?: Component;
+  /**
+   * Replaces the default fallback for unknown widget types.
+   * Receives WidgetFallbackProps.
+   */
+  widgetFallback?: Component;
+  /**
+   * Replaces the default forbidden overlay shown when a widget type
+   * cannot be dropped.
+   * Receives ForbiddenOverlayProps.
+   */
+  forbiddenOverlay?: Component;
+}
+interface ContainerDropRendererOptions {
+  activeDestination?: Ref<NodeDestination | null>;
+  containerDropDecision?: Ref<PlacementDecision | null>;
+  onContainerDragOver?: (target: ContainerDropTarget | ContainerDropRejection) => void;
+  onContainerDragLeave?: (event: DragEvent) => void;
+  onContainerDrop?: (event: DragEvent) => void;
+}
+/**
+ * Options accepted by RootRenderer as props.
+ *
+ * **Immutability constraint:** These options are captured once when RootRenderer
+ * mounts and provided to all descendants via provide/inject. Changing them after
+ * the initial render has no effect on the running renderer. If you need to swap
+ * extensions or hooks, remount RootRenderer with a different `key`.
+ */
+interface RendererOptions extends ContainerDropRendererOptions {
+  /** The core engine instance (read-only consumption) */
+  engine: DesignerEngine;
+  /** Maps node.type -> Vue component for rendering */
+  componentMap: ComponentMap;
+  /** Optional extension point overrides */
+  extensions?: RendererExtensions;
+  /** Interceptable event hooks for renderer events */
+  eventHooks?: RendererEventHooks;
+  /** Interceptors for node actions such as delete, move, duplicate, and custom actions */
+  actionInterceptors?: ActionInterceptor[];
+  /** Node action registry. If not provided, default actions are used. */
+  actionRegistry?: NodeActionRegistry;
+  /**
+   * Optional reactive ref tracking whether root is being dragged over.
+   * Managed externally by the designer package.
+   * If not provided, drag-over visual state is disabled.
+   */
+  dragOverNodeId?: Ref<string | null>;
+  /**
+   * Optional reactive ref tracking the visual insertion index during drag-over.
+   * Determines where the drop indicator is rendered within the widget list.
+   * Managed externally by the designer package.
+   */
+  dragOverIndex?: Ref<number | null>;
+  /** Optional canvas viewport used as the collision boundary for floating controls. */
+  interactionBoundary?: Ref<HTMLElement | null>;
+  /**
+   * Optional reactive ref indicating the current drag-over is forbidden.
+   * When true and dragOverNodeId is 'root', the forbidden overlay is shown
+   * instead of the drop indicator.
+   * Managed externally by the designer package.
+   */
+  isForbidden?: Ref<boolean>;
+  /** Optional reason explaining the current forbidden drag-over state. */
+  forbiddenReason?: Ref<CreationBlockReason | null>;
+}
+/**
+ * Internal context provided to all renderer descendants via provide/inject.
+ */
+interface RendererContext extends ContainerDropRendererOptions {
+  engine: DesignerEngine;
+  /** One safe schema snapshot shared by the renderer tree for each schema revision. */
+  schema: ComputedRef<DeepReadonly<DesignerSchema>>;
+  /** Root layout projection cached for the current schema revision. */
+  layoutPlan: ComputedRef<LayoutPlan>;
+  /** Ownership index cached for the current schema revision. */
+  schemaIndex: ComputedRef<SchemaIndexResult>;
+  /** Resolves action geometry and lock constraints from revision-scoped caches. */
+  resolveNodeActionPosition?: (node: SchemaNode, owner: NodeOwner) => {
+    owner: NodeOwner;
+    index: number;
+    siblingCount: number;
+    sortScope: string | false;
+    lockedIndices: Set<number>;
+  };
+  componentMap: ComponentMap;
+  extensions: RendererExtensions;
+  eventHooks: RendererEventHooks;
+  actionInterceptors: ActionInterceptor[];
+  actionRegistry: NodeActionRegistry;
+  dragOverNodeId: Ref<string | null>;
+  activeDestination: Ref<NodeDestination | null>;
+  containerDropDecision: Ref<PlacementDecision | null>;
+  /** Optional canvas viewport used as the collision boundary for floating controls. */
+  interactionBoundary?: Ref<HTMLElement | null>;
+}
+/**
+ * Injection key for the renderer context.
+ */
+declare const RENDERER_CONTEXT_KEY: InjectionKey<RendererContext>;
+/**
+ * Reactive interaction state computed for a single node.
+ * Returned by the useNodeState composable.
+ */
+interface NodeInteractionState {
+  isSelected: ComputedRef<boolean>;
+  isHovered: ComputedRef<boolean>;
+  isDragOver: ComputedRef<boolean>;
+  /** CSS class map for binding: { 'dc-node--selected': true, ... } */
+  interactionClasses: ComputedRef<Record<string, boolean>>;
+}
+//#endregion
+//#region src/action-registry.d.ts
+/**
+ * Context provided to action predicates and handlers.
+ */
+interface NodeActionContext {
+  /** The schema node this action applies to */
+  node: DeepReadonly$1<SchemaNode>;
+  /** Structural owner whose child array defines sibling ordering. */
+  owner: NodeOwner;
+  /** The node's index among siblings */
+  index: number;
+  /** Total sibling count */
+  siblingCount: number;
+  /** Sort scope this action context belongs to, or false when unsorted */
+  sortScope: string | false;
+  /** The widget meta, if registered */
+  meta: RendererWidgetMeta | undefined;
+  /** The engine instance for executing commands */
+  engine: DesignerEngine;
+  /** Safe schema snapshot shared by all action predicates for this resolution. */
+  schema: DeepReadonly$1<DesignerSchema>;
+  /** Precomputed lock set for the owning sort scope or container region. */
+  lockedIndices?: Set<number>;
+}
+/**
+ * Definition of a single node action.
+ */
+interface NodeActionDefinition {
+  /** Unique action key (e.g., 'drag', 'move-up', 'move-down', 'delete') */
+  key: string;
+  /** Display label for the action */
+  label: string;
+  /** Icon content: a string character, or a Vue component */
+  icon?: string | Component;
+  /** 'button' renders as button, 'drag-handle' renders as draggable element */
+  type: 'button' | 'drag-handle';
+  /** Sort order. Built-in actions use 100, 200, 300, 400. */
+  order: number;
+  /** Risk level used by action interceptors. */
+  risk?: ActionRisk;
+  /** Optional metadata passed through action interceptors. */
+  metadata?: Record<string, unknown>;
+  /**
+   * Whether this action is visible.
+   * Return false to hide the action for this node.
+   */
+  visible?: (ctx: NodeActionContext) => boolean;
+  /**
+   * Whether this action is available (usable) for this node.
+   * Return false to render the action in disabled state.
+   * Distinct from `visible` — an action can be visible but unavailable.
+   */
+  available?: (ctx: NodeActionContext) => boolean;
+  /**
+   * Whether this action is disabled.
+   * Return true to render the button in disabled state.
+   */
+  disabled?: (ctx: NodeActionContext) => boolean;
+  /**
+   * Command invoked when the action is triggered.
+   * Prefer this for schema writes so the action remains declarative.
+   */
+  command?: (ctx: NodeActionContext, event: MouseEvent) => Command | null | undefined;
+  /**
+   * Handler invoked when the action is triggered.
+   * Use this for side effects or actions that do not map to a core command.
+   */
+  handler?: (ctx: NodeActionContext, event: MouseEvent) => MaybePromise<void>;
+  /**
+   * CSS class name(s) to add to the action element.
+   */
+  className?: string;
+}
+/**
+ * A resolved action with computed visible/disabled state for a specific node.
+ */
+interface ResolvedNodeAction {
+  key: string;
+  label: string;
+  icon?: string | Component;
+  type: 'button' | 'drag-handle';
+  order: number;
+  risk: ActionRisk;
+  metadata?: Record<string, unknown>;
+  visible: boolean;
+  disabled: boolean;
+  handler: (event: MouseEvent) => void | Promise<void>;
+  className?: string;
+}
+/**
+ * Registry for managing node actions.
+ */
+interface NodeActionRegistry {
+  /** Get all registered global action definitions */
+  getActions: () => NodeActionDefinition[];
+  /** Register a new action definition */
+  register: (action: NodeActionDefinition) => void;
+  /** Unregister an action by key */
+  unregister: (key: string) => void;
+  /**
+   * Resolve actions for a specific node, applying visibility/disabled predicates
+   * and per-widget overrides from WidgetMeta.
+   */
+  resolve: (ctx: NodeActionContext, actionInterceptors?: ActionInterceptor[], keys?: readonly string[]) => ResolvedNodeAction[];
+}
+declare const ActionKey: {
+  readonly DRAG: "drag";
+  readonly MOVE_UP: "move-up";
+  readonly MOVE_DOWN: "move-down";
+  readonly DUPLICATE: "duplicate";
+  readonly DELETE: "delete";
+};
+declare function createDefaultActions(t?: (key: string, fallback?: string) => string): NodeActionDefinition[];
+declare function createNodeActionRegistry(initialActions?: NodeActionDefinition[]): NodeActionRegistry;
+//#endregion
+//#region src/components/ContainerRegionOutlet.d.ts
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  regionId: {
+    type: StringConstructor;
+    required: true;
+  };
+  as: {
+    type: PropType<string | Component>;
+    default: string;
+  };
+  resolveDropIndex: {
+    type: PropType<ResolveContainerDropIndex>;
+    default: undefined;
+  };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  regionId: {
+    type: StringConstructor;
+    required: true;
+  };
+  as: {
+    type: PropType<string | Component>;
+    default: string;
+  };
+  resolveDropIndex: {
+    type: PropType<ResolveContainerDropIndex>;
+    default: undefined;
+  };
+}>> & Readonly<{}>, {
+  as: string | Component;
+  resolveDropIndex: ResolveContainerDropIndex;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/DefaultContainerFallback.d.ts
+declare const _default$1: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  node: {
+    type: PropType<SchemaNode>;
+    required: true;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  node: {
+    type: PropType<SchemaNode>;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/DefaultContainerShell.d.ts
+declare const DefaultContainerShell: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  isEmpty: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  regionVNodes: {
+    type: PropType<Record<string, VNode[]>>;
+    default: () => {};
+  };
+  chromeVNodes: {
+    type: PropType<VNode[]>;
+    default: () => never[];
+  };
+  layerVNodes: {
+    type: PropType<Record<string, VNode[]>>;
+    default: () => {};
+  };
+  forbiddenOverlayVNode: {
+    type: PropType<VNode | null>;
+    default: null;
+  };
+  layoutPlan: {
+    type: PropType<LayoutPlan>;
+    default: undefined;
+  };
+  surfaceStyle: {
+    type: PropType<StyleValueMap>;
+    default: undefined;
+  };
+  selectionPresentation: {
+    type: PropType<NodeSelectionPresentationHost>;
+    default: undefined;
+  };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  isEmpty: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  regionVNodes: {
+    type: PropType<Record<string, VNode[]>>;
+    default: () => {};
+  };
+  chromeVNodes: {
+    type: PropType<VNode[]>;
+    default: () => never[];
+  };
+  layerVNodes: {
+    type: PropType<Record<string, VNode[]>>;
+    default: () => {};
+  };
+  forbiddenOverlayVNode: {
+    type: PropType<VNode | null>;
+    default: null;
+  };
+  layoutPlan: {
+    type: PropType<LayoutPlan>;
+    default: undefined;
+  };
+  surfaceStyle: {
+    type: PropType<StyleValueMap>;
+    default: undefined;
+  };
+  selectionPresentation: {
+    type: PropType<NodeSelectionPresentationHost>;
+    default: undefined;
+  };
+}>> & Readonly<{}>, {
+  isEmpty: boolean;
+  regionVNodes: Record<string, VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+  }>[]>;
+  chromeVNodes: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+  }>[];
+  layerVNodes: Record<string, VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+  }>[]>;
+  forbiddenOverlayVNode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+  }> | null;
+  layoutPlan: LayoutPlan;
+  surfaceStyle: StyleValueMap;
+  selectionPresentation: NodeSelectionPresentationHost;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/DefaultDropIndicator.d.ts
+/**
+ * Sort-scope drop indicator shown during drag-over.
+ * Renders a dashed-border rectangle placeholder indicating where
+ * the widget will be placed. Styled via CSS class `dc-drop-indicator`.
+ */
+declare const _default$2: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/DefaultEmptyState.d.ts
+/**
+ * Default empty canvas state component.
+ * Displayed when the canvas has no widgets and no drag operation is active.
+ */
+declare const _default$3: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  isDragOver: {
+    type: PropType<boolean>;
+    default: boolean;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  isDragOver: {
+    type: PropType<boolean>;
+    default: boolean;
+  };
+}>> & Readonly<{}>, {
+  isDragOver: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/DefaultForbiddenOverlay.d.ts
+/**
+ * Default forbidden overlay shown when a widget type cannot be dropped.
+ * Renders a red dashed drop zone with the blocked reason in the center.
+ */
+declare const _default$4: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  widgetType: {
+    type: PropType<string>;
+    required: true;
+  };
+  reason: {
+    type: PropType<CreationBlockReason | null>;
+    default: null;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  widgetType: {
+    type: PropType<string>;
+    required: true;
+  };
+  reason: {
+    type: PropType<CreationBlockReason | null>;
+    default: null;
+  };
+}>> & Readonly<{}>, {
+  reason: CreationBlockReason | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/DefaultNodeHandle.d.ts
+/**
+ * Default semantic selection handle for unmasked widgets and resolved containers.
+ */
+declare const _default$5: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  nodeId: {
+    type: StringConstructor;
+    required: true;
+  };
+  nodeType: {
+    type: StringConstructor;
+    required: true;
+  };
+  owner: {
+    type: PropType<NodeOwner>;
+    required: true;
+  };
+  onSelect: {
+    type: PropType<(e: MouseEvent) => void>;
+    required: true;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  nodeId: {
+    type: StringConstructor;
+    required: true;
+  };
+  nodeType: {
+    type: StringConstructor;
+    required: true;
+  };
+  owner: {
+    type: PropType<NodeOwner>;
+    required: true;
+  };
+  onSelect: {
+    type: PropType<(e: MouseEvent) => void>;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/DefaultNodeMask.d.ts
+/**
+ * Default mask overlay component for widgets with mask=true.
+ * Renders a transparent overlay that blocks widget interaction
+ * and captures clicks for selection.
+ */
+declare const _default$6: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  nodeId: {
+    type: StringConstructor;
+    required: true;
+  };
+  nodeType: {
+    type: StringConstructor;
+    required: true;
+  };
+  owner: {
+    type: PropType<NodeOwner>;
+    required: true;
+  };
+  onSelect: {
+    type: PropType<(e: MouseEvent) => void>;
+    required: true;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  nodeId: {
+    type: StringConstructor;
+    required: true;
+  };
+  nodeType: {
+    type: StringConstructor;
+    required: true;
+  };
+  owner: {
+    type: PropType<NodeOwner>;
+    required: true;
+  };
+  onSelect: {
+    type: PropType<(e: MouseEvent) => void>;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/DefaultNodeSelection.d.ts
+declare const _default$7: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  nodeId: {
+    type: StringConstructor;
+    required: true;
+  };
+  nodeType: {
+    type: StringConstructor;
+    required: true;
+  };
+  owner: {
+    type: PropType<NodeOwner>;
+    required: true;
+  };
+  projection: {
+    type: PropType<NodeSelectionProjection>;
+    required: true;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  nodeId: {
+    type: StringConstructor;
+    required: true;
+  };
+  nodeType: {
+    type: StringConstructor;
+    required: true;
+  };
+  owner: {
+    type: PropType<NodeOwner>;
+    required: true;
+  };
+  projection: {
+    type: PropType<NodeSelectionProjection>;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/DefaultNodeToolbar.d.ts
+/**
+ * Default per-node floating toolbar component.
+ * Renders actions based on the resolved action list from the action registry.
+ * Supports both 'button' and 'drag-handle' action types.
+ *
+ * Positioning is owned by WidgetRenderer's measurable floating wrapper. The
+ * resolved placement controls whether actions use a vertical or horizontal row.
+ */
+declare const _default$8: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  nodeId: {
+    type: StringConstructor;
+    required: true;
+  };
+  nodeType: {
+    type: StringConstructor;
+    required: true;
+  };
+  owner: {
+    type: PropType<NodeOwner>;
+    required: true;
+  };
+  actions: {
+    type: PropType<ResolvedNodeAction[]>;
+    required: true;
+  };
+  state: {
+    type: PropType<NodeInteractionState>;
+    required: true;
+  };
+  toolbarPosition: {
+    type: PropType<ToolbarPositionData>;
+    default: undefined;
+  };
+  onDragStart: {
+    type: PropType<(e: DragEvent) => void>;
+    required: true;
+  };
+  onDragEnd: {
+    type: PropType<(e: DragEvent) => void>;
+    required: true;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  nodeId: {
+    type: StringConstructor;
+    required: true;
+  };
+  nodeType: {
+    type: StringConstructor;
+    required: true;
+  };
+  owner: {
+    type: PropType<NodeOwner>;
+    required: true;
+  };
+  actions: {
+    type: PropType<ResolvedNodeAction[]>;
+    required: true;
+  };
+  state: {
+    type: PropType<NodeInteractionState>;
+    required: true;
+  };
+  toolbarPosition: {
+    type: PropType<ToolbarPositionData>;
+    default: undefined;
+  };
+  onDragStart: {
+    type: PropType<(e: DragEvent) => void>;
+    required: true;
+  };
+  onDragEnd: {
+    type: PropType<(e: DragEvent) => void>;
+    required: true;
+  };
+}>> & Readonly<{}>, {
+  toolbarPosition: ToolbarPositionData;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/DefaultWidgetFallback.d.ts
+declare const _default$9: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  nodeId: {
+    type: PropType<string>;
+    required: true;
+  };
+  nodeType: {
+    type: PropType<string>;
+    default: string;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  nodeId: {
+    type: PropType<string>;
+    required: true;
+  };
+  nodeType: {
+    type: PropType<string>;
+    default: string;
+  };
+}>> & Readonly<{}>, {
+  nodeType: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/RootRenderer.d.ts
+declare const _default$10: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  engine: {
+    type: PropType<DesignerEngine>;
+    required: true;
+  };
+  componentMap: {
+    type: PropType<ComponentMap>;
+    required: true;
+  };
+  extensions: {
+    type: PropType<RendererExtensions>;
+    default: () => {};
+  };
+  eventHooks: {
+    type: PropType<RendererEventHooks>;
+    default: undefined;
+  };
+  actionInterceptors: {
+    type: PropType<ActionInterceptor[]>;
+    default: undefined;
+  };
+  actionRegistry: {
+    type: PropType<NodeActionRegistry>;
+    default: undefined;
+  };
+  dragOverNodeId: {
+    type: PropType<Ref<string | null>>;
+    default: undefined;
+  };
+  dragOverIndex: {
+    type: PropType<Ref<number | null>>;
+    default: undefined;
+  };
+  activeDestination: {
+    type: PropType<Ref<NodeDestination | null>>;
+    default: undefined;
+  };
+  containerDropDecision: {
+    type: PropType<Ref<PlacementDecision | null>>;
+    default: undefined;
+  };
+  onContainerDragOver: {
+    type: PropType<(target: ContainerDropTarget | ContainerDropRejection) => void>;
+    default: undefined;
+  };
+  onContainerDragLeave: {
+    type: PropType<(event: DragEvent) => void>;
+    default: undefined;
+  };
+  onContainerDrop: {
+    type: PropType<(event: DragEvent) => void>;
+    default: undefined;
+  };
+  interactionBoundary: {
+    type: PropType<Ref<HTMLElement | null>>;
+    default: undefined;
+  };
+  isForbidden: {
+    type: PropType<Ref<boolean>>;
+    default: undefined;
+  };
+  forbiddenReason: {
+    type: PropType<Ref<CreationBlockReason | null>>;
+    default: undefined;
+  };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  engine: {
+    type: PropType<DesignerEngine>;
+    required: true;
+  };
+  componentMap: {
+    type: PropType<ComponentMap>;
+    required: true;
+  };
+  extensions: {
+    type: PropType<RendererExtensions>;
+    default: () => {};
+  };
+  eventHooks: {
+    type: PropType<RendererEventHooks>;
+    default: undefined;
+  };
+  actionInterceptors: {
+    type: PropType<ActionInterceptor[]>;
+    default: undefined;
+  };
+  actionRegistry: {
+    type: PropType<NodeActionRegistry>;
+    default: undefined;
+  };
+  dragOverNodeId: {
+    type: PropType<Ref<string | null>>;
+    default: undefined;
+  };
+  dragOverIndex: {
+    type: PropType<Ref<number | null>>;
+    default: undefined;
+  };
+  activeDestination: {
+    type: PropType<Ref<NodeDestination | null>>;
+    default: undefined;
+  };
+  containerDropDecision: {
+    type: PropType<Ref<PlacementDecision | null>>;
+    default: undefined;
+  };
+  onContainerDragOver: {
+    type: PropType<(target: ContainerDropTarget | ContainerDropRejection) => void>;
+    default: undefined;
+  };
+  onContainerDragLeave: {
+    type: PropType<(event: DragEvent) => void>;
+    default: undefined;
+  };
+  onContainerDrop: {
+    type: PropType<(event: DragEvent) => void>;
+    default: undefined;
+  };
+  interactionBoundary: {
+    type: PropType<Ref<HTMLElement | null>>;
+    default: undefined;
+  };
+  isForbidden: {
+    type: PropType<Ref<boolean>>;
+    default: undefined;
+  };
+  forbiddenReason: {
+    type: PropType<Ref<CreationBlockReason | null>>;
+    default: undefined;
+  };
+}>> & Readonly<{}>, {
+  extensions: RendererExtensions;
+  eventHooks: RendererEventHooks;
+  actionInterceptors: ActionInterceptor[];
+  actionRegistry: NodeActionRegistry;
+  dragOverNodeId: Ref<string | null, string | null>;
+  dragOverIndex: Ref<number | null, number | null>;
+  activeDestination: Ref<NodeDestination | null, NodeDestination | null>;
+  containerDropDecision: Ref<PlacementDecision | null, PlacementDecision | null>;
+  onContainerDragOver: (target: ContainerDropTarget | ContainerDropRejection) => void;
+  onContainerDragLeave: (event: DragEvent) => void;
+  onContainerDrop: (event: DragEvent) => void;
+  interactionBoundary: Ref<HTMLElement | null, HTMLElement | null>;
+  isForbidden: Ref<boolean, boolean>;
+  forbiddenReason: Ref<CreationBlockReason | null, CreationBlockReason | null>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/WidgetRenderer.d.ts
+/**
+ * WidgetRenderer — thin orchestration layer.
+ *
+ * Delegates all logic to composables (useWidgetNode, useNodeActions, useNodeDrag)
+ * and renders via configurable extension components (nodeMask, nodeHandle,
+ * nodeToolbar, widgetFallback, nodeWrapper).
+ */
+declare const _default$11: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  node: {
+    type: PropType<SchemaNode>;
+    required: true;
+  };
+  owner: {
+    type: PropType<NodeOwner>;
+    default: () => {
+      kind: string;
+    };
+  };
+  selectionPlane: {
+    type: PropType<NodeSelectionPlane>;
+    default: undefined;
+  };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  node: {
+    type: PropType<SchemaNode>;
+    required: true;
+  };
+  owner: {
+    type: PropType<NodeOwner>;
+    default: () => {
+      kind: string;
+    };
+  };
+  selectionPlane: {
+    type: PropType<NodeSelectionPlane>;
+    default: undefined;
+  };
+}>> & Readonly<{}>, {
+  owner: NodeOwner;
+  selectionPlane: NodeSelectionPlane;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/composables/useNodeActions.d.ts
+interface UseNodeActionsReturn {
+  /** Resolved actions for the current node with visibility/disabled computed */
+  actions: ComputedRef<ResolvedNodeAction[]>;
+  /** The action context for the current node */
+  actionContext: ComputedRef<NodeActionContext>;
+}
+/**
+ * Composable that resolves the action system for a specific node.
+ * Provides the list of visible, resolved actions with their handlers.
+ *
+ * @param getNode - Getter for the current schema node
+ * @param ctx - The renderer context
+ */
+declare function useNodeActions(getNode: () => SchemaNode, ctx: RendererContext, getOwner?: () => NodeOwner): UseNodeActionsReturn;
+//#endregion
+//#region src/composables/useNodeDrag.d.ts
+interface UseNodeDragReturn {
+  /** Start a drag operation from the drag handle */
+  handleDragStart: (e: DragEvent) => void;
+  /** End a drag operation */
+  handleDragEnd: (e: DragEvent) => void;
+}
+/**
+ * Composable that encapsulates drag handle behavior for a widget node.
+ * Integrates with event hooks for interceptable drag operations.
+ *
+ * @param getNode - Getter for the current schema node
+ * @param ctx - The renderer context (from useRendererContext)
+ */
+declare function useNodeDrag(getNode: () => SchemaNode, ctx: RendererContext): UseNodeDragReturn;
+//#endregion
+//#region src/composables/useNodeInteractionGeometry.d.ts
+interface NodeInteractionRect {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+  width: number;
+  height: number;
+}
+interface NodeInteractionGeometry {
+  visibleRect: NodeInteractionRect;
+  paintRect: NodeInteractionRect;
+  visible: boolean;
+}
+interface UseNodeInteractionGeometryOptions {
+  mode: NodeInteractionGeometryMode;
+  boundarySelector?: string;
+  paintInset?: number;
+  selfTargetSelector?: string;
+}
+interface UseNodeInteractionGeometryReturn {
+  geometry: Ref<NodeInteractionGeometry>;
+  update: () => void;
+}
+declare function useNodeInteractionGeometry(elRef: Ref<HTMLElement | null>, isActive: Ref<boolean>, options: UseNodeInteractionGeometryOptions): UseNodeInteractionGeometryReturn;
+//#endregion
+//#region src/composables/useNodeSelectionProjection.d.ts
+interface UseNodeSelectionProjectionOptions {
+  kind: NodeSelectionProjectionKind;
+  plane: Ref<NodeSelectionPlane>;
+  selfTargetSelector?: string;
+}
+interface UseNodeSelectionProjectionReturn {
+  projection: Ref<NodeSelectionProjection | null>;
+  target: Readonly<Ref<HTMLElement | null>>;
+  update: () => void;
+}
+declare function useNodeSelectionProjection(elRef: Ref<HTMLElement | null>, isSelected: Ref<boolean>, options: UseNodeSelectionProjectionOptions): UseNodeSelectionProjectionReturn;
+//#endregion
+//#region src/composables/useNodeState.d.ts
+/**
+ * Computes reactive interaction state for a single schema node.
+ *
+ * @param getNodeId - Getter function returning the node ID (for reactivity safety)
+ * @param ctx - The renderer context (from useRendererContext)
+ */
+declare function useNodeState(getNodeId: () => string, ctx: RendererContext): NodeInteractionState;
+//#endregion
+//#region src/composables/useToolbarPosition.d.ts
+interface UseToolbarPositionOptions {
+  gap?: number;
+  interactionBoundary?: Ref<HTMLElement | null>;
+  targetSelector?: string;
+  selfTargetSelector?: string;
+  boundarySelector?: string;
+  padding?: number;
+  interactionGeometry?: Ref<NodeInteractionGeometry>;
+  interactionGeometryUpdate?: () => void;
+  placement?: NodeToolbarPlacement;
+  orientation?: NodeToolbarOrientation;
+}
+interface UseToolbarPositionReturn {
+  position: Ref<ToolbarPositionData>;
+  update: () => Promise<void>;
+}
+declare function useToolbarPosition(referenceRef: Ref<HTMLElement | null>, floatingRef: Ref<HTMLElement | null>, isActive: Ref<boolean>, options?: UseToolbarPositionOptions): UseToolbarPositionReturn;
+//#endregion
+//#region src/composables/useWidgetNode.d.ts
+interface UseWidgetNodeReturn {
+  /** Reactive interaction state (selected, hovered, drag-over) */
+  state: NodeInteractionState;
+  /** The resolved Vue component for this widget type, or undefined */
+  resolvedComponent: ComputedRef<Component | undefined>;
+  /** The widget meta from the registry */
+  meta: ComputedRef<RendererWidgetMeta | undefined>;
+  /** Whether to use mask (from meta.mask, default true) */
+  useMask: ComputedRef<boolean>;
+  /** Whether this node is selectable (from meta.selectable, default true) */
+  selectable: ComputedRef<boolean>;
+  /** Whether this node is draggable (from meta.draggable, default true) */
+  draggable: ComputedRef<boolean>;
+  /** Whether this node is sortable / position-locked (from meta.sortable, default true) */
+  sortable: ComputedRef<boolean>;
+  /** Whether this node belongs to a sortable scope */
+  inSortScope: ComputedRef<boolean>;
+  /** Whether this node is the active drag source */
+  isDragging: ComputedRef<boolean>;
+  /** Whether this node is visible (from layout.visible, default true) */
+  visible: ComputedRef<boolean>;
+  /** Resolved open layout metadata */
+  layout: ComputedRef<ResolvedNodeLayout>;
+  /** CSS classes for the node wrapper */
+  wrapperClasses: ComputedRef<Array<string | Record<string, boolean>>>;
+  /** Handle select event */
+  handleSelect: (e: MouseEvent) => void;
+  /** Handle mouse enter */
+  handleMouseEnter: () => void;
+  /** Handle mouse leave */
+  handleMouseLeave: () => void;
+}
+/**
+ * Composable that extracts all widget node state and event handling logic.
+ * This is the primary composable for building custom node renderers.
+ *
+ * @param getNode - Getter for the current schema node
+ * @param ctx - The renderer context (from useRendererContext)
+ */
+declare function useWidgetNode(getNode: () => SchemaNode, ctx: RendererContext): UseWidgetNodeReturn;
+//#endregion
+//#region src/container-runtime.d.ts
+interface ContainerRuntime {
+  nodeId: ComputedRef<string>;
+  variant: ComputedRef<ContainerVariantId>;
+  regionDefinitions: ComputedRef<DeepReadonly<ContainerRegionDefinition[]>>;
+  getRegionNodes: (regionId: ContainerRegionId) => DeepReadonly<SchemaNode[]>;
+  requestVariantChange: (variant: ContainerVariantId) => CommandExecutionResult;
+}
+declare const CONTAINER_RUNTIME_CONTEXT_KEY: InjectionKey<ContainerRuntime>;
+declare function createContainerRuntime(getNode: () => SchemaNode, ctx: RendererContext): ContainerRuntime;
+declare function useContainerRuntime(): ContainerRuntime;
+//#endregion
+//#region src/context.d.ts
+/**
+ * Creates a RendererContext from options.
+ * Called internally by RootRenderer.
+ */
+declare function createRendererContext(options: RendererOptions): RendererContext;
+/**
+ * Injects the RendererContext from the nearest ancestor RootRenderer.
+ * Throws if called outside the renderer component tree.
+ */
+declare function useRendererContext(): RendererContext;
+//#endregion
+//#region src/drag-image.d.ts
+declare function hideNativeDragImage(dataTransfer: DataTransfer | null): void;
+//#endregion
+//#region src/messages.d.ts
+declare const rendererMessages: Record<string, MessageTree>;
+//#endregion
+//#region src/widget-runtime.d.ts
+interface WidgetRuntimeContext {
+  nodeId: Readonly<Ref<string>>;
+  nodeType: Readonly<Ref<string>>;
+  updateProps: (patch: Record<string, unknown>) => void;
+  updateStyle: (patch: NodeStyle) => void;
+  updateContainerStyle: (patch: StyleValueMap) => void;
+  updateContentStyle: (patch: StyleValueMap) => void;
+}
+declare const WIDGET_RUNTIME_CONTEXT_KEY: InjectionKey<WidgetRuntimeContext>;
+declare function useWidgetRuntime(): WidgetRuntimeContext;
+//#endregion
+export { type ActionConfirmRequest, type ActionDecision, type ActionInterceptor, type ActionInvocation, ActionKey, type ActionRisk, CONTAINER_RUNTIME_CONTEXT_KEY, type ComponentMap, type ConfirmActionInterceptorOptions, type ContainerDropRejection, type ContainerDropRendererOptions, type ContainerDropTarget, _default as ContainerRegionOutlet, type ContainerRegionOutletDropProps, type ContainerRegionOutletProps, type ContainerRuntime, type DeepReadonly, _default$1 as DefaultContainerFallback, DefaultContainerShell, _default$2 as DefaultDropIndicator, _default$3 as DefaultEmptyState, _default$4 as DefaultForbiddenOverlay, _default$5 as DefaultNodeHandle, _default$6 as DefaultNodeMask, _default$7 as DefaultNodeSelection, _default$8 as DefaultNodeToolbar, _default$9 as DefaultWidgetFallback, type DragHookPayload, type EmptyStateProps, type ForbiddenOverlayProps, type HoverHookPayload, type MaybePromise, NODE_SELECTION_PLANE_KEY, NODE_SELECTION_PRESENTATION_KEY, type NodeActionContext, type NodeActionDefinition, type NodeActionRegistry, type NodeHandleProps, type NodeInteractionGeometry, type NodeInteractionGeometryMode, type NodeInteractionPresentation, type NodeInteractionRect, type NodeInteractionState, type NodeMaskProps, type NodeSelectionPlane, type NodeSelectionPresentation, type NodeSelectionPresentationHost, type NodeSelectionProjection, type NodeSelectionProjectionKind, type NodeSelectionProps, type NodeSelectionRect, type NodeToolbarOrientation, type NodeToolbarPlacement, type NodeToolbarProps, type NodeWrapperProps, RENDERER_CONTEXT_KEY, type RendererContainerAdapter, type RendererContext, type RendererEventHooks, type RendererExtensions, type RendererOptions, type RendererWidgetActionExtra, type RendererWidgetMeta, type ResolveContainerDropIndex, type ResolveContainerDropIndexContext, type ResolvedNodeAction, _default$10 as RootRenderer, type SelectHookPayload, type ToolbarPositionData, type UseNodeActionsReturn, type UseNodeDragReturn, type UseNodeInteractionGeometryOptions, type UseNodeInteractionGeometryReturn, type UseNodeSelectionProjectionOptions, type UseNodeSelectionProjectionReturn, type UseToolbarPositionReturn, type UseWidgetNodeReturn, WIDGET_RUNTIME_CONTEXT_KEY, type WidgetActionConfig, type WidgetFallbackProps, _default$11 as WidgetRenderer, type WidgetRendererProps, type WidgetRuntimeContext, createConfirmActionInterceptor, createContainerRuntime, createDefaultActions, createDefaultEventHooks, createNodeActionRegistry, createNodeSelectionPresentation, createRendererContext, fireAfterHook, hideNativeDragImage, rendererMessages, resolveBeforeHook, resolveNodeInteractionPresentation, runActionPipeline, useContainerRuntime, useNodeActions, useNodeDrag, useNodeInteractionGeometry, useNodeSelectionPresentation, useNodeSelectionProjection, useNodeState, useRendererContext, useToolbarPosition, useWidgetNode, useWidgetRuntime };