@rstest/browser 0.11.2 → 0.11.4

package/dist/browser-container/container-static/js/117.3da95caa39.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! LICENSE: 117.3da95caa39.js.LICENSE.txt */

package/dist/watchCliShortcuts.d.ts

@@ -1,6 +0,0 @@
-export declare const isBrowserWatchCliShortcutsEnabled: () => boolean;
-export declare const getBrowserWatchCliShortcutsHintMessage: () => string;
-export declare const logBrowserWatchReadyMessage: (enableCliShortcuts: boolean) => void;
-export declare function setupBrowserWatchCliShortcuts({ close }: {
-    close: () => Promise<void>;
-}): Promise<() => void>;

package/src/AGENTS.md

@@ -1,150 +0,0 @@
-# Browser mode host architecture
-
-This document is architecture-only and focuses on browser mode scheduling in `@rstest/browser` host-side modules.
-
-## Run lifecycle ownership (browser/node isomorphism)
-
-`runBrowserController` splits finalize ownership on `context.command`:
-
-- **Non-watch runs**: the host never self-finalizes. It returns a fully-populated `BrowserTestRunResult` with a deferred `close`, and `@rstest/core`'s `finalizeRunCycle` reduces the run's `ExecutorCycleOutcome`s into the verdict — reporter `onTestRunEnd`, coverage merge + report, exit code, and the bail message. `BrowserTestRunOptions.skipOnTestRunEnd` (deprecated and ignored since the finalize unification) has been removed.
-- **Watch runs**: the host owns the per-rerun lifecycle (`onTestRunStart`/`onTestRunEnd` per rerun) and self-finalizes; core skips its finalize entirely for browser-only and zero-node mixed watch runs.
-
-Runner lifecycle events flow through per-project `RunnerEventSink`s (`createRunnerEventSink` from core — the same event pump the node pool RPC uses). The host keeps a `Map<projectName, RunnerEventSink>` and resolves sinks via `sinkForProjectName`/`sinkForTestPath` (falling back to the first project for unknown names); it never fans out to reporters or `stateManager` directly.
-
-Cross-file `bail` is enforced at file boundaries in the headless scheduler: before picking up the next file, each worker checks the cycle-wide `stateManager.getCountOfFailedTests()` and drains the remaining queue as skipped results once the budget is reached. The headed debugging UI does not apply bail; within a running file, the runner's per-test gate uses the client-local failed count (see `src/client/AGENTS.md`).
-
-## Module topology
-
-```mermaid
-flowchart LR
-  subgraph Host["@rstest/browser host (Node.js)"]
-    IDX["index.ts\nrunBrowserTests()"]
-    CV["configValidation.ts\nvalidateBrowserConfig()"]
-    HC["hostController.ts\nrunBrowserController()"]
-    RT["createBrowserRuntime()"]
-    DR["dispatchCapabilities.ts + dispatchRouter.ts\nnamespace router"]
-    BRR["browserRpcRegistry.ts\nBrowser RPC allowlists"]
-    RL["runSession.ts\nRunSessionLifecycle"]
-    SR["sessionRegistry.ts\nRunnerSessionRegistry"]
-    WP["watchRerunPlanner.ts"]
-    LS["headlessLatestRerunScheduler.ts"]
-    HT["headlessTransport.ts\nattachHeadlessRunnerTransport()"]
-    CC["concurrency.ts\ngetHeadlessConcurrency()"]
-    HQ["headedSerialTaskQueue.ts\ncreateHeadedSerialTaskQueue()"]
-  end
-
-  subgraph UI["@rstest/browser-ui container (headed path)"]
-    UR["useRpc() / birpc"]
-    CH["core/channel.ts\nforwardDispatchRpcRequest()"]
-    MH["main.tsx message listener\nforward lifecycle callbacks"]
-  end
-
-  subgraph Runner["runner runtime (src/client/entry.ts)"]
-    MSG["runner lifecycle messages"]
-    RPC["dispatch-rpc-request"]
-  end
-
-  IDX -."re-export; invoked by @rstest/core before the run".-> CV
-  IDX --> HC
-  HC --> RT
-  HC --> DR
-  DR --> BRR
-  HC --> WP
-  WP --> LS
-  HC --> RL
-  RL --> SR
-  HC --> CC
-  HC --> HQ
-  HC --> HT
-
-  UR <--> HC
-  MSG --> MH
-  MH --> UR
-  RPC --> CH
-  CH --> UR
-
-  HT -."headless bridge:\nexposeFunction(__rstest_dispatch__, __rstest_dispatch_rpc__)".-> Runner
-```
-
-## Headed transport path
-
-Primary dispatch request direction is `Runner -> Container -> Host -> Router -> Handler`.
-`Host -> Container` in this path is bootstrap setup and callback delivery, not router request initiation.
-`dispatchRouter` handles inbound request routing only; outbound response delivery is a transport reply.
-
-### Bootstrap control plane
-
-```mermaid
-sequenceDiagram
-  participant Host as browser hostController
-  participant Container as browser-ui container
-
-  Host->>Container: open container and establish birpc
-  Host->>Container: provide BrowserHostConfig
-  Container-->>Host: getTestFiles and rerun requests
-```
-
-### Runtime dispatch RPC data plane
-
-```mermaid
-sequenceDiagram
-  participant Runner as client iframe runner
-  participant Container as browser-ui channel
-  participant Host as browser hostController
-  participant Router as browser dispatchRouter
-  participant Handler as namespace handler
-
-  Runner->>Container: postMessage runner lifecycle
-  Container->>Host: forward lifecycle callbacks (onTest*)
-  Host->>Host: feed per-project RunnerEventSink (stateManager + reporters)
-
-  Runner->>Container: postMessage dispatch rpc request
-  Container->>Host: rpc.dispatch(request)
-  Host->>Router: routing inbound request
-  Router->>Handler: resolve namespace handler
-  Handler->>Host: execute host capability work
-  Host-->>Handler: capability result or error
-  Handler-->>Router: return handler result
-  Router-->>Host: routing done, response payload
-  Host-->>Container: transport reply payload
-  Container-->>Runner: transport reply to runner
-```
-
-## Headless transport path
-
-Primary dispatch request direction is `Runner -> Host -> Router -> Handler`.
-`Host -> Runner` in this path is bridge registration, not router request initiation.
-`dispatchRouter` handles inbound request routing only; outbound response delivery is a transport reply.
-
-### Bootstrap control plane
-
-```mermaid
-sequenceDiagram
-  participant Host as browser hostController
-  participant Runner as client top level runner
-
-  Host->>Runner: exposeFunction __rstest_dispatch__
-  Host->>Runner: exposeFunction __rstest_dispatch_rpc__
-```
-
-### Runtime dispatch RPC data plane
-
-```mermaid
-sequenceDiagram
-  participant Runner as client top level runner
-  participant Host as browser hostController
-  participant Router as browser dispatchRouter
-  participant Handler as namespace handler
-
-  Runner->>Host: __rstest_dispatch__ lifecycle
-  Host->>Host: feed per-project RunnerEventSink (stateManager + reporters)
-
-  Runner->>Host: __rstest_dispatch_rpc__ request
-  Host->>Router: routing inbound request
-  Router->>Handler: resolve namespace handler
-  Handler->>Host: execute host capability work
-  Host-->>Handler: capability result or error
-  Handler-->>Router: return handler result
-  Router-->>Host: routing done, response payload
-  Host-->>Runner: transport reply payload
-```

