@testspectra/react 1.1.8-rc.22 → 1.1.8-rc.23

package/dist/setup.js

@@ -0,0 +1,1415 @@
+// src/prelude.ts
+var DEFAULT_IMPLICIT_WAIT_MS = 5e3;
+function emitEvent(tag, payload) {
+  if (!__TESTSPECTRA_SEMANTIC_REPORTER__) return;
+  console.log(`[${tag}] ${payload}`);
+}
+function getImplicitWaitMs() {
+  return DEFAULT_IMPLICIT_WAIT_MS;
+}
+function getAssertionTimeoutMs() {
+  return Math.min(getImplicitWaitMs(), 2e3);
+}
+async function trackStep(_category, payloadObj, fn) {
+  const currentTest = globalThis.__CURRENT_TEST_TITLE__;
+  if (currentTest && !payloadObj.test) payloadObj.test = currentTest;
+  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)`);
+    const delay = __TESTSPECTRA_STEP_DELAY_MS__ || 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)`);
+    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;
+  }
+}
+function matchesUrlPattern(pattern, url) {
+  if (!pattern || pattern === "*" || pattern === "**" || pattern === "ALL") return true;
+  if (pattern.startsWith("/") && pattern.endsWith("/")) {
+    try {
+      return new RegExp(pattern.slice(1, -1)).test(url);
+    } catch {
+    }
+  }
+  if (pattern.includes("*")) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    try {
+      return new RegExp(escaped, "i").test(url);
+    } catch {
+    }
+  }
+  return url.toLowerCase().includes(pattern.toLowerCase());
+}
+function createMockHandle(rule) {
+  const handle = {
+    respondWith: async () => {
+      throw new Error("Spectra.intercept() is not supported in component testing mode.");
+    },
+    respondOnce: async () => {
+      throw new Error("Spectra.intercept() is not supported in component testing mode.");
+    },
+    abort: async () => {
+      throw new Error("Spectra.intercept() is not supported in component testing mode.");
+    },
+    waitForCall: async () => {
+      throw new Error("Spectra.intercept() is not supported in component testing mode.");
+    }
+  };
+  handle.callCount = Object.assign(
+    () => rule.callCount,
+    { valueOf: () => rule.callCount, [Symbol.toPrimitive]: () => rule.callCount }
+  );
+  Object.defineProperty(handle, "calls", { get: () => rule.calls, enumerable: true });
+  return handle;
+}
+function parseMockRule() {
+  return {
+    pattern: "*",
+    method: "GET",
+    response: void 0,
+    statusCode: 200,
+    callCount: 0,
+    respondOnceQueue: [],
+    calls: [],
+    waitResolvers: []
+  };
+}
+globalThis.__TS_RUNTIME__ = {
+  config: {
+    rootDir: "",
+    activePlatform: "web",
+    configuredBaseUrl: "",
+    cdpWsUrl: "",
+    driverServerUrl: ""
+  },
+  activeDriver: null,
+  mobileMockRules: [],
+  lastFocusedSelector: null,
+  emitEvent,
+  trackStep,
+  pollCondition,
+  getImplicitWaitMs,
+  getAssertionTimeoutMs,
+  matchesUrlPattern,
+  createMockHandle,
+  parseMockRule,
+  beforeHook: null,
+  afterHook: null,
+  beforeEachHook: null,
+  afterEachHook: null,
+  suiteBeforeEachHooks: {},
+  suiteAfterEachHooks: {}
+};
+
+// ../matchers/src/runtime/element_actions.ts
+function createElementActions(selector, index) {
+  const driver = () => globalThis.__TS_RUNTIME__.activeDriver;
+  async function click(_options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "action",
+      { type: "action", key: "click", target: selector, args: [] },
+      async () => {
+        await driver().click(selector, index);
+      }
+    );
+  }
+  async function doubleClick() {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "action",
+      { type: "action", key: "doubleClick", target: selector, args: [] },
+      async () => {
+        await driver().doubleClick(selector, index);
+      }
+    );
+  }
+  async function rightClick() {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "action",
+      { type: "action", key: "rightClick", target: selector, args: [] },
+      async () => {
+        await driver().rightClick(selector, index);
+      }
+    );
+  }
+  async function setValue(value) {
+    return globalThis.__TS_RUNTIME__.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 globalThis.__TS_RUNTIME__.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 globalThis.__TS_RUNTIME__.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 globalThis.__TS_RUNTIME__.trackStep(
+      "action",
+      { type: "action", key: "hover", target: selector, args: [] },
+      async () => {
+        await driver().hover(selector, index);
+      }
+    );
+  }
+  async function focus() {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "action",
+      { type: "action", key: "focus", target: selector, args: [] },
+      async () => {
+        await driver().focus(selector, index);
+      }
+    );
+  }
+  async function moveTo() {
+    await hover();
+  }
+  async function dragDrop(target) {
+    const destSelector = typeof target === "string" ? target : target?.selector || String(target);
+    return globalThis.__TS_RUNTIME__.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 globalThis.__TS_RUNTIME__.trackStep(
+      "action",
+      { type: "action", key: "longPress", target: selector, args: [duration] },
+      async () => {
+        await driver().longPress(selector, duration, index);
+      }
+    );
+  }
+  async function scrollIntoView() {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "action",
+      { type: "action", key: "scrollIntoView", target: selector, args: [] },
+      async () => {
+        await driver().scrollIntoView(selector, index);
+      }
+    );
+  }
+  return {
+    click,
+    doubleClick,
+    rightClick,
+    setValue,
+    type,
+    clearValue,
+    clear,
+    select,
+    selectByVisibleText,
+    hover,
+    focus,
+    moveTo,
+    dragDrop,
+    dragAndDrop,
+    longPress,
+    scrollIntoView
+  };
+}
+globalThis.__TS_RUNTIME__.createElementActions = createElementActions;
+
+// ../matchers/src/runtime/element_state.ts
+function createElementState(selector, index) {
+  const driver = () => globalThis.__TS_RUNTIME__.activeDriver;
+  const selectorText2 = 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 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 ?? globalThis.__TS_RUNTIME__.getImplicitWaitMs();
+    const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+      async () => driver().isExisting(selector, index),
+      waitTimeout
+    );
+    if (ok) return true;
+    throw new Error("Element not found: " + JSON.stringify(selectorText2));
+  }
+  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 ${selectorText2} not displayed after ${timeout}ms`);
+  }
+  return {
+    getText,
+    getValue,
+    isDisplayed,
+    isVisible,
+    isExisting,
+    isEnabled,
+    isSelected,
+    isChecked,
+    isFocused,
+    getAttribute,
+    getCSSProperty,
+    waitForElement,
+    waitForDisplayed
+  };
+}
+globalThis.__TS_RUNTIME__.createElementState = createElementState;
+
+// ../matchers/src/runtime/assertions.ts
+function createElementAssertions(selector, index, state) {
+  const driver = () => globalThis.__TS_RUNTIME__.activeDriver;
+  const selectorText2 = typeof selector === "string" ? selector : selector.selector;
+  async function shouldBeVisible(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "be.visible", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => state.isVisible(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" to be visible`);
+      }
+    );
+  }
+  async function shouldNotBeVisible(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.be.visible", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !await state.isVisible(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" not to be visible`);
+      }
+    );
+  }
+  async function shouldExist(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "exist", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => state.isExisting(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" to exist in DOM`);
+      }
+    );
+  }
+  async function shouldNotExist(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.exist", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !await state.isExisting(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" not to exist in DOM`);
+      }
+    );
+  }
+  async function shouldBeEnabled(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "be.enabled", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => state.isEnabled(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" to be enabled`);
+      }
+    );
+  }
+  async function shouldBeDisabled(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "be.disabled", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !await state.isEnabled(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" to be disabled`);
+      }
+    );
+  }
+  async function shouldBeClickable(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "be.clickable", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => driver().isClickable(selector, index),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" to be clickable`);
+      }
+    );
+  }
+  async function shouldNotBeClickable(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.be.clickable", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !await driver().isClickable(selector, index),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" not to be clickable`);
+      }
+    );
+  }
+  async function shouldBeChecked(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "be.checked", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => state.isChecked(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" to be checked`);
+      }
+    );
+  }
+  async function shouldNotBeChecked(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.be.checked", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !await state.isChecked(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" not to be checked`);
+      }
+    );
+  }
+  async function shouldBeFocused(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "be.focused", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => state.isFocused(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" to be focused`);
+      }
+    );
+  }
+  async function shouldNotBeFocused(options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.be.focused", target: selector, args: [] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !await state.isFocused(),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" not to be focused`);
+      }
+    );
+  }
+  async function shouldHaveValue(value, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "have.value", target: selector, args: [value] },
+      async () => {
+        let actual = "";
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          actual = await state.getValue();
+          return actual === String(value);
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText2}" to have value "${value}", but got "${actual}"`);
+      }
+    );
+  }
+  async function shouldNotHaveValue(value, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.have.value", target: selector, args: [value] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const actual = await state.getValue();
+          return actual !== String(value);
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText2}" not to have value "${value}"`);
+      }
+    );
+  }
+  async function shouldContainValue(value, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "contain.value", target: selector, args: [value] },
+      async () => {
+        let actual = "";
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          actual = await state.getValue();
+          return actual.includes(String(value));
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText2}" to contain value "${value}", but got "${actual}"`);
+      }
+    );
+  }
+  async function shouldNotContainValue(value, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.contain.value", target: selector, args: [value] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const actual = await state.getValue();
+          return !actual.includes(String(value));
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText2}" not to contain value "${value}"`);
+      }
+    );
+  }
+  async function shouldHaveText(expected, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "have.text", target: selector, args: [expected] },
+      async () => {
+        let actual = "";
+        const ok = await globalThis.__TS_RUNTIME__.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 ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) {
+          if (expected instanceof RegExp)
+            throw new Error(`Expected element "${selectorText2}" text to match ${expected}, but got "${actual}"`);
+          throw new Error(`Expected element "${selectorText2}" to have text "${expected}", but got "${actual}"`);
+        }
+      }
+    );
+  }
+  async function shouldNotHaveText(expected, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.have.text", target: selector, args: [expected] },
+      async () => {
+        let actual = "";
+        const ok = await globalThis.__TS_RUNTIME__.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 ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) {
+          if (expected instanceof RegExp)
+            throw new Error(`Expected element "${selectorText2}" text not to match ${expected}`);
+          throw new Error(`Expected element "${selectorText2}" not to have text "${expected}"`);
+        }
+      }
+    );
+  }
+  async function shouldContainText(substring, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "contain.text", target: selector, args: [substring] },
+      async () => {
+        let actual = "";
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          actual = await state.getText();
+          return actual.includes(String(substring));
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok)
+          throw new Error(`Expected element "${selectorText2}" to contain text "${substring}", but got "${actual}"`);
+      }
+    );
+  }
+  async function shouldNotContainText(substring, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.contain.text", target: selector, args: [substring] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const actual = await state.getText();
+          return !actual.includes(String(substring));
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText2}" not to contain text "${substring}"`);
+      }
+    );
+  }
+  async function shouldHaveClass(className, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "have.class", target: selector, args: [className] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          () => driver().hasClass(selector, className, index),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" to have class "${className}"`);
+      }
+    );
+  }
+  async function shouldNotHaveClass(className, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.have.class", target: selector, args: [className] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+          async () => !await driver().hasClass(selector, className, index),
+          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs()
+        );
+        if (!ok) throw new Error(`Expected element "${selectorText2}" not to have class "${className}"`);
+      }
+    );
+  }
+  async function shouldHaveAttribute(name, value, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "have.attr", target: selector, args: value !== void 0 ? [name, value] : [name] },
+      async () => {
+        let actual = null;
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          actual = await state.getAttribute(name);
+          if (value !== void 0) return actual === String(value);
+          return actual !== null;
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) {
+          if (value !== void 0)
+            throw new Error(
+              `Expected element "${selectorText2}" to have attribute "${name}" = "${value}", but got "${actual}"`
+            );
+          throw new Error(`Expected element "${selectorText2}" to have attribute "${name}"`);
+        }
+      }
+    );
+  }
+  async function shouldNotHaveAttribute(name, options) {
+    return globalThis.__TS_RUNTIME__.trackStep(
+      "assertion",
+      { type: "assertion", key: "not.have.attr", target: selector, args: [name] },
+      async () => {
+        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const actual = await state.getAttribute(name);
+          return actual === null;
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText2}" not to have attribute "${name}"`);
+      }
+    );
+  }
+  async function shouldHaveCss(property, value, options) {
+    return globalThis.__TS_RUNTIME__.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 globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const css = await state.getCSSProperty(property);
+          actualCss = css.value;
+          return norm(actualCss) === norm(value);
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok)
+          throw new Error(
+            `Expected element "${selectorText2}" to have CSS "${property}" = "${value}", but got "${actualCss}"`
+          );
+      }
+    );
+  }
+  async function shouldNotHaveCss(property, value, options) {
+    return globalThis.__TS_RUNTIME__.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 globalThis.__TS_RUNTIME__.pollCondition(async () => {
+          const css = await state.getCSSProperty(property);
+          return norm(css.value) !== norm(value);
+        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+        if (!ok) throw new Error(`Expected element "${selectorText2}" 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
+  };
+}
+globalThis.__TS_RUNTIME__.createElementAssertions = createElementAssertions;
+
+// ../matchers/src/runtime/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 = globalThis.__TS_RUNTIME__.createElementActions(selector, index);
+  const state = globalThis.__TS_RUNTIME__.createElementState(selector, index);
+  const assertions = globalThis.__TS_RUNTIME__.createElementAssertions(selector, index, state);
+  return {
+    selector: selectorTextValue,
+    index: resolvedIndex,
+    ...actions,
+    ...state,
+    ...assertions,
+    get(childSelector, childIndex = null) {
+      return globalThis.__TS_RUNTIME__.createElementProxy(
+        { selector: childSelector, index: childIndex, parent: toScopedSelector(selector, index) },
+        null
+      );
+    },
+    getAll(childSelector) {
+      return globalThis.__TS_RUNTIME__.createCollectionProxy({
+        selector: childSelector,
+        index: null,
+        parent: toScopedSelector(selector, index)
+      });
+    }
+  };
+}
+function createCollectionProxy(selector) {
+  const driver = () => globalThis.__TS_RUNTIME__.activeDriver;
+  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 globalThis.__TS_RUNTIME__.createElementProxy(...withIndex(0));
+    },
+    last() {
+      return globalThis.__TS_RUNTIME__.createElementProxy(...withIndex(-1));
+    },
+    nth(index) {
+      return globalThis.__TS_RUNTIME__.createElementProxy(...withIndex(index));
+    },
+    async shouldHaveLength(expected, options) {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        "assertion",
+        { type: "assertion", key: "have.length", target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual === expected;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" count to equal ${expected}, but got ${actual}`);
+          }
+        }
+      );
+    },
+    async shouldNotHaveLength(expected, options) {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        "assertion",
+        { type: "assertion", key: "not.have.length", target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual !== expected;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" count not to equal ${expected}`);
+          }
+        }
+      );
+    },
+    async shouldHaveLengthGreaterThan(expected, options) {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        "assertion",
+        { type: "assertion", key: "have.length.greaterThan", target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual > expected;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(
+              `Expected collection "${selectorTextValue}" count to be greater than ${expected}, but got ${actual}`
+            );
+          }
+        }
+      );
+    },
+    async shouldHaveLengthLessThan(expected, options) {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        "assertion",
+        { type: "assertion", key: "have.length.lessThan", target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual < expected;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" count to be less than ${expected}, but got ${actual}`);
+          }
+        }
+      );
+    },
+    async shouldBeEmpty(options) {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        "assertion",
+        { type: "assertion", key: "be.empty", target: selector, args: [] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual === 0;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" to be empty, but got ${actual}`);
+          }
+        }
+      );
+    },
+    async shouldNotBeEmpty(options) {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        "assertion",
+        { type: "assertion", key: "not.be.empty", target: selector, args: [] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual > 0;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" not to be empty`);
+          }
+        }
+      );
+    }
+  };
+  return collectionProxy;
+}
+function resolveTargetProxy(target) {
+  if (typeof target === "string") {
+    return globalThis.$(target);
+  }
+  if (target && typeof target === "object" && "selector" in target) {
+    return target;
+  }
+  throw new Error(`Invalid element target: ${String(target)}`);
+}
+globalThis.__TS_RUNTIME__.createElementProxy = createElementProxy;
+globalThis.__TS_RUNTIME__.createCollectionProxy = createCollectionProxy;
+globalThis.__TS_RUNTIME__.resolveTargetProxy = resolveTargetProxy;
+
+// ../matchers/src/runtime/spectra.ts
+function buildSpectra() {
+  const driver = () => globalThis.__TS_RUNTIME__.activeDriver;
+  return {
+    get: (target) => globalThis.__TS_RUNTIME__.resolveTargetProxy(target),
+    getAll: (selector) => globalThis.__TS_RUNTIME__.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 = globalThis.__TS_RUNTIME__.resolveTargetProxy(target);
+      await el.click();
+    },
+    doubleClick: async (target) => {
+      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy(target);
+      await el.doubleClick();
+    },
+    rightClick: async (target) => {
+      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy(target);
+      await el.rightClick();
+    },
+    type: async (target, text, options) => {
+      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy(target);
+      await el.type(text, options);
+    },
+    clear: async (target) => {
+      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy(target);
+      await el.clear();
+    },
+    select: async (target, option) => {
+      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy(target);
+      await el.select(option);
+    },
+    hover: async (target) => {
+      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy(target);
+      await el.hover();
+    },
+    focus: async (target) => {
+      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy(target);
+      await el.focus();
+    },
+    dragDrop: async (source, destination) => {
+      const srcEl = globalThis.__TS_RUNTIME__.resolveTargetProxy(source);
+      await srcEl.dragDrop(destination);
+    },
+    scrollIntoView: async (target) => {
+      const el = globalThis.__TS_RUNTIME__.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 = globalThis.__TS_RUNTIME__.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 = globalThis.__TS_RUNTIME__.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();
+    },
+    env: globalThis.__TS_RUNTIME__.config.environmentVariables || {}
+  };
+}
+globalThis.__TS_RUNTIME__.buildSpectra = buildSpectra;
+
+// src/auto_import.ts
+async function dynamicImport(path) {
+  const vitePath = `/@fs/${path.replace(/\\/g, "/")}`.replace(/\/@fs\/\//g, "/@fs/");
+  return import(
+    /* @vite-ignore */
+    vitePath
+  );
+}
+async function bootstrapAutoImports() {
+  const manifest = __TESTSPECTRA_AUTO_IMPORT_MANIFEST__;
+  for (const { name, path } of manifest.pageObjects) {
+    const mod = await dynamicImport(path);
+    globalThis[name] = mod.default ?? mod;
+  }
+  const fixtures = {};
+  for (const { name, path } of manifest.fixtures) {
+    const mod = await dynamicImport(path);
+    fixtures[name] = mod.default ?? mod;
+  }
+  globalThis.Fixture = fixtures;
+  const steps = {};
+  for (const { name, path } of manifest.steps) {
+    const mod = await dynamicImport(path);
+    steps[name] = mod.default ?? mod;
+  }
+  globalThis.Step = steps;
+}
+
+// src/dom_driver_bridge.ts
+var cachedUser = null;
+async function getUser() {
+  if (!cachedUser) {
+    const { userEvent } = await import("@testing-library/user-event");
+    cachedUser = userEvent.setup();
+  }
+  return cachedUser;
+}
+function resolveSelector(selector) {
+  const trimmed = selector.trim();
+  if (trimmed.startsWith("~")) {
+    return `[aria-label=${JSON.stringify(trimmed.slice(1))}]`;
+  }
+  return trimmed;
+}
+function resolveEl(selector, index) {
+  const css = resolveSelector(selector);
+  if (index === null) {
+    return document.querySelector(css);
+  }
+  const all = Array.from(document.querySelectorAll(css));
+  if (index >= 0) return all[index] ?? null;
+  return all[all.length + index] ?? null;
+}
+function isFormEl(el) {
+  const tag = el.tagName;
+  return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT";
+}
+var DomDriverBridge = class {
+  mockRules = [];
+  consoleErrors = [];
+  recordedNetwork = [];
+  /** Polls until `selector` resolves to an element, then returns it — shared by every
+   * interaction method below (user-event needs a real element handle, not a selector string). */
+  async waitForEl(selector, index) {
+    let found = null;
+    const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+      found = resolveEl(selector, index);
+      return found !== null;
+    }, globalThis.__TS_RUNTIME__.getImplicitWaitMs());
+    if (!ok || !found) throw new Error("Element not found: " + JSON.stringify(selector));
+    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 setCookies(setCookieHeaders, _url) {
+    const headers = Array.isArray(setCookieHeaders) ? setCookieHeaders : [setCookieHeaders];
+    for (const header of headers) {
+      if (typeof document !== "undefined") {
+        document.cookie = header;
+      }
+    }
+  }
+  async back() {
+    throw new Error("Spectra.back() is not supported in component testing mode.");
+  }
+  async forward() {
+    throw new Error("Spectra.forward() is not supported in component testing mode.");
+  }
+  async refresh() {
+    throw new Error("Spectra.refresh() is not supported in component testing mode.");
+  }
+  async setViewport(width, height) {
+    try {
+      window.resizeTo(width, height);
+    } catch {
+    }
+  }
+  async pause(ms) {
+    await new Promise((r) => setTimeout(r, ms));
+  }
+  // ─── Element Actions ─────────────────────────────────────────────────────
+  async click(selector, index = null) {
+    const el = await this.waitForEl(selector, index);
+    await (await getUser()).click(el);
+  }
+  async doubleClick(selector, index = null) {
+    const el = await this.waitForEl(selector, index);
+    await (await getUser()).dblClick(el);
+  }
+  async rightClick(selector, index = null) {
+    const el = await this.waitForEl(selector, index);
+    await (await getUser()).pointer({ keys: "[MouseRight]", target: el });
+  }
+  async setValue(selector, value, index = null) {
+    const el = await this.waitForEl(selector, index);
+    if (!isFormEl(el)) throw new Error("Element is not a form field: " + JSON.stringify(selector));
+    const u = await getUser();
+    await u.clear(el);
+    if (String(value).length > 0) {
+      await u.type(el, String(value));
+    }
+  }
+  async clearValue(selector, index = null) {
+    const el = await this.waitForEl(selector, index);
+    await (await getUser()).clear(el);
+  }
+  async select(selector, option, index = null) {
+    const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+      const el = resolveEl(selector, index);
+      if (!el || el.tagName !== "SELECT") return false;
+      for (let i = 0; i < el.options.length; i++) {
+        const opt = el.options[i];
+        if (opt.text === option || opt.value === option) {
+          el.selectedIndex = i;
+          el.dispatchEvent(new Event("change", { bubbles: true }));
+          return true;
+        }
+      }
+      return false;
+    });
+    if (!ok) throw new Error("Select option not found: " + JSON.stringify(option));
+  }
+  async hover(selector, index = null) {
+    const el = await this.waitForEl(selector, index);
+    await (await getUser()).hover(el);
+  }
+  async focus(selector, index = null) {
+    const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+      const el = resolveEl(selector, index);
+      if (!el) return false;
+      el.focus?.();
+      return true;
+    });
+    if (!ok) throw new Error("Element not found: " + JSON.stringify(selector));
+  }
+  async dragDrop(sourceSelector, targetSelector, sourceIndex = null) {
+    const src = resolveEl(sourceSelector, sourceIndex);
+    const dest = resolveEl(targetSelector, null);
+    if (!src || !dest) throw new Error("Drag source or destination not found");
+    const dataTransfer = new DataTransfer();
+    src.dispatchEvent(new DragEvent("dragstart", { bubbles: true, dataTransfer }));
+    dest.dispatchEvent(new DragEvent("dragover", { bubbles: true, dataTransfer }));
+    dest.dispatchEvent(new DragEvent("drop", { bubbles: true, dataTransfer }));
+    src.dispatchEvent(new DragEvent("dragend", { bubbles: true, dataTransfer }));
+  }
+  async longPress(selector, duration, index = null) {
+    const el = resolveEl(selector, index);
+    if (!el) throw new Error("Element not found: " + JSON.stringify(selector));
+    el.dispatchEvent(new TouchEvent("touchstart", { bubbles: true }));
+    await this.pause(duration);
+    el.dispatchEvent(new TouchEvent("touchend", { bubbles: true }));
+  }
+  async scrollIntoView(selector, index = null) {
+    const el = resolveEl(selector, index);
+    el?.scrollIntoView({ block: "center", inline: "center" });
+  }
+  // ─── Element State Inspection ────────────────────────────────────────────
+  async getText(selector, index = null) {
+    const el = resolveEl(selector, index);
+    if (!el) return "";
+    return el.innerText !== void 0 ? el.innerText : el.textContent || "";
+  }
+  async getValue(selector, index = null) {
+    const el = resolveEl(selector, index);
+    if (!el) return "";
+    if (isFormEl(el)) return el.value ?? "";
+    return el.getAttribute("value") || "";
+  }
+  async isDisplayed(selector, index = null) {
+    const el = resolveEl(selector, index);
+    if (!el) return false;
+    const style = window.getComputedStyle(el);
+    if (style.visibility === "hidden" || style.display === "none" || style.opacity === "0") return false;
+    const rect = el.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0 || el.getClientRects().length > 0 || el.offsetWidth > 0 && el.offsetHeight > 0;
+  }
+  async isExisting(selector, index = null) {
+    return resolveEl(selector, index) !== null;
+  }
+  async isEnabled(selector, index = null) {
+    const el = resolveEl(selector, index);
+    if (!el) return false;
+    return !el.disabled && !el.hasAttribute("disabled") && !el.classList.contains("disabled") && el.getAttribute("aria-disabled") !== "true";
+  }
+  async isSelected(selector, index = null) {
+    const el = resolveEl(selector, index);
+    if (!el) return false;
+    return !!el.checked || el.getAttribute("aria-checked") === "true" || el.getAttribute("data-state") === "checked";
+  }
+  async isFocused(selector, index = null) {
+    const el = resolveEl(selector, index);
+    if (!el) return false;
+    return document.activeElement === el || el.matches(":focus");
+  }
+  async isClickable(selector, index = null) {
+    const el = resolveEl(selector, index);
+    if (!el) return false;
+    const style = window.getComputedStyle(el);
+    if (style.visibility === "hidden" || style.display === "none" || style.opacity === "0") return false;
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 && rect.height === 0) return false;
+    return !el.disabled && !el.hasAttribute("disabled") && !el.classList.contains("disabled") && el.getAttribute("aria-disabled") !== "true";
+  }
+  async hasClass(selector, className, index = null) {
+    const el = resolveEl(selector, index);
+    return el ? el.classList.contains(className) : false;
+  }
+  async getAttribute(selector, name, index = null) {
+    const el = resolveEl(selector, index);
+    return el ? el.getAttribute(name) : null;
+  }
+  async getCSSProperty(selector, name, index = null) {
+    const el = resolveEl(selector, index);
+    return { value: el ? window.getComputedStyle(el).getPropertyValue(name) : "" };
+  }
+  async count(selector) {
+    return document.querySelectorAll(resolveSelector(selector)).length;
+  }
+  // ─── Gestures & Keys ─────────────────────────────────────────────────────
+  async pressKey(key) {
+    const active = document.activeElement || document.body;
+    const keyName = String(key);
+    active.dispatchEvent(new KeyboardEvent("keydown", { key: keyName, bubbles: true }));
+    active.dispatchEvent(new KeyboardEvent("keyup", { key: keyName, bubbles: true }));
+  }
+  async scroll(options = {}) {
+    if (options.selector) {
+      await this.scrollIntoView(String(options.selector), null);
+      return;
+    }
+    const dir = options.direction || "down";
+    const px = options.pixels || 500;
+    const deltaY = dir === "up" ? -px : dir === "down" ? px : 0;
+    const deltaX = dir === "left" ? -px : dir === "right" ? px : 0;
+    window.scrollBy(deltaX, deltaY);
+  }
+  async swipe(options) {
+    const dist = options.distance || 300;
+    const deltaY = options.direction === "up" ? dist : options.direction === "down" ? -dist : 0;
+    const deltaX = options.direction === "left" ? dist : options.direction === "right" ? -dist : 0;
+    window.scrollBy(deltaX, deltaY);
+  }
+  async grantPermission(_name) {
+  }
+  // ─── Browser-Level Bridge (SpectraBrowserBridge) ────────────────────────
+  async getUrl() {
+    return window.location.href;
+  }
+  async getTitle() {
+    return document.title;
+  }
+  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);
+    if (!ok) throw new Error(opts?.timeoutMsg || "waitUntil() condition was not met in time");
+    return ok;
+  }
+  async getLogs(_type) {
+    return [];
+  }
+  async shouldHaveUrl(expectedUrl) {
+    const actual = await this.getUrl();
+    if (actual !== expectedUrl) throw new Error(`Expected browser URL to be "${expectedUrl}", but got "${actual}"`);
+  }
+  async shouldContainUrl(expectedSubstr) {
+    const actual = await this.getUrl();
+    if (!actual.includes(expectedSubstr)) {
+      throw new Error(`Expected browser URL to contain "${expectedSubstr}", but got "${actual}"`);
+    }
+  }
+  async shouldHaveTitle(expectedTitle) {
+    const actual = await this.getTitle();
+    if (actual !== expectedTitle) throw new Error(`Expected page title to be "${expectedTitle}", but got "${actual}"`);
+  }
+  async shouldContainTitle(expectedSubstr) {
+    const actual = await this.getTitle();
+    if (!actual.includes(expectedSubstr)) {
+      throw new Error(`Expected page title to contain "${expectedSubstr}", but got "${actual}"`);
+    }
+  }
+  async shouldBeLoaded() {
+    if (document.readyState !== "complete" && document.readyState !== "interactive") {
+      throw new Error(`Expected document to be loaded, but readyState is "${document.readyState}"`);
+    }
+  }
+  async shouldHaveNoConsoleErrors() {
+    if (this.consoleErrors.length > 0) {
+      throw new Error(
+        `Expected no console errors, but found ${this.consoleErrors.length}: ${this.consoleErrors.join("; ")}`
+      );
+    }
+  }
+  async clearCookies() {
+    document.cookie.split(";").forEach((c) => {
+      const name = c.split("=")[0]?.trim();
+      if (name) document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/`;
+    });
+  }
+  async clearLocalStorage() {
+    window.localStorage.clear();
+  }
+  // ─── Network Interception (Out of Scope for Component Testing MVP) ─────
+  async intercept(_patternOrOptions, _method, _fixture, _options) {
+    throw new Error(
+      'Spectra.intercept() is not supported in component testing mode \u2014 there is no network boundary between the test and the mounted component to intercept. Mock fetch/HTTP clients directly instead (e.g. `vi.spyOn(global, "fetch")` or MSW).'
+    );
+  }
+  clearMocks() {
+  }
+};
+
+// src/mount.ts
+import * as ReactDOMClient from "react-dom/client";
+var ROOT_ID = "spectra-root";
+var cachedRoot = null;
+function getCreateRoot() {
+  const client = ReactDOMClient;
+  return client.createRoot || client.default?.createRoot || client.default;
+}
+function ensureContainer() {
+  let container = document.getElementById(ROOT_ID);
+  if (!container) {
+    container = document.createElement("div");
+    container.id = ROOT_ID;
+    document.body.appendChild(container);
+  }
+  return container;
+}
+async function mount(element) {
+  const container = ensureContainer();
+  if (!cachedRoot) {
+    const createRootFn = getCreateRoot();
+    cachedRoot = createRootFn(container);
+  }
+  const componentName = (typeof element.type === "string" ? element.type : element.type?.displayName || element.type?.name) || "component";
+  return globalThis.__TS_RUNTIME__.trackStep(
+    "action",
+    { type: "action", key: "mount", target: componentName, args: [] },
+    async () => {
+      cachedRoot.render(element);
+      await new Promise((r) => setTimeout(r, 0));
+      return globalThis.__TS_RUNTIME__.createElementProxy(`#${ROOT_ID}`);
+    }
+  );
+}
+
+// src/setup.ts
+var activeDriver = new DomDriverBridge();
+globalThis.__TS_RUNTIME__.activeDriver = activeDriver;
+globalThis.browser = activeDriver;
+globalThis.$ = function(selector) {
+  return globalThis.__TS_RUNTIME__.createElementProxy(selector);
+};
+globalThis.$$ = function(selector) {
+  return globalThis.__TS_RUNTIME__.createCollectionProxy(selector);
+};
+var spectra = globalThis.__TS_RUNTIME__.buildSpectra();
+spectra.mount = mount;
+globalThis.Spectra = spectra;
+await bootstrapAutoImports();
+var testStartedAt = 0;
+beforeEach((ctx) => {
+  testStartedAt = Date.now();
+  globalThis.__CURRENT_TEST_TITLE__ = ctx.task.name;
+  globalThis.__TS_RUNTIME__.emitEvent("TESTSPECTRA_TEST_START", JSON.stringify({ title: ctx.task.name }));
+});
+afterEach((ctx) => {
+  const duration = Date.now() - testStartedAt;
+  const failed = ctx.task.result?.state === "fail";
+  if (failed) {
+    const message = ctx.task.result?.errors?.[0]?.message;
+    if (message) globalThis.__TS_RUNTIME__.emitEvent("TESTSPECTRA_TEST_ERROR", message);
+    globalThis.__TS_RUNTIME__.emitEvent("TESTSPECTRA_TEST_FAIL", `${ctx.task.name} (${duration}ms)`);
+  } else {
+    globalThis.__TS_RUNTIME__.emitEvent("TESTSPECTRA_TEST_PASS", `${ctx.task.name} (${duration}ms)`);
+  }
+});