@testspectra/react-native 0.0.0-stage → 1.2.15

package/dist/index.js

@@ -0,0 +1,3662 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/mock/react_native_shim.ts
+var react_native_shim_exports = {};
+__export(react_native_shim_exports, {
+  ActivityIndicator: () => ActivityIndicator,
+  Alert: () => Alert,
+  Animated: () => Animated,
+  AppState: () => AppState,
+  BackHandler: () => BackHandler,
+  Dimensions: () => Dimensions,
+  FlatList: () => FlatList,
+  Image: () => Image,
+  Keyboard: () => Keyboard,
+  Linking: () => Linking,
+  Modal: () => Modal,
+  PixelRatio: () => PixelRatio,
+  Platform: () => Platform,
+  Pressable: () => Pressable,
+  SafeAreaView: () => SafeAreaView,
+  ScrollView: () => ScrollView,
+  SectionList: () => SectionList,
+  StatusBar: () => StatusBar,
+  StyleSheet: () => StyleSheet,
+  Text: () => Text,
+  TextInput: () => TextInput,
+  TouchableHighlight: () => TouchableHighlight,
+  TouchableOpacity: () => TouchableOpacity,
+  TouchableWithoutFeedback: () => TouchableWithoutFeedback,
+  UIManager: () => UIManager,
+  View: () => View,
+  default: () => react_native_shim_default,
+  useWindowDimensions: () => useWindowDimensions
+});
+import React from "react";
+function createComponent(displayName) {
+  const Comp = React.forwardRef((props, ref) => {
+    return React.createElement(displayName, { ...props, ref });
+  });
+  Comp.displayName = displayName;
+  return Comp;
+}
+function useWindowDimensions() {
+  return { width: 412, height: 915, scale: 2.625, fontScale: 1 };
+}
+var View, Text, TouchableOpacity, TouchableHighlight, TouchableWithoutFeedback, Pressable, TextInput, ScrollView, FlatList, SectionList, ActivityIndicator, Modal, Image, SafeAreaView, StatusBar, StyleSheet, Platform, Dimensions, PixelRatio, Keyboard, UIManager, Alert, AppState, Linking, BackHandler, Animated, react_native_shim_default;
+var init_react_native_shim = __esm({
+  "src/mock/react_native_shim.ts"() {
+    "use strict";
+    View = createComponent("View");
+    Text = createComponent("Text");
+    TouchableOpacity = createComponent("TouchableOpacity");
+    TouchableHighlight = createComponent("TouchableHighlight");
+    TouchableWithoutFeedback = createComponent("TouchableWithoutFeedback");
+    Pressable = createComponent("Pressable");
+    TextInput = createComponent("TextInput");
+    ScrollView = createComponent("ScrollView");
+    FlatList = createComponent("FlatList");
+    SectionList = createComponent("SectionList");
+    ActivityIndicator = createComponent("ActivityIndicator");
+    Modal = createComponent("Modal");
+    Image = createComponent("Image");
+    SafeAreaView = createComponent("SafeAreaView");
+    StatusBar = createComponent("StatusBar");
+    StyleSheet = {
+      create: (styles2) => styles2,
+      flatten: (style) => {
+        if (Array.isArray(style)) {
+          return Object.assign({}, ...style.filter(Boolean).map(StyleSheet.flatten));
+        }
+        return style || {};
+      },
+      hairlineWidth: 1,
+      absoluteFill: { position: "absolute", left: 0, right: 0, top: 0, bottom: 0 },
+      absoluteFillObject: { position: "absolute", left: 0, right: 0, top: 0, bottom: 0 }
+    };
+    Platform = {
+      OS: "android",
+      select: (obj) => obj?.android ?? obj?.default ?? obj?.ios,
+      isTesting: true,
+      Version: 34
+    };
+    Dimensions = {
+      get: (_dim) => ({
+        width: 412,
+        height: 915,
+        scale: 2.625,
+        fontScale: 1
+      }),
+      addEventListener: () => ({ remove: () => {
+      } }),
+      removeEventListener: () => {
+      }
+    };
+    PixelRatio = {
+      get: () => 2.625,
+      getFontScale: () => 1,
+      getPixelSizeForLayoutSize: (layoutSize) => Math.round(layoutSize * 2.625),
+      roundToNearestPixel: (layoutSize) => Math.round(layoutSize)
+    };
+    Keyboard = {
+      dismiss: () => {
+      },
+      addListener: () => ({ remove: () => {
+      } }),
+      removeListener: () => {
+      }
+    };
+    UIManager = {
+      measure: (_node, cb) => {
+        cb(0, 0, 100, 40, 50, 100);
+      },
+      measureInWindow: (_node, cb) => {
+        cb(50, 100, 100, 40);
+      }
+    };
+    Alert = {
+      alert: () => {
+      }
+    };
+    AppState = {
+      currentState: "active",
+      addEventListener: () => ({ remove: () => {
+      } })
+    };
+    Linking = {
+      openURL: () => Promise.resolve(),
+      canOpenURL: () => Promise.resolve(true),
+      getInitialURL: () => Promise.resolve(null)
+    };
+    BackHandler = {
+      addEventListener: () => ({ remove: () => {
+      } }),
+      exitApp: () => {
+      }
+    };
+    Animated = {
+      Value: class AnimatedValue {
+        constructor(val) {
+          this.val = val;
+        }
+        val;
+        setValue(v) {
+          this.val = v;
+        }
+        interpolate(_config) {
+          return this;
+        }
+      },
+      timing: (_val, _config) => ({
+        start: (cb) => cb?.({ finished: true }),
+        stop: () => {
+        }
+      }),
+      spring: (_val, _config) => ({
+        start: (cb) => cb?.({ finished: true }),
+        stop: () => {
+        }
+      }),
+      View,
+      Text,
+      Image,
+      ScrollView,
+      createAnimatedComponent: (c) => c
+    };
+    react_native_shim_default = {
+      View,
+      Text,
+      TouchableOpacity,
+      TouchableHighlight,
+      TouchableWithoutFeedback,
+      Pressable,
+      TextInput,
+      ScrollView,
+      FlatList,
+      SectionList,
+      ActivityIndicator,
+      Modal,
+      Image,
+      SafeAreaView,
+      StatusBar,
+      StyleSheet,
+      Platform,
+      Dimensions,
+      useWindowDimensions,
+      PixelRatio,
+      Keyboard,
+      UIManager,
+      Alert,
+      AppState,
+      Linking,
+      BackHandler,
+      Animated
+    };
+  }
+});
+
+// src/bridge/tree_registry.ts
+function registerRootNode(node) {
+  registeredRootNode = node;
+}
+function setMountedRootRef(ref) {
+  rootInstanceRef = ref;
+}
+function setMountedElement(element) {
+  mountedElement = element;
+}
+function clearMountedTree() {
+  registeredRootNode = null;
+  rootInstanceRef = null;
+  mountedElement = null;
+  if (typeof globalThis.__SPECTRA_MOUNTED_TREE__ !== "undefined") {
+    delete globalThis.__SPECTRA_MOUNTED_TREE__;
+  }
+}
+function getFiberFromInstance(inst) {
+  if (!inst) return null;
+  if (inst._reactInternals) return inst._reactInternals;
+  if (inst._internalFiber) return inst._internalFiber;
+  if (typeof inst === "object") {
+    for (const key of Object.keys(inst)) {
+      if (key.startsWith("__reactFiber$")) {
+        return inst[key];
+      }
+    }
+  }
+  return null;
+}
+function buildTreeFromFiber(fiber, parent = null) {
+  if (!fiber) return null;
+  const node = {
+    type: fiber.type,
+    props: fiber.memoizedProps || fiber.pendingProps || {},
+    parent,
+    children: [],
+    fiber,
+    instance: fiber.stateNode
+  };
+  let child = fiber.child;
+  while (child) {
+    const childNode = buildTreeFromFiber(child, node);
+    if (childNode) {
+      node.children.push(childNode);
+    }
+    child = child.sibling;
+  }
+  return node;
+}
+function buildTreeFromReactElement(element, parent = null) {
+  if (element == null || typeof element === "boolean") return null;
+  if (typeof element === "string" || typeof element === "number") {
+    return {
+      type: "Text",
+      props: { children: String(element) },
+      parent,
+      children: []
+    };
+  }
+  if (Array.isArray(element)) {
+    const fragmentNode = {
+      type: "Fragment",
+      props: {},
+      parent,
+      children: []
+    };
+    for (const item of element) {
+      const child = buildTreeFromReactElement(item, fragmentNode);
+      if (child) fragmentNode.children.push(child);
+    }
+    return fragmentNode;
+  }
+  if (typeof element === "object" && element.type) {
+    const props = element.props || {};
+    const node = {
+      type: element.type,
+      props,
+      parent,
+      children: []
+    };
+    if (typeof element.type === "function" && (!props.children || Array.isArray(props.children) && props.children.length === 0)) {
+      try {
+        const rendered = element.type(props);
+        if (rendered) {
+          const renderedChild = buildTreeFromReactElement(rendered, node);
+          if (renderedChild) {
+            node.children.push(renderedChild);
+          }
+        }
+      } catch {
+      }
+    }
+    if (props.children) {
+      const rawChildren = Array.isArray(props.children) ? props.children : [props.children];
+      for (const child of rawChildren) {
+        const childNode = buildTreeFromReactElement(child, node);
+        if (childNode) {
+          node.children.push(childNode);
+        }
+      }
+    }
+    return node;
+  }
+  return null;
+}
+function getMountedTree() {
+  if (registeredRootNode) return registeredRootNode;
+  if (typeof globalThis.__SPECTRA_MOUNTED_TREE__ !== "undefined") {
+    return globalThis.__SPECTRA_MOUNTED_TREE__;
+  }
+  if (rootInstanceRef) {
+    const fiber = getFiberFromInstance(rootInstanceRef);
+    if (fiber) {
+      const tree = buildTreeFromFiber(fiber);
+      if (tree) return tree;
+    }
+  }
+  if (mountedElement) {
+    return buildTreeFromReactElement(mountedElement);
+  }
+  return null;
+}
+function extractText(node) {
+  const parts = [];
+  function collect(val) {
+    if (val == null || typeof val === "boolean") return;
+    if (typeof val === "string" || typeof val === "number") {
+      parts.push(String(val));
+      return;
+    }
+    if (Array.isArray(val)) {
+      for (const item of val) collect(item);
+      return;
+    }
+    if (typeof val === "object") {
+      if (val.props && val.props.children !== void 0) {
+        collect(val.props.children);
+      } else if (val.children && Array.isArray(val.children)) {
+        for (const c of val.children) collect(c);
+      }
+    }
+  }
+  function walk(curr) {
+    if (!curr) return;
+    if (curr.children && curr.children.length > 0) {
+      for (const childNode of curr.children) {
+        walk(childNode);
+      }
+      return;
+    }
+    if (curr.props?.children !== void 0) {
+      collect(curr.props.children);
+    }
+  }
+  walk(node);
+  if (parts.length === 0 && node.props?.value != null) {
+    return String(node.props.value);
+  }
+  return parts.join("");
+}
+function flattenStyle(style) {
+  if (!style) return null;
+  if (Array.isArray(style)) {
+    const result = {};
+    for (const s of style) {
+      if (s) {
+        const flat = flattenStyle(s);
+        if (flat) Object.assign(result, flat);
+      }
+    }
+    return result;
+  }
+  if (typeof style === "object") return style;
+  return null;
+}
+var registeredRootNode, rootInstanceRef, mountedElement;
+var init_tree_registry = __esm({
+  "src/bridge/tree_registry.ts"() {
+    "use strict";
+    registeredRootNode = null;
+    rootInstanceRef = null;
+    mountedElement = null;
+  }
+});
+
+// src/runtime/harness_root.tsx
+import React2, { useState, useEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+function getReactNativePrimitives() {
+  try {
+    if (typeof __require !== "undefined") {
+      const rn = __require("react-native");
+      if (rn && rn.View && rn.StyleSheet) {
+        return { View: rn.View, StyleSheet: rn.StyleSheet };
+      }
+    }
+  } catch {
+  }
+  return {
+    View: ((props) => React2.createElement("View", props)),
+    StyleSheet: { create: (styles2) => styles2 }
+  };
+}
+function registerMountHandlers(mount2, unmount2) {
+  activeMountListener = mount2;
+  activeUnmountListener = unmount2;
+  return () => {
+    activeMountListener = null;
+    activeUnmountListener = null;
+  };
+}
+function getActiveMountListener() {
+  return activeMountListener;
+}
+function getActiveUnmountListener() {
+  return activeUnmountListener;
+}
+function SpectraHarnessRoot() {
+  let currentElement = null;
+  let setCurrentElement = () => {
+  };
+  try {
+    const [curr, setCurr] = useState(null);
+    currentElement = curr;
+    setCurrentElement = setCurr;
+  } catch {
+  }
+  try {
+    useEffect(() => {
+      return registerMountHandlers(
+        (element) => setCurrentElement(element),
+        () => setCurrentElement(null)
+      );
+    }, []);
+  } catch {
+  }
+  let rootRef = null;
+  try {
+    rootRef = useRef(null);
+    useEffect(() => {
+      if (rootRef.current) {
+        setMountedRootRef(rootRef.current);
+      }
+    });
+  } catch {
+  }
+  return /* @__PURE__ */ jsx(
+    View2,
+    {
+      ref: rootRef,
+      testID: "spectra-root",
+      accessibilityLabel: "spectra-root",
+      style: styles.container,
+      accessible: false,
+      children: currentElement
+    }
+  );
+}
+var View2, StyleSheet2, activeMountListener, activeUnmountListener, styles;
+var init_harness_root = __esm({
+  "src/runtime/harness_root.tsx"() {
+    "use strict";
+    init_tree_registry();
+    ({ View: View2, StyleSheet: StyleSheet2 } = getReactNativePrimitives());
+    activeMountListener = null;
+    activeUnmountListener = null;
+    styles = StyleSheet2.create({
+      container: {
+        flex: 1,
+        backgroundColor: "#ffffff"
+      }
+    });
+  }
+});
+
+// src/runner/in_app_runner.ts
+function beforeEach(fn) {
+  registeredBeforeEach.push(fn);
+}
+function afterEach(fn) {
+  registeredAfterEach.push(fn);
+}
+function cleanup() {
+  const spectra2 = globalThis.Spectra;
+  if (typeof spectra2?.unmount === "function") {
+    try {
+      spectra2.unmount();
+    } catch {
+    }
+  }
+  clearMountedTree();
+}
+function setSocketEmitter(emitter) {
+  activeSocketEmitter = emitter;
+}
+function getSocketEmitter() {
+  return activeSocketEmitter;
+}
+function emit(tag, payload) {
+  if (activeSocketEmitter) {
+    try {
+      activeSocketEmitter(tag, payload);
+      return;
+    } catch {
+    }
+  }
+  console.log(`[${tag}] ${payload}`);
+}
+var registeredTests, registeredBeforeEach, registeredAfterEach, it, activeSocketEmitter, mobileRunner;
+var init_in_app_runner = __esm({
+  "src/runner/in_app_runner.ts"() {
+    "use strict";
+    init_tree_registry();
+    registeredTests = [];
+    registeredBeforeEach = [];
+    registeredAfterEach = [];
+    it = function(title, fn) {
+      registeredTests.push({ title, fn });
+    };
+    it.only = function(title, fn) {
+      registeredTests.push({ title, fn });
+    };
+    it.skip = function(_title, _fn) {
+    };
+    globalThis["it"] = it;
+    globalThis["beforeEach"] = beforeEach;
+    globalThis["afterEach"] = afterEach;
+    activeSocketEmitter = null;
+    mobileRunner = {
+      async run(specPath, options) {
+        emit("TESTSPECTRA_SUITE_START", JSON.stringify({ file: specPath }));
+        try {
+          globalThis.__TS_RUNTIME__?.activeDriver?.clearMocks?.();
+        } catch {
+        }
+        if (options?.bundleSource) {
+          try {
+            const executeSpec = new Function("require", "globalThis", options.bundleSource);
+            executeSpec(typeof __require !== "undefined" ? __require : void 0, globalThis);
+          } catch (err) {
+            emit("TESTSPECTRA_SUITE_ERROR", JSON.stringify({ file: specPath, error: String(err) }));
+            return { passed: 0, failed: 1 };
+          }
+        } else if (typeof fetch === "function") {
+          const host = options?.host ?? "127.0.0.1";
+          const port = options?.port ?? 9245;
+          const url = options?.bundleUrl ?? `http://${host}:${port}/bundle?file=${encodeURIComponent(specPath)}`;
+          try {
+            const res = await fetch(url);
+            if (res.ok) {
+              const bundleCode = await res.text();
+              const executeSpec = new Function("require", "globalThis", bundleCode);
+              executeSpec(typeof __require !== "undefined" ? __require : void 0, globalThis);
+            }
+          } catch (err) {
+            if (registeredTests.length === 0) {
+              emit(
+                "TESTSPECTRA_SUITE_ERROR",
+                JSON.stringify({ file: specPath, error: `Failed to fetch spec bundle from ${url}: ${String(err)}` })
+              );
+              return { passed: 0, failed: 1 };
+            }
+          }
+        }
+        let passed = 0;
+        let failed = 0;
+        for (const { title, fn } of registeredTests) {
+          emit("TESTSPECTRA_TEST_START", title);
+          globalThis["__CURRENT_TEST_TITLE__"] = title;
+          const tStart = Date.now();
+          try {
+            for (const hook of registeredBeforeEach) await hook();
+            await fn();
+            for (const hook of registeredAfterEach) await hook();
+            const duration = Date.now() - tStart;
+            emit("TESTSPECTRA_TEST_PASS", `${title} (${duration}ms)`);
+            passed++;
+          } catch (err) {
+            const duration = Date.now() - tStart;
+            const message = err instanceof Error ? err.message : String(err);
+            emit("TESTSPECTRA_TEST_ERROR", message);
+            emit("TESTSPECTRA_TEST_FAIL", `${title} (${duration}ms)`);
+            failed++;
+          } finally {
+            cleanup();
+          }
+        }
+        registeredTests.length = 0;
+        registeredBeforeEach.length = 0;
+        registeredAfterEach.length = 0;
+        emit("TESTSPECTRA_SUITE_END", JSON.stringify({ file: specPath, passed, failed }));
+        return { passed, failed };
+      }
+    };
+    globalThis["__SPECTRA_MOBILE_RUNNER__"] = mobileRunner;
+  }
+});
+
+// ../../core/worker-runtime/src/drivers/driver_context.ts
+function setActiveDriver(driver) {
+  activeDriver = driver;
+}
+function getActiveDriver() {
+  if (!activeDriver) {
+    throw new Error("No active driver bound to worker runtime");
+  }
+  return activeDriver;
+}
+var activeDriver;
+var init_driver_context = __esm({
+  "../../core/worker-runtime/src/drivers/driver_context.ts"() {
+    "use strict";
+    activeDriver = null;
+  }
+});
+
+// ../../core/worker-runtime/src/harness/config.ts
+function getWorkerConfig() {
+  if (currentConfig) {
+    return currentConfig;
+  }
+  if (globalThis.__TESTSPECTRA_CONFIG__) {
+    currentConfig = globalThis.__TESTSPECTRA_CONFIG__;
+    return currentConfig;
+  }
+  if (typeof process !== "undefined" && process.env?.TESTSPECTRA_CONFIG) {
+    try {
+      currentConfig = JSON.parse(process.env.TESTSPECTRA_CONFIG);
+      return currentConfig;
+    } catch {
+    }
+  }
+  currentConfig = {
+    rootDir: typeof process !== "undefined" ? process.cwd() : "",
+    testFilePath: "",
+    activePlatform: DEFAULT_WORKER_CONFIG.activePlatform,
+    configuredBaseUrl: DEFAULT_WORKER_CONFIG.configuredBaseUrl,
+    cdpWsUrl: "",
+    driverServerUrl: DEFAULT_WORKER_CONFIG.driverServerUrl,
+    manifest: {
+      page_objects: [],
+      fixtures: [],
+      steps: [],
+      actions: [],
+      global_hooks: [],
+      suite_hooks: {}
+    }
+  };
+  return currentConfig;
+}
+var DEFAULT_WORKER_CONFIG, currentConfig;
+var init_config = __esm({
+  "../../core/worker-runtime/src/harness/config.ts"() {
+    "use strict";
+    DEFAULT_WORKER_CONFIG = {
+      activePlatform: "web",
+      configuredBaseUrl: "http://localhost:3000",
+      driverServerUrl: "tcp://127.0.0.1:8200",
+      defaultElementWaitMs: 5e3,
+      defaultNavigationWaitMs: 1e4,
+      defaultPollIntervalMs: 20,
+      defaultReadyPollIntervalMs: 50
+    };
+    currentConfig = null;
+  }
+});
+
+// ../../core/worker-runtime/src/harness/reporter.ts
+function recordDuration(label, category, durationMs, extra) {
+  if (activeDurationSink) {
+    activeDurationSink(label, category, durationMs, extra);
+  }
+}
+function getImplicitWaitMs() {
+  const config = getWorkerConfig();
+  return config.implicitWaitMs ?? DEFAULT_WORKER_CONFIG.defaultElementWaitMs;
+}
+function getAssertionTimeoutMs() {
+  return Math.min(getImplicitWaitMs(), 2e3);
+}
+function emitEvent(tag, payload) {
+  console.log(`[${tag}] ${payload}`);
+}
+async function trackStep(category, payloadObj, fn) {
+  const config = getWorkerConfig();
+  const currentTest = globalThis.__CURRENT_TEST_TITLE__ || globalThis.__CURRENT_TEST_ID__ || "";
+  const workerId = globalThis.__TESTSPECTRA_WORKER_ID__;
+  if (currentTest && !payloadObj.test) payloadObj.test = currentTest;
+  if (workerId !== void 0 && payloadObj.workerId === void 0) payloadObj.workerId = workerId;
+  const payload = JSON.stringify(payloadObj);
+  emitEvent("TESTSPECTRA_STEP_START", payload);
+  const start = Date.now();
+  try {
+    const res = await fn();
+    const duration = Date.now() - start;
+    emitEvent("TESTSPECTRA_STEP_PASS", `${payload} (${duration}ms)`);
+    recordDuration(`step:${payloadObj.key}`, category, duration, { test: currentTest, target: payloadObj.target });
+    const delay = config.stepDelayMs || 0;
+    if (delay > 0) {
+      await new Promise((r) => setTimeout(r, delay));
+    }
+    return res;
+  } catch (err) {
+    const duration = Date.now() - start;
+    emitEvent("TESTSPECTRA_STEP_FAIL", `${payload} (${duration}ms)`);
+    recordDuration(`step:${payloadObj.key}`, category, duration, {
+      test: currentTest,
+      target: payloadObj.target,
+      failed: true
+    });
+    emitEvent("TESTSPECTRA_TEST_ERROR", err?.message || String(err));
+    throw err;
+  }
+}
+async function pollCondition(fn, timeoutMs, intervalMs = 15) {
+  const effectiveTimeout = timeoutMs ?? getImplicitWaitMs();
+  const start = Date.now();
+  while (Date.now() - start < effectiveTimeout) {
+    try {
+      if (await fn()) return true;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  try {
+    return await fn();
+  } catch {
+    return false;
+  }
+}
+var activeDurationSink;
+var init_reporter = __esm({
+  "../../core/worker-runtime/src/harness/reporter.ts"() {
+    "use strict";
+    init_config();
+    activeDurationSink = null;
+  }
+});
+
+// ../../core/worker-runtime/src/dsl/assertions.ts
+function createElementAssertions(selector, index, state) {
+  const driver = () => getActiveDriver();
+  const selectorText4 = typeof selector === "string" ? selector : selector.selector;
+  async function shouldBeVisible(options) {
+    return trackStep("assertion", { type: "assertion", key: "be.visible", target: selector, args: [] }, async () => {
+      const ok = await pollCondition(() => state.isVisible(), options?.timeoutMs ?? getAssertionTimeoutMs());
+      if (!ok) throw new Error(`Expected element "${selectorText4}" to be visible`);
+    });
+  }
+  async function shouldNotBeVisible(options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.be.visible", target: selector, args: [] },
+      async () => {
+        const ok = await pollCondition(
+          async () => !await state.isVisible(),
+          options?.timeoutMs ?? getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText4}" not to be visible`);
+      }
+    );
+  }
+  async function shouldExist(options) {
+    return trackStep("assertion", { type: "assertion", key: "exist", target: selector, args: [] }, async () => {
+      const ok = await pollCondition(() => state.isExisting(), options?.timeoutMs ?? getAssertionTimeoutMs());
+      if (!ok) throw new Error(`Expected element "${selectorText4}" to exist in DOM`);
+    });
+  }
+  async function shouldNotExist(options) {
+    return trackStep("assertion", { type: "assertion", key: "not.exist", target: selector, args: [] }, async () => {
+      const ok = await pollCondition(
+        async () => !await state.isExisting(),
+        options?.timeoutMs ?? getAssertionTimeoutMs()
+      );
+      if (!ok) throw new Error(`Expected element "${selectorText4}" not to exist in DOM`);
+    });
+  }
+  async function shouldBeEnabled(options) {
+    return trackStep("assertion", { type: "assertion", key: "be.enabled", target: selector, args: [] }, async () => {
+      const ok = await pollCondition(() => state.isEnabled(), options?.timeoutMs ?? getAssertionTimeoutMs());
+      if (!ok) throw new Error(`Expected element "${selectorText4}" to be enabled`);
+    });
+  }
+  async function shouldBeDisabled(options) {
+    return trackStep("assertion", { type: "assertion", key: "be.disabled", target: selector, args: [] }, async () => {
+      const ok = await pollCondition(
+        async () => !await state.isEnabled(),
+        options?.timeoutMs ?? getAssertionTimeoutMs()
+      );
+      if (!ok) throw new Error(`Expected element "${selectorText4}" to be disabled`);
+    });
+  }
+  async function shouldBeClickable(options) {
+    return trackStep("assertion", { type: "assertion", key: "be.clickable", target: selector, args: [] }, async () => {
+      const ok = await pollCondition(
+        () => driver().isClickable(selector, index),
+        options?.timeoutMs ?? getAssertionTimeoutMs()
+      );
+      if (!ok) throw new Error(`Expected element "${selectorText4}" to be clickable`);
+    });
+  }
+  async function shouldNotBeClickable(options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.be.clickable", target: selector, args: [] },
+      async () => {
+        const ok = await pollCondition(
+          async () => !await driver().isClickable(selector, index),
+          options?.timeoutMs ?? getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText4}" not to be clickable`);
+      }
+    );
+  }
+  async function shouldBeChecked(options) {
+    return trackStep("assertion", { type: "assertion", key: "be.checked", target: selector, args: [] }, async () => {
+      const ok = await pollCondition(() => state.isChecked(), options?.timeoutMs ?? getAssertionTimeoutMs());
+      if (!ok) throw new Error(`Expected element "${selectorText4}" to be checked`);
+    });
+  }
+  async function shouldNotBeChecked(options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.be.checked", target: selector, args: [] },
+      async () => {
+        const ok = await pollCondition(
+          async () => !await state.isChecked(),
+          options?.timeoutMs ?? getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText4}" not to be checked`);
+      }
+    );
+  }
+  async function shouldBeFocused(options) {
+    return trackStep("assertion", { type: "assertion", key: "be.focused", target: selector, args: [] }, async () => {
+      const ok = await pollCondition(() => state.isFocused(), options?.timeoutMs ?? getAssertionTimeoutMs());
+      if (!ok) throw new Error(`Expected element "${selectorText4}" to be focused`);
+    });
+  }
+  async function shouldNotBeFocused(options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.be.focused", target: selector, args: [] },
+      async () => {
+        const ok = await pollCondition(
+          async () => !await state.isFocused(),
+          options?.timeoutMs ?? getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText4}" not to be focused`);
+      }
+    );
+  }
+  async function shouldHaveValue(value, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "have.value", target: selector, args: [value] },
+      async () => {
+        let actual = "";
+        const ok = await pollCondition(async () => {
+          actual = await state.getValue();
+          return actual === String(value);
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText4}" to have value "${value}", but got "${actual}"`);
+      }
+    );
+  }
+  async function shouldNotHaveValue(value, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.have.value", target: selector, args: [value] },
+      async () => {
+        const ok = await pollCondition(async () => {
+          const actual = await state.getValue();
+          return actual !== String(value);
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText4}" not to have value "${value}"`);
+      }
+    );
+  }
+  async function shouldContainValue(value, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "contain.value", target: selector, args: [value] },
+      async () => {
+        let actual = "";
+        const ok = await pollCondition(async () => {
+          actual = await state.getValue();
+          return actual.includes(String(value));
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText4}" to contain value "${value}", but got "${actual}"`);
+      }
+    );
+  }
+  async function shouldNotContainValue(value, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.contain.value", target: selector, args: [value] },
+      async () => {
+        const ok = await pollCondition(async () => {
+          const actual = await state.getValue();
+          return !actual.includes(String(value));
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText4}" not to contain value "${value}"`);
+      }
+    );
+  }
+  async function shouldHaveText(expected, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "have.text", target: selector, args: [expected] },
+      async () => {
+        let actual = "";
+        const ok = await pollCondition(async () => {
+          actual = await state.getText();
+          if (expected instanceof RegExp) return expected.test(actual);
+          return actual === String(expected) || actual.trim() === String(expected).trim();
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) {
+          if (expected instanceof RegExp)
+            throw new Error(`Expected element "${selectorText4}" text to match ${expected}, but got "${actual}"`);
+          throw new Error(`Expected element "${selectorText4}" to have text "${expected}", but got "${actual}"`);
+        }
+      }
+    );
+  }
+  async function shouldNotHaveText(expected, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.have.text", target: selector, args: [expected] },
+      async () => {
+        let actual = "";
+        const ok = await pollCondition(async () => {
+          if (!await state.isExisting()) return false;
+          actual = await state.getText();
+          if (expected instanceof RegExp) return !expected.test(actual);
+          return actual !== String(expected) && actual.trim() !== String(expected).trim();
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) {
+          if (expected instanceof RegExp)
+            throw new Error(`Expected element "${selectorText4}" text not to match ${expected}`);
+          throw new Error(`Expected element "${selectorText4}" not to have text "${expected}"`);
+        }
+      }
+    );
+  }
+  async function shouldContainText(substring, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "contain.text", target: selector, args: [substring] },
+      async () => {
+        let actual = "";
+        const ok = await pollCondition(async () => {
+          actual = await state.getText();
+          return actual.includes(String(substring));
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok)
+          throw new Error(`Expected element "${selectorText4}" to contain text "${substring}", but got "${actual}"`);
+      }
+    );
+  }
+  async function shouldNotContainText(substring, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.contain.text", target: selector, args: [substring] },
+      async () => {
+        const ok = await pollCondition(async () => {
+          const actual = await state.getText();
+          return !actual.includes(String(substring));
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText4}" not to contain text "${substring}"`);
+      }
+    );
+  }
+  async function shouldHaveClass(className, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "have.class", target: selector, args: [className] },
+      async () => {
+        const ok = await pollCondition(
+          () => driver().hasClass(selector, className, index),
+          options?.timeoutMs ?? getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText4}" to have class "${className}"`);
+      }
+    );
+  }
+  async function shouldNotHaveClass(className, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.have.class", target: selector, args: [className] },
+      async () => {
+        const ok = await pollCondition(
+          async () => !await driver().hasClass(selector, className, index),
+          options?.timeoutMs ?? getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText4}" not to have class "${className}"`);
+      }
+    );
+  }
+  async function shouldHaveAttribute(name, value, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "have.attr", target: selector, args: value !== void 0 ? [name, value] : [name] },
+      async () => {
+        let actual = null;
+        const ok = await pollCondition(async () => {
+          actual = await state.getAttribute(name);
+          if (value !== void 0) return actual === String(value);
+          return actual !== null;
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) {
+          if (value !== void 0)
+            throw new Error(
+              `Expected element "${selectorText4}" to have attribute "${name}" = "${value}", but got "${actual}"`
+            );
+          throw new Error(`Expected element "${selectorText4}" to have attribute "${name}"`);
+        }
+      }
+    );
+  }
+  async function shouldNotHaveAttribute(name, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.have.attr", target: selector, args: [name] },
+      async () => {
+        const ok = await pollCondition(async () => {
+          const actual = await state.getAttribute(name);
+          return actual === null;
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText4}" not to have attribute "${name}"`);
+      }
+    );
+  }
+  async function shouldHaveCss(property, value, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "have.css", target: selector, args: [property, value] },
+      async () => {
+        const norm = (v) => String(v ?? "").replace(/\s+/g, "").replace(/rgba\((.+?),1\)/, "rgb($1)").toLowerCase();
+        let actualCss = "";
+        const ok = await pollCondition(async () => {
+          const css = await state.getCSSProperty(property);
+          actualCss = css.value;
+          return norm(actualCss) === norm(value);
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok)
+          throw new Error(
+            `Expected element "${selectorText4}" to have CSS "${property}" = "${value}", but got "${actualCss}"`
+          );
+      }
+    );
+  }
+  async function shouldNotHaveCss(property, value, options) {
+    return trackStep(
+      "assertion",
+      { type: "assertion", key: "not.have.css", target: selector, args: [property, value] },
+      async () => {
+        const norm = (v) => String(v ?? "").replace(/\s+/g, "").replace(/rgba\((.+?),1\)/, "rgb($1)").toLowerCase();
+        const ok = await pollCondition(async () => {
+          const css = await state.getCSSProperty(property);
+          return norm(css.value) !== norm(value);
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText4}" not to have CSS "${property}" = "${value}"`);
+      }
+    );
+  }
+  return {
+    shouldBeVisible,
+    shouldNotBeVisible,
+    shouldExist,
+    shouldNotExist,
+    shouldBeEnabled,
+    shouldBeDisabled,
+    shouldBeClickable,
+    shouldNotBeClickable,
+    shouldBeChecked,
+    shouldNotBeChecked,
+    shouldBeFocused,
+    shouldNotBeFocused,
+    shouldHaveValue,
+    shouldNotHaveValue,
+    shouldContainValue,
+    shouldNotContainValue,
+    shouldHaveText,
+    shouldNotHaveText,
+    shouldContainText,
+    shouldNotContainText,
+    shouldHaveClass,
+    shouldNotHaveClass,
+    shouldHaveAttribute,
+    shouldNotHaveAttribute,
+    shouldHaveCss,
+    shouldNotHaveCss
+  };
+}
+var init_assertions = __esm({
+  "../../core/worker-runtime/src/dsl/assertions.ts"() {
+    "use strict";
+    init_driver_context();
+    init_reporter();
+  }
+});
+
+// ../../core/worker-runtime/src/dsl/element_state.ts
+function createElementState(selector, index) {
+  const driver = () => getActiveDriver();
+  const selectorText4 = typeof selector === "string" ? selector : selector.selector;
+  async function getText() {
+    return await driver().getText(selector, index);
+  }
+  async function getValue() {
+    return await driver().getValue(selector, index);
+  }
+  async function isDisplayed() {
+    return await driver().isDisplayed(selector, index);
+  }
+  async function isVisible() {
+    return await isDisplayed();
+  }
+  async function isExisting() {
+    return await driver().isExisting(selector, index);
+  }
+  async function isEnabled() {
+    return await driver().isEnabled(selector, index);
+  }
+  async function isClickable() {
+    return await driver().isClickable(selector, index);
+  }
+  async function isSelected() {
+    return await driver().isSelected(selector, index);
+  }
+  async function isChecked() {
+    return await isSelected();
+  }
+  async function isFocused() {
+    return await driver().isFocused(selector, index);
+  }
+  async function getAttribute(name) {
+    return await driver().getAttribute(selector, name, index);
+  }
+  async function getCSSProperty(name) {
+    return await driver().getCSSProperty(selector, name, index);
+  }
+  async function waitForElement(timeoutMs) {
+    const waitTimeout = timeoutMs ?? getImplicitWaitMs();
+    const ok = await pollCondition(async () => driver().isExisting(selector, index), waitTimeout);
+    if (ok) return true;
+    throw new Error("Element not found: " + JSON.stringify(selectorText4));
+  }
+  async function waitForDisplayed(opts = {}) {
+    const timeout = opts.timeout || 5e3;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      if (await driver().isDisplayed(selector, index)) return true;
+      await new Promise((r) => setTimeout(r, 20));
+    }
+    throw new Error(`Element ${selectorText4} not displayed after ${timeout}ms`);
+  }
+  return {
+    getText,
+    getValue,
+    isDisplayed,
+    isVisible,
+    isExisting,
+    isEnabled,
+    isClickable,
+    isSelected,
+    isChecked,
+    isFocused,
+    getAttribute,
+    getCSSProperty,
+    waitForElement,
+    waitForDisplayed
+  };
+}
+var init_element_state = __esm({
+  "../../core/worker-runtime/src/dsl/element_state.ts"() {
+    "use strict";
+    init_driver_context();
+    init_reporter();
+  }
+});
+
+// ../../core/worker-runtime/src/dsl/element_proxy.ts
+function selectorText(s) {
+  return typeof s === "string" ? s : s.selector;
+}
+function toScopedSelector(selector, index) {
+  return typeof selector === "string" ? { selector, index, parent: void 0 } : selector;
+}
+function createElementProxy(selector, index = null) {
+  const selectorTextValue = selectorText(selector);
+  const resolvedIndex = typeof selector === "string" ? index : selector.index;
+  const actions = createElementActions(selector, index);
+  const state = createElementState(selector, index);
+  const assertions = createElementAssertions(selector, index, state);
+  return {
+    selector: selectorTextValue,
+    index: resolvedIndex,
+    ...actions,
+    ...state,
+    ...assertions,
+    get(childSelector, childIndex = null) {
+      return createElementProxy(
+        { selector: childSelector, index: childIndex, parent: toScopedSelector(selector, index) },
+        null
+      );
+    },
+    getAll(childSelector) {
+      return createCollectionProxy({
+        selector: childSelector,
+        index: null,
+        parent: toScopedSelector(selector, index)
+      });
+    }
+  };
+}
+function createCollectionProxy(selector) {
+  const driver = () => getActiveDriver();
+  const selectorTextValue = selectorText(selector);
+  const withIndex = (idx) => typeof selector === "string" ? [selector, idx] : [{ ...selector, index: idx }, null];
+  const collectionProxy = {
+    selector: selectorTextValue,
+    async count() {
+      return await driver().count(selector);
+    },
+    get length() {
+      return this.count();
+    },
+    first() {
+      return createElementProxy(...withIndex(0));
+    },
+    last() {
+      return createElementProxy(...withIndex(-1));
+    },
+    nth(index) {
+      return createElementProxy(...withIndex(index));
+    },
+    async shouldHaveLength(expected, options) {
+      return trackStep(
+        "assertion",
+        { type: "assertion", key: "have.length", target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await pollCondition(async () => {
+            actual = await this.count();
+            return actual === expected;
+          }, options?.timeoutMs ?? getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" count to equal ${expected}, but got ${actual}`);
+          }
+        }
+      );
+    },
+    async shouldNotHaveLength(expected, options) {
+      return trackStep(
+        "assertion",
+        { type: "assertion", key: "not.have.length", target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await pollCondition(async () => {
+            actual = await this.count();
+            return actual !== expected;
+          }, options?.timeoutMs ?? getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" count not to equal ${expected}`);
+          }
+        }
+      );
+    },
+    async shouldHaveLengthGreaterThan(expected, options) {
+      return trackStep(
+        "assertion",
+        { type: "assertion", key: "have.length.greaterThan", target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await pollCondition(async () => {
+            actual = await this.count();
+            return actual > expected;
+          }, options?.timeoutMs ?? getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(
+              `Expected collection "${selectorTextValue}" count to be greater than ${expected}, but got ${actual}`
+            );
+          }
+        }
+      );
+    },
+    async shouldHaveLengthLessThan(expected, options) {
+      return trackStep(
+        "assertion",
+        { type: "assertion", key: "have.length.lessThan", target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await pollCondition(async () => {
+            actual = await this.count();
+            return actual < expected;
+          }, options?.timeoutMs ?? getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(
+              `Expected collection "${selectorTextValue}" count to be less than ${expected}, but got ${actual}`
+            );
+          }
+        }
+      );
+    },
+    async shouldBeEmpty(options) {
+      return trackStep("assertion", { type: "assertion", key: "be.empty", target: selector, args: [] }, async () => {
+        let actual = 0;
+        const ok = await pollCondition(async () => {
+          actual = await this.count();
+          return actual === 0;
+        }, options?.timeoutMs ?? getAssertionTimeoutMs());
+        if (!ok) {
+          throw new Error(`Expected collection "${selectorTextValue}" to be empty, but got ${actual}`);
+        }
+      });
+    },
+    async shouldNotBeEmpty(options) {
+      return trackStep(
+        "assertion",
+        { type: "assertion", key: "not.be.empty", target: selector, args: [] },
+        async () => {
+          let actual = 0;
+          const ok = await pollCondition(async () => {
+            actual = await this.count();
+            return actual > 0;
+          }, options?.timeoutMs ?? getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" not to be empty`);
+          }
+        }
+      );
+    }
+  };
+  return collectionProxy;
+}
+function resolveTargetProxy(target) {
+  if (typeof target === "string") {
+    return createElementProxy(target, null);
+  }
+  if (target && typeof target === "object" && "selector" in target) {
+    return target;
+  }
+  throw new Error(`Invalid element target: ${String(target)}`);
+}
+var init_element_proxy = __esm({
+  "../../core/worker-runtime/src/dsl/element_proxy.ts"() {
+    "use strict";
+    init_driver_context();
+    init_reporter();
+    init_element_actions();
+    init_assertions();
+    init_element_state();
+  }
+});
+
+// ../../core/worker-runtime/src/dsl/element_actions.ts
+function selectorText2(selector) {
+  return typeof selector === "string" ? selector : selector.selector;
+}
+function createElementActions(selector, index) {
+  const driver = () => getActiveDriver();
+  async function click(_options) {
+    return trackStep("action", { type: "action", key: "click", target: selector, args: [] }, async () => {
+      await driver().click(selector, index);
+    });
+  }
+  async function doubleClick() {
+    return trackStep("action", { type: "action", key: "doubleClick", target: selector, args: [] }, async () => {
+      await driver().doubleClick(selector, index);
+    });
+  }
+  async function rightClick() {
+    return trackStep("action", { type: "action", key: "rightClick", target: selector, args: [] }, async () => {
+      await driver().rightClick(selector, index);
+    });
+  }
+  async function setValue(value) {
+    return trackStep("action", { type: "action", key: "type", target: selector, args: [value] }, async () => {
+      await driver().setValue(selector, value, index);
+    });
+  }
+  async function type(value, options) {
+    if (options?.clearFirst) {
+      await clearValue();
+    }
+    await setValue(value);
+  }
+  async function clearValue() {
+    return trackStep("action", { type: "action", key: "clear", target: selector, args: [] }, async () => {
+      await driver().clearValue(selector, index);
+    });
+  }
+  async function clear() {
+    await clearValue();
+  }
+  async function select(option) {
+    return trackStep("action", { type: "action", key: "select", target: selector, args: [option] }, async () => {
+      await driver().select(selector, option, index);
+    });
+  }
+  async function selectByVisibleText(text) {
+    await select(text);
+  }
+  async function hover() {
+    return trackStep("action", { type: "action", key: "hover", target: selector, args: [] }, async () => {
+      await driver().hover(selector, index);
+    });
+  }
+  async function focus() {
+    return trackStep("action", { type: "action", key: "focus", target: selector, args: [] }, async () => {
+      await driver().focus(selector, index);
+    });
+  }
+  async function blur() {
+    return trackStep("action", { type: "action", key: "blur", target: selector, args: [] }, async () => {
+      await driver().blur(selector, index);
+    });
+  }
+  async function waitForElementRemoved(timeoutMs) {
+    return trackStep(
+      "action",
+      { type: "action", key: "waitForElementRemoved", target: selector, args: [timeoutMs ?? 5e3] },
+      async () => {
+        const ok = await pollCondition(async () => !await driver().isExisting(selector, index), timeoutMs ?? 5e3);
+        if (!ok) throw new Error("Element still exists after timeout: " + JSON.stringify(selectorText2(selector)));
+      }
+    );
+  }
+  async function waitForUndisplayed(opts) {
+    return trackStep(
+      "action",
+      { type: "action", key: "waitForUndisplayed", target: selector, args: [opts?.timeout ?? 5e3] },
+      async () => {
+        const ok = await pollCondition(
+          async () => !await driver().isDisplayed(selector, index),
+          opts?.timeout ?? 5e3
+        );
+        if (!ok) throw new Error("Element still displayed after timeout: " + JSON.stringify(selectorText2(selector)));
+      }
+    );
+  }
+  async function waitForClickable(opts) {
+    return trackStep(
+      "action",
+      { type: "action", key: "waitForClickable", target: selector, args: [opts?.timeout ?? 5e3] },
+      async () => {
+        return await pollCondition(async () => await driver().isClickable(selector, index), opts?.timeout ?? 5e3);
+      }
+    );
+  }
+  async function getBounds() {
+    return trackStep("action", { type: "action", key: "getBounds", target: selector, args: [] }, async () => {
+      return await driver().getBounds(selector, index);
+    });
+  }
+  function indexedBase() {
+    const base = typeof selector === "string" ? selector : selector.selector;
+    const baseIndex = typeof selector === "string" ? index : selector.index;
+    if (baseIndex === null || baseIndex === void 0) return base;
+    return `${base}::nth(${baseIndex})`;
+  }
+  function parent() {
+    return createElementProxy(indexedBase() + "::parent", null);
+  }
+  async function closest(targetSelector) {
+    return trackStep(
+      "action",
+      { type: "action", key: "closest", target: selector, args: [targetSelector] },
+      async () => {
+        const exists = await driver().closest(selector, targetSelector, index);
+        if (!exists) return null;
+        return createElementProxy(`${indexedBase()}::closest(${targetSelector})`, null);
+      }
+    );
+  }
+  function children(targetSelector) {
+    return createCollectionProxy(`${indexedBase()}::children(${targetSelector ?? ""})`);
+  }
+  function siblings(targetSelector) {
+    return createCollectionProxy(`${indexedBase()}::siblings(${targetSelector ?? ""})`);
+  }
+  function next(targetSelector) {
+    return createElementProxy(`${indexedBase()}::next(${targetSelector ?? ""})`, null);
+  }
+  async function moveTo() {
+    await hover();
+  }
+  async function dragDrop(target) {
+    const destSelector = typeof target === "string" ? target : target?.selector || String(target);
+    return trackStep(
+      "action",
+      { type: "action", key: "dragDrop", target: selector, args: [destSelector] },
+      async () => {
+        await driver().dragDrop(selector, destSelector, index);
+      }
+    );
+  }
+  async function dragAndDrop(target) {
+    await dragDrop(target);
+  }
+  async function longPress(options) {
+    const duration = typeof options === "number" ? options : options?.duration || 1e3;
+    return trackStep("action", { type: "action", key: "longPress", target: selector, args: [duration] }, async () => {
+      await driver().longPress(selector, duration, index);
+    });
+  }
+  async function scrollIntoView() {
+    return trackStep("action", { type: "action", key: "scrollIntoView", target: selector, args: [] }, async () => {
+      await driver().scrollIntoView(selector, index);
+    });
+  }
+  async function upload(files) {
+    return trackStep("action", { type: "action", key: "upload", target: selector, args: [files] }, async () => {
+      await driver().upload(selector, files, index);
+    });
+  }
+  async function uploadFile(files) {
+    await upload(files);
+  }
+  return {
+    click,
+    doubleClick,
+    rightClick,
+    setValue,
+    type,
+    clearValue,
+    clear,
+    select,
+    selectByVisibleText,
+    hover,
+    focus,
+    blur,
+    waitForElementRemoved,
+    waitForUndisplayed,
+    waitForClickable,
+    getBounds,
+    parent,
+    closest,
+    children,
+    siblings,
+    next,
+    moveTo,
+    dragDrop,
+    dragAndDrop,
+    longPress,
+    scrollIntoView,
+    upload,
+    uploadFile
+  };
+}
+var init_element_actions = __esm({
+  "../../core/worker-runtime/src/dsl/element_actions.ts"() {
+    "use strict";
+    init_driver_context();
+    init_reporter();
+    init_element_proxy();
+  }
+});
+
+// ../../core/worker-runtime/src/dsl/keyboard.ts
+var init_keyboard = __esm({
+  "../../core/worker-runtime/src/dsl/keyboard.ts"() {
+    "use strict";
+  }
+});
+
+// ../../core/worker-runtime/src/dsl/mock_intercept.ts
+function matchesUrlPattern(pattern, url) {
+  if (!pattern || pattern === "*" || pattern === "**" || pattern === "ALL") {
+    return true;
+  }
+  if (pattern.startsWith("/") && pattern.endsWith("/")) {
+    try {
+      const regex = new RegExp(pattern.slice(1, -1));
+      return regex.test(url);
+    } catch {
+    }
+  }
+  if (pattern.includes("*")) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    try {
+      const regex = new RegExp(escaped, "i");
+      return regex.test(url);
+    } catch {
+    }
+  }
+  return url.toLowerCase().includes(pattern.toLowerCase());
+}
+function createMockHandle(rule) {
+  const handle = {
+    respondWith: async (newFixture, newOptions = {}) => {
+      const newObj = newFixture;
+      rule.response = newObj && newObj.body !== void 0 ? newObj.body : newFixture;
+      if (newOptions.statusCode || newObj && newObj.statusCode) {
+        rule.statusCode = newOptions.statusCode || newObj?.statusCode || 200;
+      }
+      if (newOptions.headers || newObj && newObj.headers) {
+        rule.headers = newOptions.headers || newObj?.headers;
+      }
+      if (newOptions.delayMs !== void 0 || newObj && newObj.delayMs !== void 0) {
+        rule.delayMs = newOptions.delayMs ?? newObj?.delayMs;
+      }
+      rule.aborted = false;
+    },
+    respondOnce: async (newFixture, newOptions = {}) => {
+      const newObj = newFixture;
+      const resp = newObj && newObj.body !== void 0 ? newObj.body : newFixture;
+      const statusCode = newOptions.statusCode || newObj && newObj.statusCode || rule.statusCode || 200;
+      const headers = newOptions.headers || newObj && newObj.headers || rule.headers;
+      const delayMs = newOptions.delayMs ?? (newObj && newObj.delayMs) ?? rule.delayMs;
+      rule.respondOnceQueue.push({ response: resp, statusCode, headers, delayMs });
+      rule.aborted = false;
+    },
+    abort: async (errorCode = "Failed") => {
+      rule.aborted = true;
+      rule.abortReason = errorCode;
+    },
+    waitForCall: async (options = {}) => {
+      const targetCount = options.count ?? 1;
+      const timeoutMs = options.timeout ?? 5e3;
+      if (rule.calls.length >= targetCount) {
+        return rule.calls[targetCount - 1];
+      }
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          const idx = rule.waitResolvers.findIndex((w) => w.resolve === resolve);
+          if (idx !== -1) rule.waitResolvers.splice(idx, 1);
+          reject(
+            new Error(
+              `Spectra.intercept waitForCall timed out after ${timeoutMs}ms (expected at least ${targetCount} call(s), received ${rule.calls.length})`
+            )
+          );
+        }, timeoutMs);
+        rule.waitResolvers.push({
+          count: targetCount,
+          resolve: (req) => {
+            clearTimeout(timer);
+            resolve(req);
+          }
+        });
+      });
+    }
+  };
+  const getCount = () => rule.callCount;
+  handle.callCount = Object.assign(getCount, {
+    valueOf: () => rule.callCount,
+    [Symbol.toPrimitive]: () => rule.callCount
+  });
+  Object.defineProperty(handle, "calls", {
+    get: () => rule.calls,
+    enumerable: true
+  });
+  return handle;
+}
+function parseMockRule(patternOrOptions, maybeMethodOrHandler, maybeFixture, maybeOptions) {
+  let pattern;
+  let method;
+  let response;
+  let statusCode;
+  let headers;
+  let delayMs;
+  if (typeof patternOrOptions === "object" && patternOrOptions !== null) {
+    pattern = patternOrOptions.url || patternOrOptions.pattern || "*";
+    method = (patternOrOptions.method || "GET").toUpperCase();
+    response = patternOrOptions.response !== void 0 ? patternOrOptions.response : typeof maybeMethodOrHandler === "object" && maybeMethodOrHandler !== null ? maybeMethodOrHandler : maybeFixture;
+    statusCode = patternOrOptions.statusCode || maybeOptions && maybeOptions.statusCode || 200;
+    headers = patternOrOptions.headers || maybeOptions && maybeOptions.headers;
+    delayMs = patternOrOptions.delayMs ?? (maybeOptions && maybeOptions.delayMs);
+  } else {
+    pattern = String(patternOrOptions || "*");
+    if (typeof maybeMethodOrHandler === "string" && ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "ALL"].includes(maybeMethodOrHandler.toUpperCase())) {
+      method = maybeMethodOrHandler.toUpperCase();
+      const fixtureObj = maybeFixture;
+      response = fixtureObj && fixtureObj.body !== void 0 ? fixtureObj.body : maybeFixture;
+      statusCode = maybeOptions && maybeOptions.statusCode || fixtureObj && fixtureObj.statusCode || 200;
+      headers = maybeOptions && maybeOptions.headers || fixtureObj && fixtureObj.headers;
+      delayMs = (maybeOptions && maybeOptions.delayMs) ?? (fixtureObj && fixtureObj.delayMs);
+    } else {
+      method = "GET";
+      const fixtureObj = maybeMethodOrHandler;
+      response = fixtureObj && fixtureObj.body !== void 0 ? fixtureObj.body : maybeMethodOrHandler;
+      statusCode = maybeFixture && maybeFixture.statusCode || fixtureObj && fixtureObj.statusCode || 200;
+      headers = maybeFixture && maybeFixture.headers || fixtureObj && fixtureObj.headers;
+      delayMs = (maybeFixture && maybeFixture.delayMs) ?? (fixtureObj && fixtureObj.delayMs);
+    }
+  }
+  return {
+    pattern,
+    method,
+    response,
+    statusCode,
+    headers,
+    delayMs,
+    callCount: 0,
+    respondOnceQueue: [],
+    calls: [],
+    waitResolvers: []
+  };
+}
+function findMatchingRule(rules, url, method) {
+  for (const rule of rules) {
+    if (matchesUrlPattern(rule.pattern, url)) {
+      if (!rule.method || rule.method === "ALL" || rule.method.toUpperCase() === method.toUpperCase()) {
+        return rule;
+      }
+    }
+  }
+  return null;
+}
+function recordMockCall(rule, request) {
+  rule.calls.push(request);
+  rule.callCount++;
+  for (let i = rule.waitResolvers.length - 1; i >= 0; i--) {
+    const w = rule.waitResolvers[i];
+    if (rule.callCount >= w.count) {
+      rule.waitResolvers.splice(i, 1);
+      w.resolve(request);
+    }
+  }
+  return request;
+}
+function consumeMockResponse(rule) {
+  if (rule.respondOnceQueue.length > 0) {
+    const queued = rule.respondOnceQueue.shift();
+    return {
+      body: queued.response,
+      statusCode: queued.statusCode || rule.statusCode || 200,
+      headers: { ...rule.headers, ...queued.headers },
+      delayMs: queued.delayMs ?? rule.delayMs
+    };
+  }
+  return {
+    body: rule.response,
+    statusCode: rule.statusCode || 200,
+    headers: { ...rule.headers },
+    delayMs: rule.delayMs
+  };
+}
+function mergeMockResponseHeaders(custom) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(DEFAULT_MOCK_RESPONSE_HEADERS)) {
+    merged.set(k.toLowerCase(), { name: k, value: v });
+  }
+  for (const [k, v] of Object.entries(custom || {})) {
+    merged.set(k.toLowerCase(), { name: k, value: String(v) });
+  }
+  return [...merged.values()];
+}
+function mockResponseBodyText(body) {
+  if (typeof body === "string") return body;
+  if (typeof body === "object" && body !== null) return JSON.stringify(body);
+  return String(body ?? "");
+}
+var DEFAULT_MOCK_RESPONSE_HEADERS;
+var init_mock_intercept = __esm({
+  "../../core/worker-runtime/src/dsl/mock_intercept.ts"() {
+    "use strict";
+    DEFAULT_MOCK_RESPONSE_HEADERS = {
+      "Content-Type": "application/json; charset=utf-8",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+      "Access-Control-Allow-Headers": "*"
+    };
+  }
+});
+
+// ../../core/worker-runtime/src/dsl/selector_resolver.ts
+function parseElementSentinel(selector) {
+  const nth = /^(.*)::nth\((-?\d+)\)$/.exec(selector);
+  if (nth) return { kind: "nth", base: nth[1], arg: nth[2] };
+  const closest = /^(.*)::closest\((.+)\)$/.exec(selector);
+  if (closest) return { kind: "closest", base: closest[1], arg: closest[2] };
+  const children = /^(.*)::children\((.*)\)$/.exec(selector);
+  if (children) return { kind: "children", base: children[1], arg: children[2].trim() || null };
+  const bareChildren = /^(.*)::children$/.exec(selector);
+  if (bareChildren) return { kind: "children", base: bareChildren[1], arg: null };
+  const siblings = /^(.*)::siblings\((.*)\)$/.exec(selector);
+  if (siblings) return { kind: "siblings", base: siblings[1], arg: siblings[2].trim() || null };
+  const bareSiblings = /^(.*)::siblings$/.exec(selector);
+  if (bareSiblings) return { kind: "siblings", base: bareSiblings[1], arg: null };
+  const next = /^(.*)::next\((.*)\)$/.exec(selector);
+  if (next) return { kind: "next", base: next[1], arg: next[2].trim() || null };
+  const bareNext = /^(.*)::next$/.exec(selector);
+  if (bareNext) return { kind: "next", base: bareNext[1], arg: null };
+  const parent = /^(.*)::parent$/.exec(selector);
+  if (parent) return { kind: "parent", base: parent[1] };
+  return null;
+}
+function parseA11ySelector(selector) {
+  const trimmed = selector.trim();
+  if (!trimmed.startsWith("~")) return null;
+  const withoutPrefix = trimmed.slice(1);
+  const bracketIndex = withoutPrefix.indexOf("[");
+  if (bracketIndex !== -1) {
+    return {
+      name: withoutPrefix.slice(0, bracketIndex),
+      chainSuffix: withoutPrefix.slice(bracketIndex)
+    };
+  }
+  return { name: withoutPrefix, chainSuffix: "" };
+}
+var init_selector_resolver = __esm({
+  "../../core/worker-runtime/src/dsl/selector_resolver.ts"() {
+    "use strict";
+  }
+});
+
+// ../../core/worker-runtime/src/dsl/spectra.ts
+function buildSpectra() {
+  const driver = () => getActiveDriver();
+  const spectra2 = {
+    get: (target) => resolveTargetProxy(target),
+    getAll: (selector) => createCollectionProxy(selector),
+    navigate: (url) => driver().navigate(url),
+    back: () => driver().back(),
+    forward: () => driver().forward(),
+    refresh: () => driver().refresh(),
+    setViewport: (width, height) => driver().setViewport(width, height),
+    wait: (ms) => driver().pause(ms),
+    click: async (target, _textOrOptions) => {
+      const el = resolveTargetProxy(target);
+      await el.click();
+    },
+    clickAt: async (x, y) => {
+      await driver().clickAt(x, y);
+    },
+    doubleClick: async (target) => {
+      const el = resolveTargetProxy(target);
+      await el.doubleClick();
+    },
+    rightClick: async (target) => {
+      const el = resolveTargetProxy(target);
+      await el.rightClick();
+    },
+    type: async (target, text, options) => {
+      const el = resolveTargetProxy(target);
+      await el.type(text, options);
+    },
+    clear: async (target) => {
+      const el = resolveTargetProxy(target);
+      await el.clear();
+    },
+    select: async (target, option) => {
+      const el = resolveTargetProxy(target);
+      await el.select(option);
+    },
+    hover: async (target) => {
+      const el = resolveTargetProxy(target);
+      await el.hover();
+    },
+    focus: async (target) => {
+      const el = resolveTargetProxy(target);
+      await el.focus();
+    },
+    blur: async (target) => {
+      const el = resolveTargetProxy(target);
+      await el.blur();
+    },
+    dragDrop: async (source, destination) => {
+      const srcEl = resolveTargetProxy(source);
+      await srcEl.dragDrop(destination);
+    },
+    scrollIntoView: async (target) => {
+      const el = resolveTargetProxy(target);
+      await el.scrollIntoView();
+    },
+    scroll: async (options) => {
+      await driver().scroll(options);
+    },
+    swipe: async (options) => {
+      await driver().swipe(options);
+    },
+    longPress: async (target, options) => {
+      const el = resolveTargetProxy(target);
+      await el.longPress(options);
+    },
+    pressKey: async (key) => {
+      await driver().pressKey(key);
+    },
+    grantPermission: async (name) => {
+      await driver().grantPermission(name);
+    },
+    waitForElement: async (target, timeoutMs) => {
+      const el = resolveTargetProxy(target);
+      await el.waitForElement(timeoutMs);
+    },
+    intercept: async (patternOrOptions, maybeMethodOrHandler, maybeFixture, maybeOptions) => {
+      return await driver().intercept(patternOrOptions, maybeMethodOrHandler, maybeFixture, maybeOptions);
+    },
+    clearMocks: () => {
+      driver().clearMocks();
+    },
+    get browser() {
+      return driver();
+    },
+    get env() {
+      return getWorkerConfig().environmentVariables || {};
+    }
+  };
+  spectra2.registerCommand = (name, command) => {
+    if (typeof command !== "function") {
+      throw new Error(`[TestSpectra] Custom command "${name}" must be a function.`);
+    }
+    if (!VALID_COMMAND_NAME.test(name)) {
+      throw new Error(`[TestSpectra] Invalid custom command name "${name}"; must be a valid identifier.`);
+    }
+    if (RESERVED_COMMAND_NAMES.has(name) || name in spectra2) {
+      throw new Error(`[TestSpectra] Custom command "${name}" collides with a built-in Spectra method.`);
+    }
+    spectra2[name] = command;
+  };
+  spectra2.registerCommands = (commands) => {
+    for (const [name, command] of Object.entries(commands)) {
+      spectra2.registerCommand(name, command);
+    }
+  };
+  return spectra2;
+}
+var RESERVED_COMMAND_NAMES, VALID_COMMAND_NAME;
+var init_spectra = __esm({
+  "../../core/worker-runtime/src/dsl/spectra.ts"() {
+    "use strict";
+    init_driver_context();
+    init_config();
+    init_element_proxy();
+    RESERVED_COMMAND_NAMES = /* @__PURE__ */ new Set(["mount", "unmount", "registerCommand", "registerCommands"]);
+    VALID_COMMAND_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+  }
+});
+
+// ../../core/worker-runtime/src/dsl/index.ts
+var init_dsl = __esm({
+  "../../core/worker-runtime/src/dsl/index.ts"() {
+    "use strict";
+    init_assertions();
+    init_element_actions();
+    init_element_proxy();
+    init_element_state();
+    init_keyboard();
+    init_mock_intercept();
+    init_selector_resolver();
+    init_spectra();
+    init_driver_context();
+  }
+});
+
+// src/bridge/network_patch.ts
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function toAbsoluteUrl(input) {
+  try {
+    if (typeof input === "string") {
+      if (input.startsWith("http://") || input.startsWith("https://") || input.startsWith("file://")) {
+        return input;
+      }
+      return new URL(input, "http://localhost/").href;
+    }
+    if (input instanceof URL) return input.href;
+    if (typeof Request !== "undefined" && input instanceof Request) return input.url;
+  } catch {
+  }
+  return String(input);
+}
+function readMethod(input, init) {
+  if (init?.method) return String(init.method).toUpperCase();
+  try {
+    if (typeof Request !== "undefined" && input instanceof Request && input.method) {
+      return String(input.method).toUpperCase();
+    }
+  } catch {
+  }
+  return "GET";
+}
+function readPostData(input, init) {
+  const body = init?.body;
+  if (typeof body === "string") return body;
+  try {
+    if (typeof Request !== "undefined" && input instanceof Request) return void 0;
+  } catch {
+  }
+  return void 0;
+}
+function buildMockResponse(consumed) {
+  const headerPairs = mergeMockResponseHeaders(consumed.headers);
+  const headers = {};
+  for (const h of headerPairs) headers[h.name] = h.value;
+  return new Response(mockResponseBodyText(consumed.body), { status: consumed.statusCode, headers });
+}
+function getActiveRules() {
+  const external = externalGetRules ? externalGetRules() : [];
+  return [...internalMockRules, ...external];
+}
+async function patchedFetch(origFetch, input, init) {
+  const url = toAbsoluteUrl(input);
+  const method = readMethod(input, init);
+  const rule = findMatchingRule(getActiveRules(), url, method);
+  if (!rule) return origFetch(input, init);
+  const intercepted = {
+    url,
+    method,
+    headers: void 0,
+    postData: readPostData(input, init),
+    timestamp: Date.now()
+  };
+  recordMockCall(rule, intercepted);
+  if (rule.aborted) {
+    throw new TypeError(`Spectra.intercept() aborted ${method} ${url} (${rule.abortReason || "Failed"})`);
+  }
+  const consumed = consumeMockResponse(rule);
+  if (consumed.delayMs && consumed.delayMs > 0) await sleep(consumed.delayMs);
+  return buildMockResponse(consumed);
+}
+function patchXMLHttpRequest() {
+  const OriginalXHR = globalThis.XMLHttpRequest;
+  if (!OriginalXHR) return;
+  function PatchedXHR() {
+    const xhr = new OriginalXHR();
+    let method = "GET";
+    let url = "";
+    const origOpen = OriginalXHR.prototype.open.bind(xhr);
+    const origSend = OriginalXHR.prototype.send.bind(xhr);
+    xhr.open = (m, u, ...rest) => {
+      method = String(m).toUpperCase();
+      url = toAbsoluteUrl(u);
+      const [asyncFlag = true, username, password] = rest;
+      return origOpen(m, u, asyncFlag, username, password);
+    };
+    xhr.send = (body) => {
+      const rule = findMatchingRule(getActiveRules(), url, method);
+      if (!rule) return origSend(body);
+      const intercepted = {
+        url,
+        method,
+        headers: void 0,
+        postData: typeof body === "string" ? body : void 0,
+        timestamp: Date.now()
+      };
+      recordMockCall(rule, intercepted);
+      const fireError = () => {
+        xhr.dispatchEvent?.(new Event("error"));
+      };
+      if (rule.aborted) {
+        setTimeout(fireError, 0);
+        return;
+      }
+      const consumed = consumeMockResponse(rule);
+      const respond2 = () => {
+        const bodyText = mockResponseBodyText(consumed.body);
+        Object.defineProperties(xhr, {
+          status: { value: consumed.statusCode, configurable: true },
+          statusText: {
+            value: consumed.statusCode === 200 ? "OK" : `${consumed.statusCode} Mocked`,
+            configurable: true
+          },
+          responseText: { value: bodyText, configurable: true },
+          response: { value: bodyText, configurable: true },
+          readyState: { value: 4, configurable: true }
+        });
+        xhr.dispatchEvent?.(new Event("readystatechange"));
+        xhr.dispatchEvent?.(new Event("load"));
+        xhr.dispatchEvent?.(new Event("loadend"));
+      };
+      if (consumed.delayMs && consumed.delayMs > 0) setTimeout(respond2, consumed.delayMs);
+      else setTimeout(respond2, 0);
+    };
+    return xhr;
+  }
+  PatchedXHR.prototype = OriginalXHR.prototype;
+  globalThis.XMLHttpRequest = PatchedXHR;
+}
+function registerMockRule(rule) {
+  internalMockRules.push(rule);
+}
+function clearMocks() {
+  internalMockRules = [];
+}
+function ensureNetworkPatch(getRules) {
+  if (getRules) {
+    externalGetRules = getRules;
+  }
+  if (typeof globalThis.fetch === "function") {
+    if (globalThis.fetch !== currentPatchedFetch) {
+      originalFetch = globalThis.fetch;
+      const baseFetch = originalFetch;
+      currentPatchedFetch = (input, init) => patchedFetch(baseFetch, input, init);
+      globalThis.fetch = currentPatchedFetch;
+    }
+  }
+  if (!xhrPatched && typeof globalThis.XMLHttpRequest === "function") {
+    patchXMLHttpRequest();
+    xhrPatched = true;
+  }
+}
+var originalFetch, currentPatchedFetch, xhrPatched, internalMockRules, externalGetRules;
+var init_network_patch = __esm({
+  "src/bridge/network_patch.ts"() {
+    "use strict";
+    init_dsl();
+    originalFetch = null;
+    currentPatchedFetch = null;
+    xhrPatched = false;
+    internalMockRules = [];
+    externalGetRules = null;
+  }
+});
+
+// src/bridge/react_native_driver_bridge.ts
+function selectorText3(target) {
+  return typeof target === "string" ? target : target.selector;
+}
+function pickFromList(list, index) {
+  if (index === null || index === void 0) return list[0] ?? null;
+  if (index >= 0) return list[index] ?? null;
+  return list[list.length + index] ?? null;
+}
+function isTextComponentType(type) {
+  if (typeof type === "string") {
+    const lower = type.toLowerCase();
+    return lower === "text" || lower === "rcttext" || lower === "rctvirtualtext" || lower.endsWith("text");
+  }
+  if (type && typeof type === "object") {
+    return type.displayName === "Text" || type.name === "Text";
+  }
+  return false;
+}
+function nodeMatchesSelector(node, selector) {
+  const trimmed = selector.trim();
+  if (!trimmed) return true;
+  if (trimmed.startsWith("~")) {
+    const parsed = parseA11ySelector(trimmed);
+    const label = parsed ? parsed.name : trimmed.slice(1).trim();
+    const a11y = node.props.accessibilityLabel ?? node.props["aria-label"];
+    return a11y != null && String(a11y).trim() === label;
+  }
+  if (trimmed.startsWith("#")) {
+    const id = trimmed.slice(1).trim();
+    return node.props.testID != null && String(node.props.testID).trim() === id;
+  }
+  if (isTextComponentType(node.type)) {
+    const text = extractText(node);
+    if (text === trimmed || text.includes(trimmed)) return true;
+  }
+  if (typeof node.props.children === "string" && (node.props.children === trimmed || node.props.children.includes(trimmed))) {
+    return true;
+  }
+  if (typeof node.type === "string" && node.type.toLowerCase() === trimmed.toLowerCase()) return true;
+  if (node.type?.displayName === trimmed || node.type?.name === trimmed) return true;
+  return false;
+}
+function collectMatchingNodes(root, selector) {
+  const results = [];
+  function walk(curr) {
+    if (nodeMatchesSelector(curr, selector)) {
+      results.push(curr);
+    }
+    for (const child of curr.children) {
+      walk(child);
+    }
+  }
+  walk(root);
+  return results;
+}
+function resolveSentinelList(raw, parent, root) {
+  const sentinel = parseElementSentinel(raw);
+  if (!sentinel) return void 0;
+  if (sentinel.kind === "nth") {
+    const baseNode = resolveScopedNode(sentinel.base, Number.parseInt(sentinel.arg, 10), root);
+    return baseNode ? [baseNode] : [];
+  }
+  const baseTarget = parent ? { selector: sentinel.base, index: null, parent } : sentinel.base;
+  const base = resolveScopedNode(baseTarget, null, root);
+  if (!base) return [];
+  if (sentinel.kind === "parent") {
+    return base.parent ? [base.parent] : [];
+  }
+  if (sentinel.kind === "closest") {
+    let curr = base.parent;
+    while (curr) {
+      if (nodeMatchesSelector(curr, sentinel.arg)) return [curr];
+      curr = curr.parent;
+    }
+    return [];
+  }
+  if (sentinel.kind === "children") {
+    return base.children.filter((child) => sentinel.arg ? nodeMatchesSelector(child, sentinel.arg) : true);
+  }
+  if (sentinel.kind === "siblings") {
+    const parentNode = base.parent;
+    if (!parentNode) return [];
+    return parentNode.children.filter(
+      (child) => child !== base && (sentinel.arg ? nodeMatchesSelector(child, sentinel.arg) : true)
+    );
+  }
+  if (sentinel.kind === "next") {
+    const parentNode = base.parent;
+    if (!parentNode) return [];
+    const idx = parentNode.children.indexOf(base);
+    if (idx === -1) return [];
+    for (let i = idx + 1; i < parentNode.children.length; i++) {
+      const sib = parentNode.children[i];
+      if (!sentinel.arg || nodeMatchesSelector(sib, sentinel.arg)) {
+        return [sib];
+      }
+    }
+    return [];
+  }
+  return [];
+}
+function resolveScopedNode(target, fallbackIndex, treeRoot) {
+  const root = treeRoot ?? getMountedTree();
+  if (!root) return null;
+  if (typeof target === "string") {
+    const sentinelList2 = resolveSentinelList(target, void 0, root);
+    if (sentinelList2 !== void 0) return pickFromList(sentinelList2, fallbackIndex);
+    const matches2 = collectMatchingNodes(root, target);
+    return pickFromList(matches2, fallbackIndex);
+  }
+  const sentinelList = resolveSentinelList(target.selector, target.parent, root);
+  if (sentinelList !== void 0) return pickFromList(sentinelList, target.index ?? fallbackIndex);
+  const parentNode = target.parent ? resolveScopedNode(target.parent, target.parent.index, root) : root;
+  if (!parentNode) return null;
+  const matches = collectMatchingNodes(parentNode, target.selector);
+  const idx = target.index ?? fallbackIndex;
+  return pickFromList(matches, idx);
+}
+function isNodeVisible(node) {
+  let curr = node;
+  while (curr) {
+    const style = flattenStyle(curr.props.style);
+    if (style) {
+      if (style.display === "none") return false;
+      if (style.opacity === 0) return false;
+      if (style.height === 0 && style.width === 0) return false;
+    }
+    curr = curr.parent;
+  }
+  return true;
+}
+function findAncestorProp(node, propName) {
+  let curr = node.parent;
+  while (curr) {
+    if (typeof curr.props[propName] === "function") {
+      return curr.props[propName];
+    }
+    curr = curr.parent;
+  }
+  return void 0;
+}
+function findChildProp(node, propName) {
+  for (const child of node.children) {
+    if (typeof child.props[propName] === "function") {
+      return child.props[propName];
+    }
+    const found = findChildProp(child, propName);
+    if (found) return found;
+  }
+  return void 0;
+}
+var ReactNativeDriverBridge;
+var init_react_native_driver_bridge = __esm({
+  "src/bridge/react_native_driver_bridge.ts"() {
+    "use strict";
+    init_dsl();
+    init_tree_registry();
+    init_network_patch();
+    ReactNativeDriverBridge = class {
+      mockRules = [];
+      consoleErrors = [];
+      recordedNetwork = [];
+      async waitForScopedNode(target, fallbackIndex) {
+        const immediate = resolveScopedNode(target, fallbackIndex);
+        if (immediate) return immediate;
+        let found = null;
+        const timeoutMs = globalThis.__TS_RUNTIME__?.getImplicitWaitMs?.() ?? 5e3;
+        const ok = await globalThis.__TS_RUNTIME__?.pollCondition?.(async () => {
+          found = resolveScopedNode(target, fallbackIndex);
+          return found !== null;
+        }, timeoutMs) ?? await (async () => {
+          const start = Date.now();
+          while (Date.now() - start < timeoutMs) {
+            found = resolveScopedNode(target, fallbackIndex);
+            if (found) return true;
+            await this.pause(50);
+          }
+          return false;
+        })();
+        if (!ok || !found) {
+          throw new Error("Element not found: " + selectorText3(target));
+        }
+        return found;
+      }
+      async connect() {
+      }
+      async close() {
+      }
+      async navigate(_targetUrl) {
+        throw new Error(
+          "Spectra.navigate() is not supported in component testing mode. Use Spectra.mount(<Component />) to render a component tree instead of navigating a URL."
+        );
+      }
+      async back() {
+        throw new Error("Spectra.back() is not supported in component testing mode. Use Spectra.mount(<Component />).");
+      }
+      async forward() {
+        throw new Error("Spectra.forward() is not supported in component testing mode. Use Spectra.mount(<Component />).");
+      }
+      async refresh() {
+        throw new Error("Spectra.refresh() is not supported in component testing mode. Use Spectra.mount(<Component />).");
+      }
+      async setViewport(_width, _height) {
+      }
+      async pause(ms) {
+        await new Promise((r) => setTimeout(r, ms));
+      }
+      // ─── Element Actions ─────────────────────────────────────────────────────
+      async click(selector, index = null) {
+        const node = await this.waitForScopedNode(selector, index);
+        const onPress = node.props.onPress || node.props.onClick || findAncestorProp(node, "onPress") || findChildProp(node, "onPress");
+        if (typeof onPress !== "function") {
+          throw new Error(`Element "${selectorText3(selector)}" has no onPress handler.`);
+        }
+        await onPress({ nativeEvent: {} });
+        await this.pause(20);
+      }
+      async doubleClick(selector, index = null) {
+        await this.click(selector, index);
+        await this.pause(50);
+        await this.click(selector, index);
+      }
+      async rightClick(selector, index = null) {
+        const node = await this.waitForScopedNode(selector, index);
+        const onLongPress = node.props.onLongPress || findAncestorProp(node, "onLongPress") || node.props.onPress;
+        if (typeof onLongPress === "function") {
+          await onLongPress({ nativeEvent: {} });
+        }
+      }
+      async setValue(selector, value, index = null) {
+        const node = await this.waitForScopedNode(selector, index);
+        const strVal = String(value);
+        const onChangeText = node.props.onChangeText || findAncestorProp(node, "onChangeText") || findChildProp(node, "onChangeText");
+        if (typeof onChangeText === "function") {
+          await onChangeText(strVal);
+        } else if (typeof node.props.onChange === "function") {
+          await node.props.onChange({ nativeEvent: { text: strVal } });
+        } else {
+          throw new Error(`Element "${selectorText3(selector)}" has no onChangeText handler.`);
+        }
+        await this.pause(20);
+      }
+      async clearValue(selector, index = null) {
+        await this.setValue(selector, "", index);
+      }
+      async select(selector, option, index = null) {
+        const node = await this.waitForScopedNode(selector, index);
+        const onValueChange = node.props.onValueChange || node.props.onChangeText || node.props.onSelect;
+        if (typeof onValueChange === "function") {
+          await onValueChange(option);
+          return;
+        }
+        await this.setValue(selector, option, index);
+      }
+      async hover(selector, index = null) {
+        const node = await this.waitForScopedNode(selector, index);
+        node.props.onHoverIn?.({ nativeEvent: {} });
+      }
+      async focus(selector, index = null) {
+        const node = await this.waitForScopedNode(selector, index);
+        node.props.onFocus?.({ nativeEvent: {} });
+      }
+      async blur(selector, index = null) {
+        const node = await this.waitForScopedNode(selector, index);
+        node.props.onBlur?.({ nativeEvent: {} });
+      }
+      async dragDrop(_sourceSelector, _targetSelector, _sourceIndex = null) {
+        throw new Error("Spectra.dragDrop() is not supported for synthetic React Native component tests.");
+      }
+      async longPress(selector, duration, index = null) {
+        const node = await this.waitForScopedNode(selector, index);
+        const onLongPress = node.props.onLongPress || findAncestorProp(node, "onLongPress") || node.props.onPress;
+        if (typeof onLongPress === "function") {
+          await onLongPress({ nativeEvent: {} });
+        }
+        await this.pause(duration);
+      }
+      async scrollIntoView(_selector, _index = null) {
+      }
+      async upload(_selector, _files, _index = null) {
+        throw new Error("upload() is not applicable to React Native components.");
+      }
+      // ─── Element State Inspection ────────────────────────────────────────────
+      async getText(selector, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return "";
+        return extractText(node);
+      }
+      async getValue(selector, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return "";
+        return String(node.props.value ?? node.props.defaultValue ?? "");
+      }
+      async isDisplayed(selector, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return false;
+        return isNodeVisible(node);
+      }
+      async waitForDisplayed(selector, opts, index = null) {
+        const ok = await globalThis.__TS_RUNTIME__?.pollCondition?.(async () => {
+          return this.isDisplayed(selector, index);
+        }, opts?.timeout ?? 5e3) ?? await (async () => {
+          const timeout = opts?.timeout ?? 5e3;
+          const start = Date.now();
+          while (Date.now() - start < timeout) {
+            if (await this.isDisplayed(selector, index)) return true;
+            await this.pause(50);
+          }
+          return false;
+        })();
+        if (!ok) {
+          throw new Error("Element not displayed after timeout: " + selectorText3(selector));
+        }
+      }
+      async isExisting(selector, index = null) {
+        return resolveScopedNode(selector, index) !== null;
+      }
+      async isEnabled(selector, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return false;
+        return !node.props.disabled && node.props.accessibilityState?.disabled !== true;
+      }
+      async isSelected(selector, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return false;
+        return node.props.accessibilityState?.selected === true || node.props.selected === true || node.props.accessibilityState?.checked === true || node.props.checked === true;
+      }
+      async isFocused(selector, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return false;
+        return node.props.accessibilityState?.focused === true || node.props.focused === true || node.props.autoFocus === true;
+      }
+      async isClickable(selector, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return false;
+        if (!isNodeVisible(node)) return false;
+        if (node.props.disabled || node.props.accessibilityState?.disabled === true) return false;
+        return typeof node.props.onPress === "function" || typeof findAncestorProp(node, "onPress") === "function" || typeof findChildProp(node, "onPress") === "function";
+      }
+      async hasClass(_selector, _className, _index = null) {
+        return false;
+      }
+      async getAttribute(selector, name, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return null;
+        const val = node.props[name];
+        return val != null ? String(val) : null;
+      }
+      async getCSSProperty(selector, name, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return { value: "" };
+        const style = flattenStyle(node.props.style);
+        return { value: style && style[name] != null ? String(style[name]) : "" };
+      }
+      async count(selector) {
+        const root = getMountedTree();
+        if (!root) return 0;
+        if (typeof selector === "string") {
+          const sentinelList2 = resolveSentinelList(selector, void 0, root);
+          if (sentinelList2 !== void 0) return sentinelList2.length;
+          return collectMatchingNodes(root, selector).length;
+        }
+        const sentinelList = resolveSentinelList(selector.selector, selector.parent, root);
+        if (sentinelList !== void 0) return sentinelList.length;
+        const parentNode = selector.parent ? resolveScopedNode(selector.parent, selector.parent.index, root) : root;
+        if (!parentNode) return 0;
+        return collectMatchingNodes(parentNode, selector.selector).length;
+      }
+      async waitForElementRemoved(selector, timeoutMs = 5e3, index = null) {
+        const ok = await globalThis.__TS_RUNTIME__?.pollCondition?.(async () => {
+          return !await this.isExisting(selector, index);
+        }, timeoutMs) ?? true;
+        if (!ok) throw new Error("Element still exists after timeout: " + selectorText3(selector));
+      }
+      async waitForUndisplayed(selector, opts, index = null) {
+        const ok = await globalThis.__TS_RUNTIME__?.pollCondition?.(async () => {
+          return !await this.isDisplayed(selector, index);
+        }, opts?.timeout ?? 5e3) ?? true;
+        if (!ok) throw new Error("Element still displayed after timeout: " + selectorText3(selector));
+      }
+      async waitForClickable(selector, opts, index = null) {
+        return await globalThis.__TS_RUNTIME__?.pollCondition?.(async () => {
+          return this.isClickable(selector, index);
+        }, opts?.timeout ?? 5e3) ?? true;
+      }
+      async getBounds(selector, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return { x: 0, y: 0, top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0 };
+        const style = flattenStyle(node.props.style) || {};
+        const w = typeof style.width === "number" ? style.width : 0;
+        const h = typeof style.height === "number" ? style.height : 0;
+        return { x: 0, y: 0, top: 0, right: w, bottom: h, left: 0, width: w, height: h };
+      }
+      async closest(selector, targetSelector, index = null) {
+        const node = resolveScopedNode(selector, index);
+        if (!node) return null;
+        let curr = node.parent;
+        while (curr) {
+          if (nodeMatchesSelector(curr, targetSelector)) {
+            return typeof curr.type === "string" ? curr.type : curr.type?.displayName || curr.type?.name || "component";
+          }
+          curr = curr.parent;
+        }
+        return null;
+      }
+      async clickAt(_x, _y) {
+      }
+      async pressKey(key) {
+        const root = getMountedTree();
+        if (!root) return;
+        const focused = collectMatchingNodes(root, "*").find((n) => n.props.accessibilityState?.focused);
+        focused?.props.onKeyPress?.({ nativeEvent: { key: String(key) } });
+      }
+      async scroll(_options = {}) {
+      }
+      async swipe(_options) {
+      }
+      async grantPermission(_name) {
+      }
+      // ─── Browser/Runtime Level Bridge ────────────────────────────────────────
+      async getUrl() {
+        return "react-native://spectra-harness";
+      }
+      async getTitle() {
+        return "React Native Component Test";
+      }
+      async execute(fn, ...args) {
+        if (typeof fn === "function") {
+          return fn(...args);
+        }
+        return new Function(`return (${fn});`)();
+      }
+      async evaluate(expr) {
+        return new Function(`return (${expr});`)();
+      }
+      async waitUntil(fn, opts) {
+        const ok = await globalThis.__TS_RUNTIME__?.pollCondition?.(fn, opts?.timeout) ?? true;
+        if (!ok) throw new Error(opts?.timeoutMsg || "waitUntil() condition was not met in time");
+        return ok;
+      }
+      async getLogs(_type) {
+        return [];
+      }
+      async shouldHaveUrl(expectedUrl, _options) {
+        const actual = await this.getUrl();
+        if (actual !== expectedUrl) throw new Error(`Expected URL to be "${expectedUrl}", but got "${actual}"`);
+      }
+      async shouldContainUrl(expectedSubstr, _options) {
+        const actual = await this.getUrl();
+        if (!actual.includes(expectedSubstr)) {
+          throw new Error(`Expected URL to contain "${expectedSubstr}", but got "${actual}"`);
+        }
+      }
+      async shouldHaveTitle(expectedTitle, _options) {
+        const actual = await this.getTitle();
+        if (actual !== expectedTitle) throw new Error(`Expected title to be "${expectedTitle}", but got "${actual}"`);
+      }
+      async shouldContainTitle(expectedSubstr, _options) {
+        const actual = await this.getTitle();
+        if (!actual.includes(expectedSubstr)) {
+          throw new Error(`Expected title to contain "${expectedSubstr}", but got "${actual}"`);
+        }
+      }
+      async shouldBeLoaded(_options) {
+      }
+      async shouldHaveNoConsoleErrors(_options) {
+        if (this.consoleErrors.length > 0) {
+          throw new Error(
+            `Expected no console errors, but found ${this.consoleErrors.length}: ${this.consoleErrors.join("; ")}`
+          );
+        }
+      }
+      async clearCookies() {
+      }
+      async setCookies(_setCookieHeaders, _url) {
+      }
+      async clearLocalStorage() {
+      }
+      // ─── Network Interception ────────────────────────────────────────────────
+      async intercept(patternOrOptions, method, fixture, options) {
+        const rule = parseMockRule(patternOrOptions, method, fixture, options);
+        ensureNetworkPatch(() => this.mockRules);
+        this.mockRules.push(rule);
+        return createMockHandle(rule);
+      }
+      clearMocks() {
+        this.mockRules = [];
+        clearMocks();
+      }
+    };
+  }
+});
+
+// src/runtime/mount.ts
+async function mount(element) {
+  let mountListener = getActiveMountListener();
+  if (!mountListener) {
+    registerMountHandlers(
+      (el) => setMountedElement(el),
+      () => setMountedElement(null)
+    );
+    mountListener = getActiveMountListener();
+  }
+  setMountedElement(element);
+  mountListener(element);
+  await new Promise((resolve) => setTimeout(resolve, 35));
+  if (globalThis.__TS_RUNTIME__?.createElementProxy) {
+    return globalThis.__TS_RUNTIME__.createElementProxy("~spectra-root");
+  }
+  return { selector: "~spectra-root" };
+}
+function unmount() {
+  const unmountListener = getActiveUnmountListener();
+  unmountListener?.();
+  setMountedElement(null);
+}
+var init_mount = __esm({
+  "src/runtime/mount.ts"() {
+    "use strict";
+    init_harness_root();
+    init_tree_registry();
+  }
+});
+
+// src/runtime/setup.ts
+function expect(actual) {
+  return {
+    toBe: (exp) => {
+      if (actual !== exp) throw new Error(`Expected ${actual} to be ${exp}`);
+    },
+    toEqual: (exp) => {
+      if (JSON.stringify(actual) !== JSON.stringify(exp))
+        throw new Error(`Expected ${JSON.stringify(actual)} to equal ${JSON.stringify(exp)}`);
+    },
+    toBeTruthy: () => {
+      if (!actual) throw new Error(`Expected ${actual} to be truthy`);
+    },
+    toBeFalsy: () => {
+      if (!actual) throw new Error(`Expected ${actual} to be falsy`);
+    },
+    toBeNull: () => {
+      if (actual !== null) throw new Error(`Expected ${actual} to be null`);
+    },
+    toBeUndefined: () => {
+      if (actual !== void 0) throw new Error(`Expected ${actual} to be undefined`);
+    },
+    toBeDefined: () => {
+      if (actual === void 0) throw new Error(`Expected value to be defined`);
+    },
+    toContain: (item) => {
+      if (Array.isArray(actual)) {
+        if (!actual.includes(item)) throw new Error(`Expected array to contain ${item}`);
+      } else if (typeof actual === "string") {
+        if (!actual.includes(String(item))) throw new Error(`Expected string to contain ${item}`);
+      }
+    },
+    not: {
+      toBe: (exp) => {
+        if (actual === exp) throw new Error(`Expected ${actual} not to be ${exp}`);
+      },
+      toEqual: (exp) => {
+        if (JSON.stringify(actual) === JSON.stringify(exp))
+          throw new Error(`Expected value not to equal ${JSON.stringify(exp)}`);
+      },
+      toBeTruthy: () => {
+        if (actual) throw new Error(`Expected ${actual} not to be truthy`);
+      },
+      toBeFalsy: () => {
+        if (!actual) throw new Error(`Expected ${actual} not to be falsy`);
+      },
+      toBeNull: () => {
+        if (actual === null) throw new Error(`Expected value not to be null`);
+      },
+      toBeUndefined: () => {
+        if (actual === void 0) throw new Error(`Expected value not to be undefined`);
+      },
+      toBeDefined: () => {
+        if (actual !== void 0) throw new Error(`Expected value not to be defined`);
+      },
+      toContain: (item) => {
+        if (Array.isArray(actual)) {
+          if (actual.includes(item)) throw new Error(`Expected array not to contain ${item}`);
+        } else if (typeof actual === "string") {
+          if (actual.includes(String(item))) throw new Error(`Expected string not to contain ${item}`);
+        }
+      }
+    }
+  };
+}
+var activeDriver2, spectra;
+var init_setup = __esm({
+  "src/runtime/setup.ts"() {
+    "use strict";
+    init_react_native_driver_bridge();
+    init_mount();
+    init_dsl();
+    activeDriver2 = new ReactNativeDriverBridge();
+    setActiveDriver(activeDriver2);
+    spectra = buildSpectra();
+    spectra.mount = mount;
+    spectra.unmount = unmount;
+    globalThis.Spectra = spectra;
+    globalThis.__SPECTRA_HARNESS_READY__ = true;
+    spectra.expect = expect;
+    if (typeof globalThis.expect === "undefined") {
+      globalThis.expect = expect;
+    }
+  }
+});
+
+// src/runner/library_spec_runner.ts
+var library_spec_runner_exports = {};
+__export(library_spec_runner_exports, {
+  runLibraryComponentSpecs: () => runLibraryComponentSpecs
+});
+import fs2 from "node:fs";
+import { createRequire } from "node:module";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+import * as esbuild2 from "esbuild";
+import React3 from "react";
+import * as ReactJsxRuntime from "react/jsx-runtime";
+function getShimPath() {
+  const candidates = [
+    path2.resolve(__dirname, "mock/react_native_shim.js"),
+    path2.resolve(__dirname, "../mock/react_native_shim.js"),
+    path2.resolve(__dirname, "../src/mock/react_native_shim.ts"),
+    path2.resolve(__dirname, "mock/react_native_shim.cjs")
+  ];
+  for (const c of candidates) {
+    if (fs2.existsSync(c)) return c;
+  }
+  return candidates[0];
+}
+function createReactNativeAliasPlugin() {
+  const targetShim = getShimPath();
+  return {
+    name: "react-native-alias",
+    setup(build3) {
+      build3.onResolve({ filter: /^react-native($|\/)/ }, () => {
+        return { path: targetShim };
+      });
+    }
+  };
+}
+async function loadPageObjects(testRoot) {
+  const poDir = path2.join(testRoot, "page-objects");
+  if (!fs2.existsSync(poDir)) return;
+  const entries = fs2.readdirSync(poDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const poName = entry.name;
+    const poFolder = path2.join(poDir, poName);
+    const candidates = ["mobile.ts", "mobile.js", "android.ts", "android.js", "index.ts", "index.js"];
+    let matchedFile = null;
+    for (const cand of candidates) {
+      const full = path2.join(poFolder, cand);
+      if (fs2.existsSync(full)) {
+        matchedFile = full;
+        break;
+      }
+    }
+    if (matchedFile) {
+      try {
+        const bundle = await esbuild2.build({
+          entryPoints: [matchedFile],
+          bundle: true,
+          format: "cjs",
+          platform: "node",
+          target: "es2020",
+          external: ["@testspectra/matchers", "@testspectra/react-native", "react", "react-native"],
+          write: false,
+          plugins: [createReactNativeAliasPlugin()]
+        });
+        if (bundle.outputFiles?.[0]) {
+          const code = bundle.outputFiles[0].text;
+          const exportsObj = {};
+          const moduleObj = { exports: exportsObj };
+          const localRequire = createRequire(matchedFile);
+          const runFn = new Function("require", "module", "exports", "globalThis", code);
+          runFn(
+            (id) => {
+              if (id.startsWith("@testspectra/react-native")) return { Spectra: globalThis.Spectra };
+              if (id.startsWith("@testspectra/matchers")) return { Spectra: globalThis.Spectra };
+              if (id === "react") return React3;
+              if (id === "react-native") return react_native_shim_exports;
+              try {
+                return localRequire(id);
+              } catch {
+                return {};
+              }
+            },
+            moduleObj,
+            exportsObj,
+            globalThis
+          );
+          const instance = moduleObj.exports.default ?? moduleObj.exports;
+          globalThis[poName] = instance;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function runLibraryComponentSpecs(specFiles, options = {}) {
+  const testRoot = path2.resolve(options.testRoot ?? options.cwd ?? process.cwd());
+  const startTime = Date.now();
+  const emitLine = (line) => {
+    if (options.reporter && typeof options.reporter.addLog === "function") {
+      options.reporter.addLog({
+        timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString(),
+        level: "INFO",
+        message: line
+      });
+    }
+    options.onProtocolLine?.(line);
+  };
+  registerMountHandlers(
+    (el) => setMountedElement(el),
+    () => setMountedElement(null)
+  );
+  await loadPageObjects(testRoot);
+  const results = [];
+  let passedCount = 0;
+  let failedCount = 0;
+  for (const specRelPath of specFiles) {
+    const fullSpecPath = path2.isAbsolute(specRelPath) ? specRelPath : path2.join(testRoot, specRelPath);
+    const specStartTime = Date.now();
+    emitLine(`[TESTSPECTRA_SUITE_START] ${JSON.stringify({ file: specRelPath })}`);
+    const registeredInFile = [];
+    globalThis.it = (title, fn) => {
+      registeredInFile.push({ title, fn });
+    };
+    let specPassed = true;
+    let specError;
+    try {
+      const buildResult = await esbuild2.build({
+        entryPoints: [fullSpecPath],
+        bundle: true,
+        format: "cjs",
+        platform: "node",
+        target: "es2020",
+        external: ["@testspectra/matchers", "@testspectra/react-native"],
+        write: false,
+        jsx: "automatic",
+        jsxImportSource: "react",
+        plugins: [createReactNativeAliasPlugin()]
+      });
+      if (!buildResult.outputFiles?.[0]) {
+        throw new Error(`Failed to bundle spec: ${specRelPath}`);
+      }
+      const bundleCode = buildResult.outputFiles[0].text;
+      const exportsObj = {};
+      const moduleObj = { exports: exportsObj };
+      const localRequire = createRequire(fullSpecPath);
+      const customRequire = (pkgName) => {
+        if (pkgName === "react") return React3;
+        if (pkgName === "react/jsx-runtime" || pkgName === "react/jsx-dev-runtime") {
+          return ReactJsxRuntime;
+        }
+        if (pkgName.startsWith("@testspectra/react-native")) {
+          return {
+            Spectra: globalThis.Spectra,
+            it: globalThis.it,
+            mount: globalThis.Spectra.mount,
+            unmount: globalThis.Spectra.unmount
+          };
+        }
+        if (pkgName.startsWith("@testspectra/matchers")) {
+          return { Spectra: globalThis.Spectra };
+        }
+        if (pkgName === "react-native") {
+          return react_native_shim_exports;
+        }
+        try {
+          return localRequire(pkgName);
+        } catch {
+          return {};
+        }
+      };
+      const runSpecCode = new Function("require", "module", "exports", "globalThis", bundleCode);
+      runSpecCode(customRequire, moduleObj, exportsObj, globalThis);
+      for (const { title, fn } of registeredInFile) {
+        emitLine(`[TESTSPECTRA_TEST_START] ${title}`);
+        globalThis.__CURRENT_TEST_TITLE__ = title;
+        const testStartTime = Date.now();
+        try {
+          await fn();
+          const duration = Date.now() - testStartTime;
+          emitLine(`[TESTSPECTRA_TEST_PASS] ${title} (${duration}ms)`);
+        } catch (err) {
+          specPassed = false;
+          specError = err?.message || String(err);
+          const duration = Date.now() - testStartTime;
+          emitLine(`[TESTSPECTRA_TEST_ERROR] ${specError}`);
+          emitLine(`[TESTSPECTRA_TEST_FAIL] ${title} (${duration}ms)`);
+        } finally {
+          cleanup();
+        }
+      }
+      if (registeredInFile.length === 0) {
+        emitLine(`[TESTSPECTRA_TEST_START] ${path2.basename(specRelPath)}`);
+        emitLine(`[TESTSPECTRA_TEST_PASS] ${path2.basename(specRelPath)} (5ms)`);
+      }
+    } catch (err) {
+      specPassed = false;
+      specError = err?.message || String(err);
+      emitLine(`[TESTSPECTRA_TEST_ERROR] Bundle/Execution error in ${specRelPath}: ${specError}`);
+      emitLine(`[TESTSPECTRA_TEST_FAIL] ${path2.basename(specRelPath)} (1ms)`);
+    }
+    const durationMs = Date.now() - specStartTime;
+    emitLine(
+      `[TESTSPECTRA_SUITE_END] ${JSON.stringify({ file: specRelPath, passed: specPassed ? 1 : 0, failed: specPassed ? 0 : 1 })}`
+    );
+    if (specPassed) {
+      passedCount++;
+    } else {
+      failedCount++;
+    }
+    results.push({
+      specPath: specRelPath,
+      passed: specPassed,
+      durationMs,
+      error: specError
+    });
+  }
+  return {
+    status: failedCount === 0 ? "passed" : "failed",
+    passedCount,
+    failedCount,
+    suitesRun: specFiles.length,
+    durationMs: Date.now() - startTime,
+    results
+  };
+}
+var __filename, __dirname;
+var init_library_spec_runner = __esm({
+  "src/runner/library_spec_runner.ts"() {
+    "use strict";
+    init_react_native_shim();
+    init_harness_root();
+    init_tree_registry();
+    init_in_app_runner();
+    init_setup();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = path2.dirname(__filename);
+  }
+});
+
+// src/bundler/bundle_server.ts
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import * as esbuild from "esbuild";
+var SHARED_MOBILE_EXTERNALS = [
+  "react",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "react/compiler-runtime",
+  "react-native",
+  "react-native/*"
+];
+var bundleCache = /* @__PURE__ */ new Map();
+var inFlightBuilds = /* @__PURE__ */ new Map();
+async function buildSpecBundle(resolvedPath, options = {}) {
+  const mergedExternals = Array.from(/* @__PURE__ */ new Set([...SHARED_MOBILE_EXTERNALS, ...options.external ?? []]));
+  const format = options.format ?? "cjs";
+  const buildOptions = {
+    entryPoints: [resolvedPath],
+    bundle: true,
+    format,
+    platform: "neutral",
+    target: "es2020",
+    external: mergedExternals,
+    jsx: "automatic",
+    jsxImportSource: "react",
+    sourcemap: "inline",
+    minify: false,
+    write: false,
+    loader: {
+      ".png": "dataurl",
+      ".jpg": "dataurl",
+      ".jpeg": "dataurl",
+      ".gif": "dataurl",
+      ".webp": "dataurl",
+      ".svg": "text",
+      ".json": "json",
+      ".txt": "text",
+      ".csv": "text",
+      ".tsx": "tsx",
+      ".ts": "ts",
+      ".jsx": "jsx",
+      ".js": "js"
+    },
+    logLevel: "error",
+    plugins: options.plugins
+  };
+  const result = await esbuild.build(buildOptions);
+  if (result.errors.length > 0) {
+    const msgs = result.errors.map((e) => e.text).join("\n");
+    throw new Error(`esbuild compilation failed for ${resolvedPath}:
+${msgs}`);
+  }
+  if (!result.outputFiles || result.outputFiles.length === 0) {
+    throw new Error(`esbuild produced no output files for ${resolvedPath}`);
+  }
+  return result.outputFiles[0].text;
+}
+async function getCachedSpecBundle(cacheKey, resolvedPath, options = {}) {
+  const cached = bundleCache.get(cacheKey);
+  if (cached) return cached;
+  const existingInFlight = inFlightBuilds.get(cacheKey);
+  if (existingInFlight) return existingInFlight;
+  const buildPromise = buildSpecBundle(resolvedPath, options).then(
+    (js) => {
+      bundleCache.set(cacheKey, js);
+      inFlightBuilds.delete(cacheKey);
+      return js;
+    },
+    (err) => {
+      inFlightBuilds.delete(cacheKey);
+      throw err;
+    }
+  );
+  inFlightBuilds.set(cacheKey, buildPromise);
+  return buildPromise;
+}
+function respond(res, status, contentType, body) {
+  res.writeHead(status, { "Content-Type": contentType });
+  res.end(body);
+}
+function makeHandler(testRoot, external = [], plugins = []) {
+  return async (req, res) => {
+    const hostHeader = req.headers.host || "127.0.0.1";
+    const url = new URL(req.url ?? "/", `http://${hostHeader}`);
+    if (url.pathname === "/health") {
+      respond(res, 200, "application/json", JSON.stringify({ status: "ok" }));
+      return;
+    }
+    if (url.pathname === "/bundle") {
+      const rawFile = url.searchParams.get("file") ?? url.searchParams.get("spec");
+      if (!rawFile) {
+        respond(res, 400, "text/plain", "Missing ?file= parameter");
+        return;
+      }
+      const decodedPath = decodeURIComponent(rawFile);
+      const resolvedPath = path.isAbsolute(decodedPath) ? path.normalize(decodedPath) : path.resolve(testRoot, decodedPath);
+      if (!fs.existsSync(resolvedPath)) {
+        respond(res, 404, "text/plain", `File not found: ${decodedPath}`);
+        return;
+      }
+      const requestedFormat = url.searchParams.get("format") || "cjs";
+      const cacheKey = `${resolvedPath}:${requestedFormat}`;
+      try {
+        const js = await getCachedSpecBundle(cacheKey, resolvedPath, {
+          format: requestedFormat,
+          external,
+          plugins
+        });
+        respond(res, 200, "application/javascript; charset=utf-8", js);
+      } catch (err) {
+        const message = err?.message || String(err);
+        respond(
+          res,
+          500,
+          "application/javascript; charset=utf-8",
+          `throw new Error(${JSON.stringify(`Bundle error for ${decodedPath}: ${message}`)});`
+        );
+      }
+      return;
+    }
+    respond(res, 404, "text/plain", "Not Found");
+  };
+}
+async function listenWithFallback(server, preferredPort, host = "127.0.0.1") {
+  const portsToTry = [preferredPort, 8082, 9246, 0];
+  for (const port of portsToTry) {
+    try {
+      await new Promise((resolve, reject) => {
+        const onError = (err) => {
+          server.removeListener("listening", onListening);
+          reject(err);
+        };
+        const onListening = () => {
+          server.removeListener("error", onError);
+          resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port, host);
+      });
+      const addr = server.address();
+      return addr.port;
+    } catch (err) {
+      if (err.code === "EADDRINUSE" && port !== 0) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error("Could not bind mobile bundle server to any port");
+}
+async function startMobileBundleServer(opts = {}) {
+  const testRoot = path.resolve(opts.testRoot ?? process.cwd());
+  const host = opts.host ?? "127.0.0.1";
+  const handler = makeHandler(testRoot, opts.external ?? [], opts.plugins ?? []);
+  const server = http.createServer(handler);
+  let actualPort;
+  if (opts.port !== void 0) {
+    await new Promise((resolve, reject) => {
+      const onError = (err) => {
+        server.removeListener("listening", onListening);
+        reject(err);
+      };
+      const onListening = () => {
+        server.removeListener("error", onError);
+        resolve();
+      };
+      server.once("error", onError);
+      server.once("listening", onListening);
+      server.listen(opts.port, host);
+    });
+    actualPort = server.address().port;
+  } else {
+    actualPort = await listenWithFallback(server, 8081, host);
+  }
+  const baseUrl = `http://${host}:${actualPort}`;
+  return {
+    url: baseUrl,
+    port: actualPort,
+    stop: () => new Promise((resolve) => {
+      server.close(() => resolve());
+    })
+  };
+}
+
+// src/runner/host_mobile_runner.ts
+import fs3 from "node:fs";
+import net from "node:net";
+import path3 from "node:path";
+import spawn from "cross-spawn";
+async function checkAdbDevices() {
+  return new Promise((resolve) => {
+    const proc = spawn("adb", ["devices"], { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    proc.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        resolve({ connected: false, devices: [], raw: stderr || stdout });
+        return;
+      }
+      const lines = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+      const devices = [];
+      for (const line of lines) {
+        if (line.startsWith("List of devices attached") || line.startsWith("* daemon")) continue;
+        const [id, state] = line.split(/\s+/);
+        if (id && state === "device") {
+          devices.push(id);
+        }
+      }
+      resolve({ connected: devices.length > 0, devices, raw: stdout });
+    });
+    proc.on("error", (err) => {
+      resolve({ connected: false, devices: [], raw: err.message });
+    });
+  });
+}
+async function setupAdbPortForwarding(hostPort = 9245, devicePort = 9245, deviceId) {
+  return new Promise((resolve, reject) => {
+    const args = [];
+    if (deviceId) {
+      args.push("-s", deviceId);
+    }
+    args.push("forward", `tcp:${hostPort}`, `tcp:${devicePort}`);
+    const proc = spawn("adb", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    proc.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`adb forward failed with exit code ${code}: ${stderr.trim()}`));
+      }
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to execute adb forward: ${err.message}`));
+    });
+  });
+}
+async function removeAdbPortForwarding(hostPort = 9245, deviceId) {
+  return new Promise((resolve) => {
+    const args = [];
+    if (deviceId) {
+      args.push("-s", deviceId);
+    }
+    args.push("forward", "--remove", `tcp:${hostPort}`);
+    const proc = spawn("adb", args, { stdio: ["ignore", "pipe", "pipe"] });
+    proc.on("close", () => resolve());
+    proc.on("error", () => resolve());
+  });
+}
+async function setupAdbReversePortForwarding(devicePort = 9245, hostPort = 9245, deviceId) {
+  return new Promise((resolve) => {
+    const args = [];
+    if (deviceId) {
+      args.push("-s", deviceId);
+    }
+    args.push("reverse", `tcp:${devicePort}`, `tcp:${hostPort}`);
+    const proc = spawn("adb", args, { stdio: ["ignore", "pipe", "pipe"] });
+    proc.on("close", () => resolve());
+    proc.on("error", () => resolve());
+  });
+}
+function findMobileSpecs(testRoot, filter) {
+  const specs = [];
+  const walk = (dir) => {
+    let entries = [];
+    try {
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") {
+        continue;
+      }
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const lower = entry.name.toLowerCase();
+        if (lower === "mobile.test.tsx" || lower.endsWith(".mobile.test.tsx") || lower === "android.test.tsx" || lower.endsWith(".android.test.tsx") || lower === "mobile.test.ts" || lower.endsWith(".mobile.test.ts") || lower === "android.test.ts" || lower.endsWith(".android.test.ts")) {
+          const relPath = path3.relative(testRoot, fullPath);
+          if (!filter || relPath.includes(filter) || fullPath.includes(filter)) {
+            specs.push(relPath);
+          }
+        }
+      }
+    }
+  };
+  walk(testRoot);
+  return specs;
+}
+async function connectClientWithRetries(port, host = "127.0.0.1", maxRetries = 10, retryDelayMs = 400) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const socket = await new Promise((resolve, reject) => {
+        const s = net.createConnection({ port, host });
+        const onConnect = () => {
+          s.removeListener("error", onError);
+          resolve(s);
+        };
+        const onError = (err) => {
+          s.removeListener("connect", onConnect);
+          s.destroy();
+          reject(err);
+        };
+        s.once("connect", onConnect);
+        s.once("error", onError);
+      });
+      return socket;
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxRetries) {
+        await new Promise((r) => setTimeout(r, retryDelayMs));
+      }
+    }
+  }
+  throw lastError || new Error(`Failed to connect to harness on ${host}:${port}`);
+}
+function createHarnessServer(port, host = "127.0.0.1", timeoutMs = 15e3) {
+  return new Promise((resolve, reject) => {
+    let clientSocket = null;
+    let pendingWaiter = null;
+    const server = net.createServer((socket) => {
+      clientSocket = socket;
+      if (pendingWaiter) {
+        pendingWaiter(socket);
+        pendingWaiter = null;
+      }
+    });
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      resolve({
+        server,
+        getSocket: () => {
+          if (clientSocket && !clientSocket.destroyed) {
+            return Promise.resolve(clientSocket);
+          }
+          return new Promise((res, rej) => {
+            const timer = setTimeout(() => {
+              rej(new Error(`Timed out waiting for mobile app to connect to host port ${port}`));
+            }, timeoutMs);
+            pendingWaiter = (sock) => {
+              clearTimeout(timer);
+              res(sock);
+            };
+          });
+        }
+      });
+    });
+  });
+}
+function executeSpecOnSocket(socket, specPath, options) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const startTime = Date.now();
+  return new Promise((resolve) => {
+    let buffer = "";
+    let settled = false;
+    let specPassed = false;
+    let errorMessage;
+    const emitLine = (line) => {
+      if (options.reporter && typeof options.reporter.addLog === "function") {
+        options.reporter.addLog({
+          timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString(),
+          level: "INFO",
+          message: line
+        });
+      }
+      options.onProtocolLine?.(line);
+    };
+    const finish = (passed, err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.removeListener("data", onData);
+      socket.removeListener("close", onClose);
+      socket.removeListener("error", onError);
+      const durationMs = Date.now() - startTime;
+      resolve({
+        specPath,
+        passed,
+        durationMs,
+        error: err
+      });
+    };
+    const timer = setTimeout(() => {
+      const err = `Timeout: Spec execution exceeded ${timeoutMs}ms`;
+      emitLine(`[TESTSPECTRA_TEST_ERROR] ${err}`);
+      emitLine(`[TESTSPECTRA_TEST_FAIL] ${specPath} (${Date.now() - startTime}ms)`);
+      finish(false, err);
+    }, timeoutMs);
+    const onData = (chunk) => {
+      buffer += chunk.toString("utf8");
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line) continue;
+        emitLine(line);
+        if (line.startsWith("[TESTSPECTRA_TEST_PASS]")) {
+          specPassed = true;
+        } else if (line.startsWith("[TESTSPECTRA_TEST_FAIL]")) {
+          specPassed = false;
+        } else if (line.startsWith("[TESTSPECTRA_TEST_ERROR]")) {
+          errorMessage = line.replace("[TESTSPECTRA_TEST_ERROR]", "").trim();
+        } else if (line.startsWith("[TESTSPECTRA_SUITE_END]")) {
+          const payloadStr = line.replace("[TESTSPECTRA_SUITE_END]", "").trim();
+          try {
+            const payload = JSON.parse(payloadStr);
+            specPassed = payload.failed === 0 && (payload.passed > 0 || specPassed);
+          } catch {
+          }
+          finish(specPassed, errorMessage);
+        }
+      }
+    };
+    const onClose = () => {
+      if (!settled) {
+        const msg = errorMessage || (buffer.length === 0 ? "Connection closed immediately with 0 bytes. Ensure the React Native app is opened on the device and configured with withSpectraComponentHarness." : "Connection closed unexpectedly before test completed.");
+        emitLine(`[TESTSPECTRA_TEST_ERROR] ${msg}`);
+        finish(specPassed, msg);
+      }
+    };
+    const onError = (err) => {
+      if (!settled) {
+        emitLine(`[TESTSPECTRA_TEST_ERROR] Socket error: ${err.message}`);
+        finish(false, err.message);
+      }
+    };
+    socket.on("data", onData);
+    socket.once("close", onClose);
+    socket.once("error", onError);
+    const command = {
+      action: "RUN_SPEC",
+      specPath,
+      timeoutMs,
+      bundleUrl: options.bundleUrl ?? "http://127.0.0.1:8081"
+    };
+    socket.write(JSON.stringify(command) + "\n");
+  });
+}
+async function runMobileComponentTests(options = {}) {
+  const testRoot = path3.resolve(options.testRoot ?? options.cwd ?? process.cwd());
+  const port = options.port ?? 9245;
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const startTime = Date.now();
+  const mode = options.mode ?? "auto";
+  let specFiles;
+  if (options.specs && options.specs.length > 0) {
+    specFiles = options.specs;
+  } else if (options.spec) {
+    specFiles = findMobileSpecs(testRoot, options.spec);
+    if (specFiles.length === 0) {
+      specFiles = [options.spec];
+    }
+  } else {
+    specFiles = findMobileSpecs(testRoot);
+  }
+  const isLibraryProject = mode === "library" || mode !== "client" && mode !== "server" && !fs3.existsSync(path3.join(testRoot, "android")) && !fs3.existsSync(path3.join(testRoot, "ios"));
+  if (isLibraryProject) {
+    const { runLibraryComponentSpecs: runLibraryComponentSpecs2 } = await Promise.resolve().then(() => (init_library_spec_runner(), library_spec_runner_exports));
+    return runLibraryComponentSpecs2(specFiles, options);
+  }
+  if (specFiles.length === 0) {
+    if (options.reporter && typeof options.reporter.addLog === "function") {
+      options.reporter.addLog({
+        timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString(),
+        level: "ERROR",
+        message: "[TESTSPECTRA_TEST_ERROR] No mobile component specs found (*.mobile.test.tsx, *.android.test.tsx)."
+      });
+    }
+    return {
+      status: "passed",
+      passedCount: 0,
+      failedCount: 0,
+      suitesRun: 0,
+      durationMs: Date.now() - startTime,
+      results: []
+    };
+  }
+  if (!options.skipAdbForward) {
+    try {
+      await setupAdbPortForwarding(port, port, options.deviceId);
+    } catch (err) {
+      const errorMsg = `Failed to configure ADB port forwarding on port ${port}: ${err.message}`;
+      if (options.reporter && typeof options.reporter.addLog === "function") {
+        options.reporter.addLog({
+          timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString(),
+          level: "ERROR",
+          message: `[TESTSPECTRA_TEST_ERROR] ${errorMsg}`
+        });
+      }
+      return {
+        status: "failed",
+        passedCount: 0,
+        failedCount: specFiles.length,
+        suitesRun: specFiles.length,
+        durationMs: Date.now() - startTime,
+        results: specFiles.map((s) => ({
+          specPath: s,
+          passed: false,
+          durationMs: 0,
+          error: errorMsg
+        }))
+      };
+    }
+  }
+  let serverInstance = null;
+  let activeSocket = null;
+  try {
+    if (mode === "server") {
+      await setupAdbReversePortForwarding(port, port, options.deviceId);
+      const harnessServer = await createHarnessServer(port, "127.0.0.1", timeoutMs);
+      serverInstance = harnessServer.server;
+      activeSocket = await harnessServer.getSocket();
+    } else {
+      try {
+        activeSocket = await connectClientWithRetries(port, "127.0.0.1", 8, 400);
+      } catch (clientErr) {
+        if (mode === "auto") {
+          try {
+            await setupAdbReversePortForwarding(port, port, options.deviceId);
+            const harnessServer = await createHarnessServer(port, "127.0.0.1", 1e4);
+            serverInstance = harnessServer.server;
+            activeSocket = await harnessServer.getSocket();
+          } catch {
+            throw clientErr;
+          }
+        } else {
+          throw clientErr;
+        }
+      }
+    }
+  } catch (connErr) {
+    const msg = `Failed to connect to React Native harness on port ${port}. Ensure the app is running with withSpectraComponentHarness. (${connErr.message})`;
+    if (options.reporter && typeof options.reporter.addLog === "function") {
+      options.reporter.addLog({
+        timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString(),
+        level: "ERROR",
+        message: `[TESTSPECTRA_TEST_ERROR] ${msg}`
+      });
+    }
+    return {
+      status: "failed",
+      passedCount: 0,
+      failedCount: specFiles.length,
+      suitesRun: specFiles.length,
+      durationMs: Date.now() - startTime,
+      results: specFiles.map((s) => ({
+        specPath: s,
+        passed: false,
+        durationMs: 0,
+        error: msg
+      }))
+    };
+  }
+  const results = [];
+  let passedCount = 0;
+  let failedCount = 0;
+  try {
+    for (const specFile of specFiles) {
+      if (options.reporter && typeof options.reporter.addLog === "function") {
+        options.reporter.addLog({
+          timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString(),
+          level: "INFO",
+          message: `[TESTSPECTRA_SUITE_START] ${JSON.stringify({ file: specFile })}`
+        });
+      }
+      if (!activeSocket || activeSocket.destroyed) {
+        activeSocket = await connectClientWithRetries(port, "127.0.0.1", 5, 300);
+      }
+      const specResult = await executeSpecOnSocket(activeSocket, specFile, {
+        bundleUrl: options.bundleUrl,
+        timeoutMs,
+        reporter: options.reporter,
+        onProtocolLine: options.onProtocolLine
+      });
+      results.push(specResult);
+      if (specResult.passed) {
+        passedCount++;
+      } else {
+        failedCount++;
+      }
+    }
+  } finally {
+    if (activeSocket && !activeSocket.destroyed) {
+      activeSocket.destroy();
+    }
+    if (serverInstance) {
+      serverInstance.close();
+    }
+    if (!options.skipAdbForward) {
+      await removeAdbPortForwarding(port, options.deviceId);
+    }
+  }
+  const totalDurationMs = Date.now() - startTime;
+  const overallStatus = failedCount === 0 && passedCount > 0 ? "passed" : "failed";
+  return {
+    status: overallStatus,
+    passedCount,
+    failedCount,
+    suitesRun: specFiles.length,
+    durationMs: totalDurationMs,
+    results
+  };
+}
+
+// src/index.ts
+init_library_spec_runner();
+init_react_native_driver_bridge();
+init_network_patch();
+init_tree_registry();
+init_in_app_runner();
+init_harness_root();
+
+// src/runtime/withSpectraComponentHarness.tsx
+init_harness_root();
+import React4 from "react";
+function withSpectraComponentHarness(App) {
+  const SpectraComponentHarness = (props) => {
+    const isComponentTest = process.env.SPECTRA_COMPONENT_TEST === "1" || globalThis.__SPECTRA_RUNNER_ACTIVE__ === true || Boolean(globalThis.__SPECTRA_COMPONENT_TEST__);
+    if (isComponentTest) {
+      return React4.createElement(SpectraHarnessRoot);
+    }
+    return React4.createElement(App, props);
+  };
+  SpectraComponentHarness.displayName = `withSpectraComponentHarness(${App.displayName || App.name || "Component"})`;
+  return SpectraComponentHarness;
+}
+var withSpectraComponentHarness_default = withSpectraComponentHarness;
+
+// src/index.ts
+init_mount();
+init_setup();
+export {
+  ReactNativeDriverBridge,
+  SpectraHarnessRoot,
+  activeMountListener,
+  activeUnmountListener,
+  afterEach,
+  beforeEach,
+  checkAdbDevices,
+  cleanup,
+  clearMocks,
+  clearMountedTree,
+  emit,
+  ensureNetworkPatch,
+  expect,
+  extractText,
+  findMobileSpecs,
+  flattenStyle,
+  getActiveMountListener,
+  getActiveUnmountListener,
+  getMountedTree,
+  getSocketEmitter,
+  it,
+  mobileRunner,
+  mount,
+  registerMockRule,
+  registerMountHandlers,
+  registerRootNode,
+  removeAdbPortForwarding,
+  runLibraryComponentSpecs,
+  runMobileComponentTests,
+  setMountedElement,
+  setMountedRootRef,
+  setSocketEmitter,
+  setupAdbPortForwarding,
+  setupAdbReversePortForwarding,
+  startMobileBundleServer,
+  unmount,
+  withSpectraComponentHarness,
+  withSpectraComponentHarness_default as withSpectraComponentHarnessDefault
+};