@wdio/nightwatch-devtools 1.2.0 → 1.4.0

package/dist/index.js

@@ -17,6 +17,1894 @@ import {
 // src/index.ts
 import { fileURLToPath } from "url";
 
+// ../core/src/action-mapping.ts
+var ACTION_MAP = {
+  // WDIO browser-level
+  url: { class: "Page", method: "navigate" },
+  navigateTo: { class: "Page", method: "navigate" },
+  back: { class: "Page", method: "goBack" },
+  forward: { class: "Page", method: "goForward" },
+  refresh: { class: "Page", method: "reload" },
+  newWindow: { class: "Page", method: "goto" },
+  // Selenium WebDriver navigation (driver.get, driver.navigate().to/back/forward/refresh)
+  get: { class: "Page", method: "navigate" },
+  to: { class: "Page", method: "navigate" },
+  // WDIO element-level
+  click: { class: "Element", method: "click" },
+  doubleClick: { class: "Element", method: "dblclick" },
+  setValue: { class: "Element", method: "fill" },
+  selectByVisibleText: { class: "Element", method: "selectOption" },
+  moveTo: { class: "Element", method: "hover" },
+  scrollIntoView: { class: "Element", method: "scrollIntoViewIfNeeded" },
+  dragAndDrop: { class: "Element", method: "dragTo" },
+  // Selenium WebElement actions
+  sendKeys: { class: "Element", method: "fill" },
+  clear: { class: "Element", method: "clear" },
+  submit: { class: "Element", method: "submit" },
+  // Cross-runner
+  keys: { class: "Keyboard", method: "press" },
+  execute: { class: "Page", method: "evaluate" },
+  executeAsync: { class: "Page", method: "evaluate" },
+  switchToFrame: { class: "Frame", method: "goto" },
+  touchAction: { class: "Element", method: "tap" }
+};
+function mapCommandToAction(command) {
+  return ACTION_MAP[command] ?? null;
+}
+function formatActionTitle(action, args, params) {
+  const firstArg = args[0] ?? params?.selector;
+  if (firstArg === void 0) {
+    return `${action.class}.${action.method}()`;
+  }
+  const label = typeof firstArg === "object" ? JSON.stringify(firstArg) : String(firstArg);
+  return `${action.class}.${action.method}("${label}")`;
+}
+var FILL_METHODS = /* @__PURE__ */ new Set(["fill", "selectOption"]);
+
+// ../core/src/element-scripts.ts
+function accessibilityTreeScript(inViewportOnly) {
+  return `(function () {
+    var INPUT_TYPE_ROLES = {
+      text: 'textbox', search: 'searchbox', email: 'textbox', url: 'textbox',
+      tel: 'textbox', password: 'textbox', number: 'spinbutton',
+      checkbox: 'checkbox', radio: 'radio', range: 'slider',
+      submit: 'button', reset: 'button', image: 'button', file: 'button', color: 'button'
+    }
+
+    var CONTAINER_ROLES = new Set([
+      'navigation', 'banner', 'contentinfo', 'complementary', 'main',
+      'form', 'region', 'group', 'list', 'listitem', 'table', 'row', 'rowgroup', 'generic'
+    ])
+
+    function getRole(el) {
+      var explicit = el.getAttribute('role')
+      if (explicit) { return explicit.split(' ')[0] }
+      var tag = el.tagName.toLowerCase()
+      switch (tag) {
+        case 'button': return 'button'
+        case 'a': return el.hasAttribute('href') ? 'link' : null
+        case 'input': {
+          var type = (el.getAttribute('type') || 'text').toLowerCase()
+          if (type === 'hidden') { return null }
+          return INPUT_TYPE_ROLES[type] || 'textbox'
+        }
+        case 'select': return 'combobox'
+        case 'textarea': return 'textbox'
+        case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6': return 'heading'
+        case 'img': return 'img'
+        case 'nav': return 'navigation'
+        case 'main': return 'main'
+        case 'header': return !el.closest('article,aside,main,nav,section') ? 'banner' : null
+        case 'footer': return !el.closest('article,aside,main,nav,section') ? 'contentinfo' : null
+        case 'aside': return 'complementary'
+        case 'dialog': return 'dialog'
+        case 'form': return 'form'
+        case 'section': return el.hasAttribute('aria-label') || el.hasAttribute('aria-labelledby') ? 'region' : null
+        case 'summary': return 'button'
+        case 'details': return 'group'
+        case 'progress': return 'progressbar'
+        case 'meter': return 'meter'
+        case 'ul': case 'ol': return 'list'
+        case 'li': return 'listitem'
+        case 'table': return 'table'
+      }
+      if (el.contentEditable === 'true') { return 'textbox' }
+      if (el.hasAttribute('tabindex') && parseInt(el.getAttribute('tabindex') || '-1', 10) >= 0) { return 'generic' }
+      if (getDirectText(el)) { return 'statictext' }
+      return null
+    }
+
+    function getAccessibleName(el, role) {
+      var ariaLabel = el.getAttribute('aria-label')
+      if (ariaLabel) { return ariaLabel.trim() }
+      var labelledBy = el.getAttribute('aria-labelledby')
+      if (labelledBy) {
+        var texts = labelledBy.split(/\\s+/).map(function(id) { return (document.getElementById(id)?.textContent || '').trim() }).filter(Boolean)
+        if (texts.length > 0) { return texts.join(' ').slice(0, 200) }
+      }
+      var tag = el.tagName.toLowerCase()
+      if (tag === 'img' || (tag === 'input' && el.getAttribute('type') === 'image')) {
+        var alt = el.getAttribute('alt')
+        if (alt !== null) { return alt.trim() }
+      }
+      if (['input', 'select', 'textarea'].indexOf(tag) !== -1) {
+        var id = el.getAttribute('id')
+        if (id) {
+          var label = document.querySelector('label[for="' + CSS.escape(id) + '"]')
+          if (label) { return (label.textContent || '').trim() }
+        }
+        var parentLabel = el.closest('label')
+        if (parentLabel) {
+          var clone = parentLabel.cloneNode(true)
+          clone.querySelectorAll('input,select,textarea').forEach(function(n) { n.remove() })
+          var lt = (clone.textContent || '').trim()
+          if (lt) { return lt }
+        }
+      }
+      var ph = el.getAttribute('placeholder')
+      if (ph) { return ph.trim() }
+      var title = el.getAttribute('title')
+      if (title) { return title.trim() }
+      var childImg = el.querySelector('img')
+      if (childImg) {
+        var imgAlt = childImg.getAttribute('alt')
+        if (imgAlt) { return imgAlt.trim() }
+      }
+      if (role && CONTAINER_ROLES.has(role)) { return '' }
+      return ((el.textContent || '').trim().replace(/\\s+/g, ' ') || '').slice(0, 200)
+    }
+
+    function getSelector(element) {
+      var tag = element.tagName.toLowerCase()
+      var text = (element.textContent || '').trim().replace(/\\s+/g, ' ')
+      if (text && text.length > 0 && text.length <= 120) {
+        var sameTagElements = document.querySelectorAll(tag)
+        var matchCount = 0
+        sameTagElements.forEach(function(el) { if (el.textContent.includes(text)) { matchCount++ } })
+        if (matchCount === 1) { return tag + '*=' + text }
+      }
+      var ariaLabel = element.getAttribute('aria-label')
+      if (ariaLabel && ariaLabel.length <= 200) {
+        var sel = '[aria-label="' + CSS.escape(ariaLabel) + '"]'
+        if (document.querySelectorAll(sel).length === 1) { return sel }
+      }
+      var testId = element.getAttribute('data-testid')
+      if (testId) {
+        var testSel = '[data-testid="' + CSS.escape(testId) + '"]'
+        if (document.querySelectorAll(testSel).length === 1) { return testSel }
+      }
+      if (element.id) { return '#' + CSS.escape(element.id) }
+      var nameAttr = element.getAttribute('name')
+      if (nameAttr) {
+        var nameSel = tag + '[name="' + CSS.escape(nameAttr) + '"]'
+        if (document.querySelectorAll(nameSel).length === 1) { return nameSel }
+      }
+      if (element.className && typeof element.className === 'string') {
+        var classes = element.className.trim().split(/\\s+/).filter(Boolean)
+        for (var i = 0; i < classes.length; i++) {
+          var clsSel = tag + '.' + CSS.escape(classes[i])
+          if (document.querySelectorAll(clsSel).length === 1) { return clsSel }
+        }
+        if (classes.length >= 2) {
+          var twoClsSel = tag + classes.slice(0, 2).map(function(c) { return '.' + CSS.escape(c) }).join('')
+          if (document.querySelectorAll(twoClsSel).length === 1) { return twoClsSel }
+        }
+      }
+      var current = element
+      var path = []
+      while (current && current !== document.documentElement) {
+        var seg = current.tagName.toLowerCase()
+        if (current.id) { path.unshift('#' + CSS.escape(current.id)); break }
+        var parent = current.parentElement
+        if (parent) {
+          var siblings = Array.from(parent.children).filter(function(c) { return c.tagName === current.tagName })
+          if (siblings.length > 1) { seg += ':nth-of-type(' + (siblings.indexOf(current) + 1) + ')' }
+        }
+        path.unshift(seg)
+        current = current.parentElement
+        if (path.length >= 4) { break }
+      }
+      return path.join(' > ')
+    }
+
+    function getDirectText(el) {
+      var text = ''
+      for (var i = 0; i < el.childNodes.length; i++) {
+        if (el.childNodes[i].nodeType === 3) { text += el.childNodes[i].textContent }
+      }
+      return text.trim().replace(/\\s+/g, ' ')
+    }
+
+    function isVisible(el) {
+      if (typeof el.checkVisibility === 'function') {
+        return el.checkVisibility({ opacityProperty: true, visibilityProperty: true, contentVisibilityAuto: true })
+      }
+      var style = window.getComputedStyle(el)
+      return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0' && el.offsetWidth > 0 && el.offsetHeight > 0
+    }
+
+    function isInViewport(el) {
+      var rect = el.getBoundingClientRect()
+      return rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth)
+    }
+
+    function getLevel(el) {
+      var m = el.tagName.toLowerCase().match(/^h([1-6])$/)
+      if (m) { return parseInt(m[1], 10) }
+      var ariaLevel = el.getAttribute('aria-level')
+      if (ariaLevel) { return parseInt(ariaLevel, 10) }
+      return undefined
+    }
+
+    function getState(el) {
+      var inputEl = el
+      var isCheckable = ['input', 'menuitemcheckbox', 'menuitemradio'].indexOf(el.tagName.toLowerCase()) !== -1 || ['checkbox', 'radio', 'switch'].indexOf(el.getAttribute('role') || '') !== -1
+      return {
+        disabled: el.getAttribute('aria-disabled') === 'true' || inputEl.disabled ? 'true' : '',
+        checked: isCheckable && inputEl.checked ? 'true' : el.getAttribute('aria-checked') || '',
+        expanded: el.getAttribute('aria-expanded') || '',
+        selected: el.getAttribute('aria-selected') || '',
+        pressed: el.getAttribute('aria-pressed') || '',
+        required: inputEl.required || el.getAttribute('aria-required') === 'true' ? 'true' : '',
+        readonly: inputEl.readOnly || el.getAttribute('aria-readonly') === 'true' ? 'true' : ''
+      }
+    }
+
+    var result = []
+
+    function walk(el, depth) {
+      if (depth > 200) { return }
+      if (!isVisible(el)) { return }
+      var role = getRole(el)
+      var inViewport = isInViewport(el)
+      if (!role) {
+        for (var i = 0; i < el.children.length; i++) { walk(el.children[i], depth + 1) }
+        return
+      }
+      if (${inViewportOnly} && !inViewport) {
+        for (var i = 0; i < el.children.length; i++) { walk(el.children[i], depth + 1) }
+        return
+      }
+      var name = getAccessibleName(el, role)
+      var selector = getSelector(el)
+      var node = { role: role, name: name, selector: selector, depth: depth, level: getLevel(el) ?? '', isInViewport: inViewport }
+      var state = getState(el)
+      for (var k in state) { node[k] = state[k] }
+      result.push(node)
+      for (var i = 0; i < el.children.length; i++) { walk(el.children[i], depth + 1) }
+    }
+
+    for (var i = 0; i < document.body.children.length; i++) { walk(document.body.children[i], 0) }
+    return result
+  })()`;
+}
+function elementsScript(includeBounds, inViewportOnly) {
+  return `(function () {
+    var interactableSelectors = [
+      'a[href]', 'button', 'input:not([type="hidden"])', 'select', 'textarea',
+      '[role="button"]', '[role="link"]', '[role="checkbox"]', '[role="radio"]',
+      '[role="tab"]', '[role="menuitem"]', '[role="combobox"]', '[role="option"]',
+      '[role="switch"]', '[role="slider"]', '[role="textbox"]', '[role="searchbox"]',
+      '[role="spinbutton"]', '[contenteditable="true"]', '[tabindex]:not([tabindex="-1"])'
+    ].join(',')
+
+    function isVisible(element) {
+      if (typeof element.checkVisibility === 'function') {
+        return element.checkVisibility({ opacityProperty: true, visibilityProperty: true, contentVisibilityAuto: true })
+      }
+      var style = window.getComputedStyle(element)
+      return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0' && element.offsetWidth > 0 && element.offsetHeight > 0
+    }
+
+    function getAccessibleName(el) {
+      var ariaLabel = el.getAttribute('aria-label')
+      if (ariaLabel) { return ariaLabel.trim() }
+      var labelledBy = el.getAttribute('aria-labelledby')
+      if (labelledBy) {
+        var texts = labelledBy.split(/\\s+/).map(function(id) { return (document.getElementById(id)?.textContent || '').trim() }).filter(Boolean)
+        if (texts.length > 0) { return texts.join(' ').slice(0, 200) }
+      }
+      var tag = el.tagName.toLowerCase()
+      if (tag === 'img' || (tag === 'input' && el.getAttribute('type') === 'image')) {
+        var alt = el.getAttribute('alt')
+        if (alt !== null) { return alt.trim() }
+      }
+      if (['input', 'select', 'textarea'].indexOf(tag) !== -1) {
+        var id = el.getAttribute('id')
+        if (id) {
+          var label = document.querySelector('label[for="' + CSS.escape(id) + '"]')
+          if (label) { return (label.textContent || '').trim() }
+        }
+        var parentLabel = el.closest('label')
+        if (parentLabel) {
+          var clone = parentLabel.cloneNode(true)
+          clone.querySelectorAll('input,select,textarea').forEach(function(n) { n.remove() })
+          var lt = (clone.textContent || '').trim()
+          if (lt) { return lt }
+        }
+      }
+      var ph = el.getAttribute('placeholder')
+      if (ph) { return ph.trim() }
+      var title = el.getAttribute('title')
+      if (title) { return title.trim() }
+      return ((el.textContent || '').trim().replace(/\\s+/g, ' ') || '').slice(0, 200)
+    }
+
+    function getSelector(element) {
+      var tag = element.tagName.toLowerCase()
+      var text = (element.textContent || '').trim().replace(/\\s+/g, ' ')
+      if (text && text.length > 0 && text.length <= 120) {
+        var sameTagElements = document.querySelectorAll(tag)
+        var matchCount = 0
+        sameTagElements.forEach(function(el) { if (el.textContent.includes(text)) { matchCount++ } })
+        if (matchCount === 1) { return tag + '*=' + text }
+      }
+      var ariaLabel = element.getAttribute('aria-label')
+      if (ariaLabel && ariaLabel.length <= 200) {
+        var sel = '[aria-label="' + CSS.escape(ariaLabel) + '"]'
+        if (document.querySelectorAll(sel).length === 1) { return sel }
+      }
+      var testId = element.getAttribute('data-testid')
+      if (testId) {
+        var testSel = '[data-testid="' + CSS.escape(testId) + '"]'
+        if (document.querySelectorAll(testSel).length === 1) { return testSel }
+      }
+      if (element.id) { return '#' + CSS.escape(element.id) }
+      var nameAttr = element.getAttribute('name')
+      if (nameAttr) {
+        var nameSel = tag + '[name="' + CSS.escape(nameAttr) + '"]'
+        if (document.querySelectorAll(nameSel).length === 1) { return nameSel }
+      }
+      if (element.className && typeof element.className === 'string') {
+        var classes = element.className.trim().split(/\\s+/).filter(Boolean)
+        for (var i = 0; i < classes.length; i++) {
+          var clsSel = tag + '.' + CSS.escape(classes[i])
+          if (document.querySelectorAll(clsSel).length === 1) { return clsSel }
+        }
+        if (classes.length >= 2) {
+          var twoClsSel = tag + classes.slice(0, 2).map(function(c) { return '.' + CSS.escape(c) }).join('')
+          if (document.querySelectorAll(twoClsSel).length === 1) { return twoClsSel }
+        }
+      }
+      var current = element
+      var path = []
+      while (current && current !== document.documentElement) {
+        var seg = current.tagName.toLowerCase()
+        if (current.id) { path.unshift('#' + CSS.escape(current.id)); break }
+        var parent = current.parentElement
+        if (parent) {
+          var siblings = Array.from(parent.children).filter(function(c) { return c.tagName === current.tagName })
+          if (siblings.length > 1) { seg += ':nth-of-type(' + (siblings.indexOf(current) + 1) + ')' }
+        }
+        path.unshift(seg)
+        current = current.parentElement
+        if (path.length >= 4) { break }
+      }
+      return path.join(' > ')
+    }
+
+    var elements = []
+    var seen = new Set()
+
+    document.querySelectorAll(interactableSelectors).forEach(function(el) {
+      if (seen.has(el)) { return }
+      seen.add(el)
+      var htmlEl = el
+      if (!isVisible(htmlEl)) { return }
+      var inputEl = htmlEl
+      var rect = htmlEl.getBoundingClientRect()
+      var isInVp = rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth)
+      if (${inViewportOnly} && !isInVp) { return }
+      var entry = {
+        tagName: htmlEl.tagName.toLowerCase(),
+        name: getAccessibleName(htmlEl),
+        type: htmlEl.getAttribute('type') || '',
+        value: inputEl.value || '',
+        href: htmlEl.getAttribute('href') || '',
+        selector: getSelector(htmlEl),
+        isInViewport: isInVp
+      }
+      ${includeBounds ? "entry.boundingBox = { x: rect.x + window.scrollX, y: rect.y + window.scrollY, width: rect.width, height: rect.height }" : ""}
+      elements.push(entry)
+    })
+    return elements
+  })()`;
+}
+
+// ../core/src/locators/xml-parsing.ts
+import { DOMParser } from "@xmldom/xmldom";
+import xpath from "xpath";
+function childNodesOf(node) {
+  const children = [];
+  if (node.childNodes) {
+    for (let i = 0; i < node.childNodes.length; i++) {
+      const child = node.childNodes.item(i);
+      if (child?.nodeType === 1) {
+        children.push(child);
+      }
+    }
+  }
+  return children;
+}
+function translateRecursively(domNode, parentPath = "", index = null) {
+  const attributes = {};
+  const element = domNode;
+  if (element.attributes) {
+    for (let attrIdx = 0; attrIdx < element.attributes.length; attrIdx++) {
+      const attr = element.attributes.item(attrIdx);
+      if (attr) {
+        attributes[attr.name] = attr.value.replace(/(\n)/gm, "\\n");
+      }
+    }
+  }
+  const path10 = index === null ? "" : `${parentPath ? parentPath + "." : ""}${index}`;
+  return {
+    children: childNodesOf(domNode).map(
+      (childNode, childIndex) => translateRecursively(childNode, path10, childIndex)
+    ),
+    tagName: domNode.nodeName,
+    attributes,
+    path: path10
+  };
+}
+function isSameElement(node1, node2) {
+  if (node1.nodeType !== 1 || node2.nodeType !== 1) {
+    return false;
+  }
+  const el1 = node1;
+  const el2 = node2;
+  if (el1.nodeName !== el2.nodeName) {
+    return false;
+  }
+  const bounds1 = el1.getAttribute("bounds");
+  const bounds2 = el2.getAttribute("bounds");
+  if (bounds1 && bounds2) {
+    return bounds1 === bounds2;
+  }
+  const x1 = el1.getAttribute("x");
+  const y1 = el1.getAttribute("y");
+  const x2 = el2.getAttribute("x");
+  const y2 = el2.getAttribute("y");
+  if (x1 && y1 && x2 && y2) {
+    return x1 === x2 && y1 === y2 && el1.getAttribute("width") === el2.getAttribute("width") && el1.getAttribute("height") === el2.getAttribute("height");
+  }
+  return false;
+}
+function xmlToJSON(sourceXML) {
+  try {
+    const parser = new DOMParser();
+    const sourceDoc = parser.parseFromString(sourceXML, "text/xml");
+    const parseErrors = sourceDoc.getElementsByTagName("parsererror");
+    if (parseErrors.length > 0) {
+      console.error(
+        "[xmlToJSON] XML parsing error:",
+        parseErrors[0].textContent
+      );
+      return null;
+    }
+    const children = childNodesOf(sourceDoc);
+    const firstChild = children[0] || (sourceDoc.documentElement ? childNodesOf(sourceDoc.documentElement)[0] : null);
+    return firstChild ? translateRecursively(firstChild) : { children: [], tagName: "", attributes: {}, path: "" };
+  } catch (e) {
+    console.error("[xmlToJSON] Failed to parse XML:", e);
+    return null;
+  }
+}
+function xmlToDOM(sourceXML) {
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(sourceXML, "text/xml");
+    const parseErrors = doc.getElementsByTagName("parsererror");
+    if (parseErrors.length > 0) {
+      console.error("[xmlToDOM] XML parsing error:", parseErrors[0].textContent);
+      return null;
+    }
+    return doc;
+  } catch (e) {
+    console.error("[xmlToDOM] Failed to parse XML:", e);
+    return null;
+  }
+}
+function evaluateXPath(doc, xpathExpr) {
+  try {
+    const nodes = xpath.select(xpathExpr, doc);
+    if (Array.isArray(nodes)) {
+      return nodes;
+    }
+    return [];
+  } catch (e) {
+    console.error(`[evaluateXPath] Failed to evaluate "${xpathExpr}":`, e);
+    return [];
+  }
+}
+function checkXPathUniqueness(doc, xpathExpr, targetNode) {
+  try {
+    const nodes = evaluateXPath(doc, xpathExpr);
+    const totalMatches = nodes.length;
+    if (totalMatches === 0) {
+      return { isUnique: false };
+    }
+    if (totalMatches === 1) {
+      return { isUnique: true };
+    }
+    if (targetNode) {
+      for (let i = 0; i < nodes.length; i++) {
+        if (nodes[i] === targetNode || isSameElement(nodes[i], targetNode)) {
+          return {
+            isUnique: false,
+            index: i + 1,
+            // 1-based index for XPath
+            totalMatches
+          };
+        }
+      }
+    }
+    return { isUnique: false, totalMatches };
+  } catch (e) {
+    console.error(`[checkXPathUniqueness] Error checking "${xpathExpr}":`, e);
+    return { isUnique: false };
+  }
+}
+function findDOMNodeByPath(doc, path10) {
+  if (!path10) {
+    return doc.documentElement;
+  }
+  const indices = path10.split(".").map(Number);
+  let current = doc.documentElement;
+  for (const index of indices) {
+    if (!current) {
+      return null;
+    }
+    const children = [];
+    if (current.childNodes) {
+      for (let i = 0; i < current.childNodes.length; i++) {
+        const child = current.childNodes.item(i);
+        if (child?.nodeType === 1) {
+          children.push(child);
+        }
+      }
+    }
+    current = children[index] || null;
+  }
+  return current;
+}
+function parseAndroidBounds(bounds) {
+  const match = bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+  if (!match) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  const x1 = parseInt(match[1], 10);
+  const y1 = parseInt(match[2], 10);
+  const x2 = parseInt(match[3], 10);
+  const y2 = parseInt(match[4], 10);
+  return {
+    x: x1,
+    y: y1,
+    width: x2 - x1,
+    height: y2 - y1
+  };
+}
+function parseIOSBounds(attributes) {
+  return {
+    x: parseInt(attributes.x || "0", 10),
+    y: parseInt(attributes.y || "0", 10),
+    width: parseInt(attributes.width || "0", 10),
+    height: parseInt(attributes.height || "0", 10)
+  };
+}
+function countAttributeOccurrences(sourceXML, attribute, value) {
+  const escapedValue = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`${attribute}=["']${escapedValue}["']`, "g");
+  const matches = sourceXML.match(pattern);
+  return matches ? matches.length : 0;
+}
+function isAttributeUnique(sourceXML, attribute, value) {
+  return countAttributeOccurrences(sourceXML, attribute, value) === 1;
+}
+
+// ../core/src/locators/constants.ts
+var ANDROID_INTERACTABLE_TAGS = [
+  // Input elements
+  "android.widget.EditText",
+  "android.widget.AutoCompleteTextView",
+  "android.widget.MultiAutoCompleteTextView",
+  "android.widget.SearchView",
+  // Button-like elements
+  "android.widget.Button",
+  "android.widget.ImageButton",
+  "android.widget.ToggleButton",
+  "android.widget.CompoundButton",
+  "android.widget.RadioButton",
+  "android.widget.CheckBox",
+  "android.widget.Switch",
+  "android.widget.FloatingActionButton",
+  "com.google.android.material.button.MaterialButton",
+  "com.google.android.material.floatingactionbutton.FloatingActionButton",
+  // Text elements (often tappable)
+  "android.widget.TextView",
+  "android.widget.CheckedTextView",
+  // Image elements (often tappable)
+  "android.widget.ImageView",
+  "android.widget.QuickContactBadge",
+  // Selection elements
+  "android.widget.Spinner",
+  "android.widget.SeekBar",
+  "android.widget.RatingBar",
+  "android.widget.ProgressBar",
+  "android.widget.DatePicker",
+  "android.widget.TimePicker",
+  "android.widget.NumberPicker",
+  // List/grid items
+  "android.widget.AdapterView"
+];
+var ANDROID_LAYOUT_CONTAINERS = [
+  // Core ViewGroup classes
+  "android.view.ViewGroup",
+  "android.view.View",
+  "android.widget.FrameLayout",
+  "android.widget.LinearLayout",
+  "android.widget.RelativeLayout",
+  "android.widget.GridLayout",
+  "android.widget.TableLayout",
+  "android.widget.TableRow",
+  "android.widget.AbsoluteLayout",
+  // AndroidX layout classes
+  "androidx.constraintlayout.widget.ConstraintLayout",
+  "androidx.coordinatorlayout.widget.CoordinatorLayout",
+  "androidx.appcompat.widget.LinearLayoutCompat",
+  "androidx.cardview.widget.CardView",
+  "androidx.appcompat.widget.ContentFrameLayout",
+  "androidx.appcompat.widget.FitWindowsFrameLayout",
+  // Scrolling containers
+  "android.widget.ScrollView",
+  "android.widget.HorizontalScrollView",
+  "android.widget.NestedScrollView",
+  "androidx.core.widget.NestedScrollView",
+  "androidx.recyclerview.widget.RecyclerView",
+  "android.widget.ListView",
+  "android.widget.GridView",
+  "android.widget.AbsListView",
+  // App chrome / system elements
+  "android.widget.ActionBarContainer",
+  "android.widget.ActionBarOverlayLayout",
+  "android.view.ViewStub",
+  "androidx.appcompat.widget.ActionBarContainer",
+  "androidx.appcompat.widget.ActionBarContextView",
+  "androidx.appcompat.widget.ActionBarOverlayLayout",
+  // Decor views
+  "com.android.internal.policy.DecorView",
+  "android.widget.DecorView"
+];
+var IOS_INTERACTABLE_TAGS = [
+  // Input elements
+  "XCUIElementTypeTextField",
+  "XCUIElementTypeSecureTextField",
+  "XCUIElementTypeTextView",
+  "XCUIElementTypeSearchField",
+  // Button-like elements
+  "XCUIElementTypeButton",
+  "XCUIElementTypeLink",
+  // Text elements (often tappable)
+  "XCUIElementTypeStaticText",
+  // Image elements
+  "XCUIElementTypeImage",
+  "XCUIElementTypeIcon",
+  // Selection elements
+  "XCUIElementTypeSwitch",
+  "XCUIElementTypeSlider",
+  "XCUIElementTypeStepper",
+  "XCUIElementTypeSegmentedControl",
+  "XCUIElementTypePicker",
+  "XCUIElementTypePickerWheel",
+  "XCUIElementTypeDatePicker",
+  "XCUIElementTypePageIndicator",
+  // Table/list items
+  "XCUIElementTypeCell",
+  "XCUIElementTypeMenuItem",
+  "XCUIElementTypeMenuBarItem",
+  // Toggle elements
+  "XCUIElementTypeCheckBox",
+  "XCUIElementTypeRadioButton",
+  "XCUIElementTypeToggle",
+  // Other interactive
+  "XCUIElementTypeKey",
+  "XCUIElementTypeKeyboard",
+  "XCUIElementTypeAlert",
+  "XCUIElementTypeSheet"
+];
+var IOS_LAYOUT_CONTAINERS = [
+  // Generic containers
+  "XCUIElementTypeOther",
+  "XCUIElementTypeGroup",
+  "XCUIElementTypeLayoutItem",
+  // Scroll containers
+  "XCUIElementTypeScrollView",
+  "XCUIElementTypeTable",
+  "XCUIElementTypeCollectionView",
+  "XCUIElementTypeScrollBar",
+  // Navigation chrome
+  "XCUIElementTypeNavigationBar",
+  "XCUIElementTypeTabBar",
+  "XCUIElementTypeToolbar",
+  "XCUIElementTypeStatusBar",
+  "XCUIElementTypeMenuBar",
+  // Windows and views
+  "XCUIElementTypeWindow",
+  "XCUIElementTypeSheet",
+  "XCUIElementTypeDrawer",
+  "XCUIElementTypeDialog",
+  "XCUIElementTypePopover",
+  "XCUIElementTypePopUpButton",
+  // Outline elements
+  "XCUIElementTypeOutline",
+  "XCUIElementTypeOutlineRow",
+  "XCUIElementTypeBrowser",
+  "XCUIElementTypeSplitGroup",
+  "XCUIElementTypeSplitter",
+  // Application root
+  "XCUIElementTypeApplication"
+];
+
+// ../core/src/locators/locator-generation.ts
+function isValidValue(value) {
+  return value !== void 0 && value !== null && value !== "null" && value.trim() !== "";
+}
+function escapeText(text) {
+  return text.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+function escapeXPathValue(value) {
+  if (!value.includes("'")) {
+    return `'${value}'`;
+  }
+  if (!value.includes('"')) {
+    return `"${value}"`;
+  }
+  const parts = [];
+  let current = "";
+  for (const char of value) {
+    if (char === "'") {
+      if (current) {
+        parts.push(`'${current}'`);
+      }
+      parts.push(`"'"`);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    parts.push(`'${current}'`);
+  }
+  return `concat(${parts.join(",")})`;
+}
+function generateIndexedXPath(baseXPath, index) {
+  return `(${baseXPath})[${index}]`;
+}
+function generateIndexedUiAutomator(baseSelector, index) {
+  return `${baseSelector}.instance(${index - 1})`;
+}
+function checkUniqueness(ctx, xpath2, targetNode) {
+  if (ctx.parsedDOM) {
+    return checkXPathUniqueness(ctx.parsedDOM, xpath2, targetNode);
+  }
+  const match = xpath2.match(/\/\/\*\[@([^=]{1,200})="([^"]{1,2000})"\]/);
+  if (match) {
+    const [, attr, value] = match;
+    return { isUnique: isAttributeUnique(ctx.sourceXML, attr, value) };
+  }
+  return { isUnique: false };
+}
+function getSiblingIndex(element) {
+  const parent = element.parentNode;
+  if (!parent) {
+    return 1;
+  }
+  const tagName = element.nodeName;
+  let index = 0;
+  for (let i = 0; i < parent.childNodes.length; i++) {
+    const child = parent.childNodes.item(i);
+    if (child?.nodeType === 1 && child.nodeName === tagName) {
+      index++;
+      if (child === element) {
+        return index;
+      }
+    }
+  }
+  return 1;
+}
+function countSiblings(element) {
+  const parent = element.parentNode;
+  if (!parent) {
+    return 1;
+  }
+  const tagName = element.nodeName;
+  let count = 0;
+  for (let i = 0; i < parent.childNodes.length; i++) {
+    const child = parent.childNodes.item(i);
+    if (child?.nodeType === 1 && child.nodeName === tagName) {
+      count++;
+    }
+  }
+  return count;
+}
+function findUniqueAttribute(element, ctx) {
+  const attrs = ctx.isAndroid ? ["resource-id", "content-desc", "text"] : ["name", "label", "value"];
+  for (const attr of attrs) {
+    const value = element.getAttribute(attr);
+    if (value && value.trim()) {
+      const xpath2 = `//*[@${attr}=${escapeXPathValue(value)}]`;
+      const result = ctx.parsedDOM ? checkXPathUniqueness(ctx.parsedDOM, xpath2) : { isUnique: isAttributeUnique(ctx.sourceXML, attr, value) };
+      if (result.isUnique) {
+        return `@${attr}=${escapeXPathValue(value)}`;
+      }
+    }
+  }
+  return null;
+}
+function buildHierarchicalXPath(ctx, element, maxDepth = 3) {
+  if (!ctx.parsedDOM) {
+    return null;
+  }
+  const pathParts = [];
+  let current = element;
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    const tagName = current.nodeName;
+    const uniqueAttr = findUniqueAttribute(current, ctx);
+    if (uniqueAttr) {
+      pathParts.unshift(`//${tagName}[${uniqueAttr}]`);
+      break;
+    } else {
+      const siblingIndex = getSiblingIndex(current);
+      const siblingCount = countSiblings(current);
+      if (siblingCount > 1) {
+        pathParts.unshift(`${tagName}[${siblingIndex}]`);
+      } else {
+        pathParts.unshift(tagName);
+      }
+    }
+    const parent = current.parentNode;
+    current = parent && parent.nodeType === 1 ? parent : null;
+    depth++;
+  }
+  if (pathParts.length === 0) {
+    return null;
+  }
+  let result = pathParts[0];
+  for (let i = 1; i < pathParts.length; i++) {
+    result += "/" + pathParts[i];
+  }
+  if (!result.startsWith("//")) {
+    result = "//" + result;
+  }
+  return result;
+}
+function addXPathLocator(results, xpath2, ctx, targetNode) {
+  const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+  if (uniqueness.isUnique) {
+    results.push(["xpath", xpath2]);
+  } else if (uniqueness.index) {
+    results.push(["xpath", generateIndexedXPath(xpath2, uniqueness.index)]);
+  } else {
+    if (targetNode && ctx.parsedDOM) {
+      const hierarchical = buildHierarchicalXPath(
+        ctx,
+        targetNode
+      );
+      if (hierarchical) {
+        results.push(["xpath", hierarchical]);
+      }
+    }
+    results.push(["xpath", xpath2]);
+  }
+}
+function isInUiAutomatorScope(element, doc) {
+  if (!doc) {
+    return true;
+  }
+  const hierarchyNodes = evaluateXPath(doc, "/hierarchy/*");
+  if (hierarchyNodes.length === 0) {
+    return true;
+  }
+  const lastIndex = hierarchyNodes.length;
+  const pathParts = element.path.split(".");
+  if (pathParts.length === 0 || pathParts[0] === "") {
+    return true;
+  }
+  const firstIndex = parseInt(pathParts[0], 10);
+  return firstIndex === lastIndex - 1;
+}
+function buildUiAutomatorSelector(element) {
+  const attrs = element.attributes;
+  const parts = [];
+  if (isValidValue(attrs["resource-id"])) {
+    parts.push(`resourceId("${attrs["resource-id"]}")`);
+  }
+  if (isValidValue(attrs.text) && attrs.text.length < 100) {
+    parts.push(`text("${escapeText(attrs.text)}")`);
+  }
+  if (isValidValue(attrs["content-desc"])) {
+    parts.push(`description("${attrs["content-desc"]}")`);
+  }
+  if (isValidValue(attrs.class)) {
+    parts.push(`className("${attrs.class}")`);
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return `android=new UiSelector().${parts.join(".")}`;
+}
+function buildPredicateString(element) {
+  const attrs = element.attributes;
+  const conditions = [];
+  if (isValidValue(attrs.name)) {
+    conditions.push(`name == "${escapeText(attrs.name)}"`);
+  }
+  if (isValidValue(attrs.label)) {
+    conditions.push(`label == "${escapeText(attrs.label)}"`);
+  }
+  if (isValidValue(attrs.value)) {
+    conditions.push(`value == "${escapeText(attrs.value)}"`);
+  }
+  if (attrs.visible === "true") {
+    conditions.push("visible == 1");
+  }
+  if (attrs.enabled === "true") {
+    conditions.push("enabled == 1");
+  }
+  if (conditions.length === 0) {
+    return null;
+  }
+  return `-ios predicate string:${conditions.join(" AND ")}`;
+}
+function buildClassChain(element) {
+  const attrs = element.attributes;
+  const tagName = element.tagName;
+  if (!tagName.startsWith("XCUI")) {
+    return null;
+  }
+  let selector = `**/${tagName}`;
+  if (isValidValue(attrs.label)) {
+    selector += `[\`label == "${escapeText(attrs.label)}"\`]`;
+  } else if (isValidValue(attrs.name)) {
+    selector += `[\`name == "${escapeText(attrs.name)}"\`]`;
+  }
+  return `-ios class chain:${selector}`;
+}
+function buildXPath(element, _sourceXML, isAndroid) {
+  const attrs = element.attributes;
+  const tagName = element.tagName;
+  const conditions = [];
+  if (isAndroid) {
+    if (isValidValue(attrs["resource-id"])) {
+      conditions.push(`@resource-id="${attrs["resource-id"]}"`);
+    }
+    if (isValidValue(attrs["content-desc"])) {
+      conditions.push(`@content-desc="${attrs["content-desc"]}"`);
+    }
+    if (isValidValue(attrs.text) && attrs.text.length < 100) {
+      conditions.push(`@text="${escapeText(attrs.text)}"`);
+    }
+  } else {
+    if (isValidValue(attrs.name)) {
+      conditions.push(`@name="${attrs.name}"`);
+    }
+    if (isValidValue(attrs.label)) {
+      conditions.push(`@label="${attrs.label}"`);
+    }
+    if (isValidValue(attrs.value)) {
+      conditions.push(`@value="${attrs.value}"`);
+    }
+  }
+  if (conditions.length === 0) {
+    return `//${tagName}`;
+  }
+  return `//${tagName}[${conditions.join(" and ")}]`;
+}
+function getSimpleSuggestedLocators(element, ctx, automationName, inUiAutomatorScope, targetNode) {
+  const results = [];
+  const isAndroid = automationName.toLowerCase().includes("uiautomator");
+  const attrs = element.attributes;
+  if (isAndroid) {
+    const resourceId = attrs["resource-id"];
+    if (isValidValue(resourceId)) {
+      const xpath2 = `//*[@resource-id="${resourceId}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique && inUiAutomatorScope) {
+        results.push([
+          "id",
+          `android=new UiSelector().resourceId("${resourceId}")`
+        ]);
+      } else if (uniqueness.index && inUiAutomatorScope) {
+        const base = `android=new UiSelector().resourceId("${resourceId}")`;
+        results.push(["id", generateIndexedUiAutomator(base, uniqueness.index)]);
+      }
+    }
+    const contentDesc = attrs["content-desc"];
+    if (isValidValue(contentDesc)) {
+      const xpath2 = `//*[@content-desc="${contentDesc}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique) {
+        results.push(["accessibility-id", `~${contentDesc}`]);
+      }
+    }
+    const text = attrs.text;
+    if (isValidValue(text) && text.length < 100) {
+      const xpath2 = `//*[@text="${escapeText(text)}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique && inUiAutomatorScope) {
+        results.push([
+          "text",
+          `android=new UiSelector().text("${escapeText(text)}")`
+        ]);
+      } else if (uniqueness.index && inUiAutomatorScope) {
+        const base = `android=new UiSelector().text("${escapeText(text)}")`;
+        results.push([
+          "text",
+          generateIndexedUiAutomator(base, uniqueness.index)
+        ]);
+      }
+    }
+  } else {
+    const name = attrs.name;
+    if (isValidValue(name)) {
+      const xpath2 = `//*[@name="${name}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique) {
+        results.push(["accessibility-id", `~${name}`]);
+      }
+    }
+    const label = attrs.label;
+    if (isValidValue(label) && label !== attrs.name) {
+      const xpath2 = `//*[@label="${escapeText(label)}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique) {
+        results.push([
+          "predicate-string",
+          `-ios predicate string:label == "${escapeText(label)}"`
+        ]);
+      }
+    }
+    const value = attrs.value;
+    if (isValidValue(value)) {
+      const xpath2 = `//*[@value="${escapeText(value)}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique) {
+        results.push([
+          "predicate-string",
+          `-ios predicate string:value == "${escapeText(value)}"`
+        ]);
+      }
+    }
+  }
+  return results;
+}
+function getComplexSuggestedLocators(element, ctx, automationName, inUiAutomatorScope, targetNode) {
+  const results = [];
+  const isAndroid = automationName.toLowerCase().includes("uiautomator");
+  if (isAndroid) {
+    if (inUiAutomatorScope) {
+      const uiAutomator = buildUiAutomatorSelector(element);
+      if (uiAutomator) {
+        results.push(["uiautomator", uiAutomator]);
+      }
+    }
+    const xpath2 = buildXPath(element, ctx.sourceXML, true);
+    if (xpath2) {
+      addXPathLocator(results, xpath2, ctx, targetNode);
+    }
+    if (inUiAutomatorScope && isValidValue(element.attributes.class)) {
+      results.push([
+        "class-name",
+        `android=new UiSelector().className("${element.attributes.class}")`
+      ]);
+    }
+  } else {
+    const predicate = buildPredicateString(element);
+    if (predicate) {
+      results.push(["predicate-string", predicate]);
+    }
+    const classChain = buildClassChain(element);
+    if (classChain) {
+      results.push(["class-chain", classChain]);
+    }
+    const xpath2 = buildXPath(element, ctx.sourceXML, false);
+    if (xpath2) {
+      addXPathLocator(results, xpath2, ctx, targetNode);
+    }
+    const type = element.tagName;
+    if (type.startsWith("XCUIElementType")) {
+      results.push(["class-name", `-ios class chain:**/${type}`]);
+    }
+  }
+  return results;
+}
+function getSuggestedLocators(element, sourceXML, automationName, ctx, targetNode) {
+  const locatorCtx = ctx ?? {
+    sourceXML,
+    parsedDOM: null,
+    isAndroid: automationName.toLowerCase().includes("uiautomator")
+  };
+  const inUiAutomatorScope = locatorCtx.isAndroid ? isInUiAutomatorScope(element, locatorCtx.parsedDOM) : true;
+  const simpleLocators = getSimpleSuggestedLocators(
+    element,
+    locatorCtx,
+    automationName,
+    inUiAutomatorScope,
+    targetNode
+  );
+  const complexLocators = getComplexSuggestedLocators(
+    element,
+    locatorCtx,
+    automationName,
+    inUiAutomatorScope,
+    targetNode
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const locator of [...simpleLocators, ...complexLocators]) {
+    if (!seen.has(locator[1])) {
+      seen.add(locator[1]);
+      results.push(locator);
+    }
+  }
+  return results;
+}
+function locatorsToObject(locators) {
+  const result = {};
+  for (const [strategy, value] of locators) {
+    if (!result[strategy]) {
+      result[strategy] = value;
+    }
+  }
+  return result;
+}
+
+// ../core/src/element-snapshot.ts
+var INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "textbox",
+  "checkbox",
+  "radio",
+  "combobox",
+  "slider",
+  "searchbox",
+  "spinbutton",
+  "switch",
+  "tab",
+  "menuitem",
+  "option"
+]);
+function inferPurpose(nodes, index) {
+  const myDepth = nodes[index].depth;
+  for (let i = index - 1; i >= 0; i--) {
+    if (nodes[i].depth <= myDepth && nodes[i].name) {
+      if (nodes[i].depth === myDepth && INTERACTIVE_ROLES.has(nodes[i].role)) {
+        continue;
+      }
+      return nodes[i].name;
+    }
+  }
+  return void 0;
+}
+function serializeWebSnapshot(nodes, context, options = {}) {
+  const { inViewportOnly = true } = options;
+  let header = "[Page";
+  if (context?.title) {
+    header += `: ${context.title}`;
+  }
+  if (context?.url) {
+    header += ` \u2014 ${context.url}`;
+  }
+  header += "]";
+  const lines = [header];
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (inViewportOnly && node.isInViewport === false) {
+      continue;
+    }
+    const indent = "  ".repeat(node.depth + 1);
+    const isInteractive = INTERACTIVE_ROLES.has(node.role);
+    if (node.role === "statictext" && node.name) {
+      let echoedByParent = false;
+      for (let j = i - 1; j >= 0; j--) {
+        if (nodes[j].depth < node.depth) {
+          const parentRole = nodes[j].role;
+          const parentName = nodes[j].name;
+          if (INTERACTIVE_ROLES.has(parentRole) && parentName && parentName.includes(node.name)) {
+            echoedByParent = true;
+          }
+          break;
+        }
+      }
+      if (echoedByParent) {
+        continue;
+      }
+    }
+    const roleLabel = node.role === "heading" && node.level ? `heading[${node.level}]` : node.role;
+    if (isInteractive) {
+      if (!node.selector) {
+        continue;
+      }
+      const purpose = inferPurpose(nodes, i);
+      if (node.name) {
+        lines.push(
+          purpose ? `${indent}${roleLabel} "${node.name}" \u2208 "${purpose}"  \u2192  ${node.selector}` : `${indent}${roleLabel} "${node.name}"  \u2192  ${node.selector}`
+        );
+      } else if (purpose) {
+        lines.push(`${indent}${roleLabel} \u2208 "${purpose}"  \u2192  ${node.selector}`);
+      } else {
+        lines.push(`${indent}${roleLabel}  \u2192  ${node.selector}`);
+      }
+    } else {
+      lines.push(
+        node.name ? `${indent}${roleLabel} "${node.name}"` : `${indent}${roleLabel}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function simplifyTag(tagName) {
+  const dot = tagName.lastIndexOf(".");
+  if (dot !== -1) {
+    return tagName.slice(dot + 1);
+  }
+  return tagName.replace(/^XCUIElementType/, "");
+}
+var ANDROID_ROLE_MAP = {
+  "android.widget.Button": "button",
+  "android.widget.ImageButton": "button",
+  "android.widget.ToggleButton": "button",
+  "android.widget.FloatingActionButton": "button",
+  "com.google.android.material.button.MaterialButton": "button",
+  "com.google.android.material.floatingactionbutton.FloatingActionButton": "button",
+  "android.widget.EditText": "textbox",
+  "android.widget.AutoCompleteTextView": "textbox",
+  "android.widget.MultiAutoCompleteTextView": "textbox",
+  "android.widget.SearchView": "searchbox",
+  "android.widget.ImageView": "img",
+  "android.widget.QuickContactBadge": "img",
+  "android.widget.CheckBox": "checkbox",
+  "android.widget.RadioButton": "radio",
+  "android.widget.Switch": "switch",
+  "android.widget.Spinner": "combobox",
+  "android.widget.SeekBar": "slider",
+  "android.widget.RatingBar": "slider",
+  "android.widget.ProgressBar": "progressbar",
+  "android.widget.TextView": "statictext",
+  "android.widget.CheckedTextView": "statictext",
+  "android.widget.RecyclerView": "list",
+  "android.widget.ListView": "list",
+  "android.widget.GridView": "list",
+  "android.webkit.WebView": "webview"
+};
+var IOS_ROLE_MAP = {
+  XCUIElementTypeButton: "button",
+  XCUIElementTypeLink: "link",
+  XCUIElementTypeTextField: "textbox",
+  XCUIElementTypeSecureTextField: "textbox",
+  XCUIElementTypeTextView: "textbox",
+  XCUIElementTypeSearchField: "searchbox",
+  XCUIElementTypeImage: "img",
+  XCUIElementTypeIcon: "img",
+  XCUIElementTypeSwitch: "switch",
+  XCUIElementTypeSlider: "slider",
+  XCUIElementTypeStepper: "slider",
+  XCUIElementTypeCheckBox: "checkbox",
+  XCUIElementTypeRadioButton: "radio",
+  XCUIElementTypePicker: "combobox",
+  XCUIElementTypePickerWheel: "combobox",
+  XCUIElementTypeDatePicker: "combobox",
+  XCUIElementTypeSegmentedControl: "combobox",
+  XCUIElementTypeStaticText: "statictext",
+  XCUIElementTypeCell: "listitem",
+  XCUIElementTypeTable: "list",
+  XCUIElementTypeCollectionView: "list"
+};
+function classifyMobileRole(tagName, platform) {
+  if (platform === "android") {
+    return ANDROID_ROLE_MAP[tagName] || simplifyTag(tagName);
+  }
+  return IOS_ROLE_MAP[tagName] || simplifyTag(tagName);
+}
+function getBestAndroidLocator(attrs) {
+  if (attrs._selector) {
+    return attrs._selector;
+  }
+  if (attrs["content-desc"]) {
+    return `~${attrs["content-desc"]}`;
+  }
+  if (attrs["resource-id"]) {
+    return `id:${attrs["resource-id"]}`;
+  }
+  if (attrs.text) {
+    return `~${attrs.text}`;
+  }
+  if (attrs.class) {
+    return `class:${simplifyTag(attrs.class)}`;
+  }
+  return void 0;
+}
+function getBestIOSLocator(attrs) {
+  if (attrs._selector) {
+    return attrs._selector;
+  }
+  if (attrs.name) {
+    return `~${attrs.name}`;
+  }
+  if (attrs.label) {
+    return `~${attrs.label}`;
+  }
+  if (attrs.value) {
+    return `~${attrs.value}`;
+  }
+  if (attrs.type) {
+    return `class:${simplifyTag(attrs.type)}`;
+  }
+  return void 0;
+}
+function getMobileNodeIdentity(attrs, platform) {
+  if (platform === "android") {
+    const contentDesc = attrs["content-desc"];
+    if (contentDesc) {
+      return contentDesc;
+    }
+    if (attrs.text) {
+      return attrs.text;
+    }
+    const rid = attrs["resource-id"];
+    if (rid) {
+      const slash = rid.lastIndexOf("/");
+      return slash !== -1 ? rid.slice(slash + 1) : rid;
+    }
+    return "";
+  }
+  return attrs.name || attrs.label || attrs.value || attrs.text || "";
+}
+var ANDROID_INTERACTABLE_SET = new Set(ANDROID_INTERACTABLE_TAGS);
+var IOS_INTERACTABLE_SET = new Set(IOS_INTERACTABLE_TAGS);
+function isExplicitlyInteractive(attrs, platform) {
+  if (platform === "android") {
+    return attrs.clickable === "true" || attrs.focusable === "true" || attrs.checkable === "true" || attrs["long-clickable"] === "true";
+  }
+  return attrs.accessible === "true";
+}
+function isMobileInteractive(element, platform) {
+  const attrs = element.attributes;
+  if (platform === "android") {
+    if (ANDROID_INTERACTABLE_SET.has(element.tagName)) {
+      return true;
+    }
+    return attrs.clickable === "true" || attrs["long-clickable"] === "true" || attrs.focusable === "true" || attrs.checkable === "true";
+  }
+  if (IOS_INTERACTABLE_SET.has(element.tagName)) {
+    return true;
+  }
+  return attrs.accessible === "true";
+}
+function isMobileInViewport(element, platform, viewport) {
+  const bounds = platform === "android" ? parseAndroidBounds(element.attributes.bounds || "") : parseIOSBounds(element.attributes);
+  if (bounds.width === 0 && bounds.height === 0) {
+    return true;
+  }
+  return bounds.x >= 0 && bounds.y >= 0 && bounds.width > 0 && bounds.height > 0 && bounds.x + bounds.width <= viewport.width && bounds.y + bounds.height <= viewport.height;
+}
+function collectMobileNodes(element, platform, depth, nodes, walkOpts) {
+  const attrs = element.attributes;
+  const role = classifyMobileRole(element.tagName, platform);
+  const name = getMobileNodeIdentity(attrs, platform);
+  const explicit = isExplicitlyInteractive(attrs, platform);
+  const interactive = isMobileInteractive(element, platform);
+  const inViewport = isMobileInViewport(element, platform, walkOpts.viewport);
+  if (walkOpts.inViewportOnly) {
+    if (interactive && !inViewport) {
+      for (const child of element.children || []) {
+        collectMobileNodes(child, platform, depth + 1, nodes, walkOpts);
+      }
+      return;
+    }
+    if (!interactive && !inViewport) {
+      nodes.push({
+        role: "generic",
+        name: name ? `${role} "${name}"` : role,
+        selector: "",
+        depth,
+        isInteractive: false,
+        isExplicitInteractive: false,
+        isInViewport: false
+      });
+      return;
+    }
+  }
+  let locator = "";
+  if (interactive) {
+    if (walkOpts.sourceXML && walkOpts.automationName) {
+      const suggested = getSuggestedLocators(
+        element,
+        walkOpts.sourceXML,
+        walkOpts.automationName,
+        {
+          sourceXML: walkOpts.sourceXML,
+          parsedDOM: null,
+          isAndroid: platform === "android"
+        }
+      );
+      if (suggested.length > 0) {
+        locator = suggested[0][1];
+      }
+    }
+    if (!locator) {
+      locator = (platform === "android" ? getBestAndroidLocator(attrs) : getBestIOSLocator(attrs)) ?? "";
+    }
+  }
+  nodes.push({
+    role,
+    name,
+    selector: locator,
+    depth,
+    isInteractive: interactive,
+    isExplicitInteractive: explicit,
+    isInViewport: inViewport
+  });
+  for (const child of element.children || []) {
+    collectMobileNodes(child, platform, depth + 1, nodes, walkOpts);
+  }
+}
+var MOBILE_STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
+  "img",
+  "heading",
+  "list",
+  "listitem",
+  "webview",
+  "progressbar",
+  "slider",
+  "switch",
+  "generic"
+]);
+function mobileInferPurpose(nodes, index) {
+  const myDepth = nodes[index].depth;
+  for (let i = index - 1; i >= 0; i--) {
+    if (nodes[i].depth <= myDepth && nodes[i].name) {
+      if (nodes[i].depth === myDepth && !MOBILE_STRUCTURAL_ROLES.has(nodes[i].role)) {
+        continue;
+      }
+      return nodes[i].name;
+    }
+  }
+  return void 0;
+}
+function suppressTagOnlyChildren(nodes) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (!node.isInteractive || node.isExplicitInteractive) {
+      continue;
+    }
+    for (let j = i - 1; j >= 0; j--) {
+      if (nodes[j].depth < node.depth) {
+        if (nodes[j].isExplicitInteractive) {
+          node.isInteractive = false;
+          break;
+        }
+      }
+    }
+  }
+}
+var NOISY_ROLES = /* @__PURE__ */ new Set([
+  "FrameLayout",
+  "LinearLayout",
+  "ViewGroup",
+  "RelativeLayout",
+  "View",
+  "CardView",
+  "ConstraintLayout",
+  "ScrollView"
+]);
+function countSelectors(nodes) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.selector) {
+      counts.set(node.selector, (counts.get(node.selector) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+function renderMobileNodes(nodes) {
+  const lines = [];
+  const selectorCounts = countSelectors(nodes);
+  const selectorIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const indent = "  ".repeat(node.depth + 1);
+    if (NOISY_ROLES.has(node.role) && !node.name && node.depth > 1 && !node.isInteractive) {
+      continue;
+    }
+    if (node.isInViewport === false && !node.isInteractive) {
+      lines.push(`${indent}\u22EF ${node.name} (off-screen)`);
+      continue;
+    }
+    if (node.role === "statictext" && node.name) {
+      let echoedByParent = false;
+      for (let j = i - 1; j >= 0; j--) {
+        if (nodes[j].depth < node.depth) {
+          if (nodes[j].isInteractive && nodes[j].name && nodes[j].name.includes(node.name)) {
+            echoedByParent = true;
+          }
+          break;
+        }
+      }
+      if (echoedByParent) {
+        continue;
+      }
+    }
+    if (node.isInteractive && node.selector) {
+      let selector = node.selector;
+      const total = selectorCounts.get(selector) ?? 1;
+      if (total > 1) {
+        const idx = selectorIndex.get(selector) ?? 0;
+        selectorIndex.set(selector, idx + 1);
+        selector = `${selector}.instance(${idx})`;
+      }
+      const purpose = mobileInferPurpose(nodes, i);
+      if (node.name) {
+        lines.push(
+          purpose ? `${indent}${node.role} "${node.name}" \u2208 "${purpose}"  \u2192  ${selector}` : `${indent}${node.role} "${node.name}"  \u2192  ${selector}`
+        );
+      } else if (purpose) {
+        lines.push(`${indent}${node.role} \u2208 "${purpose}"  \u2192  ${selector}`);
+      } else {
+        lines.push(`${indent}${node.role}  \u2192  ${selector}`);
+      }
+    } else {
+      lines.push(
+        node.name ? `${indent}${node.role} "${node.name}"` : `${indent}${node.role}`
+      );
+    }
+  }
+  return lines;
+}
+function serializeMobileSnapshot(root, context, options = {}) {
+  const { platform, deviceName, viewport, sourceXML } = context;
+  const { inViewportOnly = true } = options;
+  const effectiveXML = sourceXML || root.attributes._sourceXML;
+  const effectiveViewport = viewport ?? { width: 9999, height: 9999 };
+  const automationName = platform === "android" ? "uiautomator2" : "xcuitest";
+  let header = `[${platform}`;
+  if (deviceName) {
+    header += ` \u2014 ${deviceName}`;
+  }
+  if (viewport) {
+    header += ` (${viewport.width}\xD7${viewport.height})`;
+  }
+  header += "]";
+  const nodes = [];
+  collectMobileNodes(root, platform, 0, nodes, {
+    inViewportOnly,
+    viewport: effectiveViewport,
+    sourceXML: effectiveXML,
+    automationName: effectiveXML ? automationName : void 0
+  });
+  suppressTagOnlyChildren(nodes);
+  const lines = renderMobileNodes(nodes);
+  return [header, ...lines].join("\n");
+}
+
+// ../core/src/locators/element-filter.ts
+function matchesTagList(tagName, tagList) {
+  if (tagList.includes(tagName)) {
+    return true;
+  }
+  for (const tag of tagList) {
+    if (tagName.endsWith(tag) || tagName.includes(tag)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchesTagFilters(element, includeTagNames, excludeTagNames) {
+  if (includeTagNames.length > 0 && !matchesTagList(element.tagName, includeTagNames)) {
+    return false;
+  }
+  if (matchesTagList(element.tagName, excludeTagNames)) {
+    return false;
+  }
+  return true;
+}
+function matchesAttributeFilters(element, requireAttributes, minAttributeCount) {
+  if (requireAttributes.length > 0) {
+    const hasRequiredAttr = requireAttributes.some(
+      (attr) => element.attributes?.[attr]
+    );
+    if (!hasRequiredAttr) {
+      return false;
+    }
+  }
+  if (element.attributes && minAttributeCount > 0) {
+    const attrCount = Object.values(element.attributes).filter(
+      (v) => v !== void 0 && v !== null && v !== ""
+    ).length;
+    if (attrCount < minAttributeCount) {
+      return false;
+    }
+  }
+  return true;
+}
+function isInteractableElement(element, _isNative, automationName) {
+  const isAndroid = automationName.toLowerCase().includes("uiautomator");
+  const interactableTags = isAndroid ? ANDROID_INTERACTABLE_TAGS : IOS_INTERACTABLE_TAGS;
+  if (matchesTagList(element.tagName, interactableTags)) {
+    return true;
+  }
+  if (isAndroid) {
+    if (element.attributes?.clickable === "true" || element.attributes?.focusable === "true" || element.attributes?.checkable === "true" || element.attributes?.["long-clickable"] === "true") {
+      return true;
+    }
+  }
+  if (!isAndroid) {
+    if (element.attributes?.accessible === "true") {
+      return true;
+    }
+  }
+  return false;
+}
+function isLayoutContainer(element, platform) {
+  const containerList = platform === "android" ? ANDROID_LAYOUT_CONTAINERS : IOS_LAYOUT_CONTAINERS;
+  return matchesTagList(element.tagName, containerList);
+}
+function hasMeaningfulContent(element, platform) {
+  const attrs = element.attributes;
+  if (attrs.text && attrs.text.trim() !== "" && attrs.text !== "null") {
+    return true;
+  }
+  if (platform === "android") {
+    if (attrs["content-desc"] && attrs["content-desc"].trim() !== "" && attrs["content-desc"] !== "null") {
+      return true;
+    }
+  } else {
+    if (attrs.label && attrs.label.trim() !== "" && attrs.label !== "null") {
+      return true;
+    }
+    if (attrs.name && attrs.name.trim() !== "" && attrs.name !== "null") {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldIncludeElement(element, filters, isNative, automationName) {
+  const {
+    includeTagNames = [],
+    excludeTagNames = ["hierarchy"],
+    requireAttributes = [],
+    minAttributeCount = 0,
+    fetchableOnly = false,
+    clickableOnly = false,
+    visibleOnly = true
+  } = filters;
+  if (!matchesTagFilters(element, includeTagNames, excludeTagNames)) {
+    if (element.attributes?.clickable !== "true") {
+      return false;
+    }
+  }
+  if (!matchesAttributeFilters(element, requireAttributes, minAttributeCount)) {
+    return false;
+  }
+  if (clickableOnly && element.attributes?.clickable !== "true") {
+    return false;
+  }
+  if (visibleOnly) {
+    const isAndroid = automationName.toLowerCase().includes("uiautomator");
+    if (isAndroid && element.attributes?.displayed === "false") {
+      return false;
+    }
+    if (!isAndroid && element.attributes?.visible === "false") {
+      return false;
+    }
+  }
+  if (fetchableOnly && !isInteractableElement(element, isNative, automationName)) {
+    return false;
+  }
+  return true;
+}
+function getDefaultFilters(platform, includeContainers = false) {
+  const layoutContainers = platform === "android" ? ANDROID_LAYOUT_CONTAINERS : IOS_LAYOUT_CONTAINERS;
+  return {
+    excludeTagNames: includeContainers ? ["hierarchy"] : ["hierarchy", ...layoutContainers],
+    fetchableOnly: !includeContainers,
+    visibleOnly: true,
+    clickableOnly: false
+  };
+}
+
+// ../core/src/locators/index.ts
+function parseBounds(element, platform) {
+  return platform === "android" ? parseAndroidBounds(element.attributes.bounds || "") : parseIOSBounds(element.attributes);
+}
+function isWithinViewport(bounds, viewport) {
+  return bounds.x >= 0 && bounds.y >= 0 && bounds.width > 0 && bounds.height > 0 && bounds.x + bounds.width <= viewport.width && bounds.y + bounds.height <= viewport.height;
+}
+function transformElement(element, locators, ctx) {
+  const attrs = element.attributes;
+  const bounds = parseBounds(element, ctx.platform);
+  return {
+    tagName: element.tagName,
+    locators: locatorsToObject(locators),
+    text: attrs.text || attrs.label || "",
+    contentDesc: attrs["content-desc"] || "",
+    resourceId: attrs["resource-id"] || "",
+    accessibilityId: attrs.name || attrs["content-desc"] || "",
+    label: attrs.label || "",
+    value: attrs.value || "",
+    className: attrs.class || element.tagName,
+    clickable: attrs.clickable === "true" || attrs.accessible === "true" || attrs["long-clickable"] === "true",
+    enabled: attrs.enabled !== "false",
+    displayed: ctx.platform === "android" ? attrs.displayed !== "false" : attrs.visible !== "false",
+    bounds,
+    isInViewport: isWithinViewport(bounds, ctx.viewportSize)
+  };
+}
+function shouldProcess(element, ctx) {
+  if (shouldIncludeElement(element, ctx.filters, ctx.isNative, ctx.automationName)) {
+    return true;
+  }
+  return isLayoutContainer(element, ctx.platform) && hasMeaningfulContent(element, ctx.platform);
+}
+function processElement(element, ctx) {
+  if (!shouldProcess(element, ctx)) {
+    return;
+  }
+  if (ctx.inViewportOnly) {
+    const b = parseBounds(element, ctx.platform);
+    if (!isWithinViewport(b, ctx.viewportSize)) {
+      return;
+    }
+  }
+  try {
+    const targetNode = ctx.parsedDOM ? findDOMNodeByPath(ctx.parsedDOM, element.path) : void 0;
+    const locators = getSuggestedLocators(
+      element,
+      ctx.sourceXML,
+      ctx.automationName,
+      {
+        sourceXML: ctx.sourceXML,
+        parsedDOM: ctx.parsedDOM,
+        isAndroid: ctx.platform === "android"
+      },
+      targetNode || void 0
+    );
+    if (locators.length === 0) {
+      return;
+    }
+    element.attributes._selector = locators[0][1];
+    const transformed = transformElement(element, locators, ctx);
+    if (Object.keys(transformed.locators).length === 0) {
+      return;
+    }
+    ctx.results.push(transformed);
+  } catch (error) {
+    console.error(`[processElement] Error at path ${element.path}:`, error);
+  }
+}
+function traverseTree(element, ctx) {
+  if (!element) {
+    return;
+  }
+  processElement(element, ctx);
+  for (const child of element.children || []) {
+    traverseTree(child, ctx);
+  }
+}
+function generateAllElementLocators(sourceXML, options) {
+  const sourceJSON = xmlToJSON(sourceXML);
+  if (!sourceJSON) {
+    console.error(
+      "[generateAllElementLocators] Failed to parse page source XML"
+    );
+    return [];
+  }
+  const parsedDOM = xmlToDOM(sourceXML);
+  const ctx = {
+    sourceXML,
+    platform: options.platform,
+    automationName: options.platform === "android" ? "uiautomator2" : "xcuitest",
+    isNative: options.isNative ?? true,
+    viewportSize: options.viewportSize ?? { width: 9999, height: 9999 },
+    filters: options.filters ?? {},
+    inViewportOnly: options.inViewportOnly ?? true,
+    results: [],
+    parsedDOM
+  };
+  traverseTree(sourceJSON, ctx);
+  return ctx.results;
+}
+
+// ../core/src/with-timeout.ts
+function withTimeout(promise, ms, fallback) {
+  let timer;
+  const timeout = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2(fallback), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  });
+}
+var SNAPSHOT_PROBE_TIMEOUT_MS = 2500;
+
+// ../core/src/action-snapshot.ts
+async function runWith(runScript, scriptSrc, fallback) {
+  if (!runScript) {
+    return fallback;
+  }
+  return withTimeout(
+    runScript(scriptSrc).then((r) => r),
+    SNAPSHOT_PROBE_TIMEOUT_MS,
+    fallback
+  ).catch(() => fallback);
+}
+async function captureActionSnapshot(input) {
+  try {
+    const timestamp = Date.now();
+    const isNativeMobile = !input.runScript && !!input.getPageSource;
+    const [shot, url, title, pageSource, tree, elements] = await Promise.all([
+      input.takeScreenshot?.().catch(() => null),
+      input.getUrl?.().catch(() => void 0),
+      input.getTitle?.().catch(() => void 0),
+      isNativeMobile ? input.getPageSource?.().catch(() => void 0) : void 0,
+      runWith(
+        input.runScript,
+        accessibilityTreeScript(true),
+        []
+      ),
+      runWith(
+        input.runScript,
+        elementsScript(false, true),
+        []
+      )
+    ]);
+    let snapshotText;
+    let finalElements = elements;
+    if (isNativeMobile && pageSource) {
+      const platform = input.platform ?? "android";
+      const jsonTree = xmlToJSON(pageSource);
+      if (jsonTree) {
+        jsonTree.attributes._sourceXML = pageSource;
+        snapshotText = serializeMobileSnapshot(jsonTree, {
+          platform,
+          sourceXML: pageSource
+        });
+      } else {
+        snapshotText = `[${platform}]`;
+      }
+      try {
+        const viewport = { width: 9999, height: 9999 };
+        const filters = getDefaultFilters(platform, false);
+        const locators = generateAllElementLocators(pageSource, {
+          platform,
+          viewportSize: viewport,
+          filters,
+          inViewportOnly: false
+        });
+        finalElements = locators;
+      } catch {
+      }
+    } else {
+      snapshotText = serializeWebSnapshot(tree, { url, title });
+    }
+    return {
+      timestamp,
+      command: input.command,
+      url,
+      title,
+      screenshot: shot ?? void 0,
+      elements: finalElements,
+      snapshotText
+    };
+  } catch {
+    return null;
+  }
+}
+
 // ../core/src/stack.ts
 import { parse as parseStackTrace } from "stacktrace-parser";
 function isUserCodeFrame(frame) {
@@ -44,6 +1932,462 @@ function getCallSourceFromStack() {
   return { filePath, callSource: `${filePath}:${frame.lineNumber ?? 0}` };
 }
 
+// ../core/src/trace-exporter.ts
+import fs from "fs/promises";
+import path from "path";
+
+// ../core/src/trace-har.ts
+function toHeaderArray(h) {
+  if (!h) {
+    return [];
+  }
+  return Object.entries(h).map(([name, value]) => ({ name, value }));
+}
+function toQueryString(url) {
+  try {
+    const u = new URL(url);
+    const out = [];
+    u.searchParams.forEach((value, name) => out.push({ name, value }));
+    return out;
+  } catch {
+    return [];
+  }
+}
+function networkRequestToHar(entry) {
+  const startedDateTime = new Date(entry.timestamp).toISOString();
+  const duration = entry.time ?? (entry.endTime ?? entry.startTime) - entry.startTime;
+  const status = entry.response?.status ?? entry.status ?? 0;
+  const mimeType = entry.response?.mimeType ?? "";
+  const responseHeaders = entry.response?.headers ?? entry.responseHeaders;
+  return {
+    type: "resource-snapshot",
+    snapshot: {
+      startedDateTime,
+      time: Math.max(0, duration),
+      request: {
+        method: entry.method,
+        url: entry.url,
+        httpVersion: "HTTP/1.1",
+        cookies: [],
+        headers: toHeaderArray(entry.requestHeaders ?? entry.headers),
+        queryString: toQueryString(entry.url),
+        headersSize: -1,
+        bodySize: entry.requestBody ? entry.requestBody.length : -1
+      },
+      response: {
+        status,
+        statusText: entry.statusText ?? "",
+        httpVersion: "HTTP/1.1",
+        cookies: [],
+        headers: toHeaderArray(responseHeaders),
+        content: { size: entry.size ?? 0, mimeType },
+        redirectURL: "",
+        headersSize: -1,
+        bodySize: entry.size ?? -1
+      },
+      cache: {},
+      timings: {
+        send: 0,
+        wait: Math.max(0, duration),
+        receive: 0
+      }
+    }
+  };
+}
+
+// ../core/src/trace-zip-writer.ts
+import yazl from "yazl";
+function buildTraceZip(inputs) {
+  return new Promise((resolve2, reject) => {
+    const zipFile = new yazl.ZipFile();
+    zipFile.addBuffer(Buffer.from(inputs.traceNdjson, "utf8"), "trace.trace");
+    zipFile.addBuffer(inputs.networkNdjson, "trace.network");
+    if (inputs.transcriptMd) {
+      zipFile.addBuffer(
+        Buffer.from(inputs.transcriptMd, "utf8"),
+        "transcript.md"
+      );
+    }
+    for (const resource of inputs.resources) {
+      zipFile.addBuffer(resource.data, `resources/${resource.resourceName}`);
+    }
+    zipFile.end();
+    const chunks = [];
+    zipFile.outputStream.on("data", (chunk) => chunks.push(chunk));
+    zipFile.outputStream.on("end", () => resolve2(Buffer.concat(chunks)));
+    zipFile.outputStream.on("error", reject);
+  });
+}
+
+// ../core/src/trace-exporter.ts
+var TRACE_VERSION = 8;
+var LIBRARY_NAME = "@wdio/devtools-core";
+var LIBRARY_VERSION = "1.0.0";
+function shortId(sessionId) {
+  return (sessionId ?? Math.random().toString(36).slice(2, 10)).slice(0, 8);
+}
+function resolveContextNaming(caps) {
+  const platformName = typeof caps?.platformName === "string" ? caps.platformName.toLowerCase() : void 0;
+  const deviceName = typeof caps?.["appium:deviceName"] === "string" ? caps["appium:deviceName"] : void 0;
+  if (platformName === "android" || platformName === "ios") {
+    return {
+      browserName: "chromium",
+      title: deviceName ? `${platformName} \u2014 ${deviceName}` : platformName
+    };
+  }
+  const browserName = typeof caps?.browserName === "string" ? caps.browserName : "chromium";
+  return { browserName, title: browserName };
+}
+function buildContextOptions(trace, contextId, wallTime) {
+  const caps = trace.metadata.capabilities;
+  const { browserName, title } = resolveContextNaming(caps);
+  const viewport = trace.metadata.viewport ?? { width: 1280, height: 720 };
+  return {
+    version: TRACE_VERSION,
+    type: "context-options",
+    origin: "library",
+    libraryName: LIBRARY_NAME,
+    libraryVersion: LIBRARY_VERSION,
+    browserName,
+    platform: process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "windows" : "linux",
+    wallTime,
+    monotonicTime: 0,
+    sdkLanguage: "javascript",
+    title,
+    contextId,
+    options: {
+      viewport: { width: viewport.width, height: viewport.height }
+    }
+  };
+}
+function buildActionEvents(commands, pageId, wallTime, testMetadata) {
+  const events = [];
+  let prevEndMs = 0;
+  let callCounter = 0;
+  let lastTestUid;
+  let groupCallId;
+  for (const cmd of commands) {
+    const action = mapCommandToAction(cmd.command);
+    if (!action) {
+      continue;
+    }
+    if (cmd.testUid && cmd.testUid !== lastTestUid) {
+      if (lastTestUid && groupCallId) {
+        callCounter++;
+        events.push({
+          type: "after",
+          callId: groupCallId,
+          endTime: prevEndMs
+        });
+      }
+      callCounter++;
+      groupCallId = `call@${callCounter}`;
+      const meta = testMetadata?.get(cmd.testUid);
+      const groupName = meta?.title ?? cmd.testUid;
+      events.push({
+        type: "before",
+        callId: groupCallId,
+        startTime: Math.max(
+          prevEndMs,
+          (cmd.startTime ?? cmd.timestamp) - wallTime
+        ),
+        class: "Tracing",
+        method: "tracingGroup",
+        pageId,
+        params: { name: groupName },
+        title: groupName,
+        apiName: "tracing.tracingGroup"
+      });
+      lastTestUid = cmd.testUid;
+    }
+    callCounter++;
+    const callId = `call@${callCounter}`;
+    const rawStartMs = (cmd.startTime ?? cmd.timestamp) - wallTime;
+    const rawEndMs = cmd.timestamp - wallTime;
+    const startMs = Math.max(prevEndMs, rawStartMs);
+    const endMs = Math.max(startMs + 1, rawEndMs);
+    const rawArgs = cmd.args;
+    let params;
+    const isValueMethod = FILL_METHODS.has(action.method);
+    if (action.class === "Element" && isValueMethod && rawArgs.length >= 2) {
+      params = { selector: rawArgs[0], value: rawArgs[1] };
+    } else if (action.class === "Element" && isValueMethod && rawArgs.length === 1) {
+      params = { value: rawArgs[0] };
+    } else if (action.class === "Element" && rawArgs.length === 1 && typeof rawArgs[0] === "string") {
+      params = { selector: rawArgs[0] };
+    } else if (rawArgs.length === 1 && typeof rawArgs[0] === "string") {
+      params = { url: rawArgs[0] };
+    } else {
+      params = Object.fromEntries(rawArgs.map((a, i) => [String(i), a]));
+    }
+    events.push({
+      type: "before",
+      callId,
+      startTime: startMs,
+      class: action.class,
+      method: action.method,
+      pageId,
+      params,
+      title: formatActionTitle(action, cmd.args, params),
+      apiName: `${action.class.toLowerCase()}.${action.method}`,
+      parentId: groupCallId
+    });
+    const afterEvent = {
+      type: "after",
+      callId,
+      endTime: endMs
+    };
+    if (cmd.error) {
+      const err = cmd.error;
+      afterEvent.error = { message: err.message ?? String(cmd.error) };
+    }
+    events.push(afterEvent);
+    prevEndMs = endMs;
+  }
+  if (lastTestUid && groupCallId) {
+    callCounter++;
+    events.push({
+      type: "after",
+      callId: groupCallId,
+      endTime: prevEndMs
+    });
+  }
+  return events;
+}
+function buildNetworkNdjson(requests, wallTime, pageId) {
+  if (!requests.length) {
+    return Buffer.alloc(0);
+  }
+  const lines = requests.map((r) => {
+    const entry = networkRequestToHar(r);
+    entry.snapshot = {
+      ...entry.snapshot,
+      // Monotonic offset so the viewer positions bars on the timeline.
+      _monotonicTime: Math.max(0, r.timestamp - wallTime),
+      // Browsing context ID so the viewer associates requests with the page.
+      _frameref: pageId
+    };
+    return JSON.stringify(entry);
+  });
+  return Buffer.from(lines.join("\n"), "utf8");
+}
+function buildSnapshotResources(snapshots, pageId) {
+  const out = [];
+  for (const snap of snapshots) {
+    const base = `${pageId}-${snap.timestamp}`;
+    if (snap.screenshot) {
+      out.push({
+        resourceName: `${base}.jpeg`,
+        data: Buffer.from(snap.screenshot, "base64")
+      });
+    }
+    if (snap.elements && snap.elements.length) {
+      out.push({
+        resourceName: `${base}-elements.json`,
+        data: Buffer.from(JSON.stringify(snap.elements), "utf8")
+      });
+    }
+    if (snap.snapshotText) {
+      out.push({
+        resourceName: `${base}-snapshot.txt`,
+        data: Buffer.from(snap.snapshotText, "utf8")
+      });
+    }
+  }
+  return out;
+}
+function buildScreencastFrames(snapshots, pageId, wallTime, viewport) {
+  return snapshots.filter((s) => s.screenshot).map((s) => {
+    const base = `${pageId}-${s.timestamp}`;
+    const frame = {
+      type: "screencast-frame",
+      pageId,
+      sha1: `${base}.jpeg`,
+      width: viewport.width,
+      height: viewport.height,
+      timestamp: Math.max(0, s.timestamp - wallTime)
+    };
+    if (s.elements && s.elements.length) {
+      frame.elements = `${base}-elements.json`;
+    }
+    if (s.snapshotText) {
+      frame.snapshot = `${base}-snapshot.txt`;
+    }
+    return frame;
+  });
+}
+function eventTime(e) {
+  switch (e.type) {
+    case "context-options":
+      return -Infinity;
+    case "before":
+      return e.startTime;
+    case "after":
+      return e.endTime;
+    case "screencast-frame":
+      return e.timestamp;
+  }
+}
+function eventOrder(e) {
+  switch (e.type) {
+    case "context-options":
+      return 0;
+    case "after":
+      return 1;
+    case "screencast-frame":
+      return 2;
+    case "before":
+      return 3;
+  }
+}
+function compareEvents(a, b) {
+  const dt = eventTime(a) - eventTime(b);
+  return dt !== 0 ? dt : eventOrder(a) - eventOrder(b);
+}
+function generateTranscript(commands, startWallTime, title) {
+  const wallTimeISO = new Date(startWallTime).toISOString();
+  const lines = [`# ${title ?? "Session"} \u2014 ${wallTimeISO}`, ""];
+  const captured = [];
+  for (const c of commands) {
+    const action = mapCommandToAction(String(c.command));
+    if (action) {
+      captured.push({ entry: c, action });
+    }
+  }
+  captured.forEach(({ entry, action }, idx) => {
+    const label = formatActionTitle(action, entry.args);
+    const rawArgs = entry.args;
+    const parts = [`${idx + 1}. ${label}`];
+    if (FILL_METHODS.has(action.method) && rawArgs) {
+      const valueIdx = rawArgs.length >= 2 ? 1 : 0;
+      if (rawArgs[valueIdx] !== void 0) {
+        parts.push(`value="${String(rawArgs[valueIdx])}"`);
+      }
+    }
+    if (entry.error) {
+      const msg = typeof entry.error === "object" && "message" in entry.error ? entry.error.message : String(entry.error);
+      parts.push(`ERROR: ${msg}`);
+    }
+    lines.push(parts.join("  "));
+  });
+  return lines.join("\n");
+}
+function buildTraceBundle(trace, opts = {}) {
+  const firstCommandTs = trace.commands[0]?.timestamp;
+  const wallTime = opts.wallTimeOverride ?? firstCommandTs ?? Date.now();
+  const idPrefix = shortId(opts.sessionId);
+  const contextId = `context@${idPrefix}`;
+  const pageId = `page@${idPrefix}`;
+  const viewport = trace.metadata.viewport ?? { width: 1280, height: 720 };
+  const snapshots = trace.actionSnapshots ?? [];
+  const ctxOptions = buildContextOptions(trace, contextId, wallTime);
+  const events = [ctxOptions];
+  const firstSnap = snapshots.find((s) => s.screenshot);
+  if (firstSnap) {
+    const base = `${pageId}-${firstSnap.timestamp}`;
+    const initFrame = {
+      type: "screencast-frame",
+      pageId,
+      sha1: `${base}.jpeg`,
+      width: viewport.width,
+      height: viewport.height,
+      timestamp: 0
+    };
+    if (firstSnap.elements && firstSnap.elements.length) {
+      initFrame.elements = `${base}-elements.json`;
+    }
+    if (firstSnap.snapshotText) {
+      initFrame.snapshot = `${base}-snapshot.txt`;
+    }
+    events.push(initFrame);
+  }
+  events.push(
+    ...buildScreencastFrames(
+      firstSnap ? snapshots.filter((s) => s !== firstSnap) : snapshots,
+      pageId,
+      wallTime,
+      viewport
+    ),
+    ...buildActionEvents(trace.commands, pageId, wallTime, opts.testMetadata)
+  );
+  events.sort(compareEvents);
+  const ctxBName = ctxOptions.title;
+  return {
+    traceNdjson: events.map((e) => JSON.stringify(e)).join("\n") + "\n",
+    networkNdjson: buildNetworkNdjson(trace.networkRequests, wallTime, pageId),
+    transcriptMd: generateTranscript(trace.commands, wallTime, ctxBName),
+    resources: buildSnapshotResources(snapshots, pageId)
+  };
+}
+async function exportTraceZip(trace, opts = {}) {
+  const bundle = buildTraceBundle(trace, opts);
+  return buildTraceZip({
+    traceNdjson: bundle.traceNdjson,
+    networkNdjson: bundle.networkNdjson,
+    resources: bundle.resources,
+    transcriptMd: bundle.transcriptMd
+  });
+}
+async function exportTraceDirectory(trace, targetDir, opts = {}) {
+  const bundle = buildTraceBundle(trace, opts);
+  await fs.mkdir(path.join(targetDir, "resources"), { recursive: true });
+  await Promise.all([
+    fs.writeFile(path.join(targetDir, "trace.trace"), bundle.traceNdjson),
+    fs.writeFile(
+      path.join(targetDir, "transcript.md"),
+      bundle.transcriptMd,
+      "utf8"
+    ),
+    bundle.networkNdjson.length ? fs.writeFile(
+      path.join(targetDir, "trace.network"),
+      bundle.networkNdjson
+    ) : Promise.resolve(),
+    ...bundle.resources.map(
+      (r) => fs.writeFile(path.join(targetDir, "resources", r.resourceName), r.data)
+    )
+  ]);
+}
+async function writeTraceZip(capturer, opts) {
+  const baseMetadata = capturer.metadata ?? {};
+  const actionSnapshots = opts.actionSnapshots ?? synthesizeSnapshotsFromCommands(capturer.commandsLog);
+  const traceLog = {
+    mutations: capturer.mutations,
+    logs: capturer.traceLogs,
+    consoleLogs: capturer.consoleLogs,
+    networkRequests: capturer.networkRequests,
+    metadata: {
+      ...baseMetadata,
+      ...opts.capabilities ? { capabilities: opts.capabilities } : {}
+    },
+    commands: capturer.commandsLog,
+    sources: Object.fromEntries(capturer.sources),
+    ...actionSnapshots.length ? { actionSnapshots } : {}
+  };
+  await fs.mkdir(opts.outputDir, { recursive: true });
+  const exportOpts = {
+    sessionId: opts.sessionId,
+    wallTimeOverride: capturer.startWallTime,
+    testMetadata: opts.testMetadata
+  };
+  if (opts.format === "ndjson-directory") {
+    const dir = path.join(opts.outputDir, `trace-${opts.sessionId}`);
+    await fs.mkdir(dir, { recursive: true });
+    await exportTraceDirectory(traceLog, dir, exportOpts);
+    return dir;
+  }
+  const zip = await exportTraceZip(traceLog, exportOpts);
+  const zipPath = path.join(opts.outputDir, `trace-${opts.sessionId}.zip`);
+  await fs.writeFile(zipPath, zip);
+  return zipPath;
+}
+function synthesizeSnapshotsFromCommands(commands) {
+  return commands.filter((c) => c.screenshot && mapCommandToAction(c.command)).map((c) => ({
+    timestamp: c.timestamp,
+    command: c.command,
+    screenshot: c.screenshot
+  }));
+}
+
 // ../core/src/uid.ts
 function deterministicUid(...parts) {
   const hash = parts.join("::").split("").reduce((acc, char) => (acc << 5) - acc + char.charCodeAt(0) | 0, 0);
@@ -62,13 +2406,13 @@ function resetSignatureCounters() {
 }
 
 // ../core/src/finalize-screencast.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import os2 from "os";
-import path2 from "path";
+import path3 from "path";
 
 // ../core/src/video-encoder.ts
-import fs from "fs/promises";
-import path from "path";
+import fs2 from "fs/promises";
+import path2 from "path";
 import os from "os";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -85,20 +2429,20 @@ 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 framePath = path2.join(tmpDir, frameName);
+    await fs2.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(
+  const lastFramePath = path2.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"));
+  const manifestPath = path2.join(tmpDir, "manifest.txt");
+  await fs2.writeFile(manifestPath, manifestLines.join("\n"));
   return manifestPath;
 }
 function classifyFfmpegError(err) {
@@ -121,6 +2465,15 @@ function runFfmpeg(ffmpeg, manifestPath, outputPath) {
       "cfr",
       "-r",
       "10",
+      // Force a keyframe every frame. VP8 can only seek to keyframes, and
+      // libvpx's default GOP places a single keyframe on near-static
+      // screencast content — so scrubber/marker seeks snap back to the
+      // start. At 10fps over short recordings, all-intra keeps seeking
+      // frame-accurate at an acceptable size.
+      "-g",
+      "1",
+      "-keyint_min",
+      "1",
       "-auto-alt-ref",
       "0",
       "-disposition:v",
@@ -134,14 +2487,14 @@ async function encodeToVideo(frames, outputPath, options = {}) {
   }
   const ffmpeg = loadFfmpeg();
   const ext = options.captureFormat === "png" ? "png" : "jpg";
-  const tmpDir = await fs.mkdtemp(
-    path.join(os.tmpdir(), "devtools-screencast-")
+  const tmpDir = await fs2.mkdtemp(
+    path2.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(() => {
+    await fs2.rm(tmpDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -170,11 +2523,11 @@ async function finalizeScreencast({
   }
   const fileName = `${filenamePrefix}-${sessionId}.webm`;
   const candidate = outputDir || process.cwd();
-  let videoPath = path2.join(candidate, fileName);
+  let videoPath = path3.join(candidate, fileName);
   try {
-    fs2.accessSync(candidate, fs2.constants.W_OK);
+    fs3.accessSync(candidate, fs3.constants.W_OK);
   } catch {
-    videoPath = path2.join(os2.tmpdir(), fileName);
+    videoPath = path3.join(os2.tmpdir(), fileName);
   }
   try {
     await encodeToVideo(frames, videoPath, { captureFormat });
@@ -184,7 +2537,8 @@ async function finalizeScreencast({
       videoPath,
       videoFile: fileName,
       frameCount: frames.length,
-      duration: recorder.duration
+      duration: recorder.duration,
+      startTime: frames[0]?.timestamp
     });
   } catch (err) {
     log12("warn", `Screencast encode failed: ${errorMessage(err)}`);
@@ -192,12 +2546,12 @@ async function finalizeScreencast({
 }
 
 // ../core/src/output-dir.ts
-import fs3 from "fs";
-import path3 from "path";
-var NODE_MODULES_SEGMENT = `${path3.sep}node_modules${path3.sep}`;
+import fs4 from "fs";
+import path4 from "path";
+var NODE_MODULES_SEGMENT = `${path4.sep}node_modules${path4.sep}`;
 function isWritable(dir) {
   try {
-    fs3.accessSync(dir, fs3.constants.W_OK);
+    fs4.accessSync(dir, fs4.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -210,10 +2564,10 @@ function resolveAdapterOutputDir(input = {}) {
   }
   const candidates = [];
   if (input.testFilePath) {
-    candidates.push(path3.dirname(input.testFilePath));
+    candidates.push(path4.dirname(input.testFilePath));
   }
   if (input.configPath) {
-    candidates.push(path3.dirname(input.configPath));
+    candidates.push(path4.dirname(input.configPath));
   }
   candidates.push(fallback);
   for (const dir of candidates) {
@@ -582,15 +2936,15 @@ var ScreencastRecorderBase = class {
 };
 
 // ../core/src/script-loader.ts
-import fs4 from "fs/promises";
-import path4 from "path";
+import fs5 from "fs/promises";
+import path5 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");
+  const scriptDir = path5.dirname(scriptPath);
+  const preloadScriptPath = path5.join(scriptDir, "script.js");
+  const scriptContent = await fs5.readFile(preloadScriptPath, "utf-8");
   return `(async function() { ${scriptContent} })()`;
 }
 async function pollUntilReady(check, opts = {}) {
@@ -606,7 +2960,7 @@ async function pollUntilReady(check, opts = {}) {
 }
 
 // ../core/src/session-capturer.ts
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 import { WebSocket } from "ws";
 var SessionCapturerBase = class {
   // ── State (mostly private; subclasses access shared ws via `this.ws`) ────
@@ -648,9 +3002,12 @@ var SessionCapturerBase = class {
   metadata;
   // ── Construction ────────────────────────────────────────────────────────
   constructor(opts = {}) {
-    const { hostname, port } = opts;
+    const { hostname, port, reconnect } = opts;
     if (hostname && port) {
-      this.ws = new WebSocket(`ws://${hostname}:${port}${WS_PATHS.worker}`);
+      const query = reconnect ? "?reconnect=1" : "";
+      this.ws = new WebSocket(
+        `ws://${hostname}:${port}${WS_PATHS.worker}${query}`
+      );
       this.ws.on("open", () => {
         this.#hasConnected = true;
         this.onWsOpen();
@@ -756,7 +3113,7 @@ var SessionCapturerBase = class {
       return;
     }
     try {
-      const source = (await fs5.readFile(filePath, "utf-8")).toString();
+      const source = (await fs6.readFile(filePath, "utf-8")).toString();
       this.sources.set(filePath, source);
       this.sendUpstream("sources", { [filePath]: source });
     } catch (err) {
@@ -938,17 +3295,17 @@ var SessionCapturerBase = class {
   }
   // ── 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.
+   * Build a ConsoleLog entry from the captured line, push it into the local
+   * `consoleLogs` array (so it ends up in any future trace export), and
+   * broadcast it live via the `consoleLogs` WS scope.
    *
-   * 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.
+   * Args is passed as an array (matching the original console.* call shape:
+   * `console.log('a', 'b')` → `args = ['a', 'b']`) so the multi-argument
+   * structure is preserved for the UI.
    */
   onLine(type, args, source) {
     const entry = createConsoleLogEntry(type, args, source);
+    this.consoleLogs.push(entry);
     this.sendUpstream("consoleLogs", [entry]);
   }
   /**
@@ -982,6 +3339,100 @@ function safeStringify(value) {
   }
 }
 
+// ../core/src/spec-trace-helpers.ts
+function sanitizeSpecName(specFile) {
+  return specFile.replace(/^.*[/\\]/, "").replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^_+|_+$/g, "") || "unknown-spec";
+}
+function buildSpecSessionId(specFile, sessionId) {
+  const base = sanitizeSpecName(specFile);
+  const hash = deterministicUid(specFile).split("-").pop().slice(0, 8);
+  return `${base}-${hash}-${sessionId.slice(0, 8)}`;
+}
+function buildSpecCapturer(capturer, range, nextRange) {
+  const end = nextRange ? {
+    commands: nextRange.commandStartIdx,
+    console: nextRange.consoleStartIdx,
+    network: nextRange.networkStartIdx,
+    mutations: nextRange.mutationStartIdx,
+    traceLogs: nextRange.traceLogStartIdx
+  } : void 0;
+  return {
+    mutations: capturer.mutations.slice(range.mutationStartIdx, end?.mutations),
+    traceLogs: capturer.traceLogs.slice(range.traceLogStartIdx, end?.traceLogs),
+    consoleLogs: capturer.consoleLogs.slice(
+      range.consoleStartIdx,
+      end?.console
+    ),
+    networkRequests: capturer.networkRequests.slice(
+      range.networkStartIdx,
+      end?.network
+    ),
+    commandsLog: capturer.commandsLog.slice(
+      range.commandStartIdx,
+      end?.commands
+    ),
+    sources: new Map(capturer.sources),
+    metadata: capturer.metadata,
+    startWallTime: capturer.startWallTime
+  };
+}
+function filterTestMetadataBySpec(allMetadata, specFile) {
+  const filtered = /* @__PURE__ */ new Map();
+  for (const [uid, meta] of allMetadata) {
+    if (meta.specFile === specFile) {
+      filtered.set(uid, meta);
+    }
+  }
+  return filtered;
+}
+function recordSpecBoundary(ctx, specFile, traceGranularity) {
+  if (traceGranularity !== "spec") {
+    return null;
+  }
+  const lastRange = ctx.specRanges[ctx.specRanges.length - 1];
+  if (lastRange && lastRange.specFile === specFile) {
+    return null;
+  }
+  const prevRange = lastRange && !ctx.flushedSpecs.has(lastRange.specFile) ? lastRange : null;
+  ctx.specRanges.push({
+    specFile,
+    commandStartIdx: ctx.capturer.commandsLog.length,
+    consoleStartIdx: ctx.capturer.consoleLogs.length,
+    networkStartIdx: ctx.capturer.networkRequests.length,
+    mutationStartIdx: ctx.capturer.mutations.length,
+    traceLogStartIdx: ctx.capturer.traceLogs.length,
+    snapshotCount: ctx.actionSnapshots.length
+  });
+  return prevRange;
+}
+async function writeSpecTrace(input) {
+  const specCapturer = buildSpecCapturer(
+    input.capturer,
+    input.range,
+    input.nextRange
+  );
+  const specSnapshots = input.actionSnapshots.slice(
+    input.range.snapshotCount,
+    input.nextRange?.snapshotCount ?? input.actionSnapshots.length
+  );
+  const specSessionId = buildSpecSessionId(
+    input.range.specFile,
+    input.sessionId
+  );
+  const testMetadata = filterTestMetadataBySpec(
+    input.testMetadata,
+    input.range.specFile
+  );
+  return writeTraceZip(specCapturer, {
+    outputDir: input.outputDir,
+    sessionId: specSessionId,
+    capabilities: input.capabilities,
+    actionSnapshots: specSnapshots.length > 0 ? specSnapshots : void 0,
+    format: input.format,
+    testMetadata
+  });
+}
+
 // ../core/src/suite-helpers.ts
 function createSuiteStats(init) {
   return {
@@ -1063,14 +3514,14 @@ function stampTestEnd(test, end = /* @__PURE__ */ new Date()) {
 }
 
 // ../core/src/test-discovery.ts
-import fs6 from "fs";
+import fs7 from "fs";
 function findTestDefinitions(filePath, opts = {}) {
-  if (!fs6.existsSync(filePath)) {
+  if (!fs7.existsSync(filePath)) {
     return [];
   }
   let source;
   try {
-    source = fs6.readFileSync(filePath, "utf-8");
+    source = fs7.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -1165,11 +3616,12 @@ var TestReporterBase = class {
 };
 
 // src/index.ts
+import { stop as stopBackend } from "@wdio/devtools-backend";
 import logger11 from "@wdio/logger";
 
 // src/run-lifecycle.ts
-import * as fs8 from "fs";
-import * as path6 from "path";
+import * as fs9 from "fs";
+import * as path7 from "path";
 import * as os3 from "os";
 import logger from "@wdio/logger";
 import { remote } from "webdriverio";
@@ -1229,8 +3681,8 @@ var CONFIG_FILENAMES = [
 var PLUGIN_GLOBAL_KEY = "__nightwatchDevtoolsPlugin";
 
 // src/helpers/utils.ts
-import * as fs7 from "fs";
-import * as path5 from "path";
+import * as fs8 from "fs";
+import * as path6 from "path";
 import { parse as parseStackTrace2 } from "stacktrace-parser";
 function determineTestState(testcase) {
   if (testcase.passed === 0 && testcase.failed === 0) {
@@ -1287,7 +3739,7 @@ function findTestFileFromStack() {
     return void 0;
   }
   const filePath = normalizeFilePath(frame.file);
-  return fs7.existsSync(filePath) ? filePath : void 0;
+  return fs8.existsSync(filePath) ? filePath : void 0;
 }
 function extractTestMetadata(filePath) {
   const defs = findTestDefinitions(filePath, {
@@ -1415,21 +3867,21 @@ function resolveNightwatchConfig() {
   );
   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)) {
+    const resolved = path6.isAbsolute(argvConfig) ? argvConfig : path6.resolve(process.cwd(), argvConfig);
+    if (fs8.existsSync(resolved)) {
       return resolved;
     }
   }
   let dir = process.cwd();
-  const root = path5.parse(dir).root;
+  const root = path6.parse(dir).root;
   while (dir && dir !== root) {
     for (const file of CONFIG_FILENAMES) {
-      const candidate = path5.join(dir, file);
-      if (fs7.existsSync(candidate)) {
+      const candidate = path6.join(dir, file);
+      if (fs8.existsSync(candidate)) {
         return candidate;
       }
     }
-    const parent = path5.dirname(dir);
+    const parent = path6.dirname(dir);
     if (parent === dir) {
       break;
     }
@@ -1474,20 +3926,25 @@ async function runPluginBefore(ctx) {
     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)
-    );
+    if (ctx.options.mode === "trace") {
+      log.info("Trace mode \u2014 skipping backend port-bind and UI window");
+    } else {
+      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)}`);
@@ -1496,12 +3953,12 @@ async function runPluginBefore(ctx) {
 }
 async function openDevtoolsBrowser(ctx, url) {
   try {
-    ctx.userDataDir = path6.join(
+    ctx.userDataDir = path7.join(
       os3.tmpdir(),
       `nightwatch-devtools-${ctx.options.port}-${Date.now()}`
     );
-    if (!fs8.existsSync(ctx.userDataDir)) {
-      fs8.mkdirSync(ctx.userDataDir, { recursive: true });
+    if (!fs9.existsSync(ctx.userDataDir)) {
+      fs9.mkdirSync(ctx.userDataDir, { recursive: true });
     }
     ctx.devtoolsBrowser = await remote({
       logLevel: "info",
@@ -1515,6 +3972,13 @@ async function openDevtoolsBrowser(ctx, url) {
             "--no-first-run",
             "--no-default-browser-check"
           ]
+        },
+        // Dashboard uses the Puppeteer-based 'devtools' protocol; drop the
+        // "controlled by automated test software" infobar by ignoring
+        // Puppeteer's --enable-automation default. (Runtime-valid capability
+        // not present in the type.)
+        "wdio:devtoolsOptions": {
+          ignoreDefaultArgs: ["--enable-automation"]
         }
       }
     });
@@ -1726,43 +4190,43 @@ function buildCucumberScenarioSuite(input) {
 }
 
 // src/helpers/featureFileScan.ts
-import fs9 from "fs";
-import path7 from "path";
+import fs10 from "fs";
+import path8 from "path";
 function scanFeatureFile(featureUri) {
-  const featureAbsPath = path7.resolve(process.cwd(), featureUri);
+  const featureAbsPath = path8.resolve(process.cwd(), featureUri);
   const result = {
-    featureName: path7.basename(featureUri, ".feature"),
+    featureName: path8.basename(featureUri, ".feature"),
     featureContent: "",
     featureAbsPath,
     stepDefFiles: [],
     capturedPaths: []
   };
-  if (featureUri === "unknown.feature" || !fs9.existsSync(featureAbsPath)) {
+  if (featureUri === "unknown.feature" || !fs10.existsSync(featureAbsPath)) {
     return result;
   }
-  result.featureContent = fs9.readFileSync(featureAbsPath, "utf-8");
+  result.featureContent = fs10.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 featureDir = path8.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()) {
+    const stepDir = path8.join(featureDir, candidate);
+    if (!fs10.existsSync(stepDir) || !fs10.statSync(stepDir).isDirectory()) {
       continue;
     }
-    for (const entry of fs9.readdirSync(stepDir)) {
+    for (const entry of fs10.readdirSync(stepDir)) {
       if (!/\.(js|ts|mjs|cjs)$/.test(entry)) {
         continue;
       }
-      const stepFilePath = path7.join(stepDir, entry);
+      const stepFilePath = path8.join(stepDir, entry);
       result.capturedPaths.push(stepFilePath);
       try {
         result.stepDefFiles.push({
           filePath: stepFilePath,
-          content: fs9.readFileSync(stepFilePath, "utf-8")
+          content: fs10.readFileSync(stepFilePath, "utf-8")
         });
       } catch {
       }
@@ -1929,8 +4393,8 @@ async function cucumberAfter(ctx, browser, result, pickle) {
 import logger5 from "@wdio/logger";
 
 // src/helpers/specFileResolver.ts
-import fs10 from "fs";
-import path8 from "path";
+import fs11 from "fs";
+import path9 from "path";
 function resolveSpecFilePath(testFile, modulePath, srcFolders, cachedPath) {
   let fullPath = findTestFileFromStack() || null;
   if (!fullPath && cachedPath && cachedPath.includes(testFile)) {
@@ -1946,27 +4410,27 @@ function resolveSpecFilePath(testFile, modulePath, srcFolders, cachedPath) {
   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)
+      path9.resolve(workspaceRoot, sf, normalized + ".js"),
+      path9.resolve(workspaceRoot, sf, normalized + ".ts"),
+      path9.resolve(workspaceRoot, sf, normalized + ".cjs"),
+      path9.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)
+      path9.resolve(workspaceRoot, normalized + ".js"),
+      path9.resolve(workspaceRoot, normalized + ".ts"),
+      path9.resolve(workspaceRoot, normalized + ".cjs"),
+      path9.resolve(workspaceRoot, normalized)
     ] : [],
-    path8.resolve(workspaceRoot, "tests", testFile + ".js"),
-    path8.resolve(workspaceRoot, "test", testFile + ".js"),
-    path8.resolve(workspaceRoot, testFile + ".js")
+    path9.resolve(workspaceRoot, "tests", testFile + ".js"),
+    path9.resolve(workspaceRoot, "test", testFile + ".js"),
+    path9.resolve(workspaceRoot, testFile + ".js")
   ];
   for (const candidate of possiblePaths) {
-    if (fs10.existsSync(candidate)) {
+    if (fs11.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -2182,6 +4646,18 @@ import logger10 from "@wdio/logger";
 import http from "http";
 import logger6 from "@wdio/logger";
 
+// src/action-snapshot.ts
+function captureActionSnapshot2(browser, command, takeScreenshot) {
+  const b = browser;
+  return captureActionSnapshot({
+    command,
+    runScript: (src) => browser.execute(`return (${src})`),
+    takeScreenshot,
+    getUrl: () => b.getCurrentUrl ? b.getCurrentUrl().catch(() => void 0) : Promise.resolve(void 0),
+    getTitle: () => b.getTitle ? b.getTitle().catch(() => void 0) : Promise.resolve(void 0)
+  });
+}
+
 // src/helpers/perfLogs.ts
 function applyResponseReceived(p, response) {
   const responseHeaders = {};
@@ -2194,18 +4670,22 @@ function applyResponseReceived(p, response) {
   p.mimeType = response.mimeType;
   p.type = getRequestType(p.url, response.mimeType);
 }
+function eventTimeMs(params, entry) {
+  return typeof params.timestamp === "number" ? Math.round(params.timestamp * 1e3) : entry.timestamp;
+}
 function startPendingRequest(params, entry, pending) {
   const { requestId, request: req, timestamp } = params;
   if (!req || typeof timestamp !== "number") {
     return;
   }
+  const startTime = eventTimeMs(params, entry);
   pending.set(requestId, {
     id: `${entry.timestamp}-${requestId}`,
     url: req.url,
     method: req.method,
     requestHeaders: req.headers ?? {},
-    timestamp: Math.round(timestamp * 1e3),
-    startTime: entry.timestamp
+    timestamp: startTime,
+    startTime
   });
 }
 function handlePerfLogEvent(method, params, entry, pending, completed) {
@@ -2224,8 +4704,8 @@ function handlePerfLogEvent(method, params, entry, pending, completed) {
     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;
+      p.endTime = eventTimeMs(params, entry);
+      p.time = Math.max(0, p.endTime - p.startTime);
       completed.push({ ...p });
       pending.delete(params.requestId);
     }
@@ -2235,8 +4715,8 @@ function handlePerfLogEvent(method, params, entry, pending, completed) {
     const p = pending.get(params.requestId);
     if (p) {
       p.error = params.errorText;
-      p.endTime = entry.timestamp;
-      p.time = entry.timestamp - p.startTime;
+      p.endTime = eventTimeMs(params, entry);
+      p.time = Math.max(0, p.endTime - p.startTime);
       completed.push({ ...p });
       pending.delete(params.requestId);
     }
@@ -2310,7 +4790,7 @@ function unwrapDriverValue(result) {
   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 getPath = (obj, ...path10) => path10.reduce((acc, k) => getProp(acc, k), obj);
 var firstDefined = (obj, ...keys) => {
   if (!obj || typeof obj !== "object") {
     return void 0;
@@ -2347,6 +4827,10 @@ var SessionCapturer = class extends SessionCapturerBase {
   // 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;
+  // Populated by captureCommand when mode === 'trace' (set by the plugin).
+  traceMode = "live";
+  actionSnapshots = [];
+  snapshotCaptures = [];
   constructor(devtoolsOptions = {}, browser) {
     super(devtoolsOptions);
     this.#browser = browser;
@@ -2362,15 +4846,6 @@ var SessionCapturer = class extends SessionCapturerBase {
   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++;
@@ -2393,6 +4868,20 @@ var SessionCapturer = class extends SessionCapturerBase {
         log6.warn(`Failed to capture performance data: ${errorMessage(err)}`);
       });
     }
+    if (this.traceMode === "trace" && !error && this.#browser && mapCommandToAction(command)) {
+      const browser = this.#browser;
+      this.snapshotCaptures.push(
+        captureActionSnapshot2(
+          browser,
+          command,
+          () => this.takeScreenshotViaHttp(browser)
+        ).then((snap) => {
+          if (snap) {
+            this.actionSnapshots.push(snap);
+          }
+        })
+      );
+    }
     return true;
   }
   async #capturePerformanceData(commandLogEntry, args) {
@@ -2589,13 +5078,6 @@ var SessionCapturer = class extends SessionCapturerBase {
   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;
@@ -3043,8 +5525,8 @@ var BrowserProxy = class {
   getCurrentTestFullPath() {
     return this.currentTestFullPath;
   }
-  setCurrentTestFullPath(path9) {
-    this.currentTestFullPath = path9;
+  setCurrentTestFullPath(path10) {
+    this.currentTestFullPath = path10;
   }
   /**
    * Wrap browser navigation methods (url / navigate / navigateTo) to inject
@@ -3397,7 +5879,7 @@ function broadcastSessionMetadata(ctx, browser) {
     const sf = opts.src_folders;
     ctx.srcFolders = Array.isArray(sf) ? sf : sf ? [sf] : [];
   }
-  ctx.sessionCapturer.sendUpstream("metadata", {
+  const metadata = {
     type: "testrunner" /* Testrunner */,
     capabilities,
     desiredCapabilities,
@@ -3406,7 +5888,9 @@ function broadcastSessionMetadata(ctx, browser) {
     host: opts.webdriver?.host,
     options: ctx.buildMetadataOptions(),
     url: ""
-  });
+  };
+  ctx.sessionCapturer.metadata = metadata;
+  ctx.sessionCapturer.sendUpstream("metadata", metadata);
   const browserName = capabilities.browserName || desiredCapabilities.browserName || "unknown";
   const browserVersion = capabilities.browserVersion || capabilities.version || "";
   log10.info(
@@ -3429,7 +5913,7 @@ async function tryAttachBidi(ctx, browser) {
     log10.warn("bidi:true set but browser.driver unavailable \u2014 skipping");
     return;
   }
-  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-OH4ZFDN5.js");
+  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-FIHBBGT4.js");
   const ok = await attachBidiHandlers(
     driver,
     buildBidiSinks(ctx.sessionCapturer)
@@ -3465,12 +5949,21 @@ async function ensureSessionInitialized(ctx, browser, finalizeCurrentScreencast2
     (resolve2) => setTimeout(resolve2, TIMING.INITIAL_CONNECTION_WAIT)
   );
   ctx.sessionCapturer = new SessionCapturer(
-    { port: ctx.port, hostname: ctx.hostname },
+    ctx.mode === "trace" ? {} : {
+      port: ctx.port,
+      hostname: ctx.hostname,
+      // A session change reopens the WS mid-run — tell the backend to keep
+      // the accumulated run state so earlier tests' commands survive.
+      reconnect: Boolean(isSessionChange)
+    },
     browser
   );
-  const connected = await ctx.sessionCapturer.waitForConnection(3e3);
-  if (!connected) {
-    log10.error("\u274C Worker WebSocket failed to connect!");
+  ctx.sessionCapturer.traceMode = ctx.mode;
+  if (ctx.mode !== "trace") {
+    const connected = await ctx.sessionCapturer.waitForConnection(3e3);
+    if (!connected) {
+      log10.error("\u274C Worker WebSocket failed to connect!");
+    }
   }
   if (!ctx.testReporter) {
     initReporterChain(ctx);
@@ -3523,6 +6016,10 @@ var NightwatchDevToolsPlugin = class {
   #skipCount = 0;
   #configPath;
   #srcFolders = [];
+  /** Index ranges into the session capturer's flat arrays, one per spec file. */
+  #specRanges = [];
+  /** Set of spec files already flushed to disk. */
+  #flushedSpecs = /* @__PURE__ */ new Set();
   #getRerunLabel() {
     return process.env[REUSE_ENV.RERUN_ENTRY_TYPE] === "test" ? process.env[REUSE_ENV.RERUN_LABEL]?.trim() : void 0;
   }
@@ -3532,16 +6029,22 @@ var NightwatchDevToolsPlugin = class {
   #bidiEnabled = false;
   #bidiAttachAttempted = false;
   constructor(options = {}) {
+    const mode = options.mode ?? "live";
+    const ignore = mode === "trace" && options.screencast?.enabled === true;
+    if (ignore) {
+      log11.warn("trace mode: ignoring screencast option (live-mode feature)");
+    }
+    const screencast = ignore ? {} : options.screencast ?? {};
     this.options = {
       port: options.port ?? 3e3,
       hostname: options.hostname ?? "localhost",
-      screencast: options.screencast ?? {},
-      bidi: options.bidi ?? false
-    };
-    this.#screencastOptions = {
-      ...SCREENCAST_DEFAULTS,
-      ...options.screencast ?? {}
+      screencast,
+      bidi: options.bidi ?? false,
+      mode,
+      traceFormat: options.traceFormat ?? "zip",
+      traceGranularity: options.traceGranularity ?? "session"
     };
+    this.#screencastOptions = { ...SCREENCAST_DEFAULTS, ...screencast };
     this.#bidiEnabled = options.bidi === true;
   }
   // Single internals "bag" — structurally satisfies all 4 lifecycle ctx
@@ -3565,6 +6068,9 @@ var NightwatchDevToolsPlugin = class {
       get port() {
         return self.options.port;
       },
+      get mode() {
+        return self.options.mode;
+      },
       get screencastOptions() {
         return self.#screencastOptions;
       },
@@ -3794,6 +6300,25 @@ var NightwatchDevToolsPlugin = class {
       this.sessionCapturer.captureSource(fullPath).catch(() => {
       });
     }
+    if (fullPath) {
+      const prevRange = recordSpecBoundary(
+        {
+          specRanges: this.#specRanges,
+          flushedSpecs: this.#flushedSpecs,
+          capturer: this.sessionCapturer,
+          actionSnapshots: this.sessionCapturer.actionSnapshots
+        },
+        fullPath,
+        this.options.traceGranularity
+      );
+      if (prevRange) {
+        void this.#flushSpecTrace(prevRange).catch(
+          (err) => log11.warn(
+            `Failed to flush trace for spec "${prevRange.specFile}": ${errorMessage(err)}`
+          )
+        );
+      }
+    }
     await this.#closePreviousRunningTest(currentSuite, testFile, currentTest);
     const processedTests = this.testManager.getProcessedTests(testFile);
     const currentTestName = this.#pickCurrentTestName(
@@ -3827,6 +6352,12 @@ var NightwatchDevToolsPlugin = class {
     try {
       await this.#finalizeAllSuites(browser);
       this.#logRunSummary();
+      if (this.options.mode === "trace") {
+        await this.#writeTraceZipIfNeeded();
+        await this.sessionCapturer?.closeWebSocket();
+        await stopBackend();
+        return;
+      }
       if (!this.#devtoolsBrowser) {
         this.testReporter?.updateSuites();
         log11.info("\u267B  Rerun complete \u2014 flushing WebSocket...");
@@ -3845,6 +6376,91 @@ var NightwatchDevToolsPlugin = class {
   #logRunSummary() {
     logRunSummary(this.#getInternals());
   }
+  async #flushSpecTrace(range, nextRange) {
+    if (this.#flushedSpecs.has(range.specFile)) {
+      return void 0;
+    }
+    this.#flushedSpecs.add(range.specFile);
+    const sessionId = this.sessionCapturer.metadata?.sessionId;
+    if (!sessionId) {
+      return void 0;
+    }
+    const allMetadata = /* @__PURE__ */ new Map();
+    if (this.suiteManager) {
+      for (const suite of this.suiteManager.getAllSuites().values()) {
+        for (const entry of suite.tests) {
+          if (typeof entry === "string") {
+            continue;
+          }
+          allMetadata.set(entry.uid, {
+            title: entry.fullTitle,
+            specFile: entry.file
+          });
+        }
+      }
+    }
+    const tracePath = await writeSpecTrace({
+      range,
+      nextRange,
+      capturer: this.sessionCapturer,
+      actionSnapshots: this.sessionCapturer.actionSnapshots,
+      sessionId,
+      outputDir: resolveAdapterOutputDir({ configPath: this.#configPath }),
+      format: this.options.traceFormat,
+      testMetadata: allMetadata
+    });
+    log11.info(`Trace for spec "${range.specFile}" saved to ${tracePath}`);
+    return tracePath;
+  }
+  async #writeTraceZipIfNeeded() {
+    if (this.options.mode !== "trace" || !this.sessionCapturer) {
+      return;
+    }
+    const sessionId = this.sessionCapturer.metadata?.sessionId;
+    if (!sessionId) {
+      return;
+    }
+    try {
+      if (this.sessionCapturer.snapshotCaptures.length) {
+        await Promise.allSettled(this.sessionCapturer.snapshotCaptures);
+      }
+      if (this.options.traceGranularity === "spec") {
+        for (const range of this.#specRanges) {
+          if (!this.#flushedSpecs.has(range.specFile)) {
+            await this.#flushSpecTrace(range);
+          }
+        }
+        return;
+      }
+      const testMetadata = /* @__PURE__ */ new Map();
+      if (this.suiteManager) {
+        for (const suite of this.suiteManager.getAllSuites().values()) {
+          for (const entry of suite.tests) {
+            if (typeof entry === "string") {
+              continue;
+            }
+            testMetadata.set(entry.uid, {
+              title: entry.fullTitle,
+              specFile: entry.file
+            });
+          }
+        }
+      }
+      const snapshots = this.sessionCapturer.actionSnapshots;
+      const tracePath = await writeTraceZip(this.sessionCapturer, {
+        outputDir: resolveAdapterOutputDir({
+          configPath: this.#configPath
+        }),
+        sessionId,
+        actionSnapshots: snapshots.length ? snapshots : void 0,
+        format: this.options.traceFormat,
+        testMetadata
+      });
+      log11.info(`Trace saved to ${tracePath}`);
+    } catch (err) {
+      log11.warn(`trace write failed: ${errorMessage(err)}`);
+    }
+  }
   async #waitForDevtoolsBrowserClose() {
     await waitForDevtoolsBrowserClose(this.#getInternals());
   }