@testspectra/react 1.1.8-rc.10

package/LICENSE.md

@@ -0,0 +1,48 @@
+# TestSpectra Commercial Software License Agreement
+
+Copyright (c) 2026 TestSpectra. All rights reserved.
+
+IMPORTANT NOTICE: This software is NOT open-source. Although distribution archives,
+npm packages, and editor extensions are publicly downloadable, installation,
+execution, and use of the Software are strictly conditioned upon obtaining a valid
+Commercial License or an authorized Evaluation/Trial License from TestSpectra.
+
+1. GRANT OF LICENSE
+   Subject to payment of applicable license fees or an active authorized evaluation
+   period, TestSpectra grants you a non-exclusive, non-transferable, revocable license
+   to install and execute the Software solely for authoring, debugging, and executing
+   automated software tests.
+
+2. LICENSE ACTIVATION & ENFORCEMENT
+   - Use of the Software requires activation via a valid License Key, authorized CI token,
+     or active TestSpectra Cloud account.
+   - Any attempt to circumvent, disable, modify, reverse engineer, or tamper with the
+     license verification mechanisms, cryptographic signatures, or binary checks is
+     a material breach of this Agreement and automatically terminates your license.
+
+3. RESTRICTIONS
+   You shall not, and shall not permit any third party to:
+   - Decompile, disassemble, reverse engineer, or derive source code from the binaries,
+     compiled scripts, or libraries of the Software.
+   - Sublicense, sell, rent, lease, distribute, or host the Software as a service for third parties.
+   - Re-brand, white-label, or package the Software or any of its components as part of a
+     competing commercial QA, testing, or developer tooling product.
+   - Modify, alter, or remove any proprietary notices, copyright labels, or license headers.
+
+4. INTELLECTUAL PROPERTY
+   The Software, including its source code, architecture, Rust core engine, algorithms,
+   matchers, extensions, interfaces, and documentation, represents valuable intellectual
+   property and trade secrets of TestSpectra.
+
+5. TERMINATION
+   This license is effective until terminated. Your rights under this license will terminate
+   automatically without notice if you fail to comply with any of its terms, or upon expiration
+   of your active subscription or trial term. Upon termination, you must cease all use of
+   the Software and delete all copies in your possession.
+
+6. DISCLAIMER OF WARRANTY & LIMITATION OF LIABILITY
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+   INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+   PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+   ARISING FROM THE USE OF OR INABILITY TO USE THE SOFTWARE.

package/bin/testspectra-react.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { runCli } from '../dist/cli.js';
+
+runCli().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/cli.js