package/src/client/AGENTS.md

@@ -1,89 +0,0 @@
-# Browser mode runner architecture
-
-This document is architecture-only and focuses on the browser runner runtime in `src/client`.
-
-## Runner bootstrap pipeline
-
-```mermaid
-flowchart TD
-  A["waitForConfig()"] --> B["read __RSTEST_BROWSER_OPTIONS__ + URL overrides"]
-  B --> R["send ready"]
-  R --> C["setRealTimers()"]
-  C --> D["preloadRunnerSourceMap()"]
-  D --> E["resolve project + runtimeConfig"]
-  E --> F{"execution mode"}
-
-  F -->|collect| G["create runtime + load setup/test modules + runner.collectTests()"]
-  G --> H["send collect-result / collect-complete"]
-
-  F -->|run| I["interceptConsole() + createRstestRuntime()"]
-  I --> J["send file-start"]
-  J --> K["load setup files + load test module"]
-  K --> L["runner.runTests() + send case-result"]
-  L --> N["send file-complete per file"]
-  N --> O["send complete after all files"]
-
-  H --> M["window.__RSTEST_DONE__ = true"]
-  O --> M
-```
-
-## Transport architecture
-
-```mermaid
-flowchart LR
-  subgraph IframePath["Iframe path (headed)"]
-    S1["send()"] --> P1["parent.postMessage(__rstest_dispatch__)"]
-    R1["dispatchRunnerLifecycle()"] --> P2["postMessage dispatch-rpc-request"]
-    SN1["snapshot.ts / browserRpc.ts via dispatchTransport.dispatchRpc()"] --> P3["postMessage dispatch-rpc-request + wait __rstest_dispatch_response__"]
-  end
-
-  subgraph TopLevelRunPath["Top-level page path (headless run)"]
-    S2["send()"] --> D1["window.__rstest_dispatch__"]
-    R2["dispatchRunnerLifecycle()"] --> D2["window.__rstest_dispatch_rpc__"]
-    SN2["snapshot.ts / browserRpc.ts via dispatchTransport.dispatchRpc()"] --> D3["window.__rstest_dispatch_rpc__"]
-  end
-
-  subgraph TopLevelCollectPath["Top-level page path (list collect)"]
-    S3["send()"] --> C1["window.__rstest_dispatch__"]
-  end
-```
-
-## Dispatch RPC sequence (snapshot / browser namespaces)
-
-The `snapshot` namespace (snapshot file ops) and the `browser` namespace
-(locator/page RPC from `browserRpc.ts`) share one client channel:
-`dispatchTransport.ts` owns request ids, timeouts, and pending-response
-resolution for both the iframe and top-level transports.
-
-```mermaid
-sequenceDiagram
-  participant Caller as snapshot.ts / browserRpc.ts
-  participant Transport as dispatchTransport.ts
-  participant Container as browser-ui channel
-  participant Host as host dispatch router
-
-  Caller->>Transport: dispatchRpc(request)
-
-  alt top-level runner (headless run)
-    Transport->>Host: __rstest_dispatch_rpc__(namespace=snapshot|browser)
-    Host-->>Transport: BrowserDispatchResponse
-    Transport-->>Caller: result/error
-  else iframe runner (headed)
-    Transport->>Container: postMessage(dispatch-rpc-request)
-    Container->>Host: rpc.dispatch(request)
-    Host-->>Container: BrowserDispatchResponse
-    Container-->>Transport: __rstest_dispatch_response__
-    Transport-->>Caller: resolve/reject pending request
-  end
-```
-
-List collect mode does not use the snapshot or browser RPC namespaces.
-
-## Runtime invariants
-
-- `entry.ts` is the only bootstrap entry and decides `collect` vs `run` mode.
-- Runner lifecycle events (`file-ready`, `suite-start`, `suite-result`, `case-start`) go through the `runner` dispatch namespace.
-- Snapshot file operations go through the `snapshot` dispatch namespace and never access filesystem directly in browser runtime.
-- Console interception is per test file and must restore original console methods in `finally`.
-- An unhandled window error or `unhandledrejection` that escapes a test file fails the file even when every test passed. Before finalizing each file result, the runner yields two macrotasks so a rejection leaked by a synchronous test is still observed (the browser dispatches `unhandledrejection` in a task queued after the current task).
-- The `getCountOfFailedTests` runner hook returns the client-local per-file failed count; cross-file `bail` is enforced host-side at file boundaries (see `../AGENTS.md`), not by this hook.

