@rstest/browser 0.11.6 → 0.11.8

package/src/hostPayloads.ts

@@ -1,62 +0,0 @@
-import type { Reporter, TestFileResult } from '@rstest/core/internal/browser';
-import type { BrowserLogPayload } from './protocol';
-
-/** Payload for test file start event */
-export type TestFileStartPayload = {
-  testPath: string;
-  projectName: string;
-};
-
-/** Payload for log event — single-sourced from the wire protocol. */
-export type LogPayload = BrowserLogPayload;
-
-/** Payload for fatal error event */
-export type FatalPayload = {
-  message: string;
-  stack?: string;
-};
-
-export type ReporterHookArg<THook extends keyof Reporter> =
-  NonNullable<Reporter[THook]> extends (...args: infer TArgs) => unknown
-    ? TArgs[0]
-    : never;
-
-export type TestFileReadyPayload = ReporterHookArg<'onTestFileReady'>;
-export type TestSuiteStartPayload = ReporterHookArg<'onTestSuiteStart'>;
-export type TestSuiteResultPayload = ReporterHookArg<'onTestSuiteResult'>;
-export type TestCaseStartPayload = ReporterHookArg<'onTestCaseStart'>;
-export type ReloadTestFileAck = {
-  runId: string;
-};
-export type HeadedTestFileCompletePayload = TestFileResult & {
-  runId?: string;
-};
-
-export type DeferredPromise<T> = {
-  promise: Promise<T>;
-  resolve: (value: T | PromiseLike<T>) => void;
-  reject: (reason?: unknown) => void;
-};
-
-export const getFileTaskId = (testPath: string): string => {
-  return `file:${testPath}`;
-};
-
-export const toError = (error: unknown): Error => {
-  return error instanceof Error ? error : new Error(String(error));
-};
-
-export const createDeferredPromise = <T>(): DeferredPromise<T> => {
-  let resolve!: DeferredPromise<T>['resolve'];
-  let reject!: DeferredPromise<T>['reject'];
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-
-  return {
-    promise,
-    resolve,
-    reject,
-  };
-};

package/src/index.ts

@@ -1,51 +0,0 @@
-import type {
-  BrowserHostModule,
-  BrowserTestRunOptions,
-  BrowserTestRunResult,
-  ListBrowserTestsOptions,
-  RstestContext,
-} from '@rstest/core/internal/browser';
-import { createBrowserExecutor } from './browserExecutor';
-import { validateBrowserConfig } from './configValidation';
-import {
-  type ListBrowserTestsResult,
-  listBrowserTests as listBrowserTestsImpl,
-  runBrowserController,
-} from './hostController';
-
-export { createBrowserExecutor, validateBrowserConfig };
-
-export async function runBrowserTests(
-  context: RstestContext,
-  options?: BrowserTestRunOptions,
-): Promise<BrowserTestRunResult | void> {
-  return runBrowserController(context, options);
-}
-
-export async function listBrowserTests(
-  context: RstestContext,
-  options?: ListBrowserTestsOptions,
-): Promise<ListBrowserTestsResult> {
-  // Forward `options` (e.g. `shardedEntries`) so `rstest list --shard` lists
-  // only the current shard's browser test files, matching the run path.
-  return listBrowserTestsImpl(context, options);
-}
-
-/**
- * Compile-time guard: ensure the public host exports satisfy the core-owned
- * {@link BrowserHostModule} contract (`listBrowserTests` stays a plain public
- * export — core lists through `createBrowserExecutor(...).collect()`). This
- * catches drift such as a dropped `options` argument at the load boundary.
- * No runtime side effect.
- */
-void ({
-  validateBrowserConfig,
-  createBrowserExecutor,
-  runBrowserTests,
-} satisfies BrowserHostModule);
-
-export type {
-  BrowserTestRunOptions,
-  BrowserTestRunResult,
-  ListBrowserTestsResult,
-};

package/src/manifest.d.ts