@@ -0,0 +1,82 @@
+// src/cli.ts
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+async function runComponentTests(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = fileURLToPath(new URL("../vitest.config.ts", import.meta.url));
+  const ext = process.platform === "win32" ? ".cmd" : "";
+  const vitestBin = fileURLToPath(new URL(`../node_modules/.bin/vitest${ext}`, import.meta.url));
+  const args = ["run", "--config", configPath];
+  if (options.outputFile) {
+    args.push("--reporter=default", "--reporter=json", `--outputFile.json=${options.outputFile}`);
+  }
+  if (options.spec) {
+    args.push(options.spec);
+  }
+  const semanticReporter = Boolean(options.onLine);
+  return new Promise((resolve) => {
+    const child = spawn(vitestBin, args, {
+      stdio: semanticReporter ? ["inherit", "pipe", "pipe"] : "inherit",
+      cwd,
+      env: {
+        ...process.env,
+        TESTSPECTRA_TEST_ROOT: cwd,
+        TESTSPECTRA_HEADLESS: options.headless === false ? "false" : "true",
+        TESTSPECTRA_STEP_DELAY: String(options.stepDelayMs ?? 0),
+        TESTSPECTRA_FILE_PARALLELISM: options.concurrency === 1 ? "false" : "true",
+        ...options.browserExecutablePath ? { TESTSPECTRA_BROWSER_EXECUTABLE: options.browserExecutablePath } : {},
+        TESTSPECTRA_SEMANTIC_REPORTER: semanticReporter ? "1" : "0"
+      },
+      shell: process.platform === "win32"
+    });
+    if (semanticReporter) {
+      const handleData = (buf) => {
+        for (const line of buf.toString().split("\n")) {
+          if (line.trim()) options.onLine(line);
+        }
+      };
+      child.stdout?.on("data", handleData);
+      child.stderr?.on("data", handleData);
+    }
+    child.on("exit", (code) => resolve(code === 0));
+    child.on("error", (err) => {
+      console.error(err);
+      resolve(false);
+    });
+  });
+}
+function getFlagValue(argv, ...names) {
+  const index = argv.findIndex((a) => names.includes(a));
+  return index !== -1 ? argv[index + 1] : void 0;
+}
+async function runCli(argv = process.argv.slice(2)) {
+  const [command] = argv;
+  if (command !== "test") {
+    console.error(`Unknown command: ${command ?? "(none)"}. Usage: testspectra-react test`);
+    process.exit(1);
+  }
+  let headless = true;
+  if (argv.includes("--headed") || argv.includes("--no-headless")) headless = false;
+  else if (argv.includes("--headless")) headless = true;
+  const rawDelay = getFlagValue(argv, "--step-delay", "--delay");
+  let stepDelayMs;
+  if (rawDelay !== void 0) {
+    const parsed = parseInt(String(rawDelay), 10);
+    if (!isNaN(parsed) && parsed >= 0) stepDelayMs = parsed;
+  }
+  const spec = getFlagValue(argv, "--spec", "-s");
+  const outputFile = getFlagValue(argv, "--output", "-o");
+  const rawConcurrency = getFlagValue(argv, "--concurrency", "-c");
+  let concurrency;
+  if (rawConcurrency !== void 0) {
+    const parsed = parseInt(String(rawConcurrency), 10);
+    if (!isNaN(parsed) && parsed >= 1) concurrency = parsed;
+  }
+  const browserExecutablePath = getFlagValue(argv, "--browser-executable");
+  const ok = await runComponentTests({ headless, stepDelayMs, spec, outputFile, concurrency, browserExecutablePath });
+  process.exit(ok ? 0 : 1);
+}
+export {
+  runCli,
+  runComponentTests
+};

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+import type { PlatformDriverBridge } from '@testspectra/matchers';
+
+export declare class DomDriverBridge implements PlatformDriverBridge {
+  [key: string]: any;
+}
+
+export declare function mount<P = any>(element: any): Promise<any>;
+
+export interface RunComponentTestsOptions {
+  cwd?: string;
+  headless?: boolean;
+  stepDelayMs?: number;
+  spec?: string;
+  outputFile?: string;
+  concurrency?: number;
+  browserExecutablePath?: string;
+  onLine?: (line: string) => void;
+}
+
+export declare function runComponentTests(options?: RunComponentTestsOptions): Promise<boolean>;
+export declare function runCli(argv?: string[]): Promise<void>;
+export type { ExpectStatic } from 'vitest';

package/dist/index.js

