@wdio/nightwatch-devtools 1.7.0 → 1.7.1

package/dist/index.js

@@ -6826,6 +6826,14 @@ var SessionCapturer = class extends SessionCapturerBase {
     this.commandsLog.push(entry);
     return { entry, oldTimestamp };
   }
+  /** Birth time of the document this capturer last observed, so a replacement
+   *  is still visible to a poll that starts after the navigation committed. */
+  lastDocumentOrigin;
+  /** The current document's own birth time, which is what a DOM anchor is
+   *  stamped with. Undefined when the session cannot answer. */
+  async documentOrigin(browser) {
+    return webdriverExecute(browser, "return performance.timeOrigin;").then((origin) => origin ?? void 0).catch(() => void 0);
+  }
   /**
    * Wait for a navigation to actually replace the document, then drain with a
    * forced anchor so the destination's DOM enters the stream.
@@ -6833,23 +6841,39 @@ var SessionCapturer = class extends SessionCapturerBase {
    * A Nightwatch click resolves BEFORE its navigation commits, so the drain that
    * runs at command completion still finds the outgoing page's collector: it
    * recovers nothing, and the destination is never anchored — every action on the
-   * new page then replays the page it came from. Waiting for the collector to
-   * disappear is the signal that the document was replaced; a command that
-   * navigated nowhere polls out and costs one drain of an empty buffer.
+   * new page then replays the page it came from.
+   *
+   * The replacement signal is the document's own `performance.timeOrigin`
+   * changing, NOT the collector going missing. Under the preload every document
+   * instruments itself at document-start, so the collector is never absent and
+   * that older signal stood permanently false — the destination was then only
+   * ever anchored by a drain that happened to be slow enough to land after the
+   * navigation, and tightening that latency lost the destination page entirely.
+   * A same-URL re-navigation is a new document and a new origin, so this covers
+   * it too; a command that navigated nowhere polls out and costs one drain of an
+   * empty buffer.
+   *
+   * The baseline is the last origin THIS capturer saw, never one read on entry.
+   * Reading it here would compare the document against itself: a command that
+   * completes AFTER its navigation committed (`browser.url` waits for load, so
+   * that is the normal case) would baseline the destination and then report no
+   * change, dropping the very anchor this exists to take. With no baseline yet
+   * a navigation cannot be ruled out either, so the first DOM-mutating command
+   * of a run anchors unconditionally rather than guessing — `captureCurrentDom`
+   * is idempotent per document, so an already-anchored page costs one drain.
    */
   async anchorAfterNavigation(browser) {
+    const before = this.lastDocumentOrigin;
     const replaced = await pollUntilReady(
-      async () => await webdriverExecute(
-        browser,
-        `return ${COLLECTOR_READY_EXPRESSION};`
-      ) !== true,
-      // With the preload active every document instruments itself at
-      // document-start, so there is normally nothing to catch — but ONE probe
-      // still runs rather than standing down entirely, because a document created
-      // before the registration landed has no collector and nothing else would
-      // ever notice. Without the preload this is the only detector, so it keeps
-      // the full settle poll.
-      this.preloadRegistered ? { attempts: 1, intervalMs: 0 } : { attempts: 5, intervalMs: 150 }
+      async () => {
+        const now = await this.documentOrigin(browser);
+        if (now === void 0) {
+          return false;
+        }
+        this.lastDocumentOrigin = now;
+        return before === void 0 || now !== before;
+      },
+      { attempts: 5, intervalMs: 150 }
     );
     if (!replaced) {
       return;
@@ -6970,16 +6994,16 @@ var SessionCapturer = class extends SessionCapturerBase {
       }
     }
   }