@@ -1,41 +0,0 @@
-declare module '@rstest/browser-manifest' {
-  /** Project configuration from manifest */
-  export type ManifestProjectConfig = {
-    name: string;
-    environmentName: string;
-    projectRoot: string;
-  };
-
-  /** Test context for a project */
-  export type ManifestTestContext = {
-    getTestKeys: () => string[];
-    loadTest: (key: string) => Promise<unknown>;
-    projectRoot: string;
-  };
-
-  /** All projects configuration (multi-project support) */
-  export const projects: ManifestProjectConfig[];
-
-  /** Setup loaders for each project, keyed by project name */
-  export const projectSetupLoaders: Record<
-    string,
-    Array<() => Promise<unknown>>
-  >;
-
-  /** Test contexts for each project, keyed by project name */
-  export const projectTestContexts: Record<string, ManifestTestContext>;
-
-  // Backward compatibility exports (use first project as default)
-
-  /** @deprecated Use `projects[0]` instead */
-  export const projectConfig: ManifestProjectConfig;
-
-  /** @deprecated Use `projectSetupLoaders[projectName]` instead */
-  export const setupLoaders: Array<() => Promise<unknown>>;
-
-  /** @deprecated Use `projectTestContexts[projectName].getTestKeys()` instead */
-  export function getTestKeys(): string[];
-
-  /** @deprecated Use `projectTestContexts[projectName].loadTest(key)` instead */
-  export function loadTest(key: string): Promise<unknown>;
-}

package/src/protocol.ts

