@bpmn-nova/studio 0.3.0-preview

package/dist/index.d.ts

@@ -0,0 +1,447 @@
+export * from '@bpmn-nova/core'
+export * from '@bpmn-nova/bpmn-model'
+export * from '@bpmn-nova/runtime'
+export * from '@bpmn-nova/theme'
+export * from '@bpmn-nova/designer'
+export * from '@bpmn-nova/viewer'
+export * from '@bpmn-nova/flowable'
+export * from '@bpmn-nova/activiti'
+export * from '@bpmn-nova/properties'
+export * from '@bpmn-nova/icons'
+export * from '@bpmn-nova/palette'
+
+import type {
+  BpmnEdge,
+  BpmnNode,
+  ElementSelection,
+  EngineId,
+  LayoutOptions,
+  NodeType,
+  Point,
+  ProcessModel,
+  SelectionRect,
+} from '@bpmn-nova/core'
+import type { IconRegistry } from '@bpmn-nova/icons'
+import type { PaletteRegistry } from '@bpmn-nova/palette'
+import type { PropertiesRegistry } from '@bpmn-nova/properties'
+import type { DiagramNodeRenderer, DiagramRendererOptions } from '@bpmn-nova/renderer'
+import type {
+  ActivityInstance as RuntimeActivityInstance,
+  ProcessInstanceSnapshot as RuntimeProcessInstanceSnapshot,
+} from '@bpmn-nova/runtime'
+import type { NovaThemeInput, NovaThemeMode, NovaThemeState, RuntimeAppearanceOptions, RuntimeAppearanceResolver } from '@bpmn-nova/theme'
+import type {
+  RuntimeDetailsRenderer,
+  RuntimeTransitionDetailsRenderer,
+} from '@bpmn-nova/viewer'
+
+// Aggregate compatibility surface. Studio re-exports the package-level types,
+// and keeps these frequently consumed declarations visible at its own entry.
+export interface ScopedElement { scopeId?: string }
+export type NodeVisualSurface = 'palette' | 'canvas' | 'viewer' | 'timeline'
+export interface NodeRendererContext {
+  container: HTMLElement
+  node: BpmnNode
+  mode: 'design' | 'viewer' | 'instance'
+  renderSemanticIcon(target?: Element, options?: { className?: string; title?: string }): SVGSVGElement | null
+}
+export function hydrateIcons(root: ParentNode, registry: IconRegistry): void
+export type PropertyEntryType =
+  | 'text' | 'textarea' | 'code' | 'expression' | 'number' | 'select' | 'switch' | 'range' | 'readonly' | 'action' | 'tags'
+  | 'table' | 'branchList' | 'flow-list' | 'node-list' | 'user-select' | 'form-select' | 'process-select' | 'resource-select' | 'node-select'
+  | (string & {})
+export interface PropertyEntry {
+  id: string
+  type?: PropertyEntryType
+  label?: string
+  iconId?: string
+  relation?: 'source' | 'target'
+}
+export interface GatewayRoleResolution {
+  topologyComplete: boolean
+  [key: string]: unknown
+}
+
+export interface RuntimeTransitionRouteOptions {
+  occupiedRoutes?: Array<Point[] | { points: Point[] }>
+  obstacles?: SelectionRect[]
+  labelSize?: { width: number; height: number }
+  nodeClearance?: number
+  laneGap?: number
+  laneSpacing?: number
+  nearParallelDistance?: number
+  anchorOverlapTolerance?: number
+  maxLanesPerSide?: number
+}
+export interface RuntimeTransitionRoute {
+  points: Point[]
+  labelPoint: Point
+  direction: 'horizontal' | 'vertical'
+  laneSide: 'top' | 'bottom' | 'left' | 'right'
+  laneIndex: number
+  sourceSide: 'top' | 'right' | 'bottom' | 'left'
+  targetSide: 'top' | 'right' | 'bottom' | 'left'
+  anchorStrategy: 'outer-same-side' | 'flow-axis-fallback'
+  portConflicts: number
+}
+export function routeRuntimeTransition(model: ProcessModel, transition: import('@bpmn-nova/runtime').RuntimeTransition, options?: RuntimeTransitionRouteOptions): RuntimeTransitionRoute | null
+
+export type RuntimeParticipant = import('@bpmn-nova/runtime').RuntimeParticipant
+export type RuntimeTransition = import('@bpmn-nova/runtime').RuntimeTransition
+export type NodeRuntimePresentation = import('@bpmn-nova/runtime').NodeRuntimePresentation
+export type RuntimePresentation = import('@bpmn-nova/runtime').RuntimePresentation
+export interface ActivityInstance extends RuntimeActivityInstance {
+  visitId?: string
+  multiInstanceId?: string
+  participant?: RuntimeParticipant
+  approvalMode?: 'single' | 'all' | 'any'
+  multiInstanceMode?: 'parallel' | 'sequential'
+  totalInstances?: number
+  requiredInstances?: number
+}
+export interface ProcessInstanceSnapshot extends RuntimeProcessInstanceSnapshot {
+  transitions?: RuntimeTransition[]
+}
+
+export type ViewerProjection = 'auto' | 'standard' | 'approval' | 'compact'
+export type RuntimeTraceProjection = import('@bpmn-nova/viewer').RuntimeTraceProjection
+export type RuntimeTraceItem = import('@bpmn-nova/viewer').RuntimeTraceItem
+export type RuntimeTraceLink = import('@bpmn-nova/viewer').RuntimeTraceLink
+export type RuntimeTraceGroup = import('@bpmn-nova/viewer').RuntimeTraceGroup
+export interface RuntimeTraceProjectionOptions {
+  includePredicted?: boolean
+  showStartMilestone?: boolean
+  showEndMilestone?: boolean
+}
+export interface ViewerTimelineOptions {
+  title?: string | null | ((context: import('@bpmn-nova/viewer').ViewerTimelineContext) => string | null)
+  description?: string | null | ((context: import('@bpmn-nova/viewer').ViewerTimelineContext) => string | null)
+}
+export interface RuntimeDetailsLayoutOptions {
+  placement?: 'popover' | 'center' | 'bottom'
+  width?: number | string
+  maxHeight?: number | string
+  backdrop?: boolean
+  dragToDismiss?: boolean
+}
+export interface RuntimeDetailsOptions {
+  autoOpen?: boolean
+  desktop?: RuntimeDetailsLayoutOptions
+  mobile?: RuntimeDetailsLayoutOptions
+}
+export type RuntimeTimelineRenderer = import('@bpmn-nova/viewer').RuntimeTimelineRenderer
+export type RuntimeTraceClickEvent = import('@bpmn-nova/viewer').RuntimeTraceClickEvent
+export interface ViewerOptions {
+  container: HTMLElement
+  model: ProcessModel
+  runtime?: ProcessInstanceSnapshot | null
+  iconRegistry?: IconRegistry
+  projection?: ViewerProjection
+  responsive?: boolean
+  timeline?: ViewerTimelineOptions
+  runtimeDetails?: RuntimeDetailsOptions
+  runtimeTraceOptions?: RuntimeTraceProjectionOptions
+  onTraceClick?: (event: RuntimeTraceClickEvent) => void
+  runtimePresenter?: (context: { model: ProcessModel; runtime: ProcessInstanceSnapshot | null; appearance: RuntimeAppearanceResolver }) => RuntimePresentation
+  runtimeDetailsRenderer?: RuntimeDetailsRenderer | null
+  onRuntimeDetailsOpen?: Function
+  runtimeTransitionDetailsRenderer?: RuntimeTransitionDetailsRenderer | null
+  onRuntimeTransitionDetailsOpen?: Function
+}
+export class BpmnViewer {
+  constructor(options: ViewerOptions)
+  setDisplayOptions(options: { timeline?: ViewerTimelineOptions; runtimeDetails?: RuntimeDetailsOptions; runtimeTraceOptions?: RuntimeTraceProjectionOptions }): void
+  fitView(): void
+  destroy(): void
+}
+
+export type NodeRenderer = DiagramNodeRenderer
+export interface StudioState {
+  model: ProcessModel
+  selection: ElementSelection | null
+  selectedElement: ProcessModel | BpmnNode | BpmnEdge | Array<BpmnNode | BpmnEdge> | null
+  connectingSource: string | null
+  canUndo: boolean
+  canRedo: boolean
+  engine: EngineId
+  propertiesProfile: 'business' | 'developer'
+  activeScopeId: string
+  scopePath: Array<{ id: string; name: string; kind: 'process' | 'subProcess' }>
+}
+export interface NodePreset extends Partial<Omit<BpmnNode, 'properties'>> { properties?: Record<string, unknown> }
+export interface TemplateDefinition {
+  nodes: Array<{ key: string; nodeType: NodeType; offset?: Point; preset?: NodePreset }>
+  edges?: Array<{ source: string; target: string; preset?: Partial<BpmnEdge> }>
+}
+export type SelectionLayoutOperation =
+  | { type: 'align'; alignment: 'left' | 'centerX' | 'right' | 'top' | 'centerY' | 'bottom' }
+  | { type: 'distribute'; axis: 'horizontal' | 'vertical' }
+  | { type: 'layout' }
+  | { type: 'reroute' }
+export interface StudioExtension {
+  id: string
+  setup(context: { studio: BpmnStudioController }): void | (() => void)
+}
+export interface StudioControllerOptions {
+  model: ProcessModel
+  historyLimit?: number
+  extensions?: StudioExtension[]
+  propertiesProfile?: 'business' | 'developer'
+}
+export interface StudioCommands {
+  createNode(input: { nodeType: NodeType; point?: Point; preset?: NodePreset }): BpmnNode
+  createTemplate(template: TemplateDefinition, point: Point): { nodes: BpmnNode[]; edges: BpmnEdge[] }
+  connect(source: string, target: string, overrides?: Partial<BpmnEdge>): BpmnEdge | null
+  updateProcess(patch: Partial<ProcessModel>): void
+  updateNode(id: string, patch: Partial<BpmnNode>): boolean
+  updateEdge(id: string, patch: Partial<BpmnEdge>): boolean
+  updateEdges(patches: Array<{ id: string; patch: Partial<BpmnEdge> }>): boolean
+  remove(selection?: ElementSelection | null): boolean
+  changeElementId(kind: 'process' | 'node' | 'edge', oldId: string, nextId: string): boolean
+  changeNodeType(id: string, type: NodeType): boolean
+  quickAdd(sourceId: string, type?: NodeType, preset?: NodePreset): BpmnNode | null
+  autoLayout(direction?: 'horizontal' | 'vertical'): void
+  beautify(options?: LayoutOptions): void
+  rerouteEdges(options?: LayoutOptions): void
+  resetEdgeRoute(id: string): boolean
+  setEngine(engine: EngineId): void
+  setPropertiesProfile(profile: 'business' | 'developer'): void
+  select(selection: ElementSelection | null): boolean
+  selectInRect(rect: SelectionRect, options?: { mode?: 'replace' | 'add' | 'toggle' }): ElementSelection
+  getSelectionBounds(): SelectionRect | null
+  arrangeSelection(operation: SelectionLayoutOperation): boolean
+  groupSelection(): BpmnNode | null
+  ungroup(id?: string): boolean
+  attachLane(laneId: string, participantId: string, index?: number): boolean
+  detachLane(laneId: string, point?: Point): boolean
+  enterScope(subProcessId: string): boolean
+  leaveScope(): boolean
+  navigateToScope(scopeId: string): boolean
+  getActiveGraph(): ProcessModel
+  undo(): boolean
+  redo(): boolean
+}
+export interface StudioEvent {
+  type: 'modelChanged' | 'selectionChanged' | 'historyChanged' | 'scopeChanged' | 'propertiesProfileChanged' | string
+  reason?: string
+  state: StudioState
+  [key: string]: unknown
+}
+export function canCreateSequenceFlow(model: ProcessModel, sourceId: string, targetId: string): boolean
+export class BpmnStudioController {
+  constructor(options: StudioControllerOptions)
+  readonly model: ProcessModel
+  selection: ElementSelection | null
+  connectingSource: string | null
+  activeScopeId: string
+  propertiesProfile: 'business' | 'developer'
+  readonly commands: StudioCommands
+  getState(): StudioState
+  getSelectedElement(): StudioState['selectedElement']
+  getActiveGraph(): ProcessModel
+  subscribe(listener: (event: StudioEvent) => void): () => void
+  select(selection: ElementSelection | null): boolean
+  selectInRect(rect: SelectionRect, options?: { mode?: 'replace' | 'add' | 'toggle' }): ElementSelection
+  getSelectionBounds(): SelectionRect | null
+  arrangeSelection(operation: SelectionLayoutOperation): boolean
+  groupSelection(): BpmnNode | null
+  ungroup(id?: string): boolean
+  attachLane(laneId: string, participantId: string, index?: number): boolean
+  detachLane(laneId: string, point?: Point): boolean
+  enterScope(subProcessId: string): boolean
+  leaveScope(): boolean
+  navigateToScope(scopeId: string): boolean
+  setModel(model: ProcessModel, options?: { resetHistory?: boolean }): void
+  setPropertiesProfile(profile: 'business' | 'developer'): void
+  startConnect(sourceId: string): boolean
+  cancelConnect(): void
+  createNode(input: Parameters<StudioCommands['createNode']>[0]): BpmnNode
+  createTemplate(template: TemplateDefinition, point: Point): ReturnType<StudioCommands['createTemplate']>
+  connect(source: string, target: string, overrides?: Partial<BpmnEdge>): BpmnEdge | null
+  updateProcess(patch: Partial<ProcessModel>): void
+  updateNode(id: string, patch: Partial<BpmnNode>): boolean
+  updateEdge(id: string, patch: Partial<BpmnEdge>): boolean
+  updateEdges(patches: Array<{ id: string; patch: Partial<BpmnEdge> }>): boolean
+  remove(selection?: ElementSelection | null): boolean
+  changeElementId(kind: 'process' | 'node' | 'edge', oldId: string, nextId: string): boolean
+  changeNodeType(id: string, type: NodeType): boolean
+  quickAdd(sourceId: string, type?: NodeType, preset?: NodePreset): BpmnNode | null
+  autoLayout(direction?: 'horizontal' | 'vertical'): void
+  beautify(options?: LayoutOptions): void
+  rerouteEdges(options?: LayoutOptions): void
+  resetEdgeRoute(id: string): boolean
+  setEngine(engine: EngineId): void
+  undo(): boolean
+  redo(): boolean
+  exportXml(engine?: EngineId): string
+  importXml(xml: string, engine?: EngineId): ProcessModel
+  registerExtension(extension: StudioExtension): () => void
+  destroy(): void
+}
+export function createStudioController(options: StudioControllerOptions): BpmnStudioController
+
+export const CREATE_INTENT_MIME: 'application/x-bpmn-nova-create-intent+json'
+export type CreateIntent =
+  | { kind: 'node'; nodeType: NodeType; preset?: NodePreset }
+  | { kind: 'template'; templateId: string; [key: string]: unknown }
+  | { kind: 'action'; [key: string]: unknown }
+export interface TemplateRegistration {
+  id: string
+  label?: string
+  create(context: unknown): TemplateDefinition
+}
+export class TemplateRegistry {
+  constructor(templates?: TemplateRegistration[])
+  register(template: TemplateRegistration): () => void
+  resolve(id: string): TemplateRegistration | null
+  list(): TemplateRegistration[]
+}
+export class InteractionController {
+  constructor(options: { studio: BpmnStudioController; templates?: TemplateRegistry })
+  beginCreate(intent: CreateIntent): { intent: CreateIntent; startedAt: number }
+  serialize(session: unknown): string
+  deserialize(value: string): unknown
+  drop(session: unknown, pointer: { clientX: number; clientY: number }, canvas: { clientToWorld(x: number, y: number): Point }): unknown
+}
+export function createTemplateRegistry(templates?: TemplateRegistration[]): TemplateRegistry
+export function createInteractionController(options: ConstructorParameters<typeof InteractionController>[0]): InteractionController
+
+export type ContextMenuTarget =
+  | { kind: 'canvas'; id: string }
+  | { kind: 'node' | 'edge'; id: string }
+  | { kind: 'multi'; items: Array<{ kind: 'node' | 'edge'; id: string }> }
+export interface ContextMenuContext {
+  studio: BpmnStudioController
+  canvas: BpmnCanvas
+  target: ContextMenuTarget
+  selection: ElementSelection | null
+  position?: Point
+}
+export interface ContextMenuAction {
+  id: string
+  label?: string
+  iconId?: string
+  group?: string
+  disabled?: boolean | ((context: ContextMenuContext) => boolean)
+  danger?: boolean
+  visible?: (context: ContextMenuContext) => boolean
+  position?: { before?: string; after?: string; replace?: string; remove?: string; prepend?: boolean; append?: boolean }
+  execute?(context: ContextMenuContext): unknown
+}
+export interface ContextMenuProvider { id: string; priority?: number; getActions?(context: ContextMenuContext): ContextMenuAction[]; actions?: ContextMenuAction[] }
+export const defaultContextMenuProvider: ContextMenuProvider
+export class ContextMenuRegistry {
+  registerProvider(priority: number, provider: ContextMenuProvider): () => void
+  registerProvider(provider: ContextMenuProvider): () => void
+  resolve(context: ContextMenuContext): ContextMenuAction[]
+}
+export function createContextMenuRegistry(): ContextMenuRegistry
+export function createDefaultContextMenuRegistry(options?: { providers?: ContextMenuProvider[] }): ContextMenuRegistry
+
+export type SelectionToolbarSlot = (context: {
+  container: HTMLElement
+  studio: BpmnStudioController
+  canvas: BpmnCanvas
+  selection: Extract<ElementSelection, { kind: 'multi' }>
+  elements: BpmnNode[]
+  bounds: SelectionRect
+  actions: {
+    align(alignment: Extract<SelectionLayoutOperation, { type: 'align' }>['alignment']): boolean
+    distribute(axis: Extract<SelectionLayoutOperation, { type: 'distribute' }>['axis']): boolean
+    layout(): boolean
+    reroute(): boolean
+    fit(): boolean
+    group(): BpmnNode | null
+  }
+}) => void | (() => void)
+export type ContextMenuSlot = (context: ContextMenuContext & {
+  container: HTMLElement
+  position: Point
+  actions: ContextMenuAction[]
+  execute(id: string): boolean
+  close(): void
+}) => void | (() => void)
+export interface BpmnCanvasOptions {
+  container: HTMLElement
+  studio: BpmnStudioController
+  rendererOptions?: DiagramRendererOptions
+  interactions?: InteractionController | null
+  selectionToolbar?: HTMLElement | SelectionToolbarSlot | null
+  contextMenu?: HTMLElement | ContextMenuSlot | null
+  contextMenuRegistry?: ContextMenuRegistry
+  pointerMode?: 'select' | 'marquee' | 'pan'
+  theme?: NovaThemeInput
+  onThemeChange?: (state: NovaThemeState) => void
+}
+export class BpmnCanvas {
+  constructor(options: BpmnCanvasOptions)
+  clientToWorld(clientX: number, clientY: number): Point
+  getViewportCenterWorld(): Point
+  fitView(padding?: number, options?: Record<string, unknown>): void
+  fitSelection(padding?: number): boolean
+  setPointerMode(mode: 'select' | 'marquee' | 'pan'): boolean
+  getPointerMode(): 'select' | 'marquee' | 'pan'
+  zoomBy(factor: number): void
+  actualSize(padding?: number): void
+  getViewportState(): { zoom: number; pan: Point }
+  setTheme(theme: NovaThemeInput): NovaThemeState
+  setThemeMode(mode: NovaThemeMode): NovaThemeState
+  getThemeState(): NovaThemeState
+  closeContextMenu(): void
+  destroy(): void
+}
+export function createBpmnCanvas(options: BpmnCanvasOptions): BpmnCanvas
+
+export interface StudioShellSlots {
+  left?: HTMLElement | ((context: Record<string, unknown>) => void | (() => void))
+  right?: HTMLElement | ((context: Record<string, unknown>) => void | (() => void))
+  header?: HTMLElement | ((context: Record<string, unknown>) => void | (() => void))
+  contextMenu?: ContextMenuSlot
+  selectionToolbar?: SelectionToolbarSlot
+  runtimeDetails?: RuntimeDetailsRenderer
+  runtimeTransitionDetails?: RuntimeTransitionDetailsRenderer
+  runtimeTimeline?: RuntimeTimelineRenderer
+  [name: string]: HTMLElement | Function | undefined
+}
+export interface StudioShellOptions {
+  container: HTMLElement
+  studio: BpmnStudioController
+  iconRegistry?: IconRegistry
+  paletteRegistry?: PaletteRegistry
+  propertiesRegistry?: PropertiesRegistry
+  templateRegistry?: TemplateRegistry
+  contextMenuRegistry?: ContextMenuRegistry
+  rendererOptions?: DiagramRendererOptions & {
+    runtimeTraceOptions?: RuntimeTraceProjectionOptions
+    timeline?: ViewerTimelineOptions
+  }
+  slots?: StudioShellSlots
+  layout?: (context: Record<string, unknown>) => void | (() => void)
+  runtime?: ProcessInstanceSnapshot | null
+  mode?: 'design' | 'viewer' | 'instance'
+  projection?: ViewerProjection
+  responsive?: boolean
+  projectionOptions?: Array<{ value: ViewerProjection; label: string }>
+  leftWidth?: number
+  rightWidth?: number
+  theme?: NovaThemeInput
+  runtimeAppearance?: RuntimeAppearanceOptions
+  onThemeChange?: (state: NovaThemeState) => void
+}
+export class BpmnStudioShell {
+  constructor(options: StudioShellOptions)
+  canvas?: BpmnCanvas
+  viewer?: BpmnViewer
+  setMode(mode: 'design' | 'viewer' | 'instance'): void
+  setRuntime(runtime: ProcessInstanceSnapshot | null): void
+  setProjection(projection: ViewerProjection): void
+  setTheme(theme: NovaThemeInput): NovaThemeState
+  setThemeMode(mode: NovaThemeMode): NovaThemeState
+  getThemeState(): NovaThemeState
+  subscribeTheme(listener: (state: NovaThemeState) => void): () => void
+  setRuntimeAppearance(options: RuntimeAppearanceOptions | null): void
+  fitView(): void
+  zoomBy(factor: number): void
+  destroy(): void
+}
+export function createStudioShell(options: StudioShellOptions): BpmnStudioShell