-  /**
-   * Capture trace data from the browser (network requests, console logs, etc.)
-   */
   /** `forceAnchor` forces a full-DOM anchor of the current document before
    *  draining, so a freshly injected collector's async anchor isn't lost.
    *  `anchorTimestamp` is the command this drain's anchors were CAUSED by — pass
    *  it only when the caller observed the document being replaced right after
    *  that command, since it overrides the inference at ingest. */
   async captureTrace(browser, forceAnchor = false, anchorTimestamp) {
+    await this.drainCollector(browser, forceAnchor, anchorTimestamp);
     await this.captureNetworkFromPerformanceLogs(browser);
+  }
+  async drainCollector(browser, forceAnchor, anchorTimestamp) {
     try {
       const traceData = await drainCollectorWithRecovery({
         drain: () => webdriverExecute(
@@ -8081,6 +8105,7 @@ var BrowserProxy = class {
   captureFreshCommand(browser, methodName, logArgs, serializedResult, meta, cmdSig, commandError) {
     this.retryTracker.setLastSig(cmdSig);
     this.retryTracker.setLastId(null);
+    this.drainOutgoingPage(browser, methodName);
     this.sessionCapturer.captureCommand(methodName, logArgs, serializedResult, commandError, meta).catch(
       (err) => log7.error(`Failed to capture ${methodName}: ${err.message}`)
     );
@@ -8091,32 +8116,10 @@ var BrowserProxy = class {
       log7.info(`[command] ${methodName}`);
       this.attachScreenshot(browser, lastCommand, methodName);
     }
-    this.maybeRepollMutations(browser, methodName);
+    this.anchorDestination(browser, methodName);
   }
-  /**
-   * After a DOM-mutating command, drain the collector — TWICE, for two different
-   * reasons that no single drain can serve.
-   *
-   * The first drain fires synchronously, with no setTimeout in front. It used to
-   * defer 200ms to stay off Nightwatch's callback stack, safe only because the
-   * drain went through `browser.execute`, a QUEUED command; over the raw HTTP
-   * transport it touches no queue, and because a driver serialises requests per
-   * session, a drain issued here is served BEFORE the next queued command. That
-   * is what captures the OUTGOING page's field edits — deferred, a submit click
-   * navigated first and they died with the page, so the `#password` fill row
-   * replayed with an empty password box.
-   *
-   * The second drain is what anchors the DESTINATION, and it has to wait: a
-   * Nightwatch click resolves before its navigation commits, so the first drain
-   * still finds the outgoing page's collector, recovers nothing, and the new
-   * document is never anchored — every action on it then replayed the page it
-   * came from (measured: 5 of 20 rows). `anchorAfterNavigation` keys off the
-   * document actually being replaced rather than off which command ran, so it
-   * covers any route to a new document — a submit click, a JS redirect, a
-   * same-command re-navigation — without a list of commands to keep in sync.
-   */
-  maybeRepollMutations(browser, methodName) {
-    const isDomMutating = NAVIGATION_COMMANDS.includes(methodName) || [
+  isDomMutating(methodName) {
+    return NAVIGATION_COMMANDS.includes(methodName) || [
       "click",
       "doubleClick",
       "rightClick",
@@ -8128,11 +8131,43 @@ var BrowserProxy = class {
       "forward",
       "refresh"
     ].includes(methodName);
-    if (!isDomMutating) {
+  }
+  /**
+   * Drains the OUTGOING page's field edits, which die with the document the
+   * moment a submit navigates. It goes over the raw HTTP transport, so it
+   * touches no Nightwatch queue, and a driver serialises requests per session —
+   * so it is served before the next queued command only for as long as it stays
+   * the FIRST request this class issues when a command completes. That call
+   * position, and the drain-before-perf-logs order inside `captureTrace`, are
+   * both load-bearing: behind the snapshot probes and the screenshot it needed
+   * about 130 ms of head start and got 18 ms, and the last field a test filled
+   * before submitting replayed as an empty box.
+   *
+   * It deliberately carries only this one request. `anchorAfterNavigation` is
+   * issued later, from `anchorDestination`, so the row's own screenshot and DOM
+   * snapshot are not pushed behind two round trips.
+   */
+  drainOutgoingPage(browser, methodName) {
+    if (!this.isDomMutating(methodName)) {
       return;
     }
     this.sessionCapturer.captureTrace(browser, true).catch(() => {
     });
+  }
+  /**
+   * Anchors the DESTINATION, and it has to wait: a Nightwatch click resolves
+   * before its navigation commits, so the outgoing drain still finds the old
+   * page's collector, recovers nothing, and the new document is never anchored —
+   * every action on it then replayed the page it came from (measured: 5 of 20
+   * rows). `anchorAfterNavigation` keys off the document actually being replaced
+   * rather than off which command ran, so it covers any route to a new document —
+   * a submit click, a JS redirect, a same-command re-navigation — without a list
+   * of commands to keep in sync.
+   */
+  anchorDestination(browser, methodName) {
+    if (!this.isDomMutating(methodName)) {
+      return;
+    }
     this.sessionCapturer.snapshotCaptures.push(
       this.sessionCapturer.anchorAfterNavigation(browser).catch(() => {
       })