package/src/client/formatConsole.ts

@@ -1,77 +0,0 @@
-/** Stringify a single console argument for terminal forwarding. */
-export const formatArg = (arg: unknown): string => {
-  if (arg === null) return 'null';
-  if (arg === undefined) return 'undefined';
-  if (typeof arg === 'string') return arg;
-  if (typeof arg === 'number' || typeof arg === 'boolean') return String(arg);
-  // `JSON.stringify(symbol)` is `undefined`, so a symbol must be handled before
-  // the JSON path or it would forward as an empty/`undefined` log.
-  if (typeof arg === 'symbol') return arg.toString();
-  if (arg instanceof Error) {
-    return arg.stack || `${arg.name}: ${arg.message}`;
-  }
-  try {
-    return JSON.stringify(arg, null, 2);
-  } catch {
-    return String(arg);
-  }
-};
-
-// Format specifiers understood by the browser console. `%c` applies CSS in a
-// real console; forwarded to a terminal there is no styling, so it is consumed
-// and dropped (matching how Node's `util.format` handles it). `%%` is a literal
-// percent sign. Kept aligned with the browser console spec (no Node-only `%j`,
-// since these logs originate in the browser).
-// cspell:ignore sdifo WHATWG
-const HAS_SPECIFIER = /%[sdifoOc%]/;
-const SPECIFIER = /%[sdifoOc%]/g;
-
-/**
- * Join console arguments the way a console does. When the first argument is a
- * string carrying `printf`-style specifiers, substitute the following arguments
- * into it (consuming `%c` styles without emitting them), then append any
- * leftover arguments. Otherwise fall back to a plain space-join.
- *
- * Without this, `console.info('%cText', 'font-weight:bold')` (e.g. React's
- * DevTools notice) leaks the raw `%c` directive and its CSS argument into the
- * forwarded terminal output.
- */
-export const formatConsoleArgs = (args: unknown[]): string => {
-  const first = args[0];
-  if (typeof first !== 'string' || !HAS_SPECIFIER.test(first)) {
-    return args.map(formatArg).join(' ');
-  }
-
-  let next = 1;
-  const substituted = first.replace(SPECIFIER, (spec) => {
-    if (spec === '%%') return '%';
-    if (next >= args.length) return spec;
-    const arg = args[next++];
-    switch (spec) {
-      case '%c':
-        return ''; // CSS directive: swallow the style argument
-      case '%s':
-        return formatArg(arg);
-      case '%d':
-      case '%i': {
-        // Match the browser console formatter (WHATWG): parseInt on the value,
-        // so unit-suffixed strings like '42px' format as 42 (not NaN).
-        // `String()` first keeps Symbol safe — a bare `parseInt(symbol)` throws
-        // via ToString, whereas the spec maps a Symbol to NaN.
-        const num = Number.parseInt(String(arg), 10);
-        return Number.isNaN(num) ? 'NaN' : String(num);
-      }
-      case '%f': {
-        const num = Number.parseFloat(String(arg));
-        return Number.isNaN(num) ? 'NaN' : String(num);
-      }
-      default: // %o, %O
-        return formatArg(arg);
-    }
-  });
-
-  if (next >= args.length) {
-    return substituted;
-  }
-  return [substituted, ...args.slice(next).map(formatArg)].join(' ');
-};