package/dist/index.js

@@ -0,0 +1,16 @@
+export * from '@bpmn-nova/core';
+export * from '@bpmn-nova/bpmn-model';
+export * from '@bpmn-nova/runtime';
+export * from '@bpmn-nova/theme';
+export * from '@bpmn-nova/designer';
+export * from '@bpmn-nova/viewer';
+export * from '@bpmn-nova/flowable';
+export * from '@bpmn-nova/activiti';
+export * from '@bpmn-nova/properties';
+export * from './controller.js';
+export * from './interactions.js';
+export * from './canvas.js';
+export * from './context-menu.js';
+export * from './shell.js';
+export * from '@bpmn-nova/icons';
+export * from '@bpmn-nova/palette';

package/dist/interactions.js

@@ -0,0 +1,54 @@
+import { NODE_DEFINITIONS } from '@bpmn-nova/core';
+
+export const CREATE_INTENT_MIME = 'application/x-bpmn-nova-create-intent+json';
+
+export class TemplateRegistry {
+  constructor(templates = []) { this._templates = new Map(); for (const template of templates) this.register(template); }
+  register(template) {
+    if (!template?.id || typeof template.create !== 'function') throw new Error('Template requires id and create().');
+    this._templates.set(template.id, template);
+    return () => this._templates.delete(template.id);
+  }
+  resolve(id) { return this._templates.get(id) || null; }
+  list() { return [...this._templates.values()]; }
+}
+
+export class InteractionController {
+  constructor({ studio, templates = new TemplateRegistry() } = {}) {
+    if (!studio) throw new Error('InteractionController requires a studio controller.');
+    this.studio = studio;
+    this.templates = templates;
+  }
+
+  beginCreate(intent) {
+    if (!intent || !['node', 'template', 'action'].includes(intent.kind)) throw new Error('Unsupported create intent.');
+    const copy = intent.kind === 'action' ? { ...intent } : JSON.parse(JSON.stringify(intent));
+    return Object.freeze({ intent: copy, startedAt: Date.now() });
+  }
+
+  serialize(session) {
+    if (session?.intent?.kind === 'action') throw new Error('Action intents are click-only and cannot be serialized for drag and drop.');
+    return JSON.stringify(session.intent);
+  }
+  deserialize(value) { return this.beginCreate(JSON.parse(value)); }
+
+  drop(session, pointer, canvas) {
+    if (!session?.intent || !canvas?.clientToWorld) throw new Error('Drop requires a create session and canvas coordinate adapter.');
+    const point = canvas.clientToWorld(pointer.clientX, pointer.clientY);
+    const intent = session.intent;
+    if (intent.kind === 'node') {
+      const definition = NODE_DEFINITIONS[intent.nodeType];
+      const centered = definition ? { x: point.x - definition.width / 2, y: point.y - definition.height / 2 } : point;
+      return this.studio.commands.createNode({ nodeType: intent.nodeType, point: centered, preset: intent.preset });
+    }
+    if (intent.kind === 'template') {
+      const template = this.templates.resolve(intent.templateId);
+      if (!template) throw new Error(`Unknown template: ${intent.templateId}`);
+      return this.studio.commands.createTemplate(template.create({ studio: this.studio, point, intent }), point);
+    }
+    return intent.run?.({ studio: this.studio, point }) || null;
+  }
+}
+
+export function createTemplateRegistry(templates) { return new TemplateRegistry(templates); }
+export function createInteractionController(options) { return new InteractionController(options); }