@qontinui/ui-bridge 0.1.1 → 0.3.0

package/dist/core/index.mjs

@@ -1,974 +1,3 @@
-// src/core/element-identifier.ts
-var ID_ATTRIBUTES = ["data-ui-id", "data-testid", "data-awas-element", "id"];
-function generateXPath(element) {
-  if (element.id) {
-    return `//*[@id="${element.id}"]`;
-  }
-  const parts = [];
-  let current = element;
-  while (current && current.nodeType === Node.ELEMENT_NODE) {
-    let selector = current.nodeName.toLowerCase();
-    const uiId = current.getAttribute("data-ui-id");
-    if (uiId) {
-      selector += `[@data-ui-id="${uiId}"]`;
-      parts.unshift(selector);
-      break;
-    }
-    const testId = current.getAttribute("data-testid");
-    if (testId) {
-      selector += `[@data-testid="${testId}"]`;
-      parts.unshift(selector);
-      break;
-    }
-    const id = current.id;
-    if (id) {
-      selector += `[@id="${id}"]`;
-      parts.unshift(selector);
-      break;
-    }
-    const parentEl = current.parentElement;
-    if (parentEl) {
-      const currentEl = current;
-      const siblings = Array.from(parentEl.children).filter(
-        (child) => child.nodeName === currentEl.nodeName
-      );
-      if (siblings.length > 1) {
-        const index = siblings.indexOf(currentEl) + 1;
-        selector += `[${index}]`;
-      }
-    }
-    parts.unshift(selector);
-    current = parentEl;
-  }
-  return "/" + parts.join("/");
-}
-function generateCSSSelector(element) {
-  const uiId = element.getAttribute("data-ui-id");
-  if (uiId) {
-    return `[data-ui-id="${uiId}"]`;
-  }
-  const testId = element.getAttribute("data-testid");
-  if (testId) {
-    return `[data-testid="${testId}"]`;
-  }
-  const awasId = element.getAttribute("data-awas-element");
-  if (awasId) {
-    return `[data-awas-element="${awasId}"]`;
-  }
-  if (element.id) {
-    return `#${CSS.escape(element.id)}`;
-  }
-  const path = [];
-  let current = element;
-  while (current && current.nodeType === Node.ELEMENT_NODE) {
-    let selector = current.nodeName.toLowerCase();
-    const parentUiId = current.getAttribute("data-ui-id");
-    if (parentUiId && current !== element) {
-      path.unshift(`[data-ui-id="${parentUiId}"]`);
-      break;
-    }
-    const parentTestId = current.getAttribute("data-testid");
-    if (parentTestId && current !== element) {
-      path.unshift(`[data-testid="${parentTestId}"]`);
-      break;
-    }
-    if (current.id) {
-      path.unshift(`#${CSS.escape(current.id)}`);
-      break;
-    }
-    const parentEl = current.parentElement;
-    if (parentEl) {
-      const currentEl = current;
-      const siblings = Array.from(parentEl.children);
-      const sameTagSiblings = siblings.filter(
-        (s) => s.nodeName === currentEl.nodeName
-      );
-      if (sameTagSiblings.length > 1) {
-        const index = siblings.indexOf(currentEl) + 1;
-        selector += `:nth-child(${index})`;
-      }
-    }
-    path.unshift(selector);
-    current = current.parentElement;
-  }
-  return path.join(" > ");
-}
-function getBestIdentifier(element) {
-  const uiId = element.getAttribute("data-ui-id");
-  if (uiId) return uiId;
-  const testId = element.getAttribute("data-testid");
-  if (testId) return testId;
-  const awasId = element.getAttribute("data-awas-element");
-  if (awasId) return awasId;
-  if (element.id) return element.id;
-  return generateCSSSelector(element);
-}
-function createElementIdentifier(element) {
-  return {
-    uiId: element.getAttribute("data-ui-id") || void 0,
-    testId: element.getAttribute("data-testid") || void 0,
-    awasId: element.getAttribute("data-awas-element") || void 0,
-    htmlId: element.id || void 0,
-    xpath: generateXPath(element),
-    selector: generateCSSSelector(element)
-  };
-}
-function findElementByIdentifier(identifier, root = document) {
-  if (typeof identifier === "string") {
-    const byUiId = root.querySelector(`[data-ui-id="${identifier}"]`);
-    if (byUiId) return byUiId;
-    const byTestId = root.querySelector(`[data-testid="${identifier}"]`);
-    if (byTestId) return byTestId;
-    const byAwasId = root.querySelector(`[data-awas-element="${identifier}"]`);
-    if (byAwasId) return byAwasId;
-    const byId = root.querySelector(`#${CSS.escape(identifier)}`);
-    if (byId) return byId;
-    try {
-      const bySelector = root.querySelector(identifier);
-      if (bySelector) return bySelector;
-    } catch {
-    }
-    try {
-      const result = document.evaluate(
-        identifier,
-        root,
-        null,
-        XPathResult.FIRST_ORDERED_NODE_TYPE,
-        null
-      );
-      if (result.singleNodeValue instanceof HTMLElement) {
-        return result.singleNodeValue;
-      }
-    } catch {
-    }
-    return null;
-  }
-  if (identifier.uiId) {
-    const el = root.querySelector(`[data-ui-id="${identifier.uiId}"]`);
-    if (el) return el;
-  }
-  if (identifier.testId) {
-    const el = root.querySelector(`[data-testid="${identifier.testId}"]`);
-    if (el) return el;
-  }
-  if (identifier.awasId) {
-    const el = root.querySelector(`[data-awas-element="${identifier.awasId}"]`);
-    if (el) return el;
-  }
-  if (identifier.htmlId) {
-    const el = root.querySelector(`#${CSS.escape(identifier.htmlId)}`);
-    if (el) return el;
-  }
-  if (identifier.selector) {
-    try {
-      const el = root.querySelector(identifier.selector);
-      if (el) return el;
-    } catch {
-    }
-  }
-  if (identifier.xpath) {
-    try {
-      const result = document.evaluate(
-        identifier.xpath,
-        root,
-        null,
-        XPathResult.FIRST_ORDERED_NODE_TYPE,
-        null
-      );
-      if (result.singleNodeValue instanceof HTMLElement) {
-        return result.singleNodeValue;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function findAllElementsByIdentifier(pattern, root = document) {
-  const results = [];
-  try {
-    const elements = root.querySelectorAll(pattern);
-    results.push(...Array.from(elements));
-    if (results.length > 0) return results;
-  } catch {
-  }
-  const partials = [
-    `[data-ui-id*="${pattern}"]`,
-    `[data-testid*="${pattern}"]`,
-    `[data-awas-element*="${pattern}"]`,
-    `[id*="${pattern}"]`
-  ];
-  for (const selector of partials) {
-    try {
-      const elements = root.querySelectorAll(selector);
-      for (const el of elements) {
-        if (!results.includes(el)) {
-          results.push(el);
-        }
-      }
-    } catch {
-    }
-  }
-  return results;
-}
-function elementMatchesIdentifier(element, identifier) {
-  if (typeof identifier === "string") {
-    return element.getAttribute("data-ui-id") === identifier || element.getAttribute("data-testid") === identifier || element.getAttribute("data-awas-element") === identifier || element.id === identifier || element.matches(identifier);
-  }
-  return identifier.uiId && element.getAttribute("data-ui-id") === identifier.uiId || identifier.testId && element.getAttribute("data-testid") === identifier.testId || identifier.awasId && element.getAttribute("data-awas-element") === identifier.awasId || identifier.htmlId && element.id === identifier.htmlId || false;
-}
-
-// src/core/registry.ts
-function getElementState(element) {
-  const rect = element.getBoundingClientRect();
-  const computedStyle = window.getComputedStyle(element);
-  const state = {
-    visible: isElementVisible(element, rect, computedStyle),
-    enabled: !isElementDisabled(element),
-    focused: document.activeElement === element,
-    rect: {
-      x: rect.x,
-      y: rect.y,
-      width: rect.width,
-      height: rect.height,
-      top: rect.top,
-      right: rect.right,
-      bottom: rect.bottom,
-      left: rect.left
-    },
-    textContent: element.textContent?.trim() || void 0,
-    computedStyles: {
-      display: computedStyle.display,
-      visibility: computedStyle.visibility,
-      opacity: computedStyle.opacity,
-      pointerEvents: computedStyle.pointerEvents
-    }
-  };
-  if (element instanceof HTMLInputElement) {
-    state.value = element.value;
-    if (element.type === "checkbox" || element.type === "radio") {
-      state.checked = element.checked;
-    }
-  } else if (element instanceof HTMLTextAreaElement) {
-    state.value = element.value;
-  } else if (element instanceof HTMLSelectElement) {
-    state.value = element.value;
-    state.selectedOptions = Array.from(element.selectedOptions).map((opt) => opt.value);
-  }
-  return state;
-}
-function isElementVisible(element, rect, style) {
-  if (rect.width === 0 || rect.height === 0) return false;
-  if (style.display === "none") return false;
-  if (style.visibility === "hidden") return false;
-  if (parseFloat(style.opacity) === 0) return false;
-  const inViewport = rect.top < window.innerHeight && rect.bottom > 0 && rect.left < window.innerWidth && rect.right > 0;
-  return inViewport;
-}
-function isElementDisabled(element) {
-  if ("disabled" in element && element.disabled) {
-    return true;
-  }
-  if (element.getAttribute("aria-disabled") === "true") {
-    return true;
-  }
-  return false;
-}
-function inferActions(type) {
-  const baseActions = ["focus", "blur", "hover"];
-  switch (type) {
-    case "button":
-      return [...baseActions, "click", "doubleClick", "rightClick"];
-    case "input":
-      return [...baseActions, "click", "type", "clear"];
-    case "textarea":
-      return [...baseActions, "click", "type", "clear"];
-    case "select":
-      return [...baseActions, "click", "select"];
-    case "checkbox":
-      return [...baseActions, "click", "check", "uncheck", "toggle"];
-    case "radio":
-      return [...baseActions, "click", "check"];
-    case "link":
-      return [...baseActions, "click"];
-    case "form":
-      return ["focus", "blur"];
-    case "menu":
-    case "menuitem":
-      return [...baseActions, "click"];
-    case "tab":
-      return [...baseActions, "click"];
-    case "dialog":
-      return ["focus", "blur"];
-    case "custom":
-    default:
-      return [...baseActions, "click"];
-  }
-}
-function inferElementType(element) {
-  const tagName = element.tagName.toLowerCase();
-  const role = element.getAttribute("role");
-  if (role) {
-    switch (role) {
-      case "button":
-        return "button";
-      case "textbox":
-        return "input";
-      case "checkbox":
-        return "checkbox";
-      case "radio":
-        return "radio";
-      case "link":
-        return "link";
-      case "listbox":
-      case "combobox":
-        return "select";
-      case "menu":
-        return "menu";
-      case "menuitem":
-        return "menuitem";
-      case "tab":
-        return "tab";
-      case "dialog":
-        return "dialog";
-    }
-  }
-  switch (tagName) {
-    case "button":
-      return "button";
-    case "input": {
-      const inputType = element.type;
-      if (inputType === "checkbox") return "checkbox";
-      if (inputType === "radio") return "radio";
-      if (inputType === "submit" || inputType === "button") return "button";
-      return "input";
-    }
-    case "textarea":
-      return "textarea";
-    case "select":
-      return "select";
-    case "a":
-      return "link";
-    case "form":
-      return "form";
-    default:
-      return "custom";
-  }
-}
-var UIBridgeRegistry = class {
-  constructor(options = {}) {
-    this.elements = /* @__PURE__ */ new Map();
-    this.components = /* @__PURE__ */ new Map();
-    this.workflows = /* @__PURE__ */ new Map();
-    this.eventListeners = /* @__PURE__ */ new Map();
-    // State management
-    this.states = /* @__PURE__ */ new Map();
-    this.stateGroups = /* @__PURE__ */ new Map();
-    this.transitions = /* @__PURE__ */ new Map();
-    this.activeStates = /* @__PURE__ */ new Set();
-    this.options = options;
-  }
-  /**
-   * Emit an event
-   */
-  emit(type, data) {
-    const event = {
-      type,
-      timestamp: Date.now(),
-      data
-    };
-    this.options.onEvent?.(event);
-    const listeners = this.eventListeners.get(type);
-    if (listeners) {
-      for (const listener of listeners) {
-        try {
-          listener(event);
-        } catch (error) {
-          console.error(`Error in event listener for ${type}:`, error);
-        }
-      }
-    }
-    if (this.options.verbose) {
-      console.log("[UIBridge]", type, data);
-    }
-  }
-  /**
-   * Register an event listener
-   */
-  on(type, listener) {
-    if (!this.eventListeners.has(type)) {
-      this.eventListeners.set(type, /* @__PURE__ */ new Set());
-    }
-    this.eventListeners.get(type).add(listener);
-    return () => {
-      this.eventListeners.get(type)?.delete(listener);
-    };
-  }
-  /**
-   * Remove an event listener
-   */
-  off(type, listener) {
-    this.eventListeners.get(type)?.delete(listener);
-  }
-  /**
-   * Register an element
-   */
-  registerElement(id, element, options = {}) {
-    const type = options.type ?? inferElementType(element);
-    const actions = options.actions ?? inferActions(type);
-    element.setAttribute("data-ui-id", id);
-    const registered = {
-      id,
-      element,
-      type,
-      label: options.label,
-      actions,
-      customActions: options.customActions,
-      getState: () => getElementState(element),
-      getIdentifier: () => createElementIdentifier(element),
-      registeredAt: Date.now(),
-      mounted: true
-    };
-    this.elements.set(id, registered);
-    this.emit("element:registered", { id, type, label: options.label });
-    return registered;
-  }
-  /**
-   * Unregister an element
-   */
-  unregisterElement(id) {
-    const registered = this.elements.get(id);
-    if (registered) {
-      registered.mounted = false;
-      registered.element.removeAttribute("data-ui-id");
-      this.elements.delete(id);
-      this.emit("element:unregistered", { id });
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Get a registered element
-   */
-  getElement(id) {
-    return this.elements.get(id);
-  }
-  /**
-   * Get all registered elements
-   */
-  getAllElements() {
-    return Array.from(this.elements.values());
-  }
-  /**
-   * Find element by DOM element reference
-   */
-  findByDOMElement(element) {
-    for (const registered of this.elements.values()) {
-      if (registered.element === element) {
-        return registered;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Register a component
-   */
-  registerComponent(id, options) {
-    const registered = {
-      id,
-      name: options.name,
-      description: options.description,
-      actions: options.actions?.map((a) => ({
-        id: a.id,
-        label: a.label,
-        description: a.description,
-        handler: a.handler
-      })) ?? [],
-      elementIds: options.elementIds,
-      registeredAt: Date.now(),
-      mounted: true
-    };
-    this.components.set(id, registered);
-    this.emit("component:registered", { id, name: options.name });
-    return registered;
-  }
-  /**
-   * Unregister a component
-   */
-  unregisterComponent(id) {
-    const component = this.components.get(id);
-    if (component) {
-      component.mounted = false;
-      this.components.delete(id);
-      this.emit("component:unregistered", { id });
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Get a registered component
-   */
-  getComponent(id) {
-    return this.components.get(id);
-  }
-  /**
-   * Get all registered components
-   */
-  getAllComponents() {
-    return Array.from(this.components.values());
-  }
-  /**
-   * Register a workflow
-   */
-  registerWorkflow(workflow) {
-    this.workflows.set(workflow.id, workflow);
-    return workflow;
-  }
-  /**
-   * Unregister a workflow
-   */
-  unregisterWorkflow(id) {
-    return this.workflows.delete(id);
-  }
-  /**
-   * Get a workflow
-   */
-  getWorkflow(id) {
-    return this.workflows.get(id);
-  }
-  /**
-   * Get all workflows
-   */
-  getAllWorkflows() {
-    return Array.from(this.workflows.values());
-  }
-  // ==========================================================================
-  // State Management
-  // ==========================================================================
-  /**
-   * Register a state
-   */
-  registerState(state) {
-    this.states.set(state.id, state);
-    this.emit("element:registered", { id: state.id, type: "state", name: state.name });
-    return state;
-  }
-  /**
-   * Unregister a state
-   */
-  unregisterState(id) {
-    const state = this.states.get(id);
-    if (state) {
-      this.activeStates.delete(id);
-      this.states.delete(id);
-      this.emit("element:unregistered", { id, type: "state" });
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Get a registered state
-   */
-  getState(id) {
-    return this.states.get(id);
-  }
-  /**
-   * Get all registered states
-   */
-  getAllStates() {
-    return Array.from(this.states.values());
-  }
-  /**
-   * Register a state group
-   */
-  registerStateGroup(group) {
-    this.stateGroups.set(group.id, group);
-    return group;
-  }
-  /**
-   * Unregister a state group
-   */
-  unregisterStateGroup(id) {
-    return this.stateGroups.delete(id);
-  }
-  /**
-   * Get a state group
-   */
-  getStateGroup(id) {
-    return this.stateGroups.get(id);
-  }
-  /**
-   * Get all state groups
-   */
-  getAllStateGroups() {
-    return Array.from(this.stateGroups.values());
-  }
-  /**
-   * Register a transition
-   */
-  registerTransition(transition) {
-    this.transitions.set(transition.id, transition);
-    return transition;
-  }
-  /**
-   * Unregister a transition
-   */
-  unregisterTransition(id) {
-    return this.transitions.delete(id);
-  }
-  /**
-   * Get a transition
-   */
-  getTransition(id) {
-    return this.transitions.get(id);
-  }
-  /**
-   * Get all transitions
-   */
-  getAllTransitions() {
-    return Array.from(this.transitions.values());
-  }
-  /**
-   * Get currently active states
-   */
-  getActiveStates() {
-    return Array.from(this.activeStates);
-  }
-  /**
-   * Check if a state is active
-   */
-  isStateActive(id) {
-    return this.activeStates.has(id);
-  }
-  /**
-   * Activate a state
-   */
-  activateState(id) {
-    const state = this.states.get(id);
-    if (!state) {
-      return false;
-    }
-    for (const activeId of this.activeStates) {
-      const activeState = this.states.get(activeId);
-      if (activeState?.blocking && activeState.id !== id) {
-        return false;
-      }
-      if (activeState?.blocks?.includes(id)) {
-        return false;
-      }
-    }
-    const wasActive = this.activeStates.has(id);
-    this.activeStates.add(id);
-    if (!wasActive) {
-      this.emit("element:stateChanged", {
-        stateId: id,
-        active: true,
-        activeStates: this.getActiveStates()
-      });
-    }
-    return true;
-  }
-  /**
-   * Deactivate a state
-   */
-  deactivateState(id) {
-    const wasActive = this.activeStates.has(id);
-    this.activeStates.delete(id);
-    if (wasActive) {
-      this.emit("element:stateChanged", {
-        stateId: id,
-        active: false,
-        activeStates: this.getActiveStates()
-      });
-    }
-    return wasActive;
-  }
-  /**
-   * Activate multiple states
-   */
-  activateStates(ids) {
-    const activated = [];
-    for (const id of ids) {
-      if (this.activateState(id)) {
-        activated.push(id);
-      }
-    }
-    return activated;
-  }
-  /**
-   * Deactivate multiple states
-   */
-  deactivateStates(ids) {
-    const deactivated = [];
-    for (const id of ids) {
-      if (this.deactivateState(id)) {
-        deactivated.push(id);
-      }
-    }
-    return deactivated;
-  }
-  /**
-   * Activate a state group (all states in the group)
-   */
-  activateStateGroup(groupId) {
-    const group = this.stateGroups.get(groupId);
-    if (!group) return [];
-    return this.activateStates(group.states);
-  }
-  /**
-   * Deactivate a state group (all states in the group)
-   */
-  deactivateStateGroup(groupId) {
-    const group = this.stateGroups.get(groupId);
-    if (!group) return [];
-    return this.deactivateStates(group.states);
-  }
-  /**
-   * Check if a transition can be executed from current state
-   */
-  canExecuteTransition(transitionId) {
-    const transition = this.transitions.get(transitionId);
-    if (!transition) return false;
-    return transition.fromStates.some((stateId) => this.activeStates.has(stateId));
-  }
-  /**
-   * Execute a transition
-   */
-  async executeTransition(transitionId) {
-    const startTime = performance.now();
-    const transition = this.transitions.get(transitionId);
-    if (!transition) {
-      return {
-        success: false,
-        activatedStates: [],
-        deactivatedStates: [],
-        error: `Transition not found: ${transitionId}`,
-        durationMs: performance.now() - startTime
-      };
-    }
-    if (!this.canExecuteTransition(transitionId)) {
-      return {
-        success: false,
-        activatedStates: [],
-        deactivatedStates: [],
-        error: "Precondition not met: none of the fromStates are active",
-        failedPhase: "precondition",
-        durationMs: performance.now() - startTime
-      };
-    }
-    try {
-      const deactivated = this.deactivateStates(transition.exitStates);
-      if (transition.exitGroups) {
-        for (const groupId of transition.exitGroups) {
-          deactivated.push(...this.deactivateStateGroup(groupId));
-        }
-      }
-      const activated = this.activateStates(transition.activateStates);
-      if (transition.activateGroups) {
-        for (const groupId of transition.activateGroups) {
-          activated.push(...this.activateStateGroup(groupId));
-        }
-      }
-      return {
-        success: true,
-        activatedStates: activated,
-        deactivatedStates: deactivated,
-        durationMs: performance.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        activatedStates: [],
-        deactivatedStates: [],
-        error: error instanceof Error ? error.message : String(error),
-        failedPhase: "execution",
-        durationMs: performance.now() - startTime
-      };
-    }
-  }
-  /**
-   * Find a path from current state to target states
-   *
-   * Uses a simple BFS algorithm for pathfinding.
-   * For more advanced pathfinding (Dijkstra, A*), use the Python state manager service.
-   */
-  findPath(targetStates) {
-    if (targetStates.every((t) => this.activeStates.has(t))) {
-      return {
-        found: true,
-        transitions: [],
-        totalCost: 0,
-        targetStates,
-        estimatedSteps: 0
-      };
-    }
-    const queue = [
-      { activeStates: new Set(this.activeStates), path: [], cost: 0 }
-    ];
-    const visited = /* @__PURE__ */ new Set();
-    while (queue.length > 0) {
-      const current = queue.shift();
-      const stateKey = Array.from(current.activeStates).sort().join(",");
-      if (visited.has(stateKey)) continue;
-      visited.add(stateKey);
-      if (targetStates.every((t) => current.activeStates.has(t))) {
-        return {
-          found: true,
-          transitions: current.path,
-          totalCost: current.cost,
-          targetStates,
-          estimatedSteps: current.path.length
-        };
-      }
-      for (const transition of this.transitions.values()) {
-        const canExecute = transition.fromStates.some((s) => current.activeStates.has(s));
-        if (!canExecute) continue;
-        const newActive = new Set(current.activeStates);
-        for (const s of transition.exitStates) newActive.delete(s);
-        for (const s of transition.activateStates) newActive.add(s);
-        const newCost = current.cost + (transition.pathCost ?? 1);
-        queue.push({
-          activeStates: newActive,
-          path: [...current.path, transition.id],
-          cost: newCost
-        });
-      }
-    }
-    return {
-      found: false,
-      transitions: [],
-      totalCost: 0,
-      targetStates,
-      estimatedSteps: 0
-    };
-  }
-  /**
-   * Navigate to target states using pathfinding
-   */
-  async navigateTo(targetStates) {
-    const startTime = performance.now();
-    const path = this.findPath(targetStates);
-    if (!path.found) {
-      return {
-        success: false,
-        path,
-        executedTransitions: [],
-        finalActiveStates: this.getActiveStates(),
-        error: `No path found to target states: ${targetStates.join(", ")}`,
-        durationMs: performance.now() - startTime
-      };
-    }
-    const executedTransitions = [];
-    for (const transitionId of path.transitions) {
-      const result = await this.executeTransition(transitionId);
-      if (!result.success) {
-        return {
-          success: false,
-          path,
-          executedTransitions,
-          finalActiveStates: this.getActiveStates(),
-          error: result.error,
-          durationMs: performance.now() - startTime
-        };
-      }
-      executedTransitions.push(transitionId);
-    }
-    return {
-      success: true,
-      path,
-      executedTransitions,
-      finalActiveStates: this.getActiveStates(),
-      durationMs: performance.now() - startTime
-    };
-  }
-  /**
-   * Create a state snapshot
-   */
-  createStateSnapshot() {
-    return {
-      timestamp: Date.now(),
-      activeStates: this.getActiveStates(),
-      states: this.getAllStates(),
-      groups: this.getAllStateGroups(),
-      transitions: this.getAllTransitions()
-    };
-  }
-  /**
-   * Create a snapshot of the current state
-   */
-  createSnapshot() {
-    return {
-      timestamp: Date.now(),
-      elements: this.getAllElements().map((el) => ({
-        id: el.id,
-        type: el.type,
-        label: el.label,
-        identifier: el.getIdentifier(),
-        state: el.getState(),
-        actions: el.actions,
-        customActions: el.customActions ? Object.keys(el.customActions) : void 0
-      })),
-      components: this.getAllComponents().map((comp) => ({
-        id: comp.id,
-        name: comp.name,
-        description: comp.description,
-        actions: comp.actions.map((a) => a.id),
-        elementIds: comp.elementIds
-      })),
-      workflows: this.getAllWorkflows().map((wf) => ({
-        id: wf.id,
-        name: wf.name,
-        description: wf.description,
-        stepCount: wf.steps.length
-      }))
-    };
-  }
-  /**
-   * Clear all registrations
-   */
-  clear() {
-    this.elements.clear();
-    this.components.clear();
-    this.workflows.clear();
-    this.eventListeners.clear();
-    this.states.clear();
-    this.stateGroups.clear();
-    this.transitions.clear();
-    this.activeStates.clear();
-  }
-  /**
-   * Get registry statistics
-   */
-  getStats() {
-    const elements = this.getAllElements();
-    const components = this.getAllComponents();
-    return {
-      elementCount: elements.length,
-      componentCount: components.length,
-      workflowCount: this.workflows.size,
-      mountedElementCount: elements.filter((e) => e.mounted).length,
-      mountedComponentCount: components.filter((c) => c.mounted).length,
-      stateCount: this.states.size,
-      stateGroupCount: this.stateGroups.size,
-      transitionCount: this.transitions.size,
-      activeStateCount: this.activeStates.size
-    };
-  }
-};
-var globalRegistry = null;
-function getGlobalRegistry() {
-  if (!globalRegistry) {
-    globalRegistry = new UIBridgeRegistry();
-  }
-  return globalRegistry;
-}
-function setGlobalRegistry(registry) {
-  globalRegistry = registry;
-}
-function resetGlobalRegistry() {
-  globalRegistry?.clear();
-  globalRegistry = null;
-}
-
 // src/core/websocket-client.ts
 function generateId() {
   return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
@@ -1404,6 +433,6 @@ function createWSClient(config) {
   return new UIBridgeWSClient(config);
 }
 
-export { ID_ATTRIBUTES, UIBridgeRegistry, UIBridgeWSClient, createElementIdentifier, createWSClient, elementMatchesIdentifier, findAllElementsByIdentifier, findElementByIdentifier, generateCSSSelector, generateXPath, getBestIdentifier, getGlobalRegistry, resetGlobalRegistry, setGlobalRegistry };
+export { UIBridgeWSClient, createWSClient };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map