@qontinui/ui-bridge 0.1.1

package/dist/control/index.js

@@ -0,0 +1,924 @@
+'use strict';
+
+// src/core/element-identifier.ts
+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;
+}
+
+// src/control/action-executor.ts
+var DEFAULT_WAIT_OPTIONS = {
+  visible: true,
+  enabled: true,
+  focused: false,
+  state: {},
+  timeout: 1e4,
+  interval: 100
+};
+function getElementState(element) {
+  const rect = element.getBoundingClientRect();
+  const style = window.getComputedStyle(element);
+  const state = {
+    visible: isVisible(element, rect, style),
+    enabled: !isDisabled(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
+    },
+    computedStyles: {
+      display: style.display,
+      visibility: style.visibility,
+      opacity: style.opacity,
+      pointerEvents: style.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 isVisible(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;
+  return rect.top < window.innerHeight && rect.bottom > 0 && rect.left < window.innerWidth && rect.right > 0;
+}
+function isDisabled(element) {
+  if ("disabled" in element && element.disabled) return true;
+  if (element.getAttribute("aria-disabled") === "true") return true;
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createMouseEvent(type, element, options) {
+  const rect = element.getBoundingClientRect();
+  const x = options?.position?.x ?? rect.width / 2;
+  const y = options?.position?.y ?? rect.height / 2;
+  return new MouseEvent(type, {
+    bubbles: true,
+    cancelable: true,
+    view: window,
+    button: options?.button === "right" ? 2 : options?.button === "middle" ? 1 : 0,
+    clientX: rect.left + x,
+    clientY: rect.top + y
+  });
+}
+var DefaultActionExecutor = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * Execute an action on an element
+   */
+  async executeAction(elementId, request) {
+    const startTime = performance.now();
+    let waitDurationMs = 0;
+    try {
+      const registered = this.registry.getElement(elementId);
+      let element = registered?.element ?? null;
+      if (!element) {
+        element = findElementByIdentifier(elementId);
+      }
+      if (!element) {
+        return {
+          success: false,
+          error: `Element not found: ${elementId}`,
+          durationMs: performance.now() - startTime,
+          timestamp: Date.now(),
+          requestId: request.requestId
+        };
+      }
+      if (request.waitOptions) {
+        const waitResult = await this.waitForElement(element, request.waitOptions);
+        waitDurationMs = waitResult.waitedMs;
+        if (!waitResult.met) {
+          return {
+            success: false,
+            error: waitResult.error || "Wait condition not met",
+            durationMs: performance.now() - startTime,
+            timestamp: Date.now(),
+            requestId: request.requestId,
+            waitDurationMs
+          };
+        }
+      }
+      const result = await this.performAction(element, request.action, request.params);
+      return {
+        success: true,
+        elementState: getElementState(element),
+        result,
+        durationMs: performance.now() - startTime,
+        timestamp: Date.now(),
+        requestId: request.requestId,
+        waitDurationMs
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        durationMs: performance.now() - startTime,
+        timestamp: Date.now(),
+        requestId: request.requestId,
+        waitDurationMs
+      };
+    }
+  }
+  /**
+   * Execute an action on a component
+   */
+  async executeComponentAction(componentId, request) {
+    const startTime = performance.now();
+    try {
+      const component = this.registry.getComponent(componentId);
+      if (!component) {
+        return {
+          success: false,
+          error: `Component not found: ${componentId}`,
+          durationMs: performance.now() - startTime,
+          timestamp: Date.now(),
+          requestId: request.requestId
+        };
+      }
+      const action = component.actions.find((a) => a.id === request.action);
+      if (!action) {
+        return {
+          success: false,
+          error: `Action not found: ${request.action}`,
+          durationMs: performance.now() - startTime,
+          timestamp: Date.now(),
+          requestId: request.requestId
+        };
+      }
+      const result = await action.handler(request.params);
+      return {
+        success: true,
+        result,
+        durationMs: performance.now() - startTime,
+        timestamp: Date.now(),
+        requestId: request.requestId
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        durationMs: performance.now() - startTime,
+        timestamp: Date.now(),
+        requestId: request.requestId
+      };
+    }
+  }
+  /**
+   * Wait for a condition on an element
+   */
+  async waitFor(elementId, options) {
+    const registered = this.registry.getElement(elementId);
+    let element = registered?.element ?? null;
+    if (!element) {
+      element = findElementByIdentifier(elementId);
+    }
+    if (!element) {
+      return {
+        met: false,
+        waitedMs: 0,
+        error: `Element not found: ${elementId}`
+      };
+    }
+    return this.waitForElement(element, options);
+  }
+  /**
+   * Find controllable elements
+   */
+  async find(options) {
+    const startTime = performance.now();
+    const elements = [];
+    let root = document.body;
+    if (options?.root) {
+      const rootEl = document.querySelector(options.root);
+      if (rootEl) root = rootEl;
+    }
+    const interactiveSelectors = [
+      "a[href]",
+      "button",
+      "input",
+      "select",
+      "textarea",
+      "[onclick]",
+      '[role="button"]',
+      '[role="link"]',
+      '[role="checkbox"]',
+      '[role="radio"]',
+      '[role="menuitem"]',
+      '[role="tab"]',
+      '[role="switch"]',
+      '[tabindex]:not([tabindex="-1"])',
+      '[contenteditable="true"]',
+      "[data-ui-id]",
+      "[data-testid]"
+    ];
+    const selector = options?.selector || interactiveSelectors.join(", ");
+    const foundElements = root.querySelectorAll(selector);
+    for (const el of foundElements) {
+      if (options?.limit && elements.length >= options.limit) break;
+      const state = getElementState(el);
+      if (!options?.includeHidden && !state.visible) continue;
+      if (options?.types) {
+        const type = this.inferElementType(el);
+        if (!options.types.includes(type)) continue;
+      }
+      const registered = this.registry.findByDOMElement(el);
+      elements.push({
+        id: registered?.id || this.getElementId(el),
+        type: registered?.type || this.inferElementType(el),
+        label: registered?.label || this.getElementLabel(el),
+        tagName: el.tagName.toLowerCase(),
+        role: el.getAttribute("role") || void 0,
+        accessibleName: this.getAccessibleName(el),
+        actions: registered?.actions || this.inferActions(el),
+        state,
+        registered: !!registered
+      });
+    }
+    return {
+      elements,
+      total: elements.length,
+      durationMs: performance.now() - startTime,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Discover controllable elements
+   * @deprecated Use find() instead
+   */
+  async discover(options) {
+    return this.find(options);
+  }
+  /**
+   * Get control snapshot
+   */
+  async getSnapshot() {
+    const elements = this.registry.getAllElements();
+    const components = this.registry.getAllComponents();
+    const workflows = this.registry.getAllWorkflows();
+    return {
+      timestamp: Date.now(),
+      elements: elements.map((el) => ({
+        id: el.id,
+        type: el.type,
+        label: el.label,
+        actions: [...el.actions, ...el.customActions ? Object.keys(el.customActions) : []],
+        state: el.getState()
+      })),
+      components: components.map((comp) => ({
+        id: comp.id,
+        name: comp.name,
+        actions: comp.actions.map((a) => a.id)
+      })),
+      workflows: workflows.map((wf) => ({
+        id: wf.id,
+        name: wf.name,
+        stepCount: wf.steps.length
+      })),
+      activeRuns: []
+      // Workflow engine manages this
+    };
+  }
+  /**
+   * Wait for element conditions
+   */
+  async waitForElement(element, options) {
+    const opts = { ...DEFAULT_WAIT_OPTIONS, ...options };
+    const startTime = performance.now();
+    const deadline = startTime + opts.timeout;
+    while (Date.now() < deadline) {
+      const state = getElementState(element);
+      let allMet = true;
+      if (opts.visible && !state.visible) allMet = false;
+      if (opts.enabled && !state.enabled) allMet = false;
+      if (opts.focused && !state.focused) allMet = false;
+      if (opts.state) {
+        for (const [key, value] of Object.entries(opts.state)) {
+          if (state[key] !== value) {
+            allMet = false;
+            break;
+          }
+        }
+      }
+      if (allMet) {
+        return {
+          met: true,
+          waitedMs: performance.now() - startTime,
+          state
+        };
+      }
+      await sleep(opts.interval);
+    }
+    return {
+      met: false,
+      waitedMs: performance.now() - startTime,
+      state: getElementState(element),
+      error: `Timeout waiting for conditions after ${opts.timeout}ms`
+    };
+  }
+  /**
+   * Perform an action on an element
+   */
+  async performAction(element, action, params) {
+    switch (action) {
+      case "click":
+        return this.performClick(element, params);
+      case "doubleClick":
+        return this.performDoubleClick(element, params);
+      case "rightClick":
+        return this.performRightClick(element, params);
+      case "type":
+        return this.performType(element, params);
+      case "clear":
+        return this.performClear(element);
+      case "select":
+        return this.performSelect(element, params);
+      case "focus":
+        return this.performFocus(element);
+      case "blur":
+        return this.performBlur(element);
+      case "hover":
+        return this.performHover(element);
+      case "scroll":
+        return this.performScroll(element, params);
+      case "check":
+        return this.performCheck(element, true);
+      case "uncheck":
+        return this.performCheck(element, false);
+      case "toggle":
+        return this.performToggle(element);
+      default: {
+        const registered = this.registry.findByDOMElement(element);
+        if (registered?.customActions?.[action]) {
+          return registered.customActions[action].handler(params);
+        }
+        throw new Error(`Unknown action: ${action}`);
+      }
+    }
+  }
+  performClick(element, options) {
+    element.dispatchEvent(createMouseEvent("mousedown", element, options));
+    element.dispatchEvent(createMouseEvent("mouseup", element, options));
+    element.dispatchEvent(createMouseEvent("click", element, options));
+  }
+  performDoubleClick(element, options) {
+    this.performClick(element, options);
+    this.performClick(element, options);
+    element.dispatchEvent(createMouseEvent("dblclick", element, options));
+  }
+  performRightClick(element, options) {
+    const opts = { ...options, button: "right" };
+    element.dispatchEvent(createMouseEvent("mousedown", element, opts));
+    element.dispatchEvent(createMouseEvent("mouseup", element, opts));
+    element.dispatchEvent(createMouseEvent("contextmenu", element, opts));
+  }
+  async performType(element, options) {
+    if (!(element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement)) {
+      throw new Error("Type action requires an input or textarea element");
+    }
+    element.focus();
+    if (options?.clear) {
+      element.value = "";
+      element.dispatchEvent(new Event("input", { bubbles: true }));
+    }
+    const text = options?.text || "";
+    const delay = options?.delay || 0;
+    for (const char of text) {
+      element.value += char;
+      if (options?.triggerEvents !== false) {
+        element.dispatchEvent(new Event("input", { bubbles: true }));
+      }
+      if (delay > 0) {
+        await sleep(delay);
+      }
+    }
+    if (options?.triggerEvents !== false) {
+      element.dispatchEvent(new Event("change", { bubbles: true }));
+    }
+  }
+  performClear(element) {
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+      element.value = "";
+      element.dispatchEvent(new Event("input", { bubbles: true }));
+      element.dispatchEvent(new Event("change", { bubbles: true }));
+    }
+  }
+  performSelect(element, options) {
+    if (!(element instanceof HTMLSelectElement)) {
+      throw new Error("Select action requires a select element");
+    }
+    const values = Array.isArray(options?.value) ? options.value : [options?.value];
+    if (!options?.additive) {
+      for (const option of element.options) {
+        option.selected = false;
+      }
+    }
+    for (const option of element.options) {
+      const matchValue = options?.byLabel ? option.text : option.value;
+      if (values.includes(matchValue)) {
+        option.selected = true;
+      }
+    }
+    element.dispatchEvent(new Event("change", { bubbles: true }));
+  }
+  performFocus(element) {
+    element.focus();
+    element.dispatchEvent(new FocusEvent("focus", { bubbles: true }));
+  }
+  performBlur(element) {
+    element.blur();
+    element.dispatchEvent(new FocusEvent("blur", { bubbles: true }));
+  }
+  performHover(element) {
+    element.dispatchEvent(createMouseEvent("mouseenter", element));
+    element.dispatchEvent(createMouseEvent("mouseover", element));
+  }
+  performScroll(element, options) {
+    if (options?.toElement) {
+      const target = document.querySelector(options.toElement);
+      if (target) {
+        target.scrollIntoView({ behavior: options.smooth ? "smooth" : "auto" });
+        return;
+      }
+    }
+    if (options?.position) {
+      element.scrollTo({
+        left: options.position.x,
+        top: options.position.y,
+        behavior: options.smooth ? "smooth" : "auto"
+      });
+      return;
+    }
+    const amount = options?.amount || 100;
+    const direction = options?.direction || "down";
+    switch (direction) {
+      case "up":
+        element.scrollBy({ top: -amount, behavior: options?.smooth ? "smooth" : "auto" });
+        break;
+      case "down":
+        element.scrollBy({ top: amount, behavior: options?.smooth ? "smooth" : "auto" });
+        break;
+      case "left":
+        element.scrollBy({ left: -amount, behavior: options?.smooth ? "smooth" : "auto" });
+        break;
+      case "right":
+        element.scrollBy({ left: amount, behavior: options?.smooth ? "smooth" : "auto" });
+        break;
+    }
+  }
+  performCheck(element, checked) {
+    if (element instanceof HTMLInputElement && (element.type === "checkbox" || element.type === "radio")) {
+      if (element.checked !== checked) {
+        element.checked = checked;
+        element.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+    }
+  }
+  performToggle(element) {
+    if (element instanceof HTMLInputElement && element.type === "checkbox") {
+      element.checked = !element.checked;
+      element.dispatchEvent(new Event("change", { bubbles: true }));
+    }
+  }
+  getElementId(element) {
+    return element.getAttribute("data-ui-id") || element.getAttribute("data-testid") || element.id || `${element.tagName.toLowerCase()}-${Math.random().toString(36).substr(2, 8)}`;
+  }
+  getElementLabel(element) {
+    return element.getAttribute("aria-label") || element.getAttribute("title") || element.textContent?.trim().substring(0, 50) || void 0;
+  }
+  getAccessibleName(element) {
+    const ariaLabel = element.getAttribute("aria-label");
+    if (ariaLabel) return ariaLabel;
+    const labelledBy = element.getAttribute("aria-labelledby");
+    if (labelledBy) {
+      const labels = labelledBy.split(" ").map((id) => document.getElementById(id)?.textContent?.trim()).filter(Boolean);
+      if (labels.length > 0) return labels.join(" ");
+    }
+    if (element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement) {
+      if (element.id) {
+        const label = document.querySelector(`label[for="${element.id}"]`);
+        if (label) return label.textContent?.trim();
+      }
+    }
+    return element.getAttribute("title") || element.textContent?.trim().substring(0, 50) || void 0;
+  }
+  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 type = element.type;
+        if (type === "checkbox") return "checkbox";
+        if (type === "radio") return "radio";
+        if (type === "submit" || type === "button") return "button";
+        return "input";
+      }
+      case "textarea":
+        return "textarea";
+      case "select":
+        return "select";
+      case "a":
+        return "link";
+      case "form":
+        return "form";
+      default:
+        return "custom";
+    }
+  }
+  inferActions(element) {
+    const type = this.inferElementType(element);
+    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"];
+      default:
+        return [...baseActions, "click"];
+    }
+  }
+};
+function createActionExecutor(registry) {
+  return new DefaultActionExecutor(registry);
+}
+
+// src/control/workflow-engine.ts
+function generateRunId() {
+  return `run-${Date.now()}-${Math.random().toString(36).substr(2, 8)}`;
+}
+var DefaultWorkflowEngine = class {
+  constructor(registry, executor) {
+    this.registry = registry;
+    this.executor = executor;
+    this.activeRuns = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Run a workflow
+   */
+  async run(workflowId, request) {
+    const workflow = this.registry.getWorkflow(workflowId);
+    if (!workflow) {
+      return {
+        workflowId,
+        runId: generateRunId(),
+        status: "failed",
+        steps: [],
+        totalSteps: 0,
+        success: false,
+        error: `Workflow not found: ${workflowId}`,
+        startedAt: Date.now(),
+        completedAt: Date.now(),
+        durationMs: 0
+      };
+    }
+    const runId = generateRunId();
+    const state = {
+      workflowId,
+      runId,
+      workflow,
+      request,
+      status: "running",
+      steps: [],
+      currentStep: 0,
+      startedAt: Date.now()
+    };
+    this.activeRuns.set(runId, state);
+    try {
+      await this.executeWorkflow(state);
+    } catch (error) {
+      state.status = "failed";
+      state.error = error instanceof Error ? error.message : String(error);
+    }
+    state.completedAt = Date.now();
+    state.durationMs = state.completedAt - state.startedAt;
+    state.success = state.status === "completed" && state.steps.every((s) => s.success);
+    setTimeout(() => {
+      this.activeRuns.delete(runId);
+    }, 6e4);
+    return this.buildResponse(state);
+  }
+  /**
+   * Get workflow run status
+   */
+  async getRunStatus(runId) {
+    const state = this.activeRuns.get(runId);
+    if (!state) return null;
+    return this.buildResponse(state);
+  }
+  /**
+   * Cancel a running workflow
+   */
+  async cancel(runId) {
+    const state = this.activeRuns.get(runId);
+    if (!state || state.status !== "running") return false;
+    state.status = "cancelled";
+    state.completedAt = Date.now();
+    state.durationMs = state.completedAt - state.startedAt;
+    state.error = "Workflow cancelled by user";
+    return true;
+  }
+  /**
+   * List active runs
+   */
+  async listActiveRuns() {
+    return Array.from(this.activeRuns.values()).filter((state) => state.status === "running").map((state) => this.buildResponse(state));
+  }
+  /**
+   * Execute a workflow
+   */
+  async executeWorkflow(state) {
+    const { workflow, request } = state;
+    const params = { ...workflow.defaultParams, ...request?.params };
+    let startIndex = 0;
+    if (request?.startStep) {
+      const idx = workflow.steps.findIndex((s) => s.id === request.startStep);
+      if (idx >= 0) startIndex = idx;
+    }
+    let stopIndex = workflow.steps.length;
+    if (request?.stopStep) {
+      const idx = workflow.steps.findIndex((s) => s.id === request.stopStep);
+      if (idx >= 0) stopIndex = idx + 1;
+    }
+    for (let i = startIndex; i < stopIndex; i++) {
+      if (state.status === "cancelled") break;
+      state.currentStep = i;
+      const step = workflow.steps[i];
+      const stepResult = await this.executeStep(step, params, request?.stepTimeout);
+      state.steps.push(stepResult);
+      if (!stepResult.success) {
+        state.status = "failed";
+        state.error = stepResult.error;
+        return;
+      }
+    }
+    state.status = "completed";
+  }
+  /**
+   * Execute a single step
+   */
+  async executeStep(step, params, timeout) {
+    const startTime = performance.now();
+    try {
+      const timeoutPromise = timeout ? new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Step timeout")), timeout)
+      ) : null;
+      const executePromise = this.executeStepInternal(step, params);
+      const result = timeoutPromise ? await Promise.race([executePromise, timeoutPromise]) : await executePromise;
+      return {
+        stepId: step.id,
+        stepType: step.type,
+        success: true,
+        result,
+        durationMs: performance.now() - startTime,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      return {
+        stepId: step.id,
+        stepType: step.type,
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        durationMs: performance.now() - startTime,
+        timestamp: Date.now()
+      };
+    }
+  }
+  /**
+   * Execute step internal logic
+   */
+  async executeStepInternal(step, params) {
+    const resolvedParams = this.interpolateParams(step.params || {}, params);
+    switch (step.type) {
+      case "element-action":
+        if (!step.target || !step.action) {
+          throw new Error("Element action requires target and action");
+        }
+        return this.executor.executeAction(step.target, {
+          action: step.action,
+          params: resolvedParams,
+          waitOptions: step.waitOptions
+        });
+      case "component-action":
+        if (!step.target || !step.action) {
+          throw new Error("Component action requires target and action");
+        }
+        return this.executor.executeComponentAction(step.target, {
+          action: step.action,
+          params: resolvedParams
+        });
+      case "wait": {
+        if (!step.target) {
+          throw new Error("Wait step requires target");
+        }
+        const waitResult = await this.executor.waitFor(step.target, step.waitOptions || {});
+        if (!waitResult.met) {
+          throw new Error(waitResult.error || "Wait condition not met");
+        }
+        return waitResult;
+      }
+      case "assert":
+        if (!step.target || !step.expectedState) {
+          throw new Error("Assert step requires target and expectedState");
+        }
+        return this.performAssertion(step.target, step.expectedState);
+      case "custom":
+        if (!step.handler) {
+          throw new Error("Custom step requires handler");
+        }
+        return step.handler();
+      default:
+        throw new Error(`Unknown step type: ${step.type}`);
+    }
+  }
+  /**
+   * Perform state assertion
+   */
+  async performAssertion(target, expectedState) {
+    const snapshot = await this.executor.getSnapshot();
+    const element = snapshot.elements.find((e) => e.id === target);
+    if (!element) {
+      throw new Error(`Element not found for assertion: ${target}`);
+    }
+    const differences = [];
+    for (const [key, expected] of Object.entries(expectedState)) {
+      const actual = element.state[key];
+      if (actual !== expected) {
+        differences.push(`${key}: expected ${expected}, got ${actual}`);
+      }
+    }
+    if (differences.length > 0) {
+      throw new Error(`Assertion failed:
+${differences.join("\n")}`);
+    }
+    return { passed: true, differences };
+  }
+  /**
+   * Interpolate parameters with {{param}} syntax
+   */
+  interpolateParams(stepParams, workflowParams) {
+    const result = {};
+    for (const [key, value] of Object.entries(stepParams)) {
+      if (typeof value === "string") {
+        result[key] = value.replace(/\{\{(\w+)\}\}/g, (_, name) => {
+          return String(workflowParams[name] ?? "");
+        });
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Build response from state
+   */
+  buildResponse(state) {
+    return {
+      workflowId: state.workflowId,
+      runId: state.runId,
+      status: state.status,
+      steps: [...state.steps],
+      currentStep: state.currentStep,
+      totalSteps: state.workflow.steps.length,
+      success: state.success,
+      error: state.error,
+      startedAt: state.startedAt,
+      completedAt: state.completedAt,
+      durationMs: state.durationMs
+    };
+  }
+};
+function createWorkflowEngine(registry, executor) {
+  return new DefaultWorkflowEngine(registry, executor);
+}
+
+exports.DefaultActionExecutor = DefaultActionExecutor;
+exports.DefaultWorkflowEngine = DefaultWorkflowEngine;
+exports.createActionExecutor = createActionExecutor;
+exports.createWorkflowEngine = createWorkflowEngine;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map