@@ -1,225 +0,0 @@
-import type { BrowserViewport } from '@rstest/core/internal/browser';
-import type {
-  BrowserRuntimeConfig,
-  TestFileResult,
-  TestInfo,
-  TestResult,
-} from '@rstest/core/internal/browser-runtime';
-import type { SnapshotUpdateState } from '@vitest/snapshot';
-
-export type {
-  BrowserLocatorIR,
-  BrowserRpcRequest,
-  SnapshotRpcCall,
-  SnapshotRpcMethod,
-  SnapshotRpcMethodArgs,
-  SnapshotRpcRequest,
-} from './rpcProtocol';
-export { validateBrowserRpcRequest } from './rpcProtocol';
-
-export const DISPATCH_MESSAGE_TYPE = '__rstest_dispatch__';
-export const DISPATCH_RESPONSE_TYPE = '__rstest_dispatch_response__';
-export const DISPATCH_RPC_BRIDGE_NAME = '__rstest_dispatch_rpc__';
-export const DISPATCH_RPC_REQUEST_TYPE = 'dispatch-rpc-request';
-export const RSTEST_CONFIG_MESSAGE_TYPE = 'RSTEST_CONFIG';
-
-export const DISPATCH_NAMESPACE_RUNNER = 'runner';
-export const DISPATCH_NAMESPACE_BROWSER = 'browser';
-export const DISPATCH_NAMESPACE_SNAPSHOT = 'snapshot';
-export const DISPATCH_METHOD_RPC = 'rpc';
-
-export type SerializedRuntimeConfig = BrowserRuntimeConfig;
-
-// `BrowserViewport` is a core config type (`@rstest/core` owns the canonical
-// definition used by `NormalizedBrowserModeConfig`). Re-export it so the host
-// assigns the SAME type across the seam instead of a hand-copied duplicate.
-export type { BrowserViewport };
-
-export type BrowserProjectRuntime = {
-  name: string;
-  environmentName: string;
-  projectRoot: string;
-  runtimeConfig: SerializedRuntimeConfig;
-  viewport?: BrowserViewport;
-};
-
-/**
- * Test file info with associated project name.
- * Used to track which project a test file belongs to.
- */
-export type TestFileInfo = {
-  testPath: string;
-  projectName: string;
-};
-
-/**
- * Execution mode for browser tests.
- * - 'run': Execute tests and report results (default)
- * - 'collect': Only collect test metadata without running
- */
-export type BrowserExecutionMode = 'run' | 'collect';
-
-/**
- * Wire shape of a `log` client message payload. The host receives this and maps
- * it onto core's {@link UserConsoleLog} (notably `level` → `name`); that mapper
- * (`hostController.ts` `handleLog`) annotates its result as `UserConsoleLog`, so
- * the map→core direction is compiler-checked. Owning the wire shape here as one
- * named type keeps the host's input type from drifting away from the producer.
- */
-export type BrowserLogPayload = {
-  level: 'log' | 'warn' | 'error' | 'info' | 'debug';
-  content: string;
-  /**
-   * Owning project, resolved by the client from its manifest. The host must
-   * not re-derive it from `testPath` — concurrent projects can run the same
-   * file, so a path-keyed lookup can attribute the log to the wrong project.
-   */
-  projectName: string;
-  taskId?: string;
-  taskName?: string;
-  taskParentNames?: string[];
-  taskType?: 'file' | 'suite' | 'case';
-  testPath: string;
-  type: 'stdout' | 'stderr';
-  trace?: string;
-};
-
-export type BrowserHostConfig = {
-  rootPath: string;
-  projects: BrowserProjectRuntime[];
-  snapshot: {
-    updateSnapshot: SnapshotUpdateState;
-  };
-  testFile?: string; // Optional: if provided, only run this specific test file
-  /**
-   * Per-run identifier assigned by the container.
-   * Used by browser RPC calls to prevent stale requests from previous reruns.
-   */
-  runId?: string;
-  /**
-   * Base URL for runner (iframe) pages. Container origin; used as a fallback
-   * when a project has no entry in `projectRunnerUrls`.
-   */
-  runnerUrl?: string;
-  /**
-   * Per-project runner origin base URLs, keyed by project name. Each browser
-   * project runs on its own dev server, so the container must load each test
-   * file's iframe from that project's own origin.
-   */
-  projectRunnerUrls?: Record<string, string>;
-  /**
-   * WebSocket port for container RPC.
-   */
-  wsPort?: number;
-  /**
-   * Execution mode. Defaults to 'run'.
-   */
-  mode?: BrowserExecutionMode;
-  /**
-   * Debug mode. When true, enables verbose logging in browser.
-   */
-  debug?: boolean;
-  /**
-   * Timeout for RPC operations in milliseconds (e.g., snapshot file operations).
-   * Derived from testTimeout config.
-   */
-  rpcTimeout?: number;
-};
-
-export type BrowserClientMessage =
-  | { type: 'ready' }
-  | {
-      type: 'file-start';
-      payload: { testPath: string; projectName: string };
-    }
-  | { type: 'case-result'; payload: TestResult }
-  | { type: 'file-complete'; payload: TestFileResult }
-  | { type: 'log'; payload: BrowserLogPayload }
-  | {
-      type: 'fatal';
-      payload: { message: string; stack?: string };
-    }
-  | { type: 'complete' }
-  // Collect mode messages
-  | {
-      type: 'collect-result';
-      payload: { testPath: string; project: string; tests: TestInfo[] };
-    }
-  | { type: 'collect-complete' }
-  // Unified RPC envelope for all runner -> container/host capability calls.
-  // Snapshot already uses this path via namespace "snapshot". Future PR #948
-  // capabilities can add new namespaces instead of adding new message types.
-  | {
-      type: typeof DISPATCH_RPC_REQUEST_TYPE;
-      payload: BrowserDispatchRequest;
-    };
-
-/**
- * Lifecycle methods the runner emits via `dispatchRunnerLifecycle()` as
- * dispatch-rpc-requests on the `runner` namespace (as opposed to the
- * {@link BrowserClientMessage} types it `send()`s). The runner client imports
- * this instead of redeclaring the list, so the emit site cannot drift from the
- * host router.
- */
-export type RunnerLifecycleMethod =
-  'file-ready' | 'suite-start' | 'suite-result' | 'case-start';
-
-/**
- * {@link BrowserClientMessage} types that are forwarded to the `runner`
- * namespace (by message `type`) rather than handled at the transport layer.
- * `Extract` keeps this a checked subset of the message union — renaming a
- * message type drops it here, surfacing as a missing handler downstream.
- */
-type RunnerMessageMethod = Extract<
-  BrowserClientMessage['type'],
-  'file-start' | 'case-result' | 'file-complete' | 'log' | 'fatal'
->;
-
-/**
- * Single source of truth for every method handled by the `runner` dispatch
- * namespace. The host handler table is keyed by this union (a missing key is a
- * compile error), so adding a runner method here forces a matching handler and
- * cannot silently no-op at runtime.
- */
-export type RunnerDispatchMethod = RunnerLifecycleMethod | RunnerMessageMethod;
-
-/**
- * Transport-agnostic envelope used by host routing.
- * `namespace + method + args + target` describes an operation independent of
- * the underlying message channel, and `runToken` provides run-level isolation.
- */
-export type BrowserDispatchRequest = {
-  requestId: string;
-  // Optional so headed/container paths can adopt the same envelope even when
-  // run-token isolation is only enforced in headless scheduling today.
-  runToken?: number;
-  namespace: string;
-  method: string;
-  args?: unknown;
-  // Routing reads `namespace`, `method`, `runToken`, and `target.sessionId`
-  // (see dispatchRouter.ts / dispatchBrowserRpcRequest). `target.testFile` and
-  // `target.projectName` are carried for diagnostics / forward-compatibility and
-  // are NOT consulted for routing today — adding a routing-relevant field here
-  // means wiring a reader on the host side, which structural typing won't force.
-  target?: {
-    testFile?: string;
-    sessionId?: string;
-    projectName?: string;
-  };
-};
-
-/**
- * Dispatch response envelope.
- * `stale: true` signals a safe drop from an older run generation, not a failure.
- */
-export type BrowserDispatchResponse = {
-  requestId: string;
-  runToken?: number;
-  result?: unknown;
-  error?: string;
-  stale?: boolean;
-};
-
-export type BrowserDispatchHandler = (
-  request: BrowserDispatchRequest,
-) => Promise<unknown>;