@@ -0,0 +1,422 @@
+// 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 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 { createRoot } from "react-dom/client";
+var ROOT_ID = "spectra-root";
+var cachedRoot = null;
+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) {
+    cachedRoot = createRoot(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/cli.ts
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+async function runComponentTests(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = fileURLToPath(new URL("../vitest.config.ts", import.meta.url));
+  const ext = process.platform === "win32" ? ".cmd" : "";
+  const vitestBin = fileURLToPath(new URL(`../node_modules/.bin/vitest${ext}`, import.meta.url));
+  const args = ["run", "--config", configPath];
+  if (options.outputFile) {
+    args.push("--reporter=default", "--reporter=json", `--outputFile.json=${options.outputFile}`);
+  }
+  if (options.spec) {
+    args.push(options.spec);
+  }
+  const semanticReporter = Boolean(options.onLine);
+  return new Promise((resolve) => {
+    const child = spawn(vitestBin, args, {
+      stdio: semanticReporter ? ["inherit", "pipe", "pipe"] : "inherit",
+      cwd,
+      env: {
+        ...process.env,
+        TESTSPECTRA_TEST_ROOT: cwd,
+        TESTSPECTRA_HEADLESS: options.headless === false ? "false" : "true",
+        TESTSPECTRA_STEP_DELAY: String(options.stepDelayMs ?? 0),
+        TESTSPECTRA_FILE_PARALLELISM: options.concurrency === 1 ? "false" : "true",
+        ...options.browserExecutablePath ? { TESTSPECTRA_BROWSER_EXECUTABLE: options.browserExecutablePath } : {},
+        TESTSPECTRA_SEMANTIC_REPORTER: semanticReporter ? "1" : "0"
+      },
+      shell: process.platform === "win32"
+    });
+    if (semanticReporter) {
+      const handleData = (buf) => {
+        for (const line of buf.toString().split("\n")) {
+          if (line.trim()) options.onLine(line);
+        }
+      };
+      child.stdout?.on("data", handleData);
+      child.stderr?.on("data", handleData);
+    }
+    child.on("exit", (code) => resolve(code === 0));
+    child.on("error", (err) => {
+      console.error(err);
+      resolve(false);
+    });
+  });
+}
+function getFlagValue(argv, ...names) {
+  const index = argv.findIndex((a) => names.includes(a));
+  return index !== -1 ? argv[index + 1] : void 0;
+}
+async function runCli(argv = process.argv.slice(2)) {
+  const [command] = argv;
+  if (command !== "test") {
+    console.error(`Unknown command: ${command ?? "(none)"}. Usage: testspectra-react test`);
+    process.exit(1);
+  }
+  let headless = true;
+  if (argv.includes("--headed") || argv.includes("--no-headless")) headless = false;
+  else if (argv.includes("--headless")) headless = true;
+  const rawDelay = getFlagValue(argv, "--step-delay", "--delay");
+  let stepDelayMs;
+  if (rawDelay !== void 0) {
+    const parsed = parseInt(String(rawDelay), 10);
+    if (!isNaN(parsed) && parsed >= 0) stepDelayMs = parsed;
+  }
+  const spec = getFlagValue(argv, "--spec", "-s");
+  const outputFile = getFlagValue(argv, "--output", "-o");
+  const rawConcurrency = getFlagValue(argv, "--concurrency", "-c");
+  let concurrency;
+  if (rawConcurrency !== void 0) {
+    const parsed = parseInt(String(rawConcurrency), 10);
+    if (!isNaN(parsed) && parsed >= 1) concurrency = parsed;
+  }
+  const browserExecutablePath = getFlagValue(argv, "--browser-executable");
+  const ok = await runComponentTests({ headless, stepDelayMs, spec, outputFile, concurrency, browserExecutablePath });
+  process.exit(ok ? 0 : 1);
+}
+export {
+  DomDriverBridge,
+  mount,
+  runCli,
+  runComponentTests
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@testspectra/react",
+  "version": "1.1.8-rc.10",
+  "description": "Bundled Vitest browser-mode runner for React component testing with the TestSpectra Spectra.* DSL",
+  "keywords": [
+    "testspectra",
+    "spectra",
+    "react",
+    "component-testing",
+    "vitest"
+  ],
+  "homepage": "https://github.com/TestSpectra/testspectra-source",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TestSpectra/testspectra-source.git",
+    "directory": "tools/react"
+  },
+  "bin": {
+    "testspectra-react": "./bin/testspectra-react.js"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./vitest.config.ts": "./vitest.config.ts"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "dependencies": {
+    "@testing-library/react": "^16.0.0",
+    "@testing-library/user-event": "^14.5.2",
+    "@vitejs/plugin-react": "^4.3.1",
+    "@vitest/browser": "^2.1.8",
+    "playwright": "^1.48.0",
+    "vitest": "^2.1.8",
+    "@testspectra/matchers": "1.1.8-rc.10"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "esbuild": "^0.28.2",
+    "typescript": "^5.6.3"
+  },
+  "license": "SEE LICENSE IN LICENSE.md",
+  "scripts": {
+    "build": "node scripts/build.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --config ./vitest.config.ts"
+  }
+}