@wdio/nightwatch-devtools 1.1.0 → 1.2.0

package/dist/index.js

@@ -1,797 +1,3912 @@
-/**
- * Nightwatch DevTools Plugin
- *
- * Integrates Nightwatch with WebdriverIO DevTools following the WDIO service pattern.
- * Captures commands, network requests, and console logs during test execution in real-time.
- */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { fileURLToPath } from 'node:url';
-import { start, stop } from '@wdio/devtools-backend';
-import logger from '@wdio/logger';
-import { remote } from 'webdriverio';
-import { SessionCapturer } from './session.js';
-import { TestReporter } from './reporter.js';
-import { TestManager } from './helpers/testManager.js';
-import { SuiteManager } from './helpers/suiteManager.js';
-import { BrowserProxy } from './helpers/browserProxy.js';
-import { TraceType } from './types.js';
-import { determineTestState, findTestFileFromStack, deterministicUid, extractTestMetadata, parseCucumberScenario, findStepDefinitionLine, findFreePort, resolveNightwatchConfig } from './helpers/utils.js';
-import { DEFAULTS, TIMING, TEST_STATE, PLUGIN_GLOBAL_KEY } from './constants.js';
-const log = logger('@wdio/nightwatch-devtools');
-class NightwatchDevToolsPlugin {
-    options;
-    sessionCapturer;
-    testReporter;
-    testManager;
-    suiteManager;
-    browserProxy;
-    isScriptInjected = false;
-    #currentTest = null;
-    #currentScenarioSuite = null;
-    #currentStep = null;
-    #lastSessionId = null;
-    #devtoolsBrowser;
-    #userDataDir;
-    #isCucumberRunner = false;
-    #passCount = 0;
-    #failCount = 0;
-    #skipCount = 0;
-    #configPath;
-    #srcFolders = [];
-    #getRerunLabel() {
-        return process.env.DEVTOOLS_RERUN_ENTRY_TYPE === 'test'
-            ? process.env.DEVTOOLS_RERUN_LABEL?.trim()
-            : undefined;
-    }
-    constructor(options = {}) {
-        this.options = {
-            port: options.port ?? 3000,
-            hostname: options.hostname ?? 'localhost'
-        };
+import {
+  CONSOLE_METHODS,
+  LOG_SOURCES,
+  SPINNER_RE,
+  createConsoleLogEntry,
+  detectLogLevel,
+  errorMessage,
+  findFreePort,
+  getRequestType,
+  isInternalStreamLine,
+  mapChromeBrowserLogs,
+  serializeError,
+  stripAnsi,
+  toError
+} from "./chunk-DKSBYMPM.js";
+
+// src/index.ts
+import { fileURLToPath } from "url";
+
+// ../core/src/stack.ts
+import { parse as parseStackTrace } from "stacktrace-parser";
+function isUserCodeFrame(frame) {
+  const { file } = frame;
+  return !!(file && !file.includes("/node_modules/") && !file.includes("<anonymous>") && !file.includes("node:internal") && !file.includes("/dist/") && !file.endsWith("/index.js"));
+}
+function normalizeFilePath(filePath) {
+  const stripped = filePath.replace(/^file:\/\//, "").split(":")[0];
+  try {
+    return decodeURIComponent(stripped);
+  } catch {
+    return stripped;
+  }
+}
+function getCallSourceFromStack() {
+  const stack = new Error().stack;
+  if (!stack) {
+    return { filePath: void 0, callSource: "unknown:0" };
+  }
+  const frame = parseStackTrace(stack).find(isUserCodeFrame);
+  if (!frame?.file) {
+    return { filePath: void 0, callSource: "unknown:0" };
+  }
+  const filePath = normalizeFilePath(frame.file);
+  return { filePath, callSource: `${filePath}:${frame.lineNumber ?? 0}` };
+}
+
+// ../core/src/uid.ts
+function deterministicUid(...parts) {
+  const hash = parts.join("::").split("").reduce((acc, char) => (acc << 5) - acc + char.charCodeAt(0) | 0, 0);
+  return `stable-${Math.abs(hash).toString(36)}`;
+}
+var signatureCounters = /* @__PURE__ */ new Map();
+function generateStableUid(file, name) {
+  const signature = `${file}::${name}`;
+  const count = signatureCounters.get(signature) ?? 0;
+  signatureCounters.set(signature, count + 1);
+  const input = count > 0 ? `${signature}::${count}` : signature;
+  return deterministicUid(input);
+}
+function resetSignatureCounters() {
+  signatureCounters.clear();
+}
+
+// ../core/src/finalize-screencast.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+
+// ../core/src/video-encoder.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function loadFfmpeg() {
+  try {
+    return require2("fluent-ffmpeg");
+  } catch {
+    throw new Error(
+      "VideoEncoder: fluent-ffmpeg is required for screencast encoding. Install it with: npm install fluent-ffmpeg"
+    );
+  }
+}
+async function writeFramesAndManifest(frames, tmpDir, ext) {
+  const manifestLines = ["ffconcat version 1.0"];
+  for (let i = 0; i < frames.length; i++) {
+    const frameName = `frame-${String(i).padStart(6, "0")}.${ext}`;
+    const framePath = path.join(tmpDir, frameName);
+    await fs.writeFile(framePath, Buffer.from(frames[i].data, "base64"));
+    const nextTs = frames[i + 1]?.timestamp ?? frames[i].timestamp + 100;
+    const durationSecs = Math.max((nextTs - frames[i].timestamp) / 1e3, 0.01);
+    manifestLines.push(`file '${framePath}'`);
+    manifestLines.push(`duration ${durationSecs.toFixed(6)}`);
+  }
+  const lastFramePath = path.join(
+    tmpDir,
+    `frame-${String(frames.length - 1).padStart(6, "0")}.${ext}`
+  );
+  manifestLines.push(`file '${lastFramePath}'`);
+  const manifestPath = path.join(tmpDir, "manifest.txt");
+  await fs.writeFile(manifestPath, manifestLines.join("\n"));
+  return manifestPath;
+}
+function classifyFfmpegError(err) {
+  const msg = err.message || "";
+  if (msg.includes("Cannot find ffmpeg") || msg.includes("ENOENT") || msg.includes("spawn") || msg.includes("not found")) {
+    return new Error(
+      "VideoEncoder: ffmpeg binary not found on PATH. Install ffmpeg: https://ffmpeg.org/download.html"
+    );
+  }
+  return new Error(`VideoEncoder: ffmpeg error \u2014 ${msg}`);
+}
+function runFfmpeg(ffmpeg, manifestPath, outputPath) {
+  return new Promise((resolve2, reject) => {
+    ffmpeg().input(manifestPath).inputOptions(["-f", "concat", "-safe", "0"]).videoCodec("libvpx").outputOptions([
+      "-b:v",
+      "1M",
+      "-pix_fmt",
+      "yuv420p",
+      "-vsync",
+      "cfr",
+      "-r",
+      "10",
+      "-auto-alt-ref",
+      "0",
+      "-disposition:v",
+      "default"
+    ]).output(outputPath).on("end", () => resolve2()).on("error", (err) => reject(classifyFfmpegError(err))).run();
+  });
+}
+async function encodeToVideo(frames, outputPath, options = {}) {
+  if (frames.length === 0) {
+    throw new Error("VideoEncoder: no frames to encode");
+  }
+  const ffmpeg = loadFfmpeg();
+  const ext = options.captureFormat === "png" ? "png" : "jpg";
+  const tmpDir = await fs.mkdtemp(
+    path.join(os.tmpdir(), "devtools-screencast-")
+  );
+  try {
+    const manifestPath = await writeFramesAndManifest(frames, tmpDir, ext);
+    await runFfmpeg(ffmpeg, manifestPath, outputPath);
+  } finally {
+    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+
+// ../core/src/finalize-screencast.ts
+async function finalizeScreencast({
+  recorder,
+  sessionId,
+  filenamePrefix,
+  outputDir,
+  minFrames = 1,
+  captureFormat,
+  sendUpstream,
+  onLog
+}) {
+  const log12 = (level, message) => onLog?.(level, message);
+  try {
+    await recorder.stop();
+  } catch (err) {
+    log12("warn", `Screencast stop failed: ${errorMessage(err)}`);
+    return;
+  }
+  const frames = recorder.frames;
+  if (frames.length < minFrames) {
+    return;
+  }
+  const fileName = `${filenamePrefix}-${sessionId}.webm`;
+  const candidate = outputDir || process.cwd();
+  let videoPath = path2.join(candidate, fileName);
+  try {
+    fs2.accessSync(candidate, fs2.constants.W_OK);
+  } catch {
+    videoPath = path2.join(os2.tmpdir(), fileName);
+  }
+  try {
+    await encodeToVideo(frames, videoPath, { captureFormat });
+    log12("info", `\u{1F4F9} Screencast video: ${videoPath}`);
+    sendUpstream("screencast", {
+      sessionId,
+      videoPath,
+      videoFile: fileName,
+      frameCount: frames.length,
+      duration: recorder.duration
+    });
+  } catch (err) {
+    log12("warn", `Screencast encode failed: ${errorMessage(err)}`);
+  }
+}
+
+// ../core/src/output-dir.ts
+import fs3 from "fs";
+import path3 from "path";
+var NODE_MODULES_SEGMENT = `${path3.sep}node_modules${path3.sep}`;
+function isWritable(dir) {
+  try {
+    fs3.accessSync(dir, fs3.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveAdapterOutputDir(input = {}) {
+  const fallback = input.fallbackDir ?? process.cwd();
+  if (input.userConfiguredDir) {
+    return input.userConfiguredDir;
+  }
+  const candidates = [];
+  if (input.testFilePath) {
+    candidates.push(path3.dirname(input.testFilePath));
+  }
+  if (input.configPath) {
+    candidates.push(path3.dirname(input.configPath));
+  }
+  candidates.push(fallback);
+  for (const dir of candidates) {
+    if (!dir) {
+      continue;
     }
-    async before() {
-        // When relaunched by the DevTools UI rerun button the backend is already
-        // running — skip startup and just connect the WebSocket worker.
-        const isReuse = process.env.DEVTOOLS_APP_REUSE === '1' &&
-            process.env.DEVTOOLS_APP_HOST &&
-            process.env.DEVTOOLS_APP_PORT;
-        if (isReuse) {
-            this.options.hostname = process.env.DEVTOOLS_APP_HOST;
-            this.options.port = Number(process.env.DEVTOOLS_APP_PORT);
-            log.info(`♻  Reusing DevTools backend at ${this.options.hostname}:${this.options.port}`);
-            // Clear execution data from the previous run when rerunning
-            // This ensures test names cache and suites are fresh for the new run
-            if (this.testReporter) {
-                this.testReporter.clearExecutionData();
-                this.suiteManager.clearExecutionData();
-                // Reset counters for fresh run
-                this.#passCount = 0;
-                this.#failCount = 0;
-                this.#skipCount = 0;
-                log.info('Cleared execution data for rerun');
-            }
-        }
-        this.#configPath = resolveNightwatchConfig();
-        if (this.#configPath) {
-            log.info(`✓ Config: ${this.#configPath}`);
-        }
-        else {
-            log.warn('Could not find nightwatch config — test rerun will be unavailable');
+    if (dir.includes(NODE_MODULES_SEGMENT)) {
+      continue;
+    }
+    if (isWritable(dir)) {
+      return dir;
+    }
+  }
+  return fallback;
+}
+
+// ../core/src/performance-capture.ts
+var CAPTURE_PERFORMANCE_SCRIPT = `
+  (function() {
+    const performance = window.performance;
+    const navigation = performance.getEntriesByType?.('navigation')?.[0];
+    const resources = performance.getEntriesByType?.('resource') || [];
+
+    return {
+      navigation: navigation ? {
+        url: window.location.href,
+        timing: {
+          loadTime: navigation.loadEventEnd - navigation.fetchStart,
+          domReady: navigation.domContentLoadedEventEnd - navigation.fetchStart,
+          responseTime: navigation.responseEnd - navigation.requestStart,
+          dnsLookup: navigation.domainLookupEnd - navigation.domainLookupStart,
+          tcpConnection: navigation.connectEnd - navigation.connectStart,
+          serverResponse: navigation.responseEnd - navigation.responseStart
         }
-        if (isReuse) {
-            // Register the plugin instance so Cucumber hooks can call back into it.
-            ;
-            globalThis[PLUGIN_GLOBAL_KEY] = this;
-            return;
+      } : undefined,
+      resources: resources.map(function(resource) {
+        return {
+          url: resource.name,
+          duration: resource.duration,
+          size: resource.transferSize || 0,
+          type: resource.initiatorType,
+          startTime: resource.startTime,
+          responseEnd: resource.responseEnd
+        };
+      }),
+      cookies: (function() {
+        try { return document.cookie; } catch (e) { return ''; }
+      })(),
+      documentInfo: {
+        url: window.location.href,
+        title: document.title,
+        headers: {
+          userAgent: navigator.userAgent,
+          language: navigator.language,
+          platform: navigator.platform
+        },
+        documentInfo: {
+          readyState: document.readyState,
+          referrer: document.referrer,
+          characterSet: document.characterSet
         }
+      }
+    };
+  })()
+`;
+function applyPerformanceData(command, payload, navigatedUrl) {
+  if (!payload || !payload.navigation) {
+    return false;
+  }
+  command.performance = {
+    navigation: payload.navigation,
+    resources: payload.resources
+  };
+  command.cookies = payload.cookies;
+  command.documentInfo = payload.documentInfo;
+  command.result = {
+    url: navigatedUrl,
+    loadTime: payload.navigation?.timing?.loadTime,
+    resources: payload.resources,
+    resourceCount: payload.resources?.length,
+    cookies: payload.cookies,
+    title: payload.documentInfo?.title
+  };
+  return true;
+}
+
+// ../core/src/retry-tracker.ts
+var RetryTracker = class {
+  #lastSig = null;
+  #lastId = null;
+  /** Build the canonical signature used for retry-equality checks. */
+  static signature(command, args, callSource) {
+    return JSON.stringify({ command, args, src: callSource ?? null });
+  }
+  /** True when the incoming signature matches the last captured one AND we
+   *  have an id to replace (otherwise there's nothing to replace yet). */
+  isRetry(sig) {
+    return sig === this.#lastSig && this.#lastId !== null;
+  }
+  /** The id of the last captured command, if any (for the replace-in-place
+   *  flow). */
+  get lastId() {
+    return this.#lastId;
+  }
+  /** Record a fresh capture — sets both sig and id together. */
+  recordCapture(sig, id) {
+    this.#lastSig = sig;
+    this.#lastId = id;
+  }
+  /** Record only the id (used by adapters that compute the sig but defer the
+   *  id assignment to after an async capture call). */
+  setLastId(id) {
+    this.#lastId = id;
+  }
+  /** Stage the sig before an async capture so the next call already sees the
+   *  signature change (prevents stale-sig matches on rapid back-to-back
+   *  commands). Pair with {@link setLastId} once the capture resolves. */
+  setLastSig(sig) {
+    this.#lastSig = sig;
+  }
+  /** Reset at test/scenario boundaries so the next capture is "fresh". */
+  reset() {
+    this.#lastSig = null;
+    this.#lastId = null;
+  }
+};
+
+// ../shared/src/files.ts
+var SPEC_FILE_RE = /\.(?:test|spec)\.[cm]?[jt]sx?$/i;
+
+// ../shared/src/routes.ts
+var WS_PATHS = {
+  /** Adapter session upgrade endpoint. One socket per running adapter. */
+  worker: "/worker",
+  /** App/UI client upgrade endpoint. Multiple browser tabs may connect. */
+  client: "/client"
+};
+var WS_SCOPE = {
+  /** Backend → worker: a dashboard client has subscribed. Wakes up the
+   *  adapter's `await UI ready` gate before tests start. */
+  clientConnected: "clientConnected",
+  /** Backend → worker: the last dashboard tab closed. Triggers the
+   *  interactive shutdown flow (close WS, exit, pkill the dashboard). */
+  clientDisconnected: "clientDisconnected",
+  /** Worker → backend → clients (or app-local): wipe the visualization data
+   *  for a specific test/suite uid (or the whole tree). */
+  clearExecutionData: "clearExecutionData",
+  /** Worker → backend: clear-by-test-uid request (drives clearExecutionData). */
+  clearCommands: "clearCommands",
+  /** Backend → clients: signal that the active run was stopped by the UI. */
+  testStopped: "testStopped",
+  /** Worker → backend → clients: swap an earlier captured command for an
+   *  updated entry (used when a retry coalesces commands). */
+  replaceCommand: "replaceCommand",
+  /** Worker → backend: register the config file path so reruns can spawn
+   *  with the same config. */
+  config: "config"
+};
+
+// ../shared/src/runner.ts
+var REUSE_ENV = {
+  REUSE: "DEVTOOLS_APP_REUSE",
+  HOST: "DEVTOOLS_APP_HOST",
+  PORT: "DEVTOOLS_APP_PORT",
+  RERUN_LABEL: "DEVTOOLS_RERUN_LABEL",
+  RERUN_ENTRY_TYPE: "DEVTOOLS_RERUN_ENTRY_TYPE"
+};
+
+// ../shared/src/timing.ts
+var TIMING_BASE = {
+  /** ms to let the dashboard render between rapid state updates. */
+  UI_RENDER_DELAY: 150,
+  /** ms to wait after a test starts before flushing initial state. */
+  TEST_START_DELAY: 100,
+  /** ms gap between consecutive suite-finalize broadcasts. */
+  SUITE_COMPLETE_DELAY: 200,
+  /** ms allowed for the browser-close handshake before forcing teardown. */
+  BROWSER_CLOSE_WAIT: 2e3,
+  /** ms before first worker WS connection attempt — lets backend bind. */
+  INITIAL_CONNECTION_WAIT: 500,
+  /** ms between browser-window-alive polls. */
+  BROWSER_POLL_INTERVAL: 1e3
+};
+var DEFAULTS_BASE = {
+  /** Synthetic capability ID — present on every CommandLog / TestStats. */
+  CID: "0-0",
+  /** TestStats.retries default — adapters that surface retry counts override. */
+  RETRIES: 0,
+  /** _duration placeholder for not-yet-finalized stats. */
+  DURATION: 0
+};
+
+// ../shared/src/types.ts
+var TEST_STATE = {
+  PENDING: "pending",
+  RUNNING: "running",
+  PASSED: "passed",
+  FAILED: "failed",
+  SKIPPED: "skipped"
+};
+var SCREENCAST_DEFAULTS = {
+  enabled: false,
+  captureFormat: "jpeg",
+  quality: 70,
+  maxWidth: 1280,
+  maxHeight: 720,
+  pollIntervalMs: 200
+};
+
+// ../core/src/screencast.ts
+var ScreencastRecorderBase = class {
+  buffer = [];
+  options;
+  driver;
+  #pollTimer;
+  #isRecording = false;
+  #cdpActive = false;
+  #startIndex = 0;
+  #startMarkerSet = false;
+  constructor(options = {}) {
+    this.options = { ...SCREENCAST_DEFAULTS, ...options };
+  }
+  /**
+   * Start recording. Tries the CDP fast-path first (if the subclass overrode
+   * `tryStartCdp`); falls back to screenshot polling otherwise. Safe to call
+   * even if the browser doesn't support screenshots — failures are logged and
+   * recording is simply skipped.
+   */
+  async start(driver) {
+    if (this.#isRecording) {
+      return;
+    }
+    this.driver = driver;
+    const cdpOk = await this.tryStartCdp();
+    if (cdpOk) {
+      this.#cdpActive = true;
+      this.#isRecording = true;
+      return;
+    }
+    await this.#startPolling();
+  }
+  /**
+   * Stop recording and release resources. Safe to call even if start() was
+   * never called or failed.
+   */
+  async stop() {
+    if (!this.#isRecording) {
+      return;
+    }
+    if (this.#cdpActive) {
+      await this.tryStopCdp();
+      this.#cdpActive = false;
+    } else if (this.#pollTimer !== void 0) {
+      this.#stopPolling();
+    }
+    this.#isRecording = false;
+  }
+  /**
+   * Mark the current frame position as the start of meaningful recording.
+   * Frames captured before this call (blank browser, pre-navigation pauses)
+   * are excluded from `frames`. Idempotent — only the first call takes effect.
+   */
+  setStartMarker() {
+    if (!this.#startMarkerSet) {
+      this.#startMarkerSet = true;
+      this.#startIndex = this.buffer.length;
+    }
+  }
+  /** Frames to encode — everything from the first meaningful action onwards. */
+  get frames() {
+    return this.buffer.slice(this.#startIndex);
+  }
+  /** Duration in ms between first and last captured frame. Zero if <2 frames. */
+  get duration() {
+    const f = this.frames;
+    if (f.length < 2) {
+      return 0;
+    }
+    return f[f.length - 1].timestamp - f[0].timestamp;
+  }
+  get isRecording() {
+    return this.#isRecording;
+  }
+  /**
+   * Try to start CDP push-mode recording. Return `true` on success. Default
+   * returns `false` → caller falls back to polling. Subclasses that wire CDP
+   * push themselves (WDIO via Puppeteer, Selenium via createCDPConnection)
+   * override and push frames into `this.frames` directly when CDP fires.
+   */
+  async tryStartCdp() {
+    return false;
+  }
+  /** Stop the CDP push-mode session started by `tryStartCdp`. */
+  async tryStopCdp() {
+  }
+  /**
+   * Helper for CDP subclasses: push a frame onto the buffer with the right
+   * timestamp normalization (CDP gives seconds-as-float; we store ms).
+   */
+  pushCdpFrame(data, timestampSeconds) {
+    const timestamp = typeof timestampSeconds === "number" ? Math.round(timestampSeconds * 1e3) : Date.now();
+    this.buffer.push({ data, timestamp });
+  }
+  /** Whether `setStartMarker` (or `markStartAtLatest`) has fired yet. */
+  get hasStartMarker() {
+    return this.#startMarkerSet;
+  }
+  /**
+   * Anchor the start marker to the most recently pushed frame. Used by
+   * subclasses that detect the first content-bearing frame heuristically
+   * (e.g. selenium's blank-frame-byte-size threshold) and want to skip the
+   * preceding about:blank dead-air without waiting for an explicit caller.
+   */
+  markStartAtLatest() {
+    if (!this.#startMarkerSet) {
+      this.#startMarkerSet = true;
+      this.#startIndex = Math.max(0, this.buffer.length - 1);
+    }
+  }
+  // ─── Polling implementation ─────────────────────────────────────────────
+  /**
+   * Hook fired when the polling loop starts. Default: no-op. Subclasses
+   * (adapters with their own logger) override to surface visibility.
+   */
+  onPollingStarted(_intervalMs) {
+  }
+  /** Hook fired when polling stops cleanly (driver still alive at the time). */
+  onPollingStopped(_frameCount) {
+  }
+  /** Hook fired when the polling fallback couldn't even take the first shot. */
+  onUnavailable(_err) {
+  }
+  // ─── Polling implementation ─────────────────────────────────────────────
+  async #startPolling() {
+    try {
+      const first = await this.takeScreenshot();
+      if (first === null) {
+        this.onUnavailable(new Error("first screenshot returned null"));
+        return;
+      }
+      this.buffer.push({ data: first, timestamp: Date.now() });
+      const intervalMs = this.options.pollIntervalMs;
+      this.#pollTimer = setInterval(async () => {
         try {
-            this.options.port = await findFreePort(this.options.port, this.options.hostname);
-            log.info('🚀 Starting DevTools backend...');
-            const { port } = await start(this.options);
-            this.options.port = port;
-            const url = `http://${this.options.hostname}:${this.options.port}`;
-            log.info(`✓ Backend started on port ${this.options.port}`);
-            log.info(`  DevTools UI: ${url}`);
-            try {
-                // Create unique user data directory for this instance to prevent conflicts
-                this.#userDataDir = path.join(os.tmpdir(), `nightwatch-devtools-${this.options.port}-${Date.now()}`);
-                if (!fs.existsSync(this.#userDataDir)) {
-                    fs.mkdirSync(this.#userDataDir, { recursive: true });
-                }
-                this.#devtoolsBrowser = await remote({
-                    logLevel: 'info',
-                    automationProtocol: 'devtools',
-                    capabilities: {
-                        browserName: 'chrome',
-                        'goog:chromeOptions': {
-                            args: [
-                                '--window-size=1600,1200',
-                                `--user-data-dir=${this.#userDataDir}`,
-                                '--no-first-run',
-                                '--no-default-browser-check'
-                            ]
-                        }
-                    }
-                });
-                await this.#devtoolsBrowser.url(url);
-            }
-            catch (err) {
-                log.error(`Failed to open DevTools UI: ${err.message}`);
-                log.info(`Please manually open: ${url}`);
-            }
-            await new Promise((resolve) => setTimeout(resolve, TIMING.UI_CONNECTION_WAIT));
-            globalThis[PLUGIN_GLOBAL_KEY] = this;
+          const data = await this.takeScreenshot();
+          if (data !== null) {
+            this.buffer.push({ data, timestamp: Date.now() });
+          }
+        } catch {
+          this.#stopPolling();
         }
-        catch (err) {
-            log.error(`Failed to start backend: ${err.message}`);
-            throw err;
+      }, intervalMs);
+      this.#isRecording = true;
+      this.onPollingStarted(intervalMs);
+    } catch (err) {
+      this.onUnavailable(err);
+    }
+  }
+  #stopPolling() {
+    if (this.#pollTimer !== void 0) {
+      clearInterval(this.#pollTimer);
+      this.#pollTimer = void 0;
+      this.onPollingStopped(this.buffer.length);
+    }
+  }
+};
+
+// ../core/src/script-loader.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+async function loadInjectableScript() {
+  const scriptPath = require3.resolve("@wdio/devtools-script");
+  const scriptDir = path4.dirname(scriptPath);
+  const preloadScriptPath = path4.join(scriptDir, "script.js");
+  const scriptContent = await fs4.readFile(preloadScriptPath, "utf-8");
+  return `(async function() { ${scriptContent} })()`;
+}
+async function pollUntilReady(check, opts = {}) {
+  const attempts = opts.attempts ?? 5;
+  const intervalMs = opts.intervalMs ?? 200;
+  for (let i = 0; i < attempts; i++) {
+    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+    if (await check()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// ../core/src/session-capturer.ts
+import fs5 from "fs/promises";
+import { WebSocket } from "ws";
+var SessionCapturerBase = class {
+  // ── State (mostly private; subclasses access shared ws via `this.ws`) ────
+  /**
+   * Exposed as `protected` so subclasses with framework-specific close/wait
+   * semantics (e.g. nightwatch's `closeWebSocket` with timeout) can operate
+   * on the socket directly. Default lifecycle is fully managed by the base.
+   */
+  ws;
+  #hasConnected = false;
+  #originalConsoleMethods;
+  #originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  #originalStderrWrite = process.stderr.write.bind(process.stderr);
+  // Two flags (not one): prevents re-entrant capture when console.* writes to
+  // stdout, OR when stream forwarding wants to log via console.
+  #isCapturingConsole = false;
+  #isCapturingStream = false;
+  // Command bookkeeping — used by adapters that emit commands themselves
+  // (nightwatch, selenium). The WDIO service adapter doesn't call sendCommand
+  // (WDIO owns the command lifecycle), so this state is harmless overhead.
+  // `protected` (not `#`) so subclasses can override the send/replace flow
+  // while still sharing the counter and de-dup set with base helpers.
+  commandCounter = 0;
+  sentCommandIds = /* @__PURE__ */ new Set();
+  // Map of file path → source text. Populated by `captureSource` (also
+  // accessed by adapter-specific source-discovery flows, e.g. service's
+  // `ensureSourceLoaded` which parses `file://` locations first).
+  sources = /* @__PURE__ */ new Map();
+  // Captured trace payload — populated by `processTracePayload` (driven from
+  // adapter-specific `captureTrace` flows) and by direct pushes from BiDi/CDP
+  // listeners. Mutations stay `unknown[]` here because the canonical
+  // `TraceMutation` shape is a browser-only DOM type (script package); cross-
+  // package consumers treat the array as opaque.
+  commandsLog = [];
+  consoleLogs = [];
+  networkRequests = [];
+  mutations = [];
+  traceLogs = [];
+  metadata;
+  // ── Construction ────────────────────────────────────────────────────────
+  constructor(opts = {}) {
+    const { hostname, port } = opts;
+    if (hostname && port) {
+      this.ws = new WebSocket(`ws://${hostname}:${port}${WS_PATHS.worker}`);
+      this.ws.on("open", () => {
+        this.#hasConnected = true;
+        this.onWsOpen();
+      });
+      this.ws.on("error", (err) => this.onWsError(err));
+      this.ws.on("close", () => this.onWsClose());
+      this.ws.on("message", (raw) => {
+        try {
+          const parsed = JSON.parse(raw.toString());
+          this.onWsMessage(parsed);
+        } catch {
         }
+      });
+    }
+    this.#originalConsoleMethods = {
+      log: console.log,
+      info: console.info,
+      warn: console.warn,
+      error: console.error
+    };
+  }
+  // ── Public API ──────────────────────────────────────────────────────────
+  /**
+   * Send a typed event to the dashboard. No-op if the WS isn't open. Catches
+   * send-time exceptions so a transient socket error never aborts the host
+   * runner. Subclasses that want diagnostics on drop or error override
+   * {@link onUpstreamDrop}.
+   */
+  sendUpstream(event, data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.onUpstreamDrop(event, "closed");
+      return;
+    }
+    try {
+      this.ws.send(JSON.stringify({ scope: event, data }));
+    } catch (err) {
+      this.onUpstreamDrop(event, "send-error", err);
+    }
+  }
+  /**
+   * Hook fired when a {@link sendUpstream} call can't deliver. Default: silent
+   * (matches the historical behavior of service/selenium). Nightwatch overrides
+   * this to log a warning — useful when a runner drops mid-test and the user
+   * needs to know why captured data is incomplete.
+   */
+  onUpstreamDrop(_event, _reason, _err) {
+  }
+  /** True once the WS has opened at least once and is currently OPEN. */
+  isConnected() {
+    return Boolean(this.ws) && this.ws?.readyState === WebSocket.OPEN;
+  }
+  /** Property-style alias for {@link isConnected} — used by tests that
+   *  read it as a getter while mutating `ws.readyState` directly. */
+  get isReportingUpstream() {
+    return this.isConnected();
+  }
+  /** Subclasses can read this to gate retry/reconnect logic. */
+  hasEverConnected() {
+    return this.#hasConnected;
+  }
+  /**
+   * Send a CommandLog over the WS. If the entry already has an `_id` (set by
+   * the adapter's `captureCommand` during buffering), use it; otherwise
+   * allocate a fresh one. The `_id` is the de-dup key and is stripped from
+   * the broadcast payload — it's adapter-internal bookkeeping.
+   * Returns the id, or 0 if the entry had no `_id` and none could be assigned.
+   */
+  sendCommand(command) {
+    if (command._id === void 0) {
+      command._id = this.commandCounter++;
+    }
+    const id = command._id;
+    if (this.sentCommandIds.has(id)) {
+      return id;
+    }
+    this.sentCommandIds.add(id);
+    const toSend = { ...command };
+    delete toSend._id;
+    this.sendUpstream("commands", [toSend]);
+    return id;
+  }
+  /**
+   * Emit a `replaceCommand` event swapping an earlier entry in-place. Strips
+   * the adapter-internal `_id` field before sending — that's bookkeeping for
+   * the local `sentCommandIds` set and shouldn't reach the UI.
+   */
+  sendReplaceCommand(oldTimestamp, command) {
+    const toSend = { ...command };
+    delete toSend._id;
+    this.sendUpstream(WS_SCOPE.replaceCommand, {
+      oldTimestamp,
+      command: toSend
+    });
+  }
+  /**
+   * Read a file from disk, store in `sources`, and broadcast to the UI via
+   * `sendUpstream('sources', { [path]: text })`. Idempotent — a cached path is
+   * a no-op. Read errors are logged via `onSourceReadError` (default: silent)
+   * so a missing source never aborts capture.
+   */
+  async captureSource(filePath) {
+    if (this.sources.has(filePath)) {
+      return;
+    }
+    try {
+      const source = (await fs5.readFile(filePath, "utf-8")).toString();
+      this.sources.set(filePath, source);
+      this.sendUpstream("sources", { [filePath]: source });
+    } catch (err) {
+      this.onSourceReadError(filePath, err);
+    }
+  }
+  /**
+   * Hook fired when `captureSource` can't read a file. Default: silent.
+   * Subclasses (nightwatch, selenium) override to log a warning.
+   */
+  onSourceReadError(_filePath, _err) {
+  }
+  /**
+   * Ingest the `{ mutations, traceLogs, consoleLogs, networkRequests, metadata }`
+   * payload returned by the page-side `wdioTraceCollector.getTraceData()`.
+   * Tags console logs with `source: 'browser'`, pushes each array into the
+   * matching local field, and broadcasts via the appropriate WS scopes.
+   *
+   * `skipConsoleLogs` / `skipNetworkRequests` opt out when an out-of-band
+   * channel (BiDi) is already delivering those streams — without the gate
+   * the dashboard would see each entry twice.
+   */
+  processTracePayload(payload, opts = {}) {
+    const { mutations, traceLogs, consoleLogs, networkRequests, metadata } = payload;
+    if (metadata && typeof metadata === "object") {
+      this.metadata = {
+        ...this.metadata,
+        ...metadata
+      };
+      this.sendUpstream("metadata", this.metadata);
+    }
+    if (!opts.skipConsoleLogs && Array.isArray(consoleLogs) && consoleLogs.length > 0) {
+      const tagged = consoleLogs.map((entry) => ({
+        ...entry,
+        source: LOG_SOURCES.BROWSER
+      }));
+      this.consoleLogs.push(...tagged);
+      this.sendUpstream("consoleLogs", tagged);
+    }
+    if (!opts.skipNetworkRequests && Array.isArray(networkRequests) && networkRequests.length > 0) {
+      const reqs = networkRequests;
+      this.networkRequests.push(...reqs);
+      this.sendUpstream("networkRequests", reqs);
     }
-    async #ensureSessionInitialized(browser) {
-        const currentSessionId = browser.sessionId;
-        const isSessionChange = currentSessionId &&
-            this.#lastSessionId &&
-            currentSessionId !== this.#lastSessionId;
-        if (isSessionChange) {
-            log.info('Browser session changed — reconnecting WebSocket only');
-            this.isScriptInjected = false;
-            this.sessionCapturer?.cleanup();
-            this.sessionCapturer = null;
+    if (Array.isArray(mutations) && mutations.length > 0) {
+      this.mutations.push(...mutations);
+      this.sendUpstream("mutations", mutations);
+    }
+    if (Array.isArray(traceLogs) && traceLogs.length > 0) {
+      const logs = traceLogs;
+      this.traceLogs.push(...logs);
+      this.sendUpstream("logs", logs);
+    }
+  }
+  /**
+   * Resolve when the WS reaches OPEN state, or `false` on timeout / error.
+   * Returns immediately if already open. Used by adapters that need a
+   * synchronization barrier before injecting page-side scripts.
+   */
+  async waitForConnection(timeoutMs = 5e3) {
+    if (!this.ws) {
+      return false;
+    }
+    if (this.ws.readyState === WebSocket.OPEN) {
+      return true;
+    }
+    return new Promise((resolve2) => {
+      const timeout = setTimeout(() => resolve2(false), timeoutMs);
+      this.ws.once("open", () => {
+        clearTimeout(timeout);
+        resolve2(true);
+      });
+      this.ws.once("error", () => {
+        clearTimeout(timeout);
+        resolve2(false);
+      });
+    });
+  }
+  /**
+   * Gracefully close the WS, waiting up to 2s for buffered messages to flush.
+   * Call before process exit in reuse mode (or after dashboard close) so the
+   * backend sees a clean close instead of an abrupt TCP reset.
+   */
+  async closeWebSocket() {
+    if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+      return;
+    }
+    return new Promise((resolve2) => {
+      const timeout = setTimeout(resolve2, 2e3);
+      this.ws.once("close", () => {
+        clearTimeout(timeout);
+        resolve2();
+      });
+      this.ws.close();
+    });
+  }
+  /**
+   * Restore console/streams. Does NOT close the WS — that's the subclass's
+   * call (see `closeWebSocket` on nightwatch/selenium). Closing here would
+   * break the wait-for-dashboard-close flow, since the worker WS is the
+   * channel the backend uses to signal `clientDisconnected`.
+   */
+  cleanup() {
+    this.restoreConsole();
+    this.restoreStreams();
+  }
+  // ── Patching (call from subclass constructor) ───────────────────────────
+  /** Patch `console.log/info/warn/error` to forward through `onLine`. */
+  patchConsole() {
+    CONSOLE_METHODS.forEach((method) => {
+      const original = this.#originalConsoleMethods[method];
+      console[method] = (...args) => {
+        this.#isCapturingConsole = true;
+        const result = original.apply(console, args);
+        this.#isCapturingConsole = false;
+        const serialized = args.map(
+          (a) => typeof a === "object" && a !== null ? safeStringify(a) : String(a)
+        );
+        const joined = stripAnsi(serialized.join(" ")).trim();
+        if (!joined || this.isInternalStreamLine(joined)) {
+          return result;
         }
-        this.#lastSessionId = currentSessionId ?? null;
-        if (this.sessionCapturer) {
-            return;
+        this.onLine(method, serialized, LOG_SOURCES.TEST);
+        return result;
+      };
+    });
+  }
+  /**
+   * Wrap `process.stdout.write` and `process.stderr.write` to forward chunks
+   * through `onLine`. The base's `#isCapturingConsole` flag prevents
+   * re-entrance when console patching itself writes to stdout.
+   */
+  patchStreams() {
+    const captureChunk = (raw) => {
+      if (this.#isCapturingStream) {
+        return;
+      }
+      const text = typeof raw === "string" ? raw : raw.toString();
+      if (!text?.trim()) {
+        return;
+      }
+      this.#isCapturingStream = true;
+      try {
+        for (const rawLine of text.split("\n")) {
+          const segments = rawLine.split("\r").filter((s) => s.trim());
+          const lastSegment = segments[segments.length - 1] ?? rawLine;
+          const clean = stripAnsi(lastSegment).trim();
+          if (!clean || this.isInternalStreamLine(clean) || SPINNER_RE.test(clean)) {
+            continue;
+          }
+          this.onLine(detectLogLevel(clean), [clean], LOG_SOURCES.TERMINAL);
         }
-        await new Promise((resolve) => setTimeout(resolve, TIMING.INITIAL_CONNECTION_WAIT));
-        this.sessionCapturer = new SessionCapturer({ port: this.options.port, hostname: this.options.hostname }, browser);
-        const connected = await this.sessionCapturer.waitForConnection(3000);
-        if (!connected) {
-            log.error('❌ Worker WebSocket failed to connect!');
+      } finally {
+        this.#isCapturingStream = false;
+      }
+    };
+    const wrap = (stream, original) => {
+      const capturer = this;
+      stream.write = function(chunk, ...rest) {
+        const writeAny = original;
+        const result = writeAny.call(stream, chunk, ...rest);
+        if (chunk && !capturer.#isCapturingConsole) {
+          captureChunk(chunk);
         }
-        if (!this.testReporter) {
-            // First-time setup: create reporter chain once for the entire run.
-            // These must NOT be recreated on session change — doing so generates a
-            // new feature suite with a fresh start timestamp, which DataManager sees
-            // as a new run and wipes all accumulated commands.
-            this.testReporter = new TestReporter((suitesData) => {
-                if (this.sessionCapturer) {
-                    this.sessionCapturer.sendUpstream('suites', suitesData);
-                }
-            });
-            this.testManager = new TestManager(this.testReporter);
-            this.suiteManager = new SuiteManager(this.testReporter);
-            this.browserProxy = new BrowserProxy(this.sessionCapturer, this.testManager, () => this.#currentTest ?? this.#currentScenarioSuite);
+        return result;
+      };
+    };
+    wrap(process.stdout, this.#originalStdoutWrite);
+    wrap(process.stderr, this.#originalStderrWrite);
+  }
+  restoreConsole() {
+    CONSOLE_METHODS.forEach((method) => {
+      console[method] = this.#originalConsoleMethods[method];
+    });
+  }
+  restoreStreams() {
+    process.stdout.write = this.#originalStdoutWrite;
+    process.stderr.write = this.#originalStderrWrite;
+  }
+  // ── Hooks (subclasses override) ─────────────────────────────────────────
+  /**
+   * Default: forward a single ConsoleLog via the `consoleLogs` scope.
+   * Args is passed as an array (matching the original console.* call shape:
+   * `console.log('a', 'b')` → `args = ['a', 'b']`) so subclasses can preserve
+   * the multi-argument structure for the UI.
+   *
+   * Subclasses that need to maintain local capture state (for the rerun/
+   * replay flow) should override to also push the entry into their own
+   * array — see service's onLine override.
+   */
+  onLine(type, args, source) {
+    const entry = createConsoleLogEntry(type, args, source);
+    this.sendUpstream("consoleLogs", [entry]);
+  }
+  /**
+   * Default delegates to {@link isInternalStreamLine} from `./console.js`.
+   * Subclasses can override to add framework-specific filters.
+   */
+  isInternalStreamLine(line) {
+    return isInternalStreamLine(line);
+  }
+  /** Hook: WS opened. Subclasses override to send a handshake, etc. */
+  onWsOpen() {
+  }
+  /** Hook: WS errored before opening (likely no backend listening). */
+  onWsError(_err) {
+  }
+  /** Hook: WS closed (after open, or as a result of cleanup). */
+  onWsClose() {
+  }
+  /**
+   * Hook: WS message received from the backend. Currently used by selenium's
+   * `awaitClientConnected` to know when a dashboard tab has subscribed.
+   */
+  onWsMessage(_msg) {
+  }
+};
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// ../core/src/suite-helpers.ts
+function createSuiteStats(init) {
+  return {
+    uid: init.uid,
+    cid: init.cid ?? "0-0",
+    title: init.title,
+    fullTitle: init.title,
+    file: init.file,
+    type: "suite",
+    start: init.start ?? /* @__PURE__ */ new Date(),
+    state: init.state ?? TEST_STATE.RUNNING,
+    end: null,
+    tests: [],
+    suites: [],
+    hooks: [],
+    _duration: 0,
+    callSource: init.callSource,
+    featureFile: init.featureFile,
+    parent: init.parent
+  };
+}
+function createTestStats(init) {
+  return {
+    uid: init.uid,
+    cid: init.cid ?? "0-0",
+    title: init.title,
+    fullTitle: init.fullTitle ?? init.title,
+    parent: init.parent,
+    state: init.state ?? TEST_STATE.RUNNING,
+    start: init.start ?? /* @__PURE__ */ new Date(),
+    end: null,
+    type: "test",
+    file: init.file,
+    retries: 0,
+    _duration: 0,
+    hooks: [],
+    callSource: init.callSource
+  };
+}
+function computeSuiteFinalStateStrict(suite) {
+  const tests = suite.tests;
+  const suites = suite.suites ?? [];
+  const hasFailures = tests.some((t) => t.state === TEST_STATE.FAILED) || suites.some((s) => s.state === TEST_STATE.FAILED);
+  if (hasFailures) {
+    return TEST_STATE.FAILED;
+  }
+  const allPassed = tests.every(
+    (t) => t.state === TEST_STATE.PASSED || t.state === TEST_STATE.SKIPPED
+  ) && suites.every(
+    (s) => s.state === TEST_STATE.PASSED || s.state === TEST_STATE.SKIPPED
+  );
+  const hasSkipped = tests.some((t) => t.state === TEST_STATE.SKIPPED);
+  const hasItems = tests.length > 0 || suites.length > 0;
+  if (!hasItems || allPassed) {
+    return TEST_STATE.PASSED;
+  }
+  if (hasSkipped) {
+    return TEST_STATE.PASSED;
+  }
+  return TEST_STATE.FAILED;
+}
+function computeSuiteRunningState(suite) {
+  const tests = suite.tests;
+  const suites = suite.suites ?? [];
+  const hasFailures = tests.some((t) => t.state === TEST_STATE.FAILED) || suites.some((s) => s.state === TEST_STATE.FAILED);
+  if (hasFailures) {
+    return TEST_STATE.FAILED;
+  }
+  const hasRunning = tests.some((t) => t.state === TEST_STATE.RUNNING) || suites.some((s) => s.state === TEST_STATE.RUNNING || !s.end);
+  return hasRunning ? TEST_STATE.RUNNING : TEST_STATE.PASSED;
+}
+function stampSuiteEnd(suite, end = /* @__PURE__ */ new Date()) {
+  suite.end = end;
+  suite._duration = end.getTime() - (suite.start?.getTime() || end.getTime());
+}
+function stampTestEnd(test, end = /* @__PURE__ */ new Date()) {
+  test.end = end;
+  test._duration = end.getTime() - (test.start?.getTime() ?? end.getTime());
+}
+
+// ../core/src/test-discovery.ts
+import fs6 from "fs";
+function findTestDefinitions(filePath, opts = {}) {
+  if (!fs6.existsSync(filePath)) {
+    return [];
+  }
+  let source;
+  try {
+    source = fs6.readFileSync(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  const lines = source.split("\n");
+  const suiteRe = /\b(?:describe|suite|context)\s*\(\s*['"`]([^'"`]+)['"`]/;
+  const testRe = /\b(?:it|test|specify)\s*\(\s*['"`]([^'"`]+)['"`]/;
+  const objRe = /^\s*['"`]([^'"`]+)['"`]\s*:\s*(?:async\s+)?(?:\([^)]*\)\s*=>|function\s*\()/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    const suiteMatch = line.match(suiteRe);
+    if (suiteMatch) {
+      out.push({ kind: "suite", title: suiteMatch[1], line: lineNum });
+      continue;
+    }
+    const testMatch = line.match(testRe);
+    if (testMatch) {
+      out.push({ kind: "test", title: testMatch[1], line: lineNum });
+      continue;
+    }
+    if (opts.includeNightwatchObjectStyle) {
+      const objMatch = line.match(objRe);
+      if (objMatch) {
+        out.push({ kind: "test", title: objMatch[1], line: lineNum });
+      }
+    }
+  }
+  return out;
+}
+
+// ../core/src/test-reporter.ts
+var TestReporterBase = class {
+  #report;
+  allSuites = [];
+  constructor(report) {
+    this.#report = report;
+    resetSignatureCounters();
+  }
+  /** Swap the upstream sink, e.g. after a WS reconnect. */
+  updateUpstream(report) {
+    this.#report = report;
+  }
+  /** Manually trigger a flush of current state to the UI. */
+  updateSuites() {
+    this.sendUpstream();
+  }
+  /**
+   * Reset collected state. Subclasses with extra state (test-name cache,
+   * current-suite ref) override and call `super.clearExecutionData()` first.
+   */
+  clearExecutionData() {
+    this.allSuites = [];
+    resetSignatureCounters();
+  }
+  /** Default: find by `uid`, replace in place. */
+  onTestEnd(test) {
+    for (const suite of this.allSuites) {
+      const idx = suite.tests.findIndex(
+        (t) => typeof t !== "string" && t.uid === test.uid
+      );
+      if (idx !== -1) {
+        suite.tests[idx] = test;
+        break;
+      }
+    }
+    this.sendUpstream();
+  }
+  /** Default: just flush. Subclasses with skipped-test synthesis override. */
+  onSuiteEnd(_suite) {
+    this.sendUpstream();
+  }
+  get report() {
+    return this.allSuites;
+  }
+  /**
+   * Flush current suite state to the upstream callback. Empty-payload guard
+   * matches the existing adapter behavior — UI shouldn't receive an empty
+   * array.
+   */
+  sendUpstream() {
+    const payload = [];
+    for (const suite of this.allSuites) {
+      if (suite.uid) {
+        payload.push({ [suite.uid]: suite });
+      }
+    }
+    if (payload.length > 0) {
+      this.#report(payload);
+    }
+  }
+};
+
+// src/index.ts
+import logger11 from "@wdio/logger";
+
+// src/run-lifecycle.ts
+import * as fs8 from "fs";
+import * as path6 from "path";
+import * as os3 from "os";
+import logger from "@wdio/logger";
+import { remote } from "webdriverio";
+import { start, stop } from "@wdio/devtools-backend";
+
+// src/constants.ts
+var INTERNAL_COMMANDS_TO_IGNORE = [
+  "isAppiumClient",
+  "isSafari",
+  "isChrome",
+  "isFirefox",
+  "isEdge",
+  "isMobile",
+  "isAndroid",
+  "isIOS",
+  "session",
+  "sessions",
+  "timeouts",
+  "timeoutsAsyncScript",
+  "timeoutsImplicitWait",
+  "getLog",
+  "getLogTypes",
+  "screenshot",
+  "availableContexts",
+  "currentContext",
+  "setChromeOptions",
+  "setDeviceName",
+  "perform",
+  "execute",
+  "executeAsync",
+  "executeScript",
+  // Internal Nightwatch transport commands (used for log capture, not user actions)
+  "sessionLog",
+  "sessionLogTypes",
+  "isLogAvailable",
+  "end"
+];
+var DEFAULTS = {
+  ...DEFAULTS_BASE,
+  TEST_NAME: "unknown",
+  FILE_NAME: "unknown"
+};
+var TIMING = {
+  ...TIMING_BASE,
+  /** Nightwatch boots slower than selenium — give the dashboard 10s. */
+  UI_CONNECTION_WAIT: 1e4
+};
+var BOOLEAN_COMMAND_PATTERN = /^waitFor|^is[A-Z]|^has[A-Z]|(Visible|Present|Enabled|Selected|NotVisible|NotPresent)$/;
+var NAVIGATION_COMMANDS = ["url", "navigate", "navigateTo"];
+var CONFIG_FILENAMES = [
+  "nightwatch.conf.cjs",
+  "nightwatch.conf.js",
+  "nightwatch.conf.ts",
+  "nightwatch.conf.mjs",
+  "nightwatch.json"
+];
+var PLUGIN_GLOBAL_KEY = "__nightwatchDevtoolsPlugin";
+
+// src/helpers/utils.ts
+import * as fs7 from "fs";
+import * as path5 from "path";
+import { parse as parseStackTrace2 } from "stacktrace-parser";
+function determineTestState(testcase) {
+  if (testcase.passed === 0 && testcase.failed === 0) {
+    return "skipped";
+  }
+  return testcase.passed > 0 && testcase.failed === 0 ? "passed" : "failed";
+}
+function getTestIcon(state) {
+  return state === "passed" ? "\u2705" : state === "skipped" ? "\u23ED" : "\u274C";
+}
+function incrementCounters(counters, state) {
+  if (state === "passed") {
+    counters.passCount++;
+  } else if (state === "skipped") {
+    counters.skipCount++;
+  } else {
+    counters.failCount++;
+  }
+}
+function buildPluginMetadataOptions(input) {
+  return {
+    framework: input.isCucumberRunner ? "nightwatch-cucumber" : "nightwatch",
+    configFile: input.configPath,
+    baseDir: process.cwd(),
+    runCapabilities: {
+      canRunSuites: true,
+      canRunTests: !input.isCucumberRunner,
+      canRunAll: false
+    }
+  };
+}
+function generateStableUid2(itemOrFile, name) {
+  let file, testName;
+  if (typeof itemOrFile === "object" && itemOrFile !== null && name === void 0) {
+    file = itemOrFile.file || "";
+    testName = String(itemOrFile.fullTitle || itemOrFile.title);
+  } else {
+    file = itemOrFile || "";
+    testName = String(name || "");
+  }
+  return generateStableUid(file, testName);
+}
+function findTestFileFromStack() {
+  const stack = new Error().stack;
+  if (!stack) {
+    return void 0;
+  }
+  const frames = parseStackTrace2(stack);
+  const preferred = frames.find(
+    (f) => isUserCodeFrame(f) && SPEC_FILE_RE.test(f.file)
+  );
+  const frame = preferred ?? frames.find(isUserCodeFrame);
+  if (!frame?.file) {
+    return void 0;
+  }
+  const filePath = normalizeFilePath(frame.file);
+  return fs7.existsSync(filePath) ? filePath : void 0;
+}
+function extractTestMetadata(filePath) {
+  const defs = findTestDefinitions(filePath, {
+    includeNightwatchObjectStyle: true
+  });
+  const firstSuite = defs.find((d) => d.kind === "suite");
+  const tests = defs.filter((d) => d.kind === "test");
+  return {
+    suiteTitle: firstSuite?.title ?? null,
+    suiteLine: firstSuite?.line ?? null,
+    testNames: tests.map((t) => t.title),
+    testLines: tests.map((t) => t.line)
+  };
+}
+function collectStepsAfterScenario(lines, scenarioIndex, stepCount) {
+  const stepRe = /^\s*(Given|When|Then|And|But)\s+/i;
+  const stepLines = [];
+  const stepKeywords = [];
+  for (let j = scenarioIndex + 1; j < lines.length && stepLines.length < stepCount; j++) {
+    if (/^\s*(?:Scenario:|Feature:)/i.test(lines[j])) {
+      break;
+    }
+    const m = stepRe.exec(lines[j]);
+    if (m) {
+      stepLines.push(j + 1);
+      stepKeywords.push(m[1]);
+    }
+  }
+  return { stepLines, stepKeywords };
+}
+function parseCucumberScenario(featureContent, scenarioName, stepTexts) {
+  const stepCount = stepTexts.length;
+  if (!featureContent) {
+    return {
+      featureLine: 1,
+      scenarioLine: 1,
+      stepLines: [],
+      stepKeywords: Array(stepCount).fill("")
+    };
+  }
+  const lines = featureContent.split("\n");
+  let featureLine = 1;
+  let scenarioLine = 1;
+  let stepLines = [];
+  let stepKeywords = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    if (featureLine === 1 && /^\s*Feature:/i.test(line)) {
+      featureLine = lineNum;
+      continue;
+    }
+    if (/^\s*Scenario:/i.test(line) && line.includes(scenarioName)) {
+      scenarioLine = lineNum;
+      const collected = collectStepsAfterScenario(lines, i, stepCount);
+      stepLines = collected.stepLines;
+      stepKeywords = collected.stepKeywords;
+      break;
+    }
+  }
+  while (stepKeywords.length < stepCount) {
+    stepKeywords.push("");
+  }
+  return { featureLine, scenarioLine, stepLines, stepKeywords };
+}
+var CUCUMBER_TYPE_PATTERNS = {
+  int: "-?\\d+",
+  float: "-?\\d+(?:\\.\\d+)?",
+  string: `(?:"[^"]*"|'[^']*')`,
+  word: "\\S+"
+};
+function matchesCucumberExpression(pattern, text) {
+  if (pattern === text) {
+    return true;
+  }
+  const regexSource = pattern.split(/(\{[^}]*\})/).map((part, idx) => {
+    if (idx % 2 === 1) {
+      const type = part.slice(1, -1);
+      return CUCUMBER_TYPE_PATTERNS[type] ?? "[\\s\\S]+";
+    }
+    return part.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+  }).join("");
+  try {
+    return new RegExp(`^${regexSource}$`).test(text);
+  } catch {
+    return false;
+  }
+}
+function findStepDefinitionLine(stepDefFiles, stepText) {
+  const stepDefRe = /(?:Given|When|Then|And|But)\s*\(/i;
+  for (const { filePath, content } of stepDefFiles) {
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!stepDefRe.test(line)) {
+        continue;
+      }
+      const literalMatch = line.match(
+        /(?:Given|When|Then|And|But)\s*\(\s*(['"`])(.*?)\1/i
+      );
+      if (literalMatch) {
+        if (matchesCucumberExpression(literalMatch[2], stepText)) {
+          return { filePath, line: i + 1 };
         }
-        else {
-            // Session change: update the reporter's upstream callback to use the new
-            // WebSocket, update the proxy's capturer reference (avoids re-wrapping
-            // already-wrapped browser methods which would double-capture commands),
-            // then replay current suite state to the newly-connected UI.
-            this.testReporter.updateUpstream((suitesData) => {
-                if (this.sessionCapturer) {
-                    this.sessionCapturer.sendUpstream('suites', suitesData);
-                }
-            });
-            this.browserProxy.updateSessionCapturer(this.sessionCapturer);
-            this.testReporter.updateSuites();
+        continue;
+      }
+      const regexMatch = line.match(
+        /(?:Given|When|Then|And|But)\s*\(\s*\/(.+?)\/([gimy]*)/i
+      );
+      if (regexMatch) {
+        try {
+          if (new RegExp(regexMatch[1], regexMatch[2]).test(stepText)) {
+            return { filePath, line: i + 1 };
+          }
+        } catch {
         }
-        const capabilities = browser.capabilities || {};
-        const desiredCapabilities = browser.desiredCapabilities || {};
-        const sessionId = browser.sessionId;
-        const opts = browser.options || {};
-        // Capture src_folders once so beforeEach can resolve test file paths
-        if (this.#srcFolders.length === 0) {
-            const sf = opts.src_folders;
-            this.#srcFolders = Array.isArray(sf) ? sf : sf ? [sf] : [];
+      }
+    }
+  }
+  return null;
+}
+function resolveNightwatchConfig() {
+  const configFlagIdx = process.argv.findIndex(
+    (arg) => arg === "--config" || arg === "-c"
+  );
+  if (configFlagIdx !== -1 && process.argv[configFlagIdx + 1]) {
+    const argvConfig = process.argv[configFlagIdx + 1];
+    const resolved = path5.isAbsolute(argvConfig) ? argvConfig : path5.resolve(process.cwd(), argvConfig);
+    if (fs7.existsSync(resolved)) {
+      return resolved;
+    }
+  }
+  let dir = process.cwd();
+  const root = path5.parse(dir).root;
+  while (dir && dir !== root) {
+    for (const file of CONFIG_FILENAMES) {
+      const candidate = path5.join(dir, file);
+      if (fs7.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = path5.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return void 0;
+}
+
+// src/run-lifecycle.ts
+var log = logger("@wdio/nightwatch-devtools:run-lifecycle");
+function handleReuseMode(ctx) {
+  ctx.options.hostname = process.env[REUSE_ENV.HOST];
+  ctx.options.port = Number(process.env[REUSE_ENV.PORT]);
+  log.info(
+    `\u267B  Reusing DevTools backend at ${ctx.options.hostname}:${ctx.options.port}`
+  );
+  if (ctx.testReporter) {
+    ctx.clearExecutionData();
+    ctx.passCount = 0;
+    ctx.failCount = 0;
+    ctx.skipCount = 0;
+    log.info("Cleared execution data for rerun");
+  }
+}
+async function runPluginBefore(ctx) {
+  const isReuse = process.env[REUSE_ENV.REUSE] === "1" && !!process.env[REUSE_ENV.HOST] && !!process.env[REUSE_ENV.PORT];
+  if (isReuse) {
+    ctx.handleReuse();
+  }
+  const configPath = resolveNightwatchConfig();
+  ctx.setConfigPath(configPath);
+  if (configPath) {
+    log.info(`\u2713 Config: ${configPath}`);
+  } else {
+    log.warn(
+      "Could not find nightwatch config \u2014 test rerun will be unavailable"
+    );
+  }
+  if (isReuse) {
+    ;
+    globalThis[PLUGIN_GLOBAL_KEY] = ctx.plugin;
+    return;
+  }
+  try {
+    ctx.options.port = await findFreePort(
+      ctx.options.port,
+      ctx.options.hostname
+    );
+    log.info("\u{1F680} Starting DevTools backend...");
+    const { port } = await start(ctx.options);
+    ctx.options.port = port;
+    const url = `http://${ctx.options.hostname}:${ctx.options.port}`;
+    log.info(`\u2713 Backend started on port ${ctx.options.port}`);
+    log.info(`  DevTools UI: ${url}`);
+    await ctx.openDevtoolsBrowserAt(url);
+    await new Promise(
+      (resolve2) => setTimeout(resolve2, TIMING.UI_CONNECTION_WAIT)
+    );
+    globalThis[PLUGIN_GLOBAL_KEY] = ctx.plugin;
+  } catch (err) {
+    log.error(`Failed to start backend: ${errorMessage(err)}`);
+    throw err;
+  }
+}
+async function openDevtoolsBrowser(ctx, url) {
+  try {
+    ctx.userDataDir = path6.join(
+      os3.tmpdir(),
+      `nightwatch-devtools-${ctx.options.port}-${Date.now()}`
+    );
+    if (!fs8.existsSync(ctx.userDataDir)) {
+      fs8.mkdirSync(ctx.userDataDir, { recursive: true });
+    }
+    ctx.devtoolsBrowser = await remote({
+      logLevel: "info",
+      automationProtocol: "devtools",
+      capabilities: {
+        browserName: "chrome",
+        "goog:chromeOptions": {
+          args: [
+            "--window-size=1600,1200",
+            `--user-data-dir=${ctx.userDataDir}`,
+            "--no-first-run",
+            "--no-default-browser-check"
+          ]
         }
-        this.sessionCapturer.sendUpstream('metadata', {
-            type: TraceType.Testrunner,
-            capabilities,
-            desiredCapabilities,
-            sessionId,
-            testEnv: opts.testEnv,
-            host: opts.webdriver?.host,
-            options: this.#buildMetadataOptions(),
-            url: ''
+      }
+    });
+    await ctx.devtoolsBrowser.url(url);
+  } catch (err) {
+    log.error(`Failed to open DevTools UI: ${errorMessage(err)}`);
+    log.info(`Please manually open: ${url}`);
+  }
+}
+async function finalizeAllSuites(ctx, browser) {
+  const currentTest = browser?.currentTest;
+  const testcases = currentTest?.results?.testcases ?? {};
+  for (const [, suite] of (ctx.suiteManager?.getAllSuites() ?? /* @__PURE__ */ new Map()).entries()) {
+    ctx.testManager.finalizeSuiteTests(suite, testcases);
+    await new Promise(
+      (resolve2) => setTimeout(resolve2, TIMING.SUITE_COMPLETE_DELAY)
+    );
+    ctx.suiteManager?.finalizeSuite(suite);
+  }
+  await new Promise(
+    (resolve2) => setTimeout(resolve2, TIMING.SUITE_COMPLETE_DELAY)
+  );
+}
+function logRunSummary(ctx) {
+  const summary = [
+    ctx.passCount > 0 ? `${ctx.passCount} passed` : null,
+    ctx.failCount > 0 ? `${ctx.failCount} failed` : null,
+    ctx.skipCount > 0 ? `${ctx.skipCount} skipped` : null
+  ].filter(Boolean).join("  ");
+  log.info(`${ctx.failCount > 0 ? "\u274C" : "\u2705"} Tests complete!  ${summary}`);
+  log.info(`   DevTools UI: http://${ctx.options.hostname}:${ctx.options.port}`);
+}
+async function waitForDevtoolsBrowserClose(ctx) {
+  if (!ctx.devtoolsBrowser) {
+    return;
+  }
+  ;
+  logger.setLevel(
+    "devtools",
+    "warn"
+  );
+  let exitBySignal = false;
+  const signalHandler = () => {
+    exitBySignal = true;
+    log.info("\n\u2713 Exiting... Browser window will remain open");
+    process.exit(0);
+  };
+  process.once("SIGINT", signalHandler);
+  process.once("SIGTERM", signalHandler);
+  while (true) {
+    try {
+      await ctx.devtoolsBrowser.getTitle();
+      await new Promise((res) => setTimeout(res, TIMING.BROWSER_POLL_INTERVAL));
+    } catch {
+      if (!exitBySignal) {
+        log.info("Browser window closed, stopping DevTools app");
+        break;
+      }
+    }
+  }
+  if (exitBySignal) {
+    return;
+  }
+  process.removeListener("SIGINT", signalHandler);
+  process.removeListener("SIGTERM", signalHandler);
+  logger.setLevel(
+    "devtools",
+    "info"
+  );
+  try {
+    await ctx.devtoolsBrowser.deleteSession();
+  } catch {
+  }
+  await stop();
+  process.exit(0);
+}
+
+// src/event-hub.ts
+import logger2 from "@wdio/logger";
+var log2 = logger2("@wdio/nightwatch-devtools:event-hub");
+function makeSessionMetadataHandler(bindings) {
+  return (data) => {
+    try {
+      const md = data?.metadata ?? {};
+      const capturer = bindings.getSessionCapturer();
+      const sessionCapabilities = md.sessionCapabilities;
+      const sessionId = md.sessionId;
+      if (!capturer || !sessionCapabilities && !sessionId) {
+        return;
+      }
+      capturer.sendUpstream("metadata", {
+        type: "testrunner" /* Testrunner */,
+        capabilities: sessionCapabilities ?? {},
+        sessionId,
+        testEnv: md.testEnv,
+        host: md.host,
+        modulePath: md.modulePath,
+        options: bindings.buildMetadataOptions()
+      });
+    } catch (err) {
+      log2.error(`Error in event handler: ${errorMessage(err)}`);
+    }
+  };
+}
+function registerEventHandlers(eventHub, bindings) {
+  bindings.setCucumberRunner(eventHub.runner === "cucumber");
+  if (eventHub.runner === "cucumber") {
+    log2.info("\u2713 Cucumber runner detected via NightwatchEventHub");
+  }
+  log2.info("\u2713 NightwatchEventHub registered \u2014 enriched metadata enabled");
+  const handler = makeSessionMetadataHandler(bindings);
+  eventHub.on("TestSuiteStarted", handler);
+  eventHub.on("TestRunStarted", handler);
+}
+
+// src/cucumber-lifecycle.ts
+import logger3 from "@wdio/logger";
+
+// src/helpers/cucumberResult.ts
+function cucumberResultToTestState(result) {
+  const status = String(
+    result?.status ?? "UNKNOWN"
+  ).toUpperCase();
+  if (status === "PASSED") {
+    return TEST_STATE.PASSED;
+  }
+  if (status === "SKIPPED") {
+    return TEST_STATE.SKIPPED;
+  }
+  return TEST_STATE.FAILED;
+}
+function closeOpenSteps(suite, scenarioState, now = /* @__PURE__ */ new Date()) {
+  for (const step of suite.tests) {
+    if (typeof step === "string") {
+      continue;
+    }
+    if (step.state === "running" || step.state === "pending") {
+      step.state = scenarioState === TEST_STATE.PASSED ? TEST_STATE.PASSED : TEST_STATE.FAILED;
+      step.end = now;
+    }
+  }
+}
+
+// src/helpers/cucumberScenarioBuilder.ts
+function buildScenarioStepTest(input, scenarioUid, i) {
+  const {
+    featureUri,
+    scenarioName,
+    featureAbsPath,
+    stepDefFiles,
+    steps,
+    stepLines,
+    stepKeywords
+  } = input;
+  const step = steps[i];
+  const keyword = stepKeywords[i] || "";
+  const stepLabel = keyword ? `${keyword} ${step.text}` : step.text;
+  const stepDefLoc = findStepDefinitionLine(stepDefFiles, step.text);
+  const callSource = stepDefLoc ? `${stepDefLoc.filePath}:${stepDefLoc.line}` : featureAbsPath && stepLines[i] > 0 ? `${featureAbsPath}:${stepLines[i]}` : void 0;
+  return {
+    uid: deterministicUid(featureUri, `step:${scenarioName}:${step.text}`),
+    cid: DEFAULTS.CID,
+    title: stepLabel,
+    fullTitle: `${scenarioName} ${stepLabel}`,
+    parent: scenarioUid,
+    state: TEST_STATE.PENDING,
+    start: /* @__PURE__ */ new Date(),
+    end: null,
+    type: "test",
+    file: featureUri,
+    retries: 0,
+    _duration: 0,
+    hooks: [],
+    callSource
+  };
+}
+function buildCucumberScenarioSuite(input) {
+  const {
+    featureUri,
+    scenarioName,
+    featureName,
+    featureAbsPath,
+    steps,
+    scenarioLine,
+    parentFeatureSuiteUid
+  } = input;
+  const scenarioUid = deterministicUid(featureUri, `scenario:${scenarioName}`);
+  const scenarioSuite = {
+    uid: scenarioUid,
+    cid: DEFAULTS.CID,
+    title: scenarioName,
+    fullTitle: `${featureName} ${scenarioName}`,
+    parent: parentFeatureSuiteUid,
+    type: "suite",
+    file: featureUri,
+    start: /* @__PURE__ */ new Date(),
+    state: TEST_STATE.RUNNING,
+    end: null,
+    tests: [],
+    suites: [],
+    hooks: [],
+    _duration: 0,
+    callSource: featureAbsPath && scenarioLine > 0 ? `${featureAbsPath}:${scenarioLine}` : void 0
+  };
+  for (let i = 0; i < steps.length; i++) {
+    scenarioSuite.tests.push(buildScenarioStepTest(input, scenarioUid, i));
+  }
+  return scenarioSuite;
+}
+
+// src/helpers/featureFileScan.ts
+import fs9 from "fs";
+import path7 from "path";
+function scanFeatureFile(featureUri) {
+  const featureAbsPath = path7.resolve(process.cwd(), featureUri);
+  const result = {
+    featureName: path7.basename(featureUri, ".feature"),
+    featureContent: "",
+    featureAbsPath,
+    stepDefFiles: [],
+    capturedPaths: []
+  };
+  if (featureUri === "unknown.feature" || !fs9.existsSync(featureAbsPath)) {
+    return result;
+  }
+  result.featureContent = fs9.readFileSync(featureAbsPath, "utf-8");
+  const match = result.featureContent.match(/^\s*Feature:\s*(.+)/m);
+  if (match) {
+    result.featureName = match[1].trim();
+  }
+  result.capturedPaths.push(featureAbsPath);
+  const featureDir = path7.dirname(featureAbsPath);
+  const stepDirCandidates = ["step_definitions", "steps", "support"];
+  for (const candidate of stepDirCandidates) {
+    const stepDir = path7.join(featureDir, candidate);
+    if (!fs9.existsSync(stepDir) || !fs9.statSync(stepDir).isDirectory()) {
+      continue;
+    }
+    for (const entry of fs9.readdirSync(stepDir)) {
+      if (!/\.(js|ts|mjs|cjs)$/.test(entry)) {
+        continue;
+      }
+      const stepFilePath = path7.join(stepDir, entry);
+      result.capturedPaths.push(stepFilePath);
+      try {
+        result.stepDefFiles.push({
+          filePath: stepFilePath,
+          content: fs9.readFileSync(stepFilePath, "utf-8")
         });
-        const browserName = capabilities.browserName || desiredCapabilities.browserName || 'unknown';
-        const browserVersion = capabilities.browserVersion || capabilities.version || '';
-        log.info(`✓ Browser: ${browserName}${browserVersion ? ' ' + browserVersion : ''} (session: ${sessionId})`);
-        const loggingPrefs = capabilities['goog:loggingPrefs'] ||
-            desiredCapabilities['goog:loggingPrefs'] ||
-            {};
-        if (!loggingPrefs.performance) {
-            log.warn("⚠  Network tab will be empty — add 'goog:loggingPrefs': { performance: 'ALL' } to your capabilities");
-        }
+      } catch {
+      }
     }
-    async cucumberBefore(browser, pickle) {
-        this.#isCucumberRunner = true;
-        await this.#initCucumberScenario(browser, pickle);
-    }
-    async cucumberAfter(browser, result, pickle) {
-        await this.#finalizeCucumberScenario(browser, result, pickle);
-    }
-    /** Called from Cucumber Before hook (order:1000) — one call per scenario. */
-    async #initCucumberScenario(browser, pickle) {
-        await this.#ensureSessionInitialized(browser);
-        const featureUri = pickle.uri ?? 'unknown.feature';
-        const scenarioName = pickle.name ?? 'Unknown Scenario';
-        // Derive the feature name from the "Feature: <name>" header in the file,
-        // falling back to the filename (e.g. "login") only if the file can't be read.
-        let featureName = path.basename(featureUri, '.feature');
-        let featureContent = '';
-        const featureAbsPath = path.resolve(process.cwd(), featureUri);
-        const stepDefFiles = [];
-        if (featureUri !== 'unknown.feature' && fs.existsSync(featureAbsPath)) {
-            featureContent = fs.readFileSync(featureAbsPath, 'utf-8');
-            const match = featureContent.match(/^\s*Feature:\s*(.+)/m);
-            if (match) {
-                featureName = match[1].trim();
-            }
-            this.sessionCapturer.captureSource(featureAbsPath).catch(() => { });
-            // Capture step definitions from sibling directories
-            const featureDir = path.dirname(featureAbsPath);
-            const stepDirCandidates = ['step_definitions', 'steps', 'support'];
-            for (const candidate of stepDirCandidates) {
-                const stepDir = path.join(featureDir, candidate);
-                if (fs.existsSync(stepDir) && fs.statSync(stepDir).isDirectory()) {
-                    for (const entry of fs.readdirSync(stepDir)) {
-                        if (/\.(js|ts|mjs|cjs)$/.test(entry)) {
-                            const stepFilePath = path.join(stepDir, entry);
-                            this.sessionCapturer.captureSource(stepFilePath).catch(() => { });
-                            try {
-                                stepDefFiles.push({
-                                    filePath: stepFilePath,
-                                    content: fs.readFileSync(stepFilePath, 'utf-8')
-                                });
-                            }
-                            catch {
-                                // skip unreadable files
-                            }
-                        }
-                    }
-                }
+  }
+  return result;
+}
+
+// src/cucumber-lifecycle.ts
+var log3 = logger3("@wdio/nightwatch-devtools:cucumber");
+function attachScenarioToFeature(ctx, featureSuite, scenarioSuite) {
+  const existingIdx = featureSuite.suites.findIndex(
+    (s) => s.uid === scenarioSuite.uid
+  );
+  if (existingIdx !== -1) {
+    featureSuite.suites[existingIdx] = scenarioSuite;
+    ctx.sessionCapturer.sendUpstream(WS_SCOPE.clearExecutionData, {
+      uid: scenarioSuite.uid,
+      entryType: "suite"
+    });
+  } else {
+    featureSuite.suites.push(scenarioSuite);
+  }
+}
+function createFeatureSuite(ctx, featureUri, featureName, featureContent, featureAbsPath, scenarioName, steps) {
+  const featureSuite = ctx.suiteManager.getOrCreateSuite(
+    featureUri,
+    featureName,
+    featureUri,
+    []
+  );
+  ctx.suiteManager.markSuiteAsRunning(featureSuite);
+  const { featureLine, scenarioLine, stepLines, stepKeywords } = parseCucumberScenario(
+    featureContent,
+    scenarioName,
+    steps.map((s) => s.text)
+  );
+  if (featureAbsPath && featureLine > 0) {
+    featureSuite.callSource = `${featureAbsPath}:${featureLine}`;
+  }
+  return { featureSuite, scenarioLine, stepLines, stepKeywords };
+}
+function normalizeSteps(pickleSteps) {
+  return (pickleSteps ?? []).map((s) => ({ text: s.text ?? "" }));
+}
+async function initCucumberScenario(ctx, browser, pickle) {
+  await ctx.ensureSessionInitialized(browser);
+  const featureUri = pickle.uri ?? "unknown.feature";
+  const scenarioName = pickle.name ?? "Unknown Scenario";
+  const steps = normalizeSteps(pickle.steps);
+  const {
+    featureName,
+    featureContent,
+    featureAbsPath,
+    stepDefFiles,
+    capturedPaths
+  } = scanFeatureFile(featureUri);
+  for (const p of capturedPaths) {
+    ctx.sessionCapturer.captureSource(p).catch(() => {
+    });
+  }
+  const { featureSuite, scenarioLine, stepLines, stepKeywords } = createFeatureSuite(
+    ctx,
+    featureUri,
+    featureName,
+    featureContent,
+    featureAbsPath,
+    scenarioName,
+    steps
+  );
+  const scenarioSuite = buildCucumberScenarioSuite({
+    featureUri,
+    scenarioName,
+    featureName,
+    featureAbsPath,
+    stepDefFiles,
+    steps,
+    stepLines,
+    stepKeywords,
+    scenarioLine,
+    parentFeatureSuiteUid: featureSuite.uid
+  });
+  attachScenarioToFeature(ctx, featureSuite, scenarioSuite);
+  ctx.setCurrentScenarioSuite(scenarioSuite);
+  ctx.setCurrentStep(null);
+  ctx.setCurrentTest(null);
+  ctx.testReporter.updateSuites();
+  ctx.wrapBrowserOnce(browser);
+  log3.info(`\u{1F952} Scenario: ${scenarioName}`);
+}
+async function finalizeCucumberScenario(ctx, browser, result, pickle) {
+  try {
+    const scenarioState = cucumberResultToTestState(result);
+    const scenario = ctx.getCurrentScenarioSuite();
+    if (scenario) {
+      const now = /* @__PURE__ */ new Date();
+      const duration = now.getTime() - (scenario.start?.getTime() ?? now.getTime());
+      scenario.state = scenarioState;
+      scenario.end = now;
+      scenario._duration = duration;
+      closeOpenSteps(scenario, scenarioState, now);
+      const featureUri = pickle?.uri ?? "unknown.feature";
+      ctx.testManager.markTestAsProcessed(featureUri, pickle?.name ?? "");
+      const featureSuite = ctx.suiteManager.getSuite(featureUri);
+      if (featureSuite) {
+        ctx.suiteManager.finalizeSuiteState(featureSuite);
+      }
+      ctx.incrementCount(scenarioState);
+      const icon = ctx.testIcon(scenarioState);
+      log3.info(
+        `  ${icon} ${pickle?.name ?? "Unknown"} (${(duration / 1e3).toFixed(2)}s)`
+      );
+      ctx.testReporter.updateSuites();
+      ctx.setCurrentScenarioSuite(null);
+      ctx.setCurrentStep(null);
+      ctx.setCurrentTest(null);
+    }
+    await ctx.sessionCapturer.captureTrace(browser);
+  } catch (err) {
+    log3.error(`Failed to finalize Cucumber scenario: ${errorMessage(err)}`);
+  }
+}
+async function cucumberBeforeStep(ctx, _browser, pickleStep, _pickle) {
+  const scenario = ctx.getCurrentScenarioSuite();
+  if (!scenario) {
+    return;
+  }
+  ctx.browserProxy?.resetCommandTracking();
+  const stepText = pickleStep?.text ?? "";
+  const step = scenario.tests.find(
+    (t) => typeof t !== "string" && (t.title?.endsWith(stepText) === true || t.title === stepText)
+  );
+  if (step) {
+    step.state = TEST_STATE.RUNNING;
+    step.start = /* @__PURE__ */ new Date();
+    step.end = null;
+    ctx.setCurrentStep(step);
+    ctx.testReporter.updateSuites();
+  }
+}
+async function cucumberAfterStep(ctx, _browser, result, pickleStep, _pickle) {
+  const step = ctx.getCurrentStep();
+  if (!step) {
+    return;
+  }
+  const status = String(result?.status ?? "UNKNOWN").toUpperCase();
+  const stepState = status === "PASSED" ? TEST_STATE.PASSED : status === "SKIPPED" ? TEST_STATE.SKIPPED : TEST_STATE.FAILED;
+  step.state = stepState;
+  step.end = /* @__PURE__ */ new Date();
+  step._duration = Date.now() - (step.start?.getTime() ?? Date.now());
+  ctx.setCurrentStep(null);
+  ctx.testReporter.updateSuites();
+  void pickleStep;
+}
+async function cucumberBefore(ctx, browser, pickle) {
+  ctx.setCucumberRunner(true);
+  await initCucumberScenario(ctx, browser, pickle);
+}
+async function cucumberAfter(ctx, browser, result, pickle) {
+  await finalizeCucumberScenario(ctx, browser, result, pickle);
+}
+
+// src/test-lifecycle.ts
+import logger5 from "@wdio/logger";
+
+// src/helpers/specFileResolver.ts
+import fs10 from "fs";
+import path8 from "path";
+function resolveSpecFilePath(testFile, modulePath, srcFolders, cachedPath) {
+  let fullPath = findTestFileFromStack() || null;
+  if (!fullPath && cachedPath && cachedPath.includes(testFile)) {
+    fullPath = cachedPath;
+  }
+  if (fullPath) {
+    return fullPath;
+  }
+  if (!testFile) {
+    return null;
+  }
+  const workspaceRoot = process.cwd();
+  const normalized = (modulePath || "").replace(/\\/g, "/");
+  const srcFolderPaths = srcFolders.flatMap(
+    (sf) => normalized ? [
+      path8.resolve(workspaceRoot, sf, normalized + ".js"),
+      path8.resolve(workspaceRoot, sf, normalized + ".ts"),
+      path8.resolve(workspaceRoot, sf, normalized + ".cjs"),
+      path8.resolve(workspaceRoot, sf, normalized)
+    ] : []
+  );
+  const possiblePaths = [
+    ...srcFolderPaths,
+    // Treat module path as relative to cwd (works when src_folders isn't nested)
+    ...normalized ? [
+      path8.resolve(workspaceRoot, normalized + ".js"),
+      path8.resolve(workspaceRoot, normalized + ".ts"),
+      path8.resolve(workspaceRoot, normalized + ".cjs"),
+      path8.resolve(workspaceRoot, normalized)
+    ] : [],
+    path8.resolve(workspaceRoot, "tests", testFile + ".js"),
+    path8.resolve(workspaceRoot, "test", testFile + ".js"),
+    path8.resolve(workspaceRoot, testFile + ".js")
+  ];
+  for (const candidate of possiblePaths) {
+    if (fs10.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+// src/helpers/closePreviousTest.ts
+import logger4 from "@wdio/logger";
+var log4 = logger4("@wdio/nightwatch-devtools:closePreviousTest");
+async function closePreviousTest(input) {
+  const {
+    runningTest,
+    testFile,
+    testcases,
+    testManager,
+    incrementCount,
+    testIcon
+  } = input;
+  if (testcases[runningTest.title]) {
+    const testcase = testcases[runningTest.title];
+    const testState = determineTestState(testcase);
+    runningTest.state = testState;
+    runningTest.end = /* @__PURE__ */ new Date();
+    runningTest._duration = parseFloat(testcase.time || "0") * 1e3;
+    testManager.updateTestState(runningTest, testState);
+    testManager.markTestAsProcessed(testFile, runningTest.title);
+    incrementCount(testState);
+    log4.info(
+      `  ${testIcon(testState)} ${runningTest.title} (${(runningTest._duration / 1e3).toFixed(2)}s)`
+    );
+  } else {
+    const endTime = /* @__PURE__ */ new Date();
+    const duration = endTime.getTime() - (runningTest.start?.getTime() || 0);
+    testManager.updateTestState(
+      runningTest,
+      TEST_STATE.PASSED,
+      endTime,
+      duration
+    );
+    testManager.markTestAsProcessed(testFile, runningTest.title);
+    incrementCount(TEST_STATE.PASSED);
+    log4.info(`  \u2705 ${runningTest.title} (${(duration / 1e3).toFixed(2)}s)`);
+  }
+  await new Promise((resolve2) => setTimeout(resolve2, TIMING.UI_RENDER_DELAY));
+}
+
+// src/test-lifecycle.ts
+var log5 = logger5("@wdio/nightwatch-devtools:test-lifecycle");
+function resolveSuiteMetadata(ctx, currentTest) {
+  const moduleName = currentTest.module ?? "";
+  const testFile = moduleName.split("/").pop() || moduleName || DEFAULTS.FILE_NAME;
+  const fullPath = resolveSpecFilePath(
+    testFile,
+    moduleName,
+    ctx.srcFolders,
+    ctx.browserProxy.getCurrentTestFullPath() || void 0
+  );
+  if (!fullPath) {
+    log5.warn(
+      `[beforeEach] Could not resolve file path for "${testFile}" \u2014 source view will be unavailable`
+    );
+  }
+  let suiteTitle = testFile;
+  let testNames = [];
+  let suiteLine = null;
+  let testLines = [];
+  if (fullPath) {
+    const parsed = extractTestMetadata(fullPath);
+    if (parsed.suiteTitle) {
+      suiteTitle = parsed.suiteTitle;
+    }
+    testNames = parsed.testNames;
+    suiteLine = parsed.suiteLine;
+    testLines = parsed.testLines;
+  }
+  const rerunLabel = ctx.getRerunLabel();
+  if (rerunLabel) {
+    const targetIndex = testNames.findIndex((name) => name === rerunLabel);
+    if (targetIndex !== -1) {
+      testNames = [testNames[targetIndex]];
+      testLines = testLines[targetIndex] ? [testLines[targetIndex]] : [];
+    }
+  }
+  return { testFile, fullPath, suiteTitle, testNames, suiteLine, testLines };
+}
+function pickCurrentTestName(currentTest, testNames, processedTests) {
+  const runtimeTestName = typeof currentTest?.name === "string" ? currentTest.name.trim() : void 0;
+  const matchedRuntimeTestName = runtimeTestName ? testNames.find(
+    (name) => runtimeTestName === name || runtimeTestName.endsWith(` ${name}`)
+  ) : void 0;
+  return matchedRuntimeTestName || testNames.find((name) => !processedTests.has(name));
+}
+async function startNextTest(ctx, currentSuite, currentTestName, processedTests) {
+  if (processedTests.size === 0) {
+    ctx.suiteManager.markSuiteAsRunning(currentSuite);
+  }
+  const test = ctx.testManager.findTestInSuite(currentSuite, currentTestName);
+  if (test) {
+    test.state = TEST_STATE.RUNNING;
+    test.start = /* @__PURE__ */ new Date();
+    test.end = null;
+    ctx.testReporter.onTestStart(test);
+    ctx.setCurrentTest(test);
+    log5.info(`  \u25B6 ${currentTestName}`);
+    await new Promise((resolve2) => setTimeout(resolve2, TIMING.TEST_START_DELAY));
+  } else {
+    log5.warn(
+      `Test "${currentTestName}" not found in suite "${currentSuite.title}"`
+    );
+    ctx.setCurrentTest(null);
+  }
+}
+async function closePreviousRunningTest(ctx, currentSuite, testFile, currentTest) {
+  const runningTest = currentSuite.tests.find(
+    (t) => typeof t !== "string" && t.state === TEST_STATE.RUNNING
+  );
+  if (!runningTest) {
+    return;
+  }
+  await closePreviousTest({
+    runningTest,
+    testFile,
+    testcases: currentTest?.results?.testcases || {},
+    testManager: ctx.testManager,
+    incrementCount: (state) => ctx.incrementCount(state),
+    testIcon: (state) => ctx.testIcon(state)
+  });
+}
+function wrapBrowserOnce(ctx, browser) {
+  if (!ctx.isScriptInjected) {
+    ctx.browserProxy.wrapUrlMethod(browser);
+    ctx.isScriptInjected = true;
+  }
+  ctx.browserProxy.resetCommandTracking();
+  ctx.browserProxy.wrapBrowserCommands(browser);
+}
+function closeUnreportedRunningTest(ctx, currentSuite, testFile, results, processedTests) {
+  const runningTest = currentSuite.tests.find(
+    (t) => typeof t !== "string" && t.state === TEST_STATE.RUNNING
+  );
+  if (!runningTest || processedTests.has(runningTest.title)) {
+    return;
+  }
+  const failed = (results.errors ?? 0) > 0 || (results.failed ?? 0) > 0;
+  const testState = failed ? TEST_STATE.FAILED : TEST_STATE.PASSED;
+  const endTime = /* @__PURE__ */ new Date();
+  const duration = endTime.getTime() - (runningTest.start?.getTime() || 0);
+  ctx.testManager.updateTestState(runningTest, testState, endTime, duration);
+  ctx.testManager.markTestAsProcessed(testFile, runningTest.title);
+  ctx.incrementCount(testState);
+  const icon = ctx.testIcon(testState);
+  log5.info(`  ${icon} ${runningTest.title} (${(duration / 1e3).toFixed(2)}s)`);
+}
+async function closeReportedTestcases(ctx, currentSuite, testFile, testcases, processedTests) {
+  const testcaseNames = Object.keys(testcases);
+  const unprocessedTests = testcaseNames.filter(
+    (name) => !processedTests.has(name)
+  );
+  for (const currentTestName of unprocessedTests) {
+    const testcase = testcases[currentTestName];
+    const testState = determineTestState(testcase);
+    const test = ctx.testManager.findTestInSuite(currentSuite, currentTestName);
+    if (test) {
+      const dur = parseFloat(testcase.time || "0") * 1e3;
+      ctx.testManager.updateTestState(test, testState, /* @__PURE__ */ new Date(), dur);
+      ctx.incrementCount(testState);
+      const icon = ctx.testIcon(testState);
+      log5.info(`  ${icon} ${currentTestName} (${(dur / 1e3).toFixed(2)}s)`);
+    }
+    ctx.testManager.markTestAsProcessed(testFile, currentTestName);
+  }
+  if (processedTests.size === testcaseNames.length) {
+    ctx.suiteManager.finalizeSuite(currentSuite);
+    await new Promise(
+      (resolve2) => setTimeout(resolve2, TIMING.SUITE_COMPLETE_DELAY)
+    );
+  }
+}
+async function closeOutTestcases(ctx, browser) {
+  const currentTest = browser.currentTest ?? {};
+  const results = currentTest.results ?? {};
+  const moduleName = currentTest.module ?? "";
+  const testFile = moduleName.split("/").pop() || DEFAULTS.FILE_NAME;
+  const testcases = results.testcases ?? {};
+  const currentSuite = ctx.suiteManager.getSuite(testFile);
+  if (!currentSuite) {
+    return;
+  }
+  const processedTests = ctx.testManager.getProcessedTests(testFile);
+  if (Object.keys(testcases).length === 0) {
+    closeUnreportedRunningTest(
+      ctx,
+      currentSuite,
+      testFile,
+      results,
+      processedTests
+    );
+  } else {
+    await closeReportedTestcases(
+      ctx,
+      currentSuite,
+      testFile,
+      testcases,
+      processedTests
+    );
+  }
+}
+
+// src/session-init.ts
+import logger10 from "@wdio/logger";
+
+// src/session.ts
+import http from "http";
+import logger6 from "@wdio/logger";
+
+// src/helpers/perfLogs.ts
+function applyResponseReceived(p, response) {
+  const responseHeaders = {};
+  for (const [k, v] of Object.entries(response.headers || {})) {
+    responseHeaders[k.toLowerCase()] = String(v);
+  }
+  p.status = response.status;
+  p.statusText = response.statusText;
+  p.responseHeaders = responseHeaders;
+  p.mimeType = response.mimeType;
+  p.type = getRequestType(p.url, response.mimeType);
+}
+function startPendingRequest(params, entry, pending) {
+  const { requestId, request: req, timestamp } = params;
+  if (!req || typeof timestamp !== "number") {
+    return;
+  }
+  pending.set(requestId, {
+    id: `${entry.timestamp}-${requestId}`,
+    url: req.url,
+    method: req.method,
+    requestHeaders: req.headers ?? {},
+    timestamp: Math.round(timestamp * 1e3),
+    startTime: entry.timestamp
+  });
+}
+function handlePerfLogEvent(method, params, entry, pending, completed) {
+  if (method === "Network.requestWillBeSent") {
+    startPendingRequest(params, entry, pending);
+    return;
+  }
+  if (method === "Network.responseReceived") {
+    const p = pending.get(params.requestId);
+    if (p && params.response) {
+      applyResponseReceived(p, params.response);
+    }
+    return;
+  }
+  if (method === "Network.loadingFinished") {
+    const p = pending.get(params.requestId);
+    if (p && p.status !== void 0) {
+      p.size = params.encodedDataLength;
+      p.endTime = entry.timestamp;
+      p.time = entry.timestamp - p.startTime;
+      completed.push({ ...p });
+      pending.delete(params.requestId);
+    }
+    return;
+  }
+  if (method === "Network.loadingFailed") {
+    const p = pending.get(params.requestId);
+    if (p) {
+      p.error = params.errorText;
+      p.endTime = entry.timestamp;
+      p.time = entry.timestamp - p.startTime;
+      completed.push({ ...p });
+      pending.delete(params.requestId);
+    }
+  }
+}
+function parseNetworkFromPerfLogs(logs) {
+  const pending = /* @__PURE__ */ new Map();
+  const completed = [];
+  for (const entry of logs) {
+    let parsed;
+    try {
+      parsed = JSON.parse(entry.message);
+    } catch {
+      continue;
+    }
+    const message = parsed?.message;
+    const method = message?.method;
+    const params = message?.params;
+    if (!method || !params) {
+      continue;
+    }
+    handlePerfLogEvent(method, params, entry, pending, completed);
+  }
+  return completed;
+}
+function dedupeNetworkRequests(incoming, existing) {
+  const failedKey = (entry) => {
+    try {
+      const u = new URL(entry.url);
+      return `err:${entry.method}:${u.origin}${u.pathname}`;
+    } catch {
+      return `err:${entry.method}:${entry.url}`;
+    }
+  };
+  const alreadySeen = new Set(
+    existing.map(
+      (r) => r.error !== void 0 ? failedKey(r) : `ok:${r.method}:${r.url}:${r.timestamp}`
+    )
+  );
+  const deduped = [];
+  const seenFailedInBatch = /* @__PURE__ */ new Map();
+  for (const entry of incoming) {
+    if (entry.error !== void 0) {
+      const key = failedKey(entry);
+      if (alreadySeen.has(key)) {
+        continue;
+      }
+      const existingIdx = seenFailedInBatch.get(key);
+      if (existingIdx !== void 0) {
+        deduped[existingIdx] = entry;
+      } else {
+        seenFailedInBatch.set(key, deduped.length);
+        deduped.push(entry);
+      }
+    } else {
+      const key = `ok:${entry.method}:${entry.url}:${entry.timestamp}`;
+      if (!alreadySeen.has(key)) {
+        deduped.push(entry);
+      }
+    }
+  }
+  return deduped;
+}
+
+// src/session.ts
+var log6 = logger6("@wdio/nightwatch-devtools:SessionCapturer");
+function unwrapDriverValue(result) {
+  if (result && typeof result === "object" && "value" in result) {
+    return result.value;
+  }
+  return result;
+}
+var getProp = (obj, key) => obj && typeof obj === "object" ? obj[key] : void 0;
+var getPath = (obj, ...path9) => path9.reduce((acc, k) => getProp(acc, k), obj);
+var firstDefined = (obj, ...keys) => {
+  if (!obj || typeof obj !== "object") {
+    return void 0;
+  }
+  const rec = obj;
+  for (const k of keys) {
+    const v = rec[k];
+    if (v !== void 0 && v !== null) {
+      return v;
+    }
+  }
+  return void 0;
+};
+function resolveWebDriverAddress(browser) {
+  const transportSettings = getPath(browser, "transport", "settings", "webdriver") || getPath(browser, "queue", "transport", "settings", "webdriver") || getPath(
+    browser,
+    "nightwatchInstance",
+    "transport",
+    "settings",
+    "webdriver"
+  ) || {};
+  const opts = getProp(browser, "options") ?? {};
+  const nightwatchSettings = getPath(browser, "nightwatchInstance", "settings") || getPath(browser, "globals", "nightwatchInstance", "settings") || {};
+  const driverHost = String(
+    firstDefined(transportSettings, "host", "server_address") || firstDefined(getProp(opts, "webdriver"), "host") || firstDefined(getProp(nightwatchSettings, "webdriver"), "host") || "localhost"
+  );
+  const driverPort = Number(
+    firstDefined(transportSettings, "port") || firstDefined(getProp(opts, "webdriver"), "port") || firstDefined(getProp(nightwatchSettings, "webdriver"), "port") || 9515
+  );
+  return { driverHost, driverPort };
+}
+var SessionCapturer = class extends SessionCapturerBase {
+  #browser;
+  // True once BiDi inspectors are attached — the per-command perf-log network
+  // capture path skips when set, so we don't double-emit network requests.
+  bidiActive = false;
+  constructor(devtoolsOptions = {}, browser) {
+    super(devtoolsOptions);
+    this.#browser = browser;
+    this.patchConsole();
+    this.patchStreams();
+  }
+  onWsOpen() {
+    log6.info("\u2713 Worker WebSocket connected to backend");
+  }
+  onWsError(err) {
+    log6.error(`Couldn't connect to devtools backend: ${errorMessage(err)}`);
+  }
+  onWsClose() {
+    log6.info("Worker WebSocket disconnected");
+  }
+  /**
+   * Push every captured line into the local `consoleLogs` array so it ends up
+   * in any future trace export, in addition to the live WS broadcast.
+   */
+  onLine(type, args, source) {
+    const entry = createConsoleLogEntry(type, args, source);
+    this.consoleLogs.push(entry);
+    this.sendUpstream("consoleLogs", [entry]);
+  }
+  async captureCommand(command, args, result, error, testUid, callSource, timestamp) {
+    const serializedError = serializeError(error);
+    const commandId = this.commandCounter++;
+    const commandLogEntry = {
+      _id: commandId,
+      command,
+      args,
+      result,
+      error: serializedError,
+      timestamp: timestamp || Date.now(),
+      callSource,
+      testUid
+    };
+    this.commandsLog.push(commandLogEntry);
+    const isNavigationCommand = NAVIGATION_COMMANDS.some(
+      (cmd) => command.toLowerCase().includes(cmd.toLowerCase())
+    );
+    if (isNavigationCommand && this.#browser && !error) {
+      this.#capturePerformanceData(commandLogEntry, args).catch((err) => {
+        log6.warn(`Failed to capture performance data: ${errorMessage(err)}`);
+      });
+    }
+    return true;
+  }
+  async #capturePerformanceData(commandLogEntry, args) {
+    await new Promise((resolve2) => setTimeout(resolve2, 500));
+    const raw = await this.#browser.execute(CAPTURE_PERFORMANCE_SCRIPT);
+    const payload = unwrapDriverValue(
+      raw
+    );
+    applyPerformanceData(
+      commandLogEntry,
+      payload,
+      typeof args[0] === "string" ? args[0] : void 0
+    );
+  }
+  /**
+   * Replace an already-captured command entry (used for retried commands so
+   * only the final execution result is shown in the UI).
+   * Removes the old entry from commandsLog, revokes its sent-status so the
+   * replacement can be sent, and returns the new entry together with the
+   * old entry's timestamp (so the UI can locate and replace it in-place).
+   */
+  replaceCommand(oldId, command, args, result, error, testUid, callSource, timestamp) {
+    const idx = this.commandsLog.findIndex(
+      (c) => c._id === oldId
+    );
+    const oldTimestamp = idx !== -1 ? this.commandsLog[idx]?.timestamp ?? 0 : 0;
+    if (idx !== -1) {
+      this.commandsLog.splice(idx, 1);
+    }
+    this.sentCommandIds.delete(oldId);
+    const serializedError = serializeError(error);
+    const commandId = this.commandCounter++;
+    const entry = {
+      _id: commandId,
+      command,
+      args,
+      result,
+      error: serializedError,
+      timestamp: timestamp || Date.now(),
+      callSource,
+      testUid
+    };
+    this.commandsLog.push(entry);
+    return { entry, oldTimestamp };
+  }
+  /**
+   * Take a screenshot by calling the WebDriver HTTP endpoint directly.
+   * This completely bypasses Nightwatch's command queue so there is no risk
+   * of the request being appended after `end()` / `quit()`.
+   */
+  // Nightwatch's internal config lives at non-public paths (transport,
+  // queue.transport, nightwatchInstance.settings, globals.nightwatchInstance);
+  // none are in the NightwatchBrowser type. Cast for dynamic access.
+  #resolveDriverEndpoint(browser, sessionId) {
+    const { driverHost, driverPort } = resolveWebDriverAddress(browser);
+    return `http://${driverHost}:${driverPort}/session/${sessionId}/screenshot`;
+  }
+  takeScreenshotViaHttp(browser) {
+    const sessionId = browser.sessionId;
+    if (!sessionId) {
+      return Promise.resolve(null);
+    }
+    const endpoint = this.#resolveDriverEndpoint(browser, sessionId);
+    return new Promise((resolve2) => {
+      const req = http.get(endpoint, (res) => {
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          try {
+            const value = JSON.parse(body).value || null;
+            if (!value) {
+              log6.warn(`[screenshot] Empty response from ${endpoint}`);
             }
-        }
-        // Get or create the feature-level suite (no individual test names — scenarios go into suites[])
-        const featureSuite = this.suiteManager.getOrCreateSuite(featureUri, featureName, featureUri, []);
-        this.suiteManager.markSuiteAsRunning(featureSuite);
-        // Parse step keywords from the feature file
-        const steps = pickle.steps ?? [];
-        // Parse line numbers and keywords for TestLens navigation and step labels
-        const { featureLine, scenarioLine, stepLines, stepKeywords } = parseCucumberScenario(featureContent, scenarioName, steps.map((s) => s.text));
-        if (featureAbsPath && featureLine > 0) {
-            featureSuite.callSource = `${featureAbsPath}:${featureLine}`;
-        }
-        // Create a scenario sub-suite (child of feature suite).
-        // Use deterministicUid (no counter) so the SAME scenario always maps to the
-        // SAME uid across retries, enabling correct retry detection below.
-        const scenarioUid = deterministicUid(featureUri, `scenario:${scenarioName}`);
-        const scenarioSuite = {
-            uid: scenarioUid,
-            cid: DEFAULTS.CID,
-            title: scenarioName,
-            fullTitle: `${featureName} ${scenarioName}`,
-            parent: featureSuite.uid,
-            type: 'suite',
-            file: featureUri,
-            start: new Date(),
-            state: 'running',
-            end: null,
-            tests: [],
-            suites: [],
-            hooks: [],
-            _duration: 0,
-            callSource: featureAbsPath && scenarioLine > 0
-                ? `${featureAbsPath}:${scenarioLine}`
-                : undefined
-        };
-        // Create a TestStats entry for each step
-        steps.forEach((step, i) => {
-            const keyword = stepKeywords[i] || '';
-            const stepLabel = keyword ? `${keyword} ${step.text}` : step.text;
-            const stepUid = deterministicUid(featureUri, `step:${scenarioName}:${step.text}`);
-            scenarioSuite.tests.push({
-                uid: stepUid,
-                cid: DEFAULTS.CID,
-                title: stepLabel,
-                fullTitle: `${scenarioName} ${stepLabel}`,
-                parent: scenarioUid,
-                state: 'pending',
-                start: new Date(),
-                end: null,
-                type: 'test',
-                file: featureUri,
-                retries: 0,
-                _duration: 0,
-                hooks: [],
-                callSource: (() => {
-                    const loc = findStepDefinitionLine(stepDefFiles, step.text);
-                    if (loc) {
-                        return `${loc.filePath}:${loc.line}`;
-                    }
-                    if (featureAbsPath && stepLines[i] > 0) {
-                        return `${featureAbsPath}:${stepLines[i]}`;
-                    }
-                    return undefined;
-                })()
-            });
+            resolve2(value);
+          } catch {
+            log6.warn(`[screenshot] Failed to parse response from ${endpoint}`);
+            resolve2(null);
+          }
         });
-        // Add scenario sub-suite to the feature suite.
-        // If a suite with this uid already exists it means this is a RETRY of the same
-        // scenario — clear execution data so only the latest attempt's commands are shown.
-        const existingIdx = featureSuite.suites.findIndex((s) => s.uid === scenarioUid);
-        const isRetry = existingIdx !== -1;
-        if (isRetry) {
-            featureSuite.suites[existingIdx] = scenarioSuite;
-            // Pass the specific scenario uid so only this scenario's execution data
-            // is reset — a uid-less clearExecutionData would mark ALL suites as
-            // running, destroying the previous terminal states of sibling scenarios.
-            this.sessionCapturer.sendUpstream('clearExecutionData', {
-                uid: scenarioUid,
-                entryType: 'suite'
-            });
-        }
-        else {
-            featureSuite.suites.push(scenarioSuite);
-        }
-        this.#currentScenarioSuite = scenarioSuite;
-        this.#currentStep = null;
-        this.#currentTest = null;
-        this.testReporter.updateSuites();
-        if (!this.isScriptInjected) {
-            this.browserProxy.wrapUrlMethod(browser);
-            this.isScriptInjected = true;
-        }
-        this.browserProxy.wrapBrowserCommands(browser);
-        this.browserProxy.resetCommandTracking();
-        log.info(`🥒 Scenario: ${scenarioName}`);
+      });
+      req.on("error", (err) => {
+        log6.warn(
+          `[screenshot] HTTP request failed (${endpoint}): ${errorMessage(err)}`
+        );
+        resolve2(null);
+      });
+      req.setTimeout(5e3, () => {
+        log6.warn(`[screenshot] Request timed out (${endpoint})`);
+        req.destroy();
+        resolve2(null);
+      });
+    });
+  }
+  onSourceReadError(filePath, err) {
+    log6.warn(`Failed to read source file ${filePath}: ${errorMessage(err)}`);
+  }
+  onUpstreamDrop(event, reason, err) {
+    if (reason === "send-error") {
+      log6.warn(`[upstream] Failed to send "${event}": ${errorMessage(err)}`);
+      return;
     }
-    /** Called from Cucumber After hook (order:1000) — one call per scenario. */
-    async #finalizeCucumberScenario(browser, result, pickle) {
-        try {
-            const status = String(result?.status ?? 'UNKNOWN').toUpperCase();
-            const scenarioState = status === 'PASSED'
-                ? TEST_STATE.PASSED
-                : status === 'SKIPPED'
-                    ? TEST_STATE.SKIPPED
-                    : TEST_STATE.FAILED;
-            if (this.#currentScenarioSuite) {
-                const duration = Date.now() -
-                    (this.#currentScenarioSuite.start?.getTime() ?? Date.now());
-                this.#currentScenarioSuite.state = scenarioState;
-                this.#currentScenarioSuite.end = new Date();
-                this.#currentScenarioSuite._duration = duration;
-                // Ensure any still-running or pending steps are marked appropriately
-                for (const step of this.#currentScenarioSuite.tests) {
-                    if (typeof step !== 'string' &&
-                        (step.state === 'running' || step.state === 'pending')) {
-                        step.state =
-                            scenarioState === TEST_STATE.PASSED
-                                ? TEST_STATE.PASSED
-                                : TEST_STATE.FAILED;
-                        step.end = new Date();
-                    }
-                }
-                const featureUri = pickle?.uri ?? 'unknown.feature';
-                this.testManager.markTestAsProcessed(featureUri, pickle?.name ?? '');
-                const featureSuite = this.suiteManager.getSuite(featureUri);
-                if (featureSuite) {
-                    // Finalize is not called until all scenarios are done — just update state
-                    this.suiteManager.finalizeSuiteState(featureSuite);
-                }
-                this.#incrementCount(scenarioState);
-                const icon = this.#testIcon(scenarioState);
-                const durationSec = (duration / 1000).toFixed(2);
-                log.info(`  ${icon} ${pickle?.name ?? 'Unknown'} (${durationSec}s)`);
-                this.testReporter.updateSuites();
-                this.#currentScenarioSuite = null;
-                this.#currentStep = null;
-                this.#currentTest = null;
-            }
-            await this.sessionCapturer.captureTrace(browser);
-        }
-        catch (err) {
-            log.error(`Failed to finalize Cucumber scenario: ${err.message}`);
-        }
+    if (this.hasEverConnected()) {
+      log6.warn(`[upstream] WebSocket not open \u2014 dropping "${event}" event`);
     }
-    /** Called from Cucumber BeforeStep hook — marks the step as running. */
-    async cucumberBeforeStep(browser, pickleStep, _pickle) {
-        if (!this.#currentScenarioSuite) {
-            return;
-        }
-        // Reset per-step dedup tracking so commands in step N are never
-        // mistaken for retries of identically-signatured commands from step N-1.
-        this.browserProxy?.resetCommandTracking();
-        const stepText = pickleStep?.text ?? '';
-        const step = this.#currentScenarioSuite.tests.find((t) => typeof t !== 'string' &&
-            (t.title.endsWith(stepText) || t.title === stepText));
-        if (step) {
-            step.state = TEST_STATE.RUNNING;
-            step.start = new Date();
-            step.end = null;
-            this.#currentStep = step;
-            this.testReporter.updateSuites();
-        }
+  }
+  /**
+   * Inject the WDIO devtools script into the browser page
+   */
+  async injectScript(browser) {
+    try {
+      const scriptContent = await loadInjectableScript();
+      const injectionScript = `
+        const script = document.createElement('script');
+        script.textContent = arguments[0];
+        document.head.appendChild(script);
+        return true;
+      `;
+      await browser.execute(injectionScript, [scriptContent]);
+      const hasCollector = await pollUntilReady(async () => {
+        const checkResult = await browser.execute(
+          'return typeof window.wdioTraceCollector !== "undefined"'
+        );
+        return unwrapDriverValue(checkResult) === true;
+      });
+      if (hasCollector) {
+        log6.info("\u2713 Script injected and collector ready");
+      } else {
+        log6.warn("Script injection may have failed \u2014 collector not found");
+      }
+    } catch (err) {
+      log6.error(`Failed to inject script: ${errorMessage(err)}`);
+      throw err;
     }
-    /** Called from Cucumber AfterStep hook — records the step result. */
-    async cucumberAfterStep(_browser, result, pickleStep, _pickle) {
-        const step = this.#currentStep;
-        if (!step) {
-            return;
-        }
-        const status = String(result?.status ?? 'UNKNOWN').toUpperCase();
-        const stepState = status === 'PASSED'
-            ? TEST_STATE.PASSED
-            : status === 'SKIPPED'
-                ? TEST_STATE.SKIPPED
-                : TEST_STATE.FAILED;
-        step.state = stepState;
-        step.end = new Date();
-        step._duration = Date.now() - (step.start?.getTime() ?? Date.now());
-        this.#currentStep = null;
-        this.testReporter.updateSuites();
-        void pickleStep; // used by BeforeStep to find the step
-    }
-    async beforeEach(browser) {
-        if (this.#isCucumberRunner) {
-            return;
-        }
-        await this.#ensureSessionInitialized(browser);
-        const currentTest = browser.currentTest;
-        if (!currentTest) {
-            return;
-        }
-        const testFile = (currentTest.module || '').split('/').pop() ||
-            currentTest.module ||
-            DEFAULTS.FILE_NAME;
-        let fullPath = findTestFileFromStack() || null;
-        const cachedPath = this.browserProxy.getCurrentTestFullPath();
-        if (!fullPath && cachedPath && cachedPath.includes(testFile)) {
-            fullPath = cachedPath;
-        }
-        if (!fullPath && testFile) {
-            const workspaceRoot = process.cwd();
-            // currentTest.module is the path relative to a src_folder, e.g. "basic/ecosia"
-            // So we must try: path.join(cwd, srcFolder, module + '.js') for each src_folder
-            const modulePath = (currentTest.module || '').replace(/\\/g, '/');
-            const srcFolderPaths = this.#srcFolders.flatMap((sf) => modulePath
-                ? [
-                    path.join(workspaceRoot, sf, modulePath + '.js'),
-                    path.join(workspaceRoot, sf, modulePath + '.ts'),
-                    path.join(workspaceRoot, sf, modulePath + '.cjs'),
-                    path.join(workspaceRoot, sf, modulePath)
-                ]
-                : []);
-            const possiblePaths = [
-                // Highest priority: expand module path via each configured src_folder
-                ...srcFolderPaths,
-                // Fallback: treat module path as relative to cwd (works when src_folders isn't nested)
-                ...(modulePath
-                    ? [
-                        path.join(workspaceRoot, modulePath + '.js'),
-                        path.join(workspaceRoot, modulePath + '.ts'),
-                        path.join(workspaceRoot, modulePath + '.cjs'),
-                        path.join(workspaceRoot, modulePath)
-                    ]
-                    : []),
-                path.join(workspaceRoot, 'example/tests', testFile + '.js'),
-                path.join(workspaceRoot, 'example/tests', testFile),
-                path.join(workspaceRoot, 'tests', testFile + '.js'),
-                path.join(workspaceRoot, 'test', testFile + '.js'),
-                path.join(workspaceRoot, testFile + '.js')
-            ];
-            for (const possiblePath of possiblePaths) {
-                if (fs.existsSync(possiblePath)) {
-                    fullPath = possiblePath;
-                    break;
-                }
-            }
-        }
-        // Extract suite title and test metadata
-        let suiteTitle = testFile;
-        if (!fullPath) {
-            log.warn(`[beforeEach] Could not resolve file path for "${testFile}" — source view will be unavailable`);
-        }
-        let testNames = [];
-        let suiteLine = null;
-        let testLines = [];
-        if (fullPath) {
-            const { suiteTitle: parsedTitle, testNames: parsedNames, suiteLine: parsedSuiteLine, testLines: parsedTestLines } = extractTestMetadata(fullPath);
-            if (parsedTitle) {
-                suiteTitle = parsedTitle;
-            }
-            testNames = parsedNames;
-            suiteLine = parsedSuiteLine;
-            testLines = parsedTestLines;
-        }
-        const rerunLabel = this.#getRerunLabel();
-        if (rerunLabel) {
-            const targetIndex = testNames.findIndex((name) => name === rerunLabel);
-            if (targetIndex !== -1) {
-                testNames = [testNames[targetIndex]];
-                testLines = testLines[targetIndex] ? [testLines[targetIndex]] : [];
-            }
-        }
-        // Get or create suite for this test file
-        const currentSuite = this.suiteManager.getOrCreateSuite(testFile, suiteTitle, fullPath, testNames, suiteLine, testLines);
-        // Capture source file for display
-        if (fullPath && fullPath.includes('/')) {
-            this.sessionCapturer.captureSource(fullPath).catch(() => { });
-        }
-        const runningTest = currentSuite.tests.find((t) => typeof t !== 'string' && t.state === TEST_STATE.RUNNING);
-        if (runningTest) {
-            const testcases = currentTest?.results?.testcases || {};
-            if (testcases[runningTest.title]) {
-                const testcase = testcases[runningTest.title];
-                const testState = determineTestState(testcase);
-                runningTest.state = testState;
-                runningTest.end = new Date();
-                runningTest._duration = parseFloat(testcase.time || '0') * 1000;
-                this.testManager.updateTestState(runningTest, testState);
-                this.testManager.markTestAsProcessed(testFile, runningTest.title);
-                this.#incrementCount(testState);
-                const prevIcon = this.#testIcon(testState);
-                log.info(`  ${prevIcon} ${runningTest.title} (${(runningTest._duration / 1000).toFixed(2)}s)`);
-            }
-            else {
-                const endTime = new Date();
-                const duration = endTime.getTime() - (runningTest.start?.getTime() || 0);
-                this.testManager.updateTestState(runningTest, TEST_STATE.PASSED, endTime, duration);
-                this.testManager.markTestAsProcessed(testFile, runningTest.title);
-                this.#passCount++;
-                log.info(`  ✅ ${runningTest.title} (${(duration / 1000).toFixed(2)}s)`);
-            }
-            await new Promise((resolve) => setTimeout(resolve, TIMING.UI_RENDER_DELAY));
-        }
-        const processedTests = this.testManager.getProcessedTests(testFile);
-        const runtimeTestName = typeof currentTest?.name === 'string'
-            ? currentTest.name.trim()
-            : undefined;
-        const matchedRuntimeTestName = runtimeTestName
-            ? testNames.find((name) => runtimeTestName === name || runtimeTestName.endsWith(` ${name}`))
-            : undefined;
-        const currentTestName = matchedRuntimeTestName ||
-            testNames.find((name) => !processedTests.has(name));
-        if (currentTestName) {
-            if (processedTests.size === 0) {
-                this.suiteManager.markSuiteAsRunning(currentSuite);
-            }
-            const test = this.testManager.findTestInSuite(currentSuite, currentTestName);
-            if (test) {
-                test.state = TEST_STATE.RUNNING;
-                test.start = new Date();
-                test.end = null;
-                this.testReporter.onTestStart(test);
-                this.#currentTest = test;
-                log.info(`  ▶ ${currentTestName}`);
-                await new Promise((resolve) => setTimeout(resolve, TIMING.TEST_START_DELAY));
-            }
-            else {
-                log.warn(`Test "${currentTestName}" not found in suite "${currentSuite.title}"`);
-                this.#currentTest = null;
-            }
-        }
-        if (!this.isScriptInjected) {
-            this.browserProxy.wrapUrlMethod(browser);
-            this.isScriptInjected = true;
-        }
-        this.browserProxy.resetCommandTracking();
-        this.browserProxy.wrapBrowserCommands(browser);
+  }
+  /**
+   * Capture Chrome DevTools browser console logs via WebDriver log API.
+   * Requires loggingPrefs: { browser: 'ALL' } in Chrome capabilities.
+   */
+  async captureBrowserLogs(browser) {
+    try {
+      const rawLogs = await browser.getLog("browser");
+      const logs = unwrapDriverValue(rawLogs);
+      if (!Array.isArray(logs) || logs.length === 0) {
+        return;
+      }
+      const entries = mapChromeBrowserLogs(logs);
+      this.consoleLogs.push(...entries);
+      this.sendUpstream("consoleLogs", entries);
+    } catch {
     }
-    async afterEach(browser) {
-        // Cucumber runner manages its own lifecycle via cucumberHooks.cjs
-        if (this.#isCucumberRunner) {
-            return;
-        }
-        if (browser && this.sessionCapturer) {
-            try {
-                const currentTest = browser.currentTest;
-                const results = currentTest?.results || {};
-                const testFile = (currentTest.module || '').split('/').pop() || DEFAULTS.FILE_NAME;
-                const testcases = results.testcases || {};
-                const testcaseNames = Object.keys(testcases);
-                const currentSuite = this.suiteManager.getSuite(testFile);
-                if (currentSuite) {
-                    const processedTests = this.testManager.getProcessedTests(testFile);
-                    if (testcaseNames.length === 0) {
-                        const runningTest = currentSuite.tests.find((t) => typeof t !== 'string' && t.state === TEST_STATE.RUNNING);
-                        if (runningTest && !processedTests.has(runningTest.title)) {
-                            const testState = results.errors > 0 || results.failed > 0
-                                ? TEST_STATE.FAILED
-                                : TEST_STATE.PASSED;
-                            const endTime = new Date();
-                            const duration = endTime.getTime() - (runningTest.start?.getTime() || 0);
-                            this.testManager.updateTestState(runningTest, testState, endTime, duration);
-                            this.testManager.markTestAsProcessed(testFile, runningTest.title);
-                            this.#incrementCount(testState);
-                            const icon = this.#testIcon(testState);
-                            log.info(`  ${icon} ${runningTest.title} (${(duration / 1000).toFixed(2)}s)`);
-                        }
-                    }
-                    else {
-                        const unprocessedTests = testcaseNames.filter((name) => !processedTests.has(name));
-                        for (const currentTestName of unprocessedTests) {
-                            const testcase = testcases[currentTestName];
-                            const testState = determineTestState(testcase);
-                            const test = this.testManager.findTestInSuite(currentSuite, currentTestName);
-                            if (test) {
-                                const dur = parseFloat(testcase.time || '0') * 1000;
-                                this.testManager.updateTestState(test, testState, new Date(), dur);
-                                this.#incrementCount(testState);
-                                const icon = this.#testIcon(testState);
-                                log.info(`  ${icon} ${currentTestName} (${(dur / 1000).toFixed(2)}s)`);
-                            }
-                            this.testManager.markTestAsProcessed(testFile, currentTestName);
-                        }
-                        if (processedTests.size === testcaseNames.length) {
-                            this.suiteManager.finalizeSuite(currentSuite);
-                            await new Promise((resolve) => setTimeout(resolve, TIMING.SUITE_COMPLETE_DELAY));
-                        }
-                    }
-                }
-                await this.sessionCapturer.captureTrace(browser);
-            }
-            catch (err) {
-                log.error(`Failed to capture trace: ${err.message}`);
-            }
-        }
+  }
+  /**
+   * Parse Chrome performance logs to extract network request entries.
+   * Requires loggingPrefs: { performance: 'ALL' } in Chrome capabilities.
+   */
+  async captureNetworkFromPerformanceLogs(browser) {
+    if (this.bidiActive) {
+      return;
     }
-    async after(browser) {
-        try {
-            const currentTest = browser?.currentTest;
-            const testcases = currentTest?.results?.testcases || {};
-            for (const [, suite] of (this.suiteManager?.getAllSuites() ?? new Map()).entries()) {
-                this.testManager.finalizeSuiteTests(suite, testcases);
-                await new Promise((resolve) => setTimeout(resolve, TIMING.SUITE_COMPLETE_DELAY));
-                this.suiteManager.finalizeSuite(suite);
-            }
-            await new Promise((resolve) => setTimeout(resolve, TIMING.SUITE_COMPLETE_DELAY));
-            const summary = [
-                this.#passCount > 0 ? `${this.#passCount} passed` : null,
-                this.#failCount > 0 ? `${this.#failCount} failed` : null,
-                this.#skipCount > 0 ? `${this.#skipCount} skipped` : null
-            ]
-                .filter(Boolean)
-                .join('  ');
-            const totalFailed = this.#failCount;
-            log.info(`${totalFailed > 0 ? '❌' : '✅'} Tests complete!  ${summary}`);
-            log.info(`   DevTools UI: http://${this.options.hostname}:${this.options.port}`);
-            if (!this.#devtoolsBrowser) {
-                // Reuse mode: force one final suites broadcast so the UI reflects the
-                // actual outcome before the process exits.
-                this.testReporter?.updateSuites();
-                log.info('♻  Rerun complete — flushing WebSocket...');
-                await this.sessionCapturer?.closeWebSocket();
-                return;
-            }
-            log.info('💡 Please close the DevTools browser window to finish...');
-            if (this.#devtoolsBrowser) {
-                ;
-                logger.setLevel('devtools', 'warn');
-                let exitBySignal = false;
-                const signalHandler = () => {
-                    exitBySignal = true;
-                    log.info('\n✓ Exiting... Browser window will remain open');
-                    process.exit(0);
-                };
-                process.once('SIGINT', signalHandler);
-                process.once('SIGTERM', signalHandler);
-                while (true) {
-                    try {
-                        await this.#devtoolsBrowser.getTitle();
-                        await new Promise((res) => setTimeout(res, TIMING.BROWSER_POLL_INTERVAL));
-                    }
-                    catch {
-                        if (!exitBySignal) {
-                            log.info('Browser window closed, stopping DevTools app');
-                            break;
-                        }
-                    }
-                }
-                if (!exitBySignal) {
-                    process.removeListener('SIGINT', signalHandler);
-                    process.removeListener('SIGTERM', signalHandler);
-                    logger.setLevel('devtools', 'info');
-                    try {
-                        await this.#devtoolsBrowser.deleteSession();
-                    }
-                    catch {
-                        // session already closed
-                    }
-                    await stop();
-                    process.exit(0);
-                }
-            }
+    try {
+      const rawLogs = await browser.getLog("performance");
+      const logs = unwrapDriverValue(rawLogs);
+      if (!Array.isArray(logs) || logs.length === 0) {
+        return;
+      }
+      const networkEntries = parseNetworkFromPerfLogs(logs);
+      if (networkEntries.length === 0) {
+        return;
+      }
+      const deduped = dedupeNetworkRequests(
+        networkEntries,
+        this.networkRequests
+      );
+      if (deduped.length > 0) {
+        const normalized = deduped.map((d) => ({
+          ...d,
+          type: d.type ?? "unknown"
+        }));
+        this.networkRequests.push(...normalized);
+        this.sendUpstream("networkRequests", normalized);
+      }
+    } catch (err) {
+      const msg = errorMessage(err) ?? "";
+      if (!msg.includes("log type") && !msg.includes("performance")) {
+        log6.warn(`Performance log capture failed: ${msg}`);
+      }
+    }
+  }
+  /**
+   * Capture trace data from the browser (network requests, console logs, etc.)
+   */
+  async captureTrace(browser) {
+    await this.captureNetworkFromPerformanceLogs(browser);
+    try {
+      const checkResult = await browser.execute(
+        'return typeof window.wdioTraceCollector !== "undefined"'
+      );
+      const collectorExists = unwrapDriverValue(checkResult) === true;
+      if (!collectorExists) {
+        return;
+      }
+      const result = await browser.execute(`
+        if (typeof window.wdioTraceCollector === 'undefined') {
+          return null;
         }
-        catch (err) {
-            log.error(`Failed to stop backend: ${err.message}`);
+        return window.wdioTraceCollector.getTraceData();
+      `);
+      const traceData = unwrapDriverValue(
+        result
+      );
+      if (!traceData) {
+        return;
+      }
+      this.processTracePayload(traceData);
+      const mutationCount = Array.isArray(
+        traceData.mutations
+      ) ? traceData.mutations.length : 0;
+      if (mutationCount > 0) {
+        log6.info(`[trace] Captured ${mutationCount} DOM mutation(s)`);
+      }
+    } catch (err) {
+      log6.error(
+        `Failed to capture trace from injected script: ${errorMessage(err)}`
+      );
+    }
+  }
+};
+
+// src/reporter.ts
+import logger7 from "@wdio/logger";
+var log7 = logger7("@wdio/nightwatch-devtools:Reporter");
+var TestReporter = class extends TestReporterBase {
+  #currentSpecFile;
+  #testNamesCache = /* @__PURE__ */ new Map();
+  #currentSuite;
+  onSuiteStart(suiteStats) {
+    this.#currentSpecFile = suiteStats.file;
+    this.#currentSuite = suiteStats;
+    const rerunLabel = process.env[REUSE_ENV.RERUN_ENTRY_TYPE] === "test" ? process.env[REUSE_ENV.RERUN_LABEL]?.trim() : void 0;
+    if (!suiteStats.uid) {
+      suiteStats.uid = generateStableUid2(suiteStats);
+    }
+    if (this.#currentSpecFile && !this.#testNamesCache.has(this.#currentSpecFile)) {
+      const metadata = extractTestMetadata(this.#currentSpecFile);
+      const testNames = rerunLabel ? metadata.testNames.filter((name) => name === rerunLabel) : metadata.testNames;
+      if (testNames.length > 0) {
+        this.#testNamesCache.set(this.#currentSpecFile, testNames);
+        log7.info(
+          `\u{1F4DD} Extracted ${testNames.length} test names from ${this.#currentSpecFile}`
+        );
+      }
+    }
+    this.allSuites.push(suiteStats);
+    this.sendUpstream();
+  }
+  clearExecutionData() {
+    super.clearExecutionData();
+    this.#testNamesCache.clear();
+    this.#currentSuite = void 0;
+    this.#currentSpecFile = void 0;
+  }
+  getCurrentSuite() {
+    return this.#currentSuite;
+  }
+  /** Find by title within parent suite — Nightwatch retries reuse the title slot. */
+  onTestStart(testStats) {
+    if (!testStats.uid || testStats.uid.includes("temp-")) {
+      testStats.uid = generateStableUid2(testStats);
+    }
+    for (const suite of this.allSuites) {
+      const testIndex = suite.tests.findIndex((t) => {
+        if (typeof t === "string") {
+          return false;
         }
+        return t.title === testStats.title && t.parent === suite.uid;
+      });
+      if (testIndex !== -1) {
+        suite.tests[testIndex] = testStats;
+        this.sendUpstream();
+        return;
+      }
     }
-    #buildMetadataOptions() {
-        return {
-            framework: this.#isCucumberRunner ? 'nightwatch-cucumber' : 'nightwatch',
-            configFile: this.#configPath,
-            baseDir: process.cwd(),
-            runCapabilities: {
-                canRunSuites: true,
-                canRunTests: !this.#isCucumberRunner,
-                canRunAll: false
-            }
+    if (this.#currentSuite) {
+      this.#currentSuite.tests.push(testStats);
+    }
+    this.sendUpstream();
+  }
+  /** Synthesize `skipped` entries for tests that never executed. */
+  onSuiteEnd(suiteStats) {
+    const cachedNames = this.#testNamesCache.get(suiteStats.file) || [];
+    const processedTestNames = new Set(
+      suiteStats.tests.map((t) => typeof t === "string" ? t : t.title).filter((title) => Boolean(title))
+    );
+    cachedNames.forEach((testName) => {
+      if (!processedTestNames.has(testName)) {
+        const skippedTest = {
+          uid: generateStableUid2({
+            file: suiteStats.file,
+            fullTitle: `${suiteStats.title} ${testName}`
+          }),
+          cid: DEFAULTS.CID,
+          title: testName,
+          fullTitle: `${suiteStats.title} ${testName}`,
+          parent: suiteStats.uid,
+          state: "skipped",
+          start: /* @__PURE__ */ new Date(),
+          end: /* @__PURE__ */ new Date(),
+          type: "test",
+          file: suiteStats.file,
+          retries: DEFAULTS.RETRIES,
+          _duration: DEFAULTS.DURATION,
+          hooks: []
         };
+        suiteStats.tests.push(skippedTest);
+        log7.info(`Created skipped test "${testName}" (never executed)`);
+      }
+    });
+    this.sendUpstream();
+  }
+  /** Replace a suite when its UID changes mid-run (after spec rescan). */
+  updateSuite(suiteStats) {
+    const index = this.allSuites.findIndex((s) => s.file === suiteStats.file);
+    if (index !== -1) {
+      this.allSuites.splice(index, 1);
+    }
+    this.allSuites.push(suiteStats);
+    this.#currentSuite = suiteStats;
+    this.sendUpstream();
+  }
+};
+
+// src/helpers/testManager.ts
+var TestManager = class {
+  constructor(testReporter) {
+    this.testReporter = testReporter;
+  }
+  testReporter;
+  processedTests = /* @__PURE__ */ new Map();
+  lastKnownTestName = null;
+  /**
+   * Update test state and report to UI
+   */
+  updateTestState(test, state, endTime, duration) {
+    test.state = state;
+    if (endTime) {
+      test.end = endTime;
+    }
+    if (duration !== void 0) {
+      test._duration = duration;
     }
-    #incrementCount(state) {
-        if (state === TEST_STATE.PASSED) {
-            this.#passCount++;
+    if (state === TEST_STATE.PASSED) {
+      this.testReporter.onTestEnd(test);
+    } else if (state === TEST_STATE.FAILED) {
+      this.testReporter.onTestEnd(test);
+    } else if (state === TEST_STATE.RUNNING) {
+      this.testReporter.onTestStart(test);
+    }
+    if (state !== TEST_STATE.RUNNING) {
+      this.testReporter.onTestEnd(test);
+    }
+  }
+  /**
+   * Find test in suite by title
+   */
+  findTestInSuite(suite, testTitle) {
+    return suite.tests.find(
+      (t) => typeof t !== "string" && t.title === testTitle
+    );
+  }
+  /**
+   * Mark test as processed to avoid duplicate reporting
+   */
+  markTestAsProcessed(testFile, testTitle) {
+    if (!this.processedTests.has(testFile)) {
+      this.processedTests.set(testFile, /* @__PURE__ */ new Set());
+    }
+    this.processedTests.get(testFile).add(testTitle);
+  }
+  /**
+   * Check if test has been processed
+   */
+  isTestProcessed(testFile, testTitle) {
+    return this.processedTests.get(testFile)?.has(testTitle) ?? false;
+  }
+  /**
+   * Get processed tests for a file
+   */
+  getProcessedTests(testFile) {
+    return this.processedTests.get(testFile) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Detect test boundary and finalize previous test if needed
+   * Returns the current test name
+   */
+  detectTestBoundary(currentNightwatchTest) {
+    const currentTestName = currentNightwatchTest?.name || DEFAULTS.TEST_NAME;
+    if (this.lastKnownTestName && currentTestName !== this.lastKnownTestName && currentTestName !== DEFAULTS.TEST_NAME) {
+      const testFile = currentNightwatchTest.module?.split("/").pop() || DEFAULTS.FILE_NAME;
+      const currentSuite = this.testReporter.getCurrentSuite();
+      if (currentSuite) {
+        const prevTest = this.findTestInSuite(
+          currentSuite,
+          this.lastKnownTestName
+        );
+        if (prevTest && prevTest.state === TEST_STATE.RUNNING) {
+          const prevTestCase = currentNightwatchTest.results?.testcases?.[this.lastKnownTestName];
+          if (prevTestCase) {
+            const testState = determineTestState(prevTestCase);
+            this.updateTestState(
+              prevTest,
+              testState,
+              /* @__PURE__ */ new Date(),
+              parseFloat(prevTestCase.time || "0") * 1e3
+            );
+            this.markTestAsProcessed(testFile, this.lastKnownTestName);
+          }
         }
-        else if (state === TEST_STATE.SKIPPED) {
-            this.#skipCount++;
+      }
+    }
+    if (currentTestName !== DEFAULTS.TEST_NAME) {
+      this.lastKnownTestName = currentTestName;
+    }
+    return currentTestName;
+  }
+  /**
+   * Start a pending test if this is its first command
+   */
+  startTestIfPending(currentTestName) {
+    if (currentTestName === DEFAULTS.TEST_NAME || this.lastKnownTestName !== currentTestName) {
+      return;
+    }
+    const currentSuite = this.testReporter.getCurrentSuite();
+    if (!currentSuite) {
+      return;
+    }
+    const test = this.findTestInSuite(currentSuite, currentTestName);
+    if (test && test.state === TEST_STATE.PENDING) {
+      test.start = /* @__PURE__ */ new Date();
+      test.end = null;
+      this.updateTestState(test, TEST_STATE.RUNNING);
+    }
+  }
+  /**
+   * Finalize all incomplete tests in a suite
+   */
+  finalizeSuiteTests(suite, testcases) {
+    suite.tests.forEach((entry) => {
+      if (typeof entry === "string") {
+        return;
+      }
+      const test = entry;
+      if (test.state === TEST_STATE.RUNNING && test.start) {
+        test.state = TEST_STATE.PASSED;
+        stampTestEnd(test);
+        this.updateTestState(test, TEST_STATE.PASSED);
+      } else if (test.state === TEST_STATE.PENDING) {
+        const testcase = testcases[test.title];
+        if (testcase) {
+          const testState = determineTestState(testcase);
+          test.start = test.start || /* @__PURE__ */ new Date();
+          this.updateTestState(
+            test,
+            testState,
+            /* @__PURE__ */ new Date(),
+            parseFloat(testcase.time || "0") * 1e3
+          );
+        } else {
+          this.updateTestState(
+            test,
+            TEST_STATE.SKIPPED,
+            /* @__PURE__ */ new Date(),
+            0
+          );
         }
-        else {
-            this.#failCount++;
+      }
+    });
+  }
+  /**
+   * Reset internal state for new test files
+   */
+  reset() {
+    this.lastKnownTestName = null;
+  }
+};
+
+// src/helpers/suiteManager.ts
+var SuiteManager = class {
+  constructor(testReporter) {
+    this.testReporter = testReporter;
+  }
+  testReporter;
+  currentSuiteByFile = /* @__PURE__ */ new Map();
+  /**
+   * Clear execution data when a rerun starts.
+   * Resets all cached suites so they're recreated fresh during the new run.
+   */
+  clearExecutionData() {
+    this.currentSuiteByFile.clear();
+  }
+  /**
+   * Get or create suite for a test file
+   */
+  getOrCreateSuite(testFile, suiteTitle, fullPath, testNames, suiteLine, testLines) {
+    if (!this.currentSuiteByFile.has(testFile)) {
+      const file = fullPath || testFile;
+      const suiteStats = createSuiteStats({
+        uid: generateStableUid2(file, suiteTitle),
+        cid: DEFAULTS.CID,
+        title: suiteTitle,
+        file,
+        state: TEST_STATE.PENDING,
+        callSource: suiteLine && fullPath ? `${fullPath}:${suiteLine}` : void 0
+      });
+      for (let idx = 0; idx < testNames.length; idx++) {
+        const testName = testNames[idx];
+        const testLine = testLines?.[idx];
+        const fullTitle = `${suiteTitle} ${testName}`;
+        const testEntry = createTestStats({
+          uid: generateStableUid2(file, fullTitle),
+          cid: DEFAULTS.CID,
+          title: testName,
+          fullTitle,
+          file,
+          parent: suiteStats.uid,
+          state: TEST_STATE.PENDING,
+          callSource: testLine && fullPath ? `${fullPath}:${testLine}` : void 0
+        });
+        suiteStats.tests.push(testEntry);
+      }
+      this.currentSuiteByFile.set(testFile, suiteStats);
+      this.testReporter.onSuiteStart(suiteStats);
+    }
+    return this.currentSuiteByFile.get(testFile);
+  }
+  /**
+   * Get suite for a test file
+   */
+  getSuite(testFile) {
+    return this.currentSuiteByFile.get(testFile);
+  }
+  /**
+   * Mark suite as running.
+   * Clears `end` so that the `finalizeSuite` guard (`if (suite.end) return`)
+   * does not skip re-finalization during a rerun.
+   */
+  markSuiteAsRunning(suite) {
+    suite.state = TEST_STATE.RUNNING;
+    suite.end = null;
+    this.testReporter.updateSuites();
+  }
+  /**
+   * Update suite state from current children without marking it as ended.
+   * Used during Cucumber runs to keep the feature-level suite state fresh.
+   */
+  finalizeSuiteState(suite) {
+    suite.state = computeSuiteRunningState(suite);
+    this.testReporter.updateSuites();
+  }
+  /**
+   * Finalize suite with test results
+   */
+  finalizeSuite(suite) {
+    if (suite.end) {
+      return;
+    }
+    stampSuiteEnd(suite);
+    suite.state = computeSuiteFinalStateStrict(suite);
+    this.testReporter.onSuiteEnd(suite);
+  }
+  /**
+   * Get all suites
+   */
+  getAllSuites() {
+    return this.currentSuiteByFile;
+  }
+};
+
+// src/helpers/browserProxy.ts
+import logger8 from "@wdio/logger";
+
+// src/helpers/serializeCommandResult.ts
+function serializeCommandResult(callbackResult, methodName) {
+  if (callbackResult === null || callbackResult === void 0) {
+    return void 0;
+  }
+  const isBooleanCommand = BOOLEAN_COMMAND_PATTERN.test(methodName);
+  if (typeof callbackResult === "object") {
+    const r = callbackResult;
+    if ("passed" in r) {
+      return r.passed ? true : {
+        passed: false,
+        actual: r.actual,
+        expected: r.expected,
+        message: r.message
+      };
+    }
+    if ("value" in r) {
+      const raw = r.value;
+      return raw === null && isBooleanCommand ? false : raw;
+    }
+  }
+  if (typeof callbackResult !== "function") {
+    try {
+      return JSON.parse(JSON.stringify(callbackResult));
+    } catch {
+      return String(callbackResult);
+    }
+  }
+  return void 0;
+}
+
+// src/helpers/browserProxy.ts
+var log8 = logger8("@wdio/nightwatch-devtools:browserProxy");
+var BrowserProxy = class {
+  constructor(sessionCapturer, testManager, getCurrentTest) {
+    this.sessionCapturer = sessionCapturer;
+    this.testManager = testManager;
+    this.getCurrentTest = getCurrentTest;
+  }
+  sessionCapturer;
+  testManager;
+  getCurrentTest;
+  /** Tracks which browser *instances* have already been proxied to avoid double-wrapping. */
+  proxiedBrowsers = /* @__PURE__ */ new WeakSet();
+  commandStack = [];
+  lastCommandSig = null;
+  currentTestFullPath = null;
+  /**
+   * Tracks the last captured command so that consecutive retries of the same
+   * command (e.g. getText inside a waitFor loop) overwrite the previous entry
+   * rather than appending, showing only the final execution result.
+   */
+  retryTracker = new RetryTracker();
+  /**
+   * Update the session capturer reference after a WebDriver session change.
+   * Does NOT re-wrap browser methods — wrapping is permanent per browser object.
+   */
+  updateSessionCapturer(capturer) {
+    this.sessionCapturer = capturer;
+  }
+  resetCommandTracking() {
+    this.commandStack = [];
+    this.lastCommandSig = null;
+    this.retryTracker.reset();
+  }
+  getCurrentTestFullPath() {
+    return this.currentTestFullPath;
+  }
+  setCurrentTestFullPath(path9) {
+    this.currentTestFullPath = path9;
+  }
+  /**
+   * Wrap browser navigation methods (url / navigate / navigateTo) to inject
+   * the DevTools script after every navigation.
+   *
+   * Uses `browser` from the closure (not `this` inside perform) so it works
+   * for both standard Nightwatch (chainable API) and Cucumber async/await mode
+   * where `this` inside a perform callback is not the browser.
+   */
+  wrapUrlMethod(browser) {
+    const sessionCapturer = this.sessionCapturer;
+    const b = browser;
+    const wrapNav = (methodName) => {
+      if (typeof b[methodName] !== "function") {
+        return;
+      }
+      const original = b[methodName].bind(browser);
+      b[methodName] = function(...args) {
+        const result = original(...args);
+        const injectAndCapture = () => {
+          log8.info(`[nav] ${methodName}(${args[0] ?? ""}) \u2014 injecting script`);
+          return sessionCapturer.injectScript(browser).then(() => sessionCapturer.captureTrace(browser)).catch(
+            (err) => log8.error(`Failed to inject script: ${err.message}`)
+          );
+        };
+        const chainable = result;
+        if (chainable && typeof chainable.perform === "function") {
+          chainable.perform((done) => {
+            injectAndCapture().finally(() => done && done());
+          });
+          return result;
         }
+        return Promise.resolve(result).then(injectAndCapture).catch(() => {
+        });
+      };
+    };
+    wrapNav("url");
+    wrapNav("navigate");
+    wrapNav("navigateTo");
+    log8.info("\u2713 Script injection wrapped");
+  }
+  wrapBrowserCommands(browser) {
+    if (this.proxiedBrowsers.has(browser)) {
+      return;
+    }
+    const browserAny = browser;
+    const allMethods = /* @__PURE__ */ new Set([
+      ...Object.keys(browser),
+      ...Object.getOwnPropertyNames(Object.getPrototypeOf(browser))
+    ]);
+    const wrappedMethods = [];
+    allMethods.forEach((methodName) => {
+      if (methodName === "constructor" || typeof browserAny[methodName] !== "function") {
+        return;
+      }
+      if (INTERNAL_COMMANDS_TO_IGNORE.includes(
+        methodName
+      ) || methodName.startsWith("__")) {
+        return;
+      }
+      const originalMethod = browserAny[methodName].bind(browser);
+      browserAny[methodName] = (...args) => {
+        return this.handleCommandExecution(
+          browser,
+          browserAny,
+          methodName,
+          originalMethod,
+          args
+        );
+      };
+      wrappedMethods.push(methodName);
+    });
+    this.proxiedBrowsers.add(browser);
+    log8.info(`\u2713 Wrapped ${wrappedMethods.length} browser methods`);
+  }
+  handleRetryReplacement(browser, methodName, logArgs, serializedResult, effectiveUid, callSource, commandTimestamp) {
+    const { entry, oldTimestamp } = this.sessionCapturer.replaceCommand(
+      this.retryTracker.lastId,
+      methodName,
+      logArgs,
+      serializedResult,
+      void 0,
+      effectiveUid,
+      callSource,
+      commandTimestamp
+    );
+    this.retryTracker.setLastId(entry._id ?? null);
+    this.sessionCapturer.sendReplaceCommand(oldTimestamp, entry);
+    this.attachScreenshot(browser, entry, methodName, " (retry)");
+  }
+  captureFreshCommand(browser, methodName, logArgs, serializedResult, effectiveUid, callSource, commandTimestamp, cmdSig) {
+    this.retryTracker.setLastSig(cmdSig);
+    this.retryTracker.setLastId(null);
+    this.sessionCapturer.captureCommand(
+      methodName,
+      logArgs,
+      serializedResult,
+      void 0,
+      effectiveUid,
+      callSource,
+      commandTimestamp
+    ).catch(
+      (err) => log8.error(`Failed to capture ${methodName}: ${err.message}`)
+    );
+    const lastCommand = this.sessionCapturer.commandsLog[this.sessionCapturer.commandsLog.length - 1];
+    if (lastCommand) {
+      this.retryTracker.setLastId(lastCommand._id ?? null);
+      this.sessionCapturer.sendCommand(lastCommand);
+      log8.info(`[command] ${methodName}`);
+      this.attachScreenshot(browser, lastCommand, methodName);
+    }
+    this.maybeRepollMutations(browser, methodName);
+  }
+  // After DOM-mutating commands, re-poll mutations from the injected script
+  // so the browser preview stays in sync. setTimeout runs OUTSIDE Nightwatch's
+  // current callback stack (safer queue-wise).
+  maybeRepollMutations(browser, methodName) {
+    const isDomMutating = NAVIGATION_COMMANDS.includes(methodName) || [
+      "click",
+      "doubleClick",
+      "rightClick",
+      "setValue",
+      "clearValue",
+      "sendKeys",
+      "submitForm",
+      "back",
+      "forward",
+      "refresh"
+    ].includes(methodName);
+    if (!isDomMutating) {
+      return;
+    }
+    setTimeout(() => {
+      this.sessionCapturer.captureTrace(browser).catch(() => {
+      });
+    }, 200);
+  }
+  popCommandStackIfMatches(methodName, cmdSig) {
+    const stackFrame = this.commandStack[this.commandStack.length - 1];
+    if (stackFrame?.command === methodName && stackFrame.signature === cmdSig) {
+      this.commandStack.pop();
     }
-    #testIcon(state) {
-        return state === TEST_STATE.PASSED
-            ? '✅'
-            : state === TEST_STATE.SKIPPED
-                ? '⏭'
-                : '❌';
-    }
-    registerEventHandlers(eventHub) {
-        this.#isCucumberRunner = eventHub.runner === 'cucumber';
-        if (this.#isCucumberRunner) {
-            log.info('✓ Cucumber runner detected via NightwatchEventHub');
+  }
+  // Result-capturing callback factory — called by Nightwatch's async queue
+  // when the command completes. This is where we get the *actual* result.
+  makeCaptureCallback(browser, methodName, logArgs, cmdSig, callSource, commandTimestamp, testUid, userCallback) {
+    return (callbackResult) => {
+      this.popCommandStackIfMatches(methodName, cmdSig);
+      const serializedResult = serializeCommandResult(
+        callbackResult,
+        methodName
+      );
+      const effectiveUid = this.getCurrentTest()?.uid ?? testUid;
+      if (effectiveUid) {
+        if (this.retryTracker.isRetry(cmdSig)) {
+          this.handleRetryReplacement(
+            browser,
+            methodName,
+            logArgs,
+            serializedResult,
+            effectiveUid,
+            callSource,
+            commandTimestamp
+          );
+        } else {
+          this.captureFreshCommand(
+            browser,
+            methodName,
+            logArgs,
+            serializedResult,
+            effectiveUid,
+            callSource,
+            commandTimestamp,
+            cmdSig
+          );
         }
-        log.info('✓ NightwatchEventHub registered — enriched metadata enabled');
-        const handleSessionMetadata = (data) => {
-            try {
-                const { sessionCapabilities, sessionId, testEnv, host, modulePath } = data?.metadata ?? {};
-                if (this.sessionCapturer && (sessionCapabilities || sessionId)) {
-                    this.sessionCapturer.sendUpstream('metadata', {
-                        type: TraceType.Testrunner,
-                        capabilities: sessionCapabilities ?? {},
-                        sessionId,
-                        testEnv,
-                        host,
-                        modulePath,
-                        options: this.#buildMetadataOptions()
-                    });
-                }
-            }
-            catch (err) {
-                log.error(`Error in event handler: ${err.message}`);
-            }
-        };
-        eventHub.on('TestSuiteStarted', handleSessionMetadata);
-        eventHub.on('TestRunStarted', handleSessionMetadata);
+      }
+      if (userCallback) {
+        return userCallback(callbackResult);
+      }
+    };
+  }
+  pushCommandStackIfNew(methodName, cmdSig, callSource) {
+    if (this.lastCommandSig === cmdSig) {
+      return;
     }
+    this.commandStack.push({
+      command: methodName,
+      callSource,
+      signature: cmdSig
+    });
+    this.lastCommandSig = cmdSig;
+  }
+  handleCommandExecution(browser, browserAny, methodName, originalMethod, args) {
+    this.testManager.startTestIfPending(
+      this.testManager.detectTestBoundary(
+        browserAny.currentTest
+      )
+    );
+    const callInfo = getCallSourceFromStack();
+    if (callInfo.filePath && !this.currentTestFullPath) {
+      this.currentTestFullPath = callInfo.filePath;
+    }
+    const lastArg = args[args.length - 1];
+    const hasUserCallback = typeof lastArg === "function";
+    const userCallback = hasUserCallback ? lastArg : null;
+    const logArgs = hasUserCallback ? args.slice(0, -1) : args;
+    const cmdSig = JSON.stringify({
+      command: methodName,
+      args: logArgs,
+      src: callInfo.callSource
+    });
+    this.pushCommandStackIfNew(methodName, cmdSig, callInfo.callSource);
+    const callSource = callInfo.callSource;
+    const commandTimestamp = Date.now();
+    const captureCallback = this.makeCaptureCallback(
+      browser,
+      methodName,
+      logArgs,
+      cmdSig,
+      callSource,
+      commandTimestamp,
+      this.getCurrentTest()?.uid,
+      userCallback
+    );
+    const modifiedArgs = [...logArgs, captureCallback];
+    try {
+      return originalMethod(...modifiedArgs);
+    } catch (error) {
+      this.popCommandStackIfMatches(methodName, cmdSig);
+      this.captureCommandError(methodName, logArgs, error, callSource);
+      throw error;
+    }
+  }
+  captureCommandError(methodName, args, error, callSource) {
+    const currentTest = this.getCurrentTest();
+    if (!currentTest) {
+      return;
+    }
+    const normalizedError = toError(error);
+    log8.error(`[command error] ${methodName}: ${normalizedError.message}`);
+    this.sessionCapturer.captureCommand(
+      methodName,
+      args,
+      void 0,
+      normalizedError,
+      currentTest.uid,
+      callSource
+    ).catch(
+      (err) => log8.error(`Failed to capture ${methodName}: ${err.message}`)
+    );
+    const lastCommand = this.sessionCapturer.commandsLog[this.sessionCapturer.commandsLog.length - 1];
+    if (lastCommand) {
+      this.sessionCapturer.sendCommand(lastCommand);
+    }
+  }
+  isProxied(browser) {
+    return this.proxiedBrowsers.has(browser);
+  }
+  /**
+   * Fire-and-forget: pull a screenshot via the WebDriver HTTP endpoint and
+   * attach it to an already-captured command entry. The `suffix` is appended
+   * to the log line so retried-command screenshots show `(retry)`. Errors
+   * are silently swallowed — screenshots are best-effort and shouldn't fail
+   * the run.
+   */
+  attachScreenshot(browser, entry, methodName, suffix = "") {
+    const ts = entry.timestamp ?? 0;
+    this.sessionCapturer.takeScreenshotViaHttp(browser).then((screenshot) => {
+      if (screenshot) {
+        entry.screenshot = screenshot;
+        this.sessionCapturer.sendReplaceCommand(ts, entry);
+        log8.info(`[screenshot] Attached to ${methodName}${suffix}`);
+      }
+    }).catch(() => {
+    });
+  }
+};
+
+// src/screencast.ts
+import logger9 from "@wdio/logger";
+var log9 = logger9("@wdio/nightwatch-devtools:ScreencastRecorder");
+var ScreencastRecorder = class extends ScreencastRecorderBase {
+  #sessionCapturer;
+  constructor(sessionCapturer, options) {
+    super(options);
+    this.#sessionCapturer = sessionCapturer;
+  }
+  onPollingStarted(intervalMs) {
+    log9.info(
+      `\u2713 Screencast recording started (polling mode, ${intervalMs} ms interval)`
+    );
+  }
+  onPollingStopped(frameCount) {
+    log9.info(`\u2713 Screencast stopped \u2014 ${frameCount} frame(s) collected`);
+  }
+  onUnavailable(err) {
+    log9.warn(
+      `Screencast unavailable (${errorMessage(err)}). Recording skipped.`
+    );
+  }
+  async takeScreenshot() {
+    const browser = this.driver;
+    if (!browser) {
+      return null;
+    }
+    return this.#sessionCapturer.takeScreenshotViaHttp(browser);
+  }
+};
+
+// src/session-init.ts
+var log10 = logger10("@wdio/nightwatch-devtools:session-init");
+async function handleSessionChange(ctx, finalizeCurrent) {
+  log10.info("Browser session changed \u2014 reconnecting WebSocket only");
+  ctx.isScriptInjected = false;
+  ctx.bidiAttachAttempted = false;
+  await finalizeCurrent();
+  ctx.sessionCapturer?.cleanup();
+  ctx.sessionCapturer = null;
 }
-export const cucumberHooksPath = fileURLToPath(new URL('./helpers/cucumberHooks.cjs', import.meta.url));
-export default function createNightwatchDevTools(options) {
-    const plugin = new NightwatchDevToolsPlugin(options);
-    return {
-        // Set long timeout to allow user to review DevTools UI
-        // The after() hook waits for the browser window to be closed
-        asyncHookTimeout: 3600000,
-        before: async function () {
-            await plugin.before();
-        },
-        beforeEach: async function (browser) {
-            await plugin.beforeEach(browser);
-        },
-        afterEach: async function (browser) {
-            await plugin.afterEach(browser);
-        },
-        after: async function () {
-            await plugin.after();
-        },
-        registerEventHandlers: function (eventHub) {
-            plugin.registerEventHandlers(eventHub);
-        }
+function initReporterChain(ctx) {
+  ctx.testReporter = new TestReporter((suitesData) => {
+    if (ctx.sessionCapturer) {
+      ctx.sessionCapturer.sendUpstream("suites", suitesData);
+    }
+  });
+  ctx.testManager = new TestManager(ctx.testReporter);
+  ctx.suiteManager = new SuiteManager(ctx.testReporter);
+  ctx.browserProxy = new BrowserProxy(
+    ctx.sessionCapturer,
+    ctx.testManager,
+    () => ctx.getCurrentTest() ?? ctx.getCurrentScenarioSuite()
+  );
+}
+function rebindReporterToNewSession(ctx) {
+  ctx.testReporter.updateUpstream((suitesData) => {
+    if (ctx.sessionCapturer) {
+      ctx.sessionCapturer.sendUpstream("suites", suitesData);
+    }
+  });
+  ctx.browserProxy.updateSessionCapturer(ctx.sessionCapturer);
+  ctx.testReporter.updateSuites();
+}
+function broadcastSessionMetadata(ctx, browser) {
+  const capabilities = browser.capabilities || {};
+  const desiredCapabilities = browser.desiredCapabilities || {};
+  const sessionId = browser.sessionId;
+  const opts = browser.options || {};
+  if (ctx.srcFolders.length === 0) {
+    const sf = opts.src_folders;
+    ctx.srcFolders = Array.isArray(sf) ? sf : sf ? [sf] : [];
+  }
+  ctx.sessionCapturer.sendUpstream("metadata", {
+    type: "testrunner" /* Testrunner */,
+    capabilities,
+    desiredCapabilities,
+    sessionId,
+    testEnv: opts.testEnv,
+    host: opts.webdriver?.host,
+    options: ctx.buildMetadataOptions(),
+    url: ""
+  });
+  const browserName = capabilities.browserName || desiredCapabilities.browserName || "unknown";
+  const browserVersion = capabilities.browserVersion || capabilities.version || "";
+  log10.info(
+    `\u2713 Browser: ${browserName}${browserVersion ? " " + browserVersion : ""} (session: ${sessionId})`
+  );
+  const loggingPrefs = capabilities["goog:loggingPrefs"] || desiredCapabilities["goog:loggingPrefs"] || {};
+  if (!loggingPrefs.performance && !ctx.bidiEnabled) {
+    log10.warn(
+      "\u26A0  Network tab will be empty \u2014 add 'goog:loggingPrefs': { performance: 'ALL' } to your capabilities (or enable bidi:true)"
+    );
+  }
+}
+async function tryAttachBidi(ctx, browser) {
+  if (!ctx.bidiEnabled || ctx.bidiAttachAttempted) {
+    return;
+  }
+  ctx.bidiAttachAttempted = true;
+  const driver = browser.driver;
+  if (!driver) {
+    log10.warn("bidi:true set but browser.driver unavailable \u2014 skipping");
+    return;
+  }
+  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-OH4ZFDN5.js");
+  const ok = await attachBidiHandlers(
+    driver,
+    buildBidiSinks(ctx.sessionCapturer)
+  );
+  if (ok) {
+    ctx.sessionCapturer.bidiActive = true;
+    log10.info("\u2713 BiDi attached \u2014 perf-log network capture disabled");
+  }
+}
+async function tryStartScreencast(ctx, browser, sessionId) {
+  if (!ctx.screencastOptions.enabled || ctx.screencastRecorder || !sessionId) {
+    return;
+  }
+  ctx.screencastRecorder = new ScreencastRecorder(
+    ctx.sessionCapturer,
+    ctx.screencastOptions
+  );
+  ctx.screencastSessionId = sessionId;
+  log10.info(`\u{1F3AC} Starting screencast for session ${sessionId}`);
+  await ctx.screencastRecorder.start(browser);
+}
+async function ensureSessionInitialized(ctx, browser, finalizeCurrentScreencast2) {
+  const currentSessionId = browser.sessionId;
+  const isSessionChange = currentSessionId && ctx.lastSessionId && currentSessionId !== ctx.lastSessionId;
+  if (isSessionChange) {
+    await handleSessionChange(ctx, finalizeCurrentScreencast2);
+  }
+  ctx.lastSessionId = currentSessionId ?? null;
+  if (ctx.sessionCapturer) {
+    return;
+  }
+  await new Promise(
+    (resolve2) => setTimeout(resolve2, TIMING.INITIAL_CONNECTION_WAIT)
+  );
+  ctx.sessionCapturer = new SessionCapturer(
+    { port: ctx.port, hostname: ctx.hostname },
+    browser
+  );
+  const connected = await ctx.sessionCapturer.waitForConnection(3e3);
+  if (!connected) {
+    log10.error("\u274C Worker WebSocket failed to connect!");
+  }
+  if (!ctx.testReporter) {
+    initReporterChain(ctx);
+  } else {
+    rebindReporterToNewSession(ctx);
+  }
+  broadcastSessionMetadata(ctx, browser);
+  await tryAttachBidi(ctx, browser);
+  await tryStartScreencast(ctx, browser, browser.sessionId);
+}
+async function finalizeCurrentScreencast(ctx) {
+  if (!ctx.screencastRecorder || !ctx.screencastSessionId) {
+    return;
+  }
+  await finalizeScreencast({
+    recorder: ctx.screencastRecorder,
+    sessionId: ctx.screencastSessionId,
+    filenamePrefix: "nightwatch-video",
+    outputDir: resolveAdapterOutputDir({
+      testFilePath: ctx.browserProxy?.getCurrentTestFullPath?.() ?? void 0,
+      configPath: ctx.configPath
+    }),
+    captureFormat: ctx.screencastOptions.captureFormat,
+    sendUpstream: (scope, data) => ctx.sessionCapturer?.sendUpstream(scope, data),
+    onLog: (level, message) => log10[level](message)
+  });
+  ctx.screencastRecorder = void 0;
+  ctx.screencastSessionId = void 0;
+}
+
+// src/index.ts
+var log11 = logger11("@wdio/nightwatch-devtools");
+var NightwatchDevToolsPlugin = class {
+  options;
+  sessionCapturer;
+  testReporter;
+  testManager;
+  suiteManager;
+  browserProxy;
+  isScriptInjected = false;
+  #currentTest = null;
+  #currentScenarioSuite = null;
+  #currentStep = null;
+  #lastSessionId = null;
+  #devtoolsBrowser;
+  #userDataDir;
+  #isCucumberRunner = false;
+  #passCount = 0;
+  #failCount = 0;
+  #skipCount = 0;
+  #configPath;
+  #srcFolders = [];
+  #getRerunLabel() {
+    return process.env[REUSE_ENV.RERUN_ENTRY_TYPE] === "test" ? process.env[REUSE_ENV.RERUN_LABEL]?.trim() : void 0;
+  }
+  #screencastOptions;
+  #screencastRecorder;
+  #screencastSessionId;
+  #bidiEnabled = false;
+  #bidiAttachAttempted = false;
+  constructor(options = {}) {
+    this.options = {
+      port: options.port ?? 3e3,
+      hostname: options.hostname ?? "localhost",
+      screencast: options.screencast ?? {},
+      bidi: options.bidi ?? false
+    };
+    this.#screencastOptions = {
+      ...SCREENCAST_DEFAULTS,
+      ...options.screencast ?? {}
+    };
+    this.#bidiEnabled = options.bidi === true;
+  }
+  // Single internals "bag" — structurally satisfies all 4 lifecycle ctx
+  // interfaces. Lifecycle modules cast it to their narrow type at call time.
+  #internals;
+  // Declarative accessor map — splitting this purely to satisfy the
+  // line-count rule hurts readability; the body is mechanical wiring.
+  // eslint-disable-next-line max-lines-per-function
+  #getInternals() {
+    if (this.#internals) {
+      return this.#internals;
+    }
+    const self = this;
+    this.#internals = {
+      get options() {
+        return self.options;
+      },
+      get hostname() {
+        return self.options.hostname;
+      },
+      get port() {
+        return self.options.port;
+      },
+      get screencastOptions() {
+        return self.#screencastOptions;
+      },
+      get bidiEnabled() {
+        return self.#bidiEnabled;
+      },
+      get sessionCapturer() {
+        return self.sessionCapturer;
+      },
+      set sessionCapturer(v) {
+        self.sessionCapturer = v;
+      },
+      get testReporter() {
+        return self.testReporter;
+      },
+      set testReporter(v) {
+        self.testReporter = v;
+      },
+      get testManager() {
+        return self.testManager;
+      },
+      set testManager(v) {
+        self.testManager = v;
+      },
+      get suiteManager() {
+        return self.suiteManager;
+      },
+      set suiteManager(v) {
+        self.suiteManager = v;
+      },
+      get browserProxy() {
+        return self.browserProxy;
+      },
+      set browserProxy(v) {
+        self.browserProxy = v;
+      },
+      get isScriptInjected() {
+        return self.isScriptInjected;
+      },
+      set isScriptInjected(v) {
+        self.isScriptInjected = v;
+      },
+      get devtoolsBrowser() {
+        return self.#devtoolsBrowser;
+      },
+      set devtoolsBrowser(v) {
+        self.#devtoolsBrowser = v;
+      },
+      get userDataDir() {
+        return self.#userDataDir;
+      },
+      set userDataDir(v) {
+        self.#userDataDir = v;
+      },
+      get passCount() {
+        return self.#passCount;
+      },
+      set passCount(v) {
+        self.#passCount = v;
+      },
+      get failCount() {
+        return self.#failCount;
+      },
+      set failCount(v) {
+        self.#failCount = v;
+      },
+      get skipCount() {
+        return self.#skipCount;
+      },
+      set skipCount(v) {
+        self.#skipCount = v;
+      },
+      get lastSessionId() {
+        return self.#lastSessionId;
+      },
+      set lastSessionId(v) {
+        self.#lastSessionId = v;
+      },
+      get bidiAttachAttempted() {
+        return self.#bidiAttachAttempted;
+      },
+      set bidiAttachAttempted(v) {
+        self.#bidiAttachAttempted = v;
+      },
+      get srcFolders() {
+        return self.#srcFolders;
+      },
+      set srcFolders(v) {
+        self.#srcFolders = v;
+      },
+      get screencastRecorder() {
+        return self.#screencastRecorder;
+      },
+      set screencastRecorder(v) {
+        self.#screencastRecorder = v;
+      },
+      get screencastSessionId() {
+        return self.#screencastSessionId;
+      },
+      set screencastSessionId(v) {
+        self.#screencastSessionId = v;
+      },
+      get configPath() {
+        return self.#configPath;
+      },
+      getCurrentTest: () => self.#currentTest,
+      getCurrentScenarioSuite: () => self.#currentScenarioSuite,
+      getCurrentStep: () => self.#currentStep,
+      setCurrentTest: (t) => {
+        self.#currentTest = t;
+      },
+      setCurrentScenarioSuite: (s) => {
+        self.#currentScenarioSuite = s;
+      },
+      setCurrentStep: (s) => {
+        self.#currentStep = s;
+      },
+      clearExecutionData: () => {
+        self.testReporter.clearExecutionData();
+        self.suiteManager.clearExecutionData();
+      },
+      buildMetadataOptions: () => self.#buildMetadataOptions(),
+      ensureSessionInitialized: (b) => self.#ensureSessionInitialized(b),
+      wrapBrowserOnce: (b) => self.#wrapBrowserOnce(b),
+      incrementCount: (s) => self.#incrementCount(s),
+      testIcon: (s) => self.#testIcon(s),
+      setCucumberRunner: (v) => {
+        self.#isCucumberRunner = v;
+      },
+      getRerunLabel: () => self.#getRerunLabel()
+    };
+    return this.#internals;
+  }
+  #handleReuseMode() {
+    handleReuseMode(this.#getInternals());
+  }
+  async #openDevtoolsBrowser(url) {
+    await openDevtoolsBrowser(this.#getInternals(), url);
+  }
+  async before() {
+    const internals = this.#getInternals();
+    internals.setConfigPath = (v) => {
+      this.#configPath = v;
+    };
+    internals.openDevtoolsBrowserAt = (url) => this.#openDevtoolsBrowser(url);
+    internals.handleReuse = () => this.#handleReuseMode();
+    internals.plugin = this;
+    await runPluginBefore(internals);
+  }
+  async #ensureSessionInitialized(browser) {
+    await ensureSessionInitialized(
+      this.#getInternals(),
+      browser,
+      () => this.#finalizeCurrentScreencast()
+    );
+  }
+  async #finalizeCurrentScreencast() {
+    await finalizeCurrentScreencast(this.#getInternals());
+  }
+  async cucumberBefore(browser, pickle) {
+    await cucumberBefore(this.#getInternals(), browser, pickle);
+  }
+  async cucumberAfter(browser, result, pickle) {
+    await cucumberAfter(this.#getInternals(), browser, result, pickle);
+  }
+  async cucumberBeforeStep(browser, pickleStep, pickle) {
+    await cucumberBeforeStep(
+      this.#getInternals(),
+      browser,
+      pickleStep,
+      pickle
+    );
+  }
+  async cucumberAfterStep(browser, result, pickleStep, pickle) {
+    await cucumberAfterStep(
+      this.#getInternals(),
+      browser,
+      result,
+      pickleStep,
+      pickle
+    );
+  }
+  #resolveSuiteMetadata(currentTest) {
+    return resolveSuiteMetadata(this.#getInternals(), currentTest);
+  }
+  #pickCurrentTestName(currentTest, testNames, processedTests) {
+    return pickCurrentTestName(currentTest, testNames, processedTests);
+  }
+  async #startNextTest(currentSuite, currentTestName, processedTests) {
+    await startNextTest(
+      this.#getInternals(),
+      currentSuite,
+      currentTestName,
+      processedTests
+    );
+  }
+  async #closePreviousRunningTest(currentSuite, testFile, currentTest) {
+    await closePreviousRunningTest(
+      this.#getInternals(),
+      currentSuite,
+      testFile,
+      currentTest
+    );
+  }
+  #wrapBrowserOnce(browser) {
+    wrapBrowserOnce(this.#getInternals(), browser);
+  }
+  async beforeEach(browser) {
+    if (this.#isCucumberRunner) {
+      return;
+    }
+    await this.#ensureSessionInitialized(browser);
+    const currentTest = browser.currentTest;
+    if (!currentTest) {
+      return;
+    }
+    const { testFile, fullPath, suiteTitle, testNames, suiteLine, testLines } = this.#resolveSuiteMetadata(currentTest);
+    const currentSuite = this.suiteManager.getOrCreateSuite(
+      testFile,
+      suiteTitle,
+      fullPath,
+      testNames,
+      suiteLine,
+      testLines
+    );
+    if (fullPath && fullPath.includes("/")) {
+      this.sessionCapturer.captureSource(fullPath).catch(() => {
+      });
+    }
+    await this.#closePreviousRunningTest(currentSuite, testFile, currentTest);
+    const processedTests = this.testManager.getProcessedTests(testFile);
+    const currentTestName = this.#pickCurrentTestName(
+      currentTest,
+      testNames,
+      processedTests
+    );
+    if (currentTestName) {
+      await this.#startNextTest(currentSuite, currentTestName, processedTests);
+    }
+    this.#wrapBrowserOnce(browser);
+  }
+  async afterEach(browser) {
+    if (this.#isCucumberRunner) {
+      return;
+    }
+    if (browser && this.sessionCapturer) {
+      try {
+        await this.#closeOutTestcases(browser);
+        await this.sessionCapturer.captureTrace(browser);
+      } catch (err) {
+        log11.error(`Failed to capture trace: ${errorMessage(err)}`);
+      }
+    }
+  }
+  async #closeOutTestcases(browser) {
+    await closeOutTestcases(this.#getInternals(), browser);
+  }
+  async after(browser) {
+    await this.#finalizeCurrentScreencast();
+    try {
+      await this.#finalizeAllSuites(browser);
+      this.#logRunSummary();
+      if (!this.#devtoolsBrowser) {
+        this.testReporter?.updateSuites();
+        log11.info("\u267B  Rerun complete \u2014 flushing WebSocket...");
+        await this.sessionCapturer?.closeWebSocket();
+        return;
+      }
+      log11.info("\u{1F4A1} Please close the DevTools browser window to finish...");
+      await this.#waitForDevtoolsBrowserClose();
+    } catch (err) {
+      log11.error(`Failed to stop backend: ${errorMessage(err)}`);
+    }
+  }
+  async #finalizeAllSuites(browser) {
+    await finalizeAllSuites(this.#getInternals(), browser);
+  }
+  #logRunSummary() {
+    logRunSummary(this.#getInternals());
+  }
+  async #waitForDevtoolsBrowserClose() {
+    await waitForDevtoolsBrowserClose(this.#getInternals());
+  }
+  #buildMetadataOptions() {
+    return buildPluginMetadataOptions({
+      isCucumberRunner: this.#isCucumberRunner,
+      configPath: this.#configPath
+    });
+  }
+  #incrementCount(state) {
+    const counters = {
+      passCount: this.#passCount,
+      failCount: this.#failCount,
+      skipCount: this.#skipCount
     };
+    incrementCounters(counters, state);
+    this.#passCount = counters.passCount;
+    this.#failCount = counters.failCount;
+    this.#skipCount = counters.skipCount;
+  }
+  #testIcon(state) {
+    return getTestIcon(state);
+  }
+  registerEventHandlers(eventHub) {
+    registerEventHandlers(eventHub, {
+      getSessionCapturer: () => this.sessionCapturer,
+      buildMetadataOptions: () => this.#buildMetadataOptions(),
+      setCucumberRunner: (v) => {
+        this.#isCucumberRunner = v;
+      }
+    });
+  }
+};
+var cucumberHooksPath = fileURLToPath(
+  new URL("./helpers/cucumberHooks.cjs", import.meta.url)
+);
+function createNightwatchDevTools(options) {
+  const plugin = new NightwatchDevToolsPlugin(options);
+  return {
+    // Set long timeout to allow user to review DevTools UI
+    // The after() hook waits for the browser window to be closed
+    asyncHookTimeout: 36e5,
+    before: async function() {
+      await plugin.before();
+    },
+    beforeEach: async function(browser) {
+      await plugin.beforeEach(browser);
+    },
+    afterEach: async function(browser) {
+      await plugin.afterEach(browser);
+    },
+    after: async function() {
+      await plugin.after();
+    },
+    registerEventHandlers: function(eventHub) {
+      plugin.registerEventHandlers(eventHub);
+    }
+  };
 }
-export { NightwatchDevToolsPlugin };
+export {
+  NightwatchDevToolsPlugin,
+  cucumberHooksPath,
+  createNightwatchDevTools as default
+};
 //# sourceMappingURL=index.js.map