package/src/providers/index.ts

@@ -1,126 +0,0 @@
-import type { BrowserProvider } from '@rstest/core/internal/browser';
-import type { BrowserRpcRequest } from '../rpcProtocol';
-import { playwrightProviderImplementation } from './playwright';
-
-/**
- * Browser provider contract hub.
- *
- * When adding a new built-in provider, implement `BrowserProviderImplementation`
- * and register it in `providerImplementations` below.
- *
- * Provider-agnostic policy:
- * - keep shared contracts and behavior provider-neutral
- * - `browser.providerOptions` stays opaque at the framework boundary
- * - do not export provider-owned config types from `@rstest/browser`
- * - do not reference optional peer provider types from public declarations
- * - keep provider-specific behavior and config decoding inside provider implementations
- * - prefer direct passthrough to provider APIs over provider-specific translation
- *
- * The provider-name union is owned by `@rstest/core` (see `BROWSER_PROVIDERS`)
- * because core's CLI `init` templates need it but cannot import this package
- * (peer-dependency direction). `providerImplementations` below is keyed by the
- * re-exported union, so a provider added in core without an implementation here
- * is a compile error.
- */
-export type { BrowserProvider };
-
-/** Minimal console shape needed by host logging bridge. */
-export type BrowserConsoleMessage = {
-  text: () => string;
-};
-
-/**
- * Minimal page API surface required by hostController.
- *
- * This is a structural type (shape interface), NOT a direct Playwright import.
- * It currently mirrors a subset of Playwright's Page API because that is the
- * only provider. When adding a second provider whose page primitive diverges
- * (e.g. WebDriver BiDi), consider pushing page-level orchestration (goto,
- * exposeFunction, addInitScript, event listeners) into provider-specific
- * implementations so hostController only calls high-level semantic methods.
- */
-export type BrowserProviderPage = {
-  goto: (url: string, options?: { waitUntil?: 'load' }) => Promise<unknown>;
-  exposeFunction: (name: string, fn: (...args: any[]) => any) => Promise<void>;
-  addInitScript: (script: string) => Promise<void>;
-  on: {
-    (event: 'popup', listener: (page: BrowserProviderPage) => void): void;
-    (
-      event: 'console',
-      listener: (message: BrowserConsoleMessage) => void,
-    ): void;
-    // Page died: renderer crash or unexpected close. Headless scheduling wires
-    // these to fail the file immediately. Listeners take no payload.
-    (event: 'crash' | 'close', listener: () => void): void;
-  };
-  close: () => Promise<void>;
-  [Symbol.asyncDispose]: () => Promise<void>;
-};
-
-/** Minimal browser context API surface required by hostController. */
-export type BrowserProviderContext = {
-  newPage: () => Promise<BrowserProviderPage>;
-  on: (event: 'page', listener: (page: BrowserProviderPage) => void) => void;
-  close: () => Promise<void>;
-  [Symbol.asyncDispose]: () => Promise<void>;
-};
-
-/** Minimal browser API surface required by hostController. */
-export type BrowserProviderBrowser = {
-  close: () => Promise<void>;
-  [Symbol.asyncDispose]: () => Promise<void>;
-  newContext: (options: {
-    viewport: { width: number; height: number } | null;
-    providerOptions?: Record<string, unknown>;
-  }) => Promise<BrowserProviderContext>;
-};
-
-/** Provider launch result consumed by hostController. */
-export type BrowserProviderRuntime = {
-  browser: BrowserProviderBrowser;
-};
-
-/** Input contract for browser launch. */
-export type LaunchBrowserInput = {
-  browserName: 'chromium' | 'firefox' | 'webkit';
-  headless: boolean | undefined;
-  providerOptions: Record<string, unknown>;
-};
-
-/** Input contract for provider-side browser RPC dispatch. */
-export type DispatchBrowserRpcInput = {
-  containerPage?: BrowserProviderPage;
-  runnerPage?: BrowserProviderPage;
-  request: BrowserRpcRequest;
-  timeoutFallbackMs: number;
-};
-
-/**
- * Core provider implementation contract.
- *
- * Any new built-in provider must:
- * - launch browser runtime for test execution
- * - execute browser RPC requests (locator actions + assertions)
- */
-export type BrowserProviderImplementation = {
-  name: BrowserProvider;
-  launchRuntime: (input: LaunchBrowserInput) => Promise<BrowserProviderRuntime>;
-  dispatchRpc: (input: DispatchBrowserRpcInput) => Promise<unknown>;
-};
-
-const providerImplementations: Record<
-  BrowserProvider,
-  BrowserProviderImplementation
-> = {
-  playwright: playwrightProviderImplementation,
-};
-
-export function getBrowserProviderImplementation(
-  provider: BrowserProvider,
-): BrowserProviderImplementation {
-  const implementation = providerImplementations[provider];
-  if (!implementation) {
-    throw new Error(`Unsupported browser provider: ${String(provider)}`);
-  }
-  return implementation;
-}