package/src/client/public.ts

@@ -1,12 +0,0 @@
-/**
- * Re-export runtime API from @rstest/core/internal/browser-runtime for browser use.
- * This file is used as an alias target for '@rstest/core' in browser mode.
- *
- * Uses @rstest/core/internal/browser-runtime which only exports the test APIs
- * (describe, it, expect, etc.) without any Node.js dependencies.
- */
-
-// Re-export types from @rstest/core (these are compile-time only)
-export type { Assertion, Mock } from '@rstest/core';
-// Re-export all public test APIs
-export * from '@rstest/core/internal/browser-runtime';

package/src/watchCliShortcuts.ts

@@ -1,77 +0,0 @@
-import { color, isTTY, logger } from '@rstest/core/internal/browser';
-
-export const isBrowserWatchCliShortcutsEnabled = (): boolean => isTTY('stdin');
-
-export const getBrowserWatchCliShortcutsHintMessage = (): string => {
-  return `  ${color.dim('press')} ${color.bold('q')} ${color.dim('to quit')}\n`;
-};
-
-export const logBrowserWatchReadyMessage = (
-  enableCliShortcuts: boolean,
-): void => {
-  logger.log(color.green('  Waiting for file changes...'));
-
-  if (enableCliShortcuts) {
-    logger.log(getBrowserWatchCliShortcutsHintMessage());
-  }
-};
-
-export async function setupBrowserWatchCliShortcuts({
-  close,
-}: {
-  close: () => Promise<void>;
-}): Promise<() => void> {
-  const { emitKeypressEvents } = await import('node:readline');
-
-  emitKeypressEvents(process.stdin);
-  process.stdin.setRawMode(true);
-  process.stdin.resume();
-  process.stdin.setEncoding('utf8');
-
-  let isClosing = false;
-
-  const handleKeypress = (
-    str: string,
-    key: { name: string; ctrl: boolean },
-  ) => {
-    if (key.ctrl && key.name === 'c') {
-      process.kill(process.pid, 'SIGINT');
-      return;
-    }
-
-    if (key.ctrl && key.name === 'z') {
-      if (process.platform !== 'win32') {
-        process.kill(process.pid, 'SIGTSTP');
-      }
-      return;
-    }
-
-    if (str !== 'q' || isClosing) {
-      return;
-    }
-
-    // TODO: Support more browser watch shortcuts only after this path is
-    // refactored to share the same shortcut model as node mode.
-    isClosing = true;
-    void (async () => {
-      try {
-        await close();
-      } finally {
-        process.exit(0);
-      }
-    })();
-  };
-
-  process.stdin.on('keypress', handleKeypress);
-
-  return () => {
-    try {
-      process.stdin.setRawMode(false);
-      process.stdin.pause();
-    } catch {
-      // do nothing
-    }
-
-    process.stdin.off('keypress', handleKeypress);
-  };
-}