package/src/providers/playwright/compileLocator.ts

@@ -1,130 +0,0 @@
-import type { FrameLocator, Locator, Page } from 'playwright';
-import type { BrowserLocatorIR } from '../../protocol';
-import { reviveBrowserLocatorText } from './textMatcher';
-
-export const compilePlaywrightLocator = (
-  frame: FrameLocator | Page,
-  locatorIR: BrowserLocatorIR,
-): Locator => {
-  const compileFromFrame = (ir: BrowserLocatorIR): Locator => {
-    let current: FrameLocator | Page | Locator = frame;
-
-    const ensureLocator = (): Locator => {
-      if ((current as any).filter) {
-        return current as Locator;
-      }
-      // Convert FrameLocator to a Locator within the frame.
-      current = (current as FrameLocator).locator(':root');
-      return current as Locator;
-    };
-
-    for (const step of ir.steps as any[]) {
-      switch (step.type) {
-        case 'getByRole': {
-          const name = step.options?.name
-            ? reviveBrowserLocatorText(step.options.name)
-            : undefined;
-          const options = step.options ? { ...step.options, name } : undefined;
-          current = (current as any).getByRole(step.role, options);
-          break;
-        }
-        case 'locator':
-          current = (current as any).locator(step.selector);
-          break;
-        case 'getByText':
-          current = (current as any).getByText(
-            reviveBrowserLocatorText(step.text),
-            step.options,
-          );
-          break;
-        case 'getByLabel':
-          current = (current as any).getByLabel(
-            reviveBrowserLocatorText(step.text),
-            step.options,
-          );
-          break;
-        case 'getByPlaceholder':
-          current = (current as any).getByPlaceholder(
-            reviveBrowserLocatorText(step.text),
-            step.options,
-          );
-          break;
-        case 'getByAltText':
-          current = (current as any).getByAltText(
-            reviveBrowserLocatorText(step.text),
-            step.options,
-          );
-          break;
-        case 'getByTitle':
-          current = (current as any).getByTitle(
-            reviveBrowserLocatorText(step.text),
-            step.options,
-          );
-          break;
-        case 'getByTestId':
-          current = (current as any).getByTestId(
-            reviveBrowserLocatorText(step.text) as any,
-          );
-          break;
-        case 'filter': {
-          const locator = ensureLocator();
-          const options: {
-            hasText?: string | RegExp;
-            hasNotText?: string | RegExp;
-            has?: Locator;
-            hasNot?: Locator;
-          } = {};
-          if (step.options?.hasText) {
-            options.hasText = reviveBrowserLocatorText(step.options.hasText);
-          }
-          if (step.options?.hasNotText) {
-            options.hasNotText = reviveBrowserLocatorText(
-              step.options.hasNotText,
-            );
-          }
-          if (step.options?.has) {
-            options.has = compileFromFrame(step.options.has);
-          }
-          if (step.options?.hasNot) {
-            options.hasNot = compileFromFrame(step.options.hasNot);
-          }
-          current = locator.filter(options);
-          break;
-        }
-        case 'and': {
-          const locator = ensureLocator();
-          const other = compileFromFrame(step.locator);
-          current = locator.and(other);
-          break;
-        }
-        case 'or': {
-          const locator = ensureLocator();
-          const other = compileFromFrame(step.locator);
-          current = locator.or(other);
-          break;
-        }
-        case 'nth': {
-          const locator = ensureLocator();
-          current = locator.nth(step.index);
-          break;
-        }
-        case 'first': {
-          const locator = ensureLocator();
-          current = locator.first();
-          break;
-        }
-        case 'last': {
-          const locator = ensureLocator();
-          current = locator.last();
-          break;
-        }
-        default:
-          throw new Error(`Unknown locator step: ${String(step?.type)}`);
-      }
-    }
-
-    return ensureLocator();
-  };
-
-  return compileFromFrame(locatorIR);
-};