capybara-simulated 0.0.2

data/vendor/js/runtime.js

@@ -0,0 +1,2054 @@
+// Driver-side runtime running inside a single mini_racer Context.
+// `__csim_bundle` is the IIFE exposing happy-dom (built by build.mjs).
+// Every Capybara session shares this Context — DOM state is reset per
+// visit by recreating the window, never the V8 isolate.
+
+(function () {
+  const {Window, URL: WhatwgURL, URLSearchParams: WhatwgURLSearchParams,
+         evaluateXPathToNodes} = globalThis.__csim_bundle;
+  if (!globalThis.URL) globalThis.URL = WhatwgURL;
+  if (!globalThis.URLSearchParams) globalThis.URLSearchParams = WhatwgURLSearchParams;
+
+  const handles = new Map();
+  let nextHandleId = 0;
+  let currentWindow = null;
+  let currentDocument = null;
+  let activeHandleId = null;
+
+  const modalQueue = [];
+  let modalResponses = {alert: [], confirm: [], prompt: []};
+  // Stack of {type, text, response} pushed by accept_modal /
+  // dismiss_modal blocks; consumed by the modal stubs above.
+  const modalHandlers = [];
+  let asyncSlot = null;
+
+  function track(node) {
+    if (node == null) return null;
+    for (const [id, n] of handles) if (n === node) return id;
+    const id = ++nextHandleId;
+    handles.set(id, node);
+    return id;
+  }
+  function lookup(id) {
+    if (id == null) return null;
+    const node = handles.get(id);
+    if (!node) throw new Error('stale or unknown node handle: ' + id);
+    // Element is detached from the live document — surface a stale-handle
+    // error so Capybara's automatic_reload retry kicks in.
+    if (node.nodeType === 1 && node.isConnected === false) {
+      throw new Error('stale or unknown node handle: ' + id + ' (detached)');
+    }
+    return node;
+  }
+
+  function resetState() {
+    if (currentWindow) {
+      try { currentWindow.happyDOM && currentWindow.happyDOM.close && currentWindow.happyDOM.close(); }
+      catch (_) {}
+    }
+    handles.clear();
+    nextHandleId = 0;
+    activeHandleId = null;
+    modalQueue.length = 0;
+    modalHandlers.length = 0;
+    asyncSlot = null;
+    currentWindow = null;
+    currentDocument = null;
+    if (typeof globalThis.__csim_clearTimers === 'function') {
+      try { globalThis.__csim_clearTimers(); } catch (_) {}
+    }
+  }
+
+  // happy-dom keys its private fields with module-level `Symbol("name")`s,
+  // so within a single bundle a description maps to one stable symbol.
+  // Cache by description to skip the O(symbols) walk on hot paths
+  // (`MutationObserver.observe` runs this every time).
+  const SYMBOL_CACHE = new Map();
+  function findHDSymbol(obj, description) {
+    let sym = SYMBOL_CACHE.get(description);
+    if (sym) return sym;
+    sym = Object.getOwnPropertySymbols(obj).find((s) => s.description === description);
+    if (sym) SYMBOL_CACHE.set(description, sym);
+    return sym;
+  }
+
+  function patchWindowGlobals(win) {
+    // happy-dom expects a handful of constructors to live on the window
+    // because page-supplied scripts and selector parsers grab them via
+    // `this.window.SyntaxError` etc. mini_racer's bare V8 isolate does not
+    // wire those up automatically.
+    const PASS = ['SyntaxError', 'TypeError', 'Error', 'RangeError',
+                  'ReferenceError', 'Promise', 'Map', 'Set', 'WeakMap',
+                  'WeakSet', 'Symbol', 'Proxy', 'Reflect', 'Array',
+                  'Object', 'String', 'Number', 'Boolean', 'JSON',
+                  'Math', 'Date', 'RegExp', 'ArrayBuffer', 'Uint8Array',
+                  'Int8Array', 'Uint16Array', 'Int16Array', 'Uint32Array',
+                  'Int32Array', 'Float32Array', 'Float64Array', 'DataView'];
+    for (const name of PASS) {
+      if (typeof globalThis[name] !== 'undefined' && !win[name]) {
+        win[name] = globalThis[name];
+      }
+    }
+    // Modal stubs — happy-dom does not implement alert/confirm/prompt.
+    // Two response paths live in parallel:
+    //
+    //   * `modalHandlers` — text-matched handlers pushed by
+    //     `accept_modal` / `dismiss_modal` blocks. Picked first because
+    //     they encode the user's intent and support nesting.
+    //   * `modalResponses` — legacy unkeyed FIFO queue still consumed
+    //     when no matching handler is found, kept for backwards
+    //     compatibility with code that calls `set_modal_responses`
+    //     directly.
+    //
+    // For `prompt(message, defaultValue)`, falling through to the
+    // default response returns the page-supplied default when no
+    // handler / queue entry overrides it.
+    const mkResponder = (type) => function (message, defaultValue) {
+      const msg = message == null ? null : String(message);
+      const recorded = {type, message: msg, response: null};
+      const handlerIdx = modalHandlers.findIndex((h) => h.type === type && modalTextMatches(h.text, msg));
+      let resolved = false;
+      if (handlerIdx >= 0) {
+        const handler = modalHandlers[handlerIdx];
+        modalHandlers.splice(handlerIdx, 1);
+        recorded.response = encodeModalResponse(type, handler.response, defaultValue);
+        resolved = true;
+      } else {
+        const queue = modalResponses[type] || [];
+        if (queue.length > 0) {
+          recorded.response = encodeModalResponse(type, queue.shift(), defaultValue);
+          resolved = true;
+        }
+      }
+      if (!resolved) {
+        if (type === 'prompt') recorded.response = defaultValue == null ? null : String(defaultValue);
+        else                   recorded.response = type === 'confirm' ? true : undefined;
+      }
+      modalQueue.push(recorded);
+      return recorded.response;
+    };
+    function encodeModalResponse(type, v, defaultValue) {
+      if (type !== 'prompt') return v;
+      if (v === false) return null;
+      if (v == null)   return defaultValue == null ? '' : String(defaultValue);
+      return v;
+    }
+    function modalTextMatches(matcher, message) {
+      if (matcher == null) return true;
+      if (typeof matcher === 'string') return String(message || '').indexOf(matcher) >= 0;
+      if (typeof matcher === 'object' && 'regexp' in matcher) {
+        try {
+          const flags = decodeRegexpFlags(matcher.flags || 0);
+          return new RegExp(matcher.regexp, flags).test(String(message || ''));
+        } catch (_) { return false; }
+      }
+      return false;
+    }
+    function decodeRegexpFlags(rubyFlags) {
+      // Ruby Regexp#options bitset: 1=IGNORECASE, 2=EXTENDED, 4=MULTILINE.
+      let s = '';
+      if (rubyFlags & 1) s += 'i';
+      if (rubyFlags & 4) s += 'm';
+      return s;
+    }
+    win.alert = mkResponder('alert');
+    win.confirm = mkResponder('confirm');
+    win.prompt = mkResponder('prompt');
+    // Replace happy-dom's real-time timer scheduler with our synchronous
+    // queue so drainTimers() can run pending callbacks on demand. Without
+    // this, setTimeout-based handlers (jQuery's $(elem).click → setTimeout)
+    // never fire because the driver runs the test in a single tick.
+    win.setTimeout    = globalThis.setTimeout;
+    win.clearTimeout  = globalThis.clearTimeout;
+    win.setInterval   = globalThis.setInterval;
+    win.clearInterval = globalThis.clearInterval;
+    win.setImmediate  = globalThis.setImmediate;
+    win.clearImmediate = globalThis.clearImmediate;
+    win.queueMicrotask = globalThis.queueMicrotask;
+    win.requestAnimationFrame = (cb) => globalThis.setTimeout(() => cb(Date.now()), 16);
+    win.cancelAnimationFrame  = (id) => globalThis.clearTimeout(id);
+    installValidationMessages(win);
+    installMutationObserverPin(win);
+  }
+
+  // happy-dom's MutationObserverListener wraps its dispatch arrow in a
+  // `WeakRef` with no other strong reference. V8 collects it before the
+  // next mutation arrives; `target[mutationListeners]` still carries the
+  // listener but `callback.deref()` returns undefined and every record
+  // (plus the subtree-propagation hop in `appendChild`) is silently
+  // dropped. Replace each WeakRef with a strong-reference shim that
+  // keeps the same `.deref()` shape.
+  function installMutationObserverPin(win) {
+    const MO = win.MutationObserver;
+    if (!MO || !MO.prototype || MO.prototype.__csim_pinned) return;
+    const origObserve = MO.prototype.observe;
+    MO.prototype.observe = function (target, options) {
+      const result = origObserve.call(this, target, options);
+      if (target && typeof target === 'object') {
+        const sym = findHDSymbol(target, 'mutationListeners');
+        const listeners = sym && target[sym];
+        if (listeners && listeners.length) {
+          for (const ml of listeners) {
+            const cb = ml && ml.callback;
+            if (cb && typeof cb.deref === 'function' && !cb.__csim_strong) {
+              const fn = cb.deref();
+              if (fn) {
+                ml.callback = {deref() { return fn; }, __csim_strong: true};
+              }
+            }
+          }
+        }
+      }
+      return result;
+    };
+    MO.prototype.__csim_pinned = true;
+  }
+
+  // happy-dom computes `validity` flags but always reports an empty
+  // `validationMessage`. Capybara's `have_field validation_message:` test
+  // and Rails apps that surface the constraint-validation message rely
+  // on the Chrome-style English defaults; shim them once per Window.
+  function installValidationMessages(win) {
+    const protos = [win.HTMLInputElement && win.HTMLInputElement.prototype,
+                    win.HTMLTextAreaElement && win.HTMLTextAreaElement.prototype,
+                    win.HTMLSelectElement && win.HTMLSelectElement.prototype];
+    for (const proto of protos) {
+      if (!proto || proto.__csim_validation_patched) continue;
+      Object.defineProperty(proto, 'validationMessage', {
+        configurable: true,
+        get() {
+          if (!this.validity || this.validity.valid) return '';
+          const v = this.validity;
+          if (v.valueMissing)    return 'Please fill out this field.';
+          if (v.typeMismatch)    return 'Please enter a valid value.';
+          if (v.patternMismatch) return 'Please match the requested format.';
+          if (v.tooShort)        return 'Please lengthen this text to ' + this.minLength + ' characters or more.';
+          if (v.tooLong)         return 'Please shorten this text to ' + this.maxLength + ' characters or less.';
+          if (v.rangeUnderflow)  return 'Value must be greater than or equal to ' + this.min + '.';
+          if (v.rangeOverflow)   return 'Value must be less than or equal to ' + this.max + '.';
+          if (v.stepMismatch)    return 'Please enter a valid value.';
+          if (v.badInput)        return 'Please enter a number.';
+          if (v.customError && this.__csim_customMessage) return this.__csim_customMessage;
+          return '';
+        }
+      });
+      proto.__csim_validation_patched = true;
+    }
+  }
+
+  // happy-dom's CustomElementRegistry stubs out the upgrade step
+  // (`upgrade(_root) { /* Do nothing */ }`), so existing tags in the
+  // parsed DOM never get promoted to their custom element class. This
+  // breaks Turbo: a `<turbo-frame>` in server-rendered HTML stays as a
+  // plain HTMLElement and FrameController is never constructed, so frame
+  // form submissions fall through to a session-level handler that does
+  // not attach the `Turbo-Frame` request header. Patch `define` to walk
+  // the document and re-create matching elements through
+  // `document.createElement`, which runs the registered constructor and
+  // wires `connectedCallback` on insert.
+  function installCustomElementUpgrade(win) {
+    if (!win.customElements || win.customElements.__csim_patched) return;
+    const registry = win.customElements;
+    const origDefine = registry.define.bind(registry);
+    registry.define = function (name, ctor, options) {
+      const out = origDefine(name, ctor, options);
+      try { upgradeExisting(name); } catch (_) {}
+      return out;
+    };
+    registry.__csim_patched = true;
+
+    function upgradeExisting(name) {
+      const doc = currentDocument;
+      if (!doc || !doc.getElementsByTagName) return;
+      const ctor = registry.get(name);
+      const matches = Array.from(doc.getElementsByTagName(name));
+      for (const old of matches) {
+        if (ctor && old instanceof ctor) {
+          // happy-dom 20's auto-upgrade swaps the element returned by
+          // `getElementsByTagName` to an instance of the registered class
+          // but leaves the original (unupgraded) element sitting in the
+          // document's `elementIdMap`. Subsequent `getElementById` calls
+          // then hand back the ghost — empty id, wrong class. Re-toggle
+          // the id attribute so happy-dom evicts the stale entry and
+          // re-registers the live element.
+          rebindIdIndex(old);
+          continue;
+        }
+        const parent = old.parentNode;
+        if (!parent) continue;
+        const next = old.nextSibling;
+        const attrs = [];
+        for (const attr of Array.from(old.attributes || [])) {
+          attrs.push([attr.name, attr.value]);
+        }
+        const children = [];
+        while (old.firstChild) children.push(old.removeChild(old.firstChild));
+        for (const [n] of attrs) {
+          try { old.removeAttribute(n); } catch (_) {}
+        }
+        parent.removeChild(old);
+        const fresh = doc.createElement(name);
+        for (const [n, v] of attrs) {
+          try { fresh.setAttribute(n, v); } catch (_) {}
+        }
+        for (const child of children) fresh.appendChild(child);
+        if (next && next.parentNode === parent) parent.insertBefore(fresh, next);
+        else parent.appendChild(fresh);
+      }
+    }
+
+    function rebindIdIndex(el) {
+      const id = el.getAttribute && el.getAttribute('id');
+      if (!id) return;
+      // Reach through happy-dom's private elementIdMap symbol — the
+      // public removeAttribute/setAttribute path appends the live element
+      // *after* the ghost, so `getElementById` (which returns
+      // entry.elements[0]) keeps handing back the wrong instance until
+      // we evict the ghost manually.
+      try {
+        const doc = currentWindow && currentWindow.document;
+        if (!doc) return;
+        const sym = findHDSymbol(doc, 'elementIdMap');
+        if (!sym) return;
+        const map = doc[sym];
+        const entry = map && map.get(id);
+        if (!entry || !entry.elements) return;
+        entry.elements = entry.elements.filter((e) => e === el || (e.isConnected && e.getAttribute && e.getAttribute('id') === id));
+        if (entry.elements.indexOf(el) < 0) entry.elements.unshift(el);
+      } catch (_) {}
+    }
+  }
+
+  // Replace happy-dom's network-going `fetch` with one that round-trips
+  // through the host Rack app. Synchronous under the hood — `__csim_fetch`
+  // is attached from Ruby and returns immediately — but the wrapper still
+  // resolves a Promise so consumers (Turbo, Stimulus) `await` normally.
+  function installFetchShim(win) {
+    const ResponseCtor = win.Response;
+    const HeadersCtor  = win.Headers;
+    const URLSearchParamsCtor = win.URLSearchParams || globalThis.URLSearchParams;
+    const FormDataCtor = win.FormData;
+    const DOMExceptionCtor = win.DOMException || Error;
+
+    function headerEntries(input) {
+      if (!input) return [];
+      if (typeof input.entries === 'function') return Array.from(input.entries());
+      if (Array.isArray(input)) return input.slice();
+      return Object.keys(input).map((k) => [k, input[k]]);
+    }
+
+    function encodeMultipart(formData) {
+      const boundary = '----CapybaraSimulatedFetch' + Math.random().toString(16).slice(2);
+      const parts = [];
+      for (const [name, value] of formData.entries()) {
+        if (value && typeof value === 'object' && 'name' in value && 'arrayBuffer' in value) {
+          // File / Blob — serialise basename only; binary upload via fetch
+          // is rare in Turbo and would need binary-safe transport.
+          parts.push('--' + boundary + '\r\n' +
+            'Content-Disposition: form-data; name="' + name + '"; filename="' + (value.name || '') + '"\r\n' +
+            'Content-Type: ' + (value.type || 'application/octet-stream') + '\r\n\r\n' +
+            '\r\n');
+        } else {
+          parts.push('--' + boundary + '\r\n' +
+            'Content-Disposition: form-data; name="' + name + '"\r\n\r\n' +
+            String(value) + '\r\n');
+        }
+      }
+      return {body: parts.join('') + '--' + boundary + '--\r\n', contentType: 'multipart/form-data; boundary=' + boundary};
+    }
+
+    function serializeBody(body, headers) {
+      if (body == null) return '';
+      if (typeof body === 'string') return body;
+      if (URLSearchParamsCtor && body instanceof URLSearchParamsCtor) {
+        if (!headers['Content-Type'] && !headers['content-type']) {
+          headers['Content-Type'] = 'application/x-www-form-urlencoded;charset=UTF-8';
+        }
+        return body.toString();
+      }
+      if (FormDataCtor && body instanceof FormDataCtor) {
+        const enc = encodeMultipart(body);
+        if (!headers['Content-Type'] && !headers['content-type']) {
+          headers['Content-Type'] = enc.contentType;
+        }
+        return enc.body;
+      }
+      // ArrayBuffer / TypedArray — best-effort to a Latin-1 string
+      if (body && body.byteLength != null) {
+        const view = body.buffer ? new Uint8Array(body.buffer, body.byteOffset || 0, body.byteLength) : new Uint8Array(body);
+        let s = '';
+        for (let i = 0; i < view.length; i++) s += String.fromCharCode(view[i]);
+        return s;
+      }
+      return String(body);
+    }
+
+    win.fetch = function (input, init) {
+      return new Promise((resolve, reject) => {
+        try {
+          let url, method = 'GET', headers = {}, body = null, signal = null;
+          if (input && typeof input === 'object' && input.url) {
+            url = input.url;
+            method = input.method || 'GET';
+            try { for (const [k, v] of input.headers) headers[k] = v; } catch (_) {}
+          } else {
+            url = String(input);
+          }
+          if (init) {
+            if (init.method) method = init.method;
+            for (const [k, v] of headerEntries(init.headers)) headers[k] = v;
+            if (init.body != null) body = init.body;
+            if (init.signal) signal = init.signal;
+          }
+          if (signal && signal.aborted) {
+            return reject(new DOMExceptionCtor('The operation was aborted.', 'AbortError'));
+          }
+          const serialized = serializeBody(body, headers);
+          const result = globalThis.__csim_fetch(method.toUpperCase(), url, headers, serialized);
+          if (!result) return reject(new TypeError('fetch failed'));
+          if (result.error) return reject(new TypeError(String(result.error)));
+          const respHeaders = new HeadersCtor();
+          const rh = result.headers || {};
+          for (const k of Object.keys(rh)) {
+            const v = rh[k];
+            const parts = typeof v === 'string' ? v.split('\n') : (Array.isArray(v) ? v : [String(v)]);
+            for (const part of parts) {
+              try { respHeaders.append(k, part); } catch (_) {}
+            }
+          }
+          const r = new ResponseCtor(result.body == null ? '' : result.body, {
+            status: result.status || 200,
+            statusText: result.statusText || '',
+            headers: respHeaders
+          });
+          try { Object.defineProperty(r, 'url', {value: result.finalUrl || url, configurable: true}); } catch (_) {}
+          try { Object.defineProperty(r, 'redirected', {value: !!result.redirected, configurable: true}); } catch (_) {}
+          resolve(r);
+        } catch (e) {
+          reject(e);
+        }
+      });
+    };
+  }
+
+  function visibleAncestorChainOk(el) {
+    let cur = el;
+    while (cur && cur.nodeType === 1) {
+      if (isHidden(cur)) return false;
+      // Inside a closed <details>, only the <summary> branch is visible.
+      if ((cur.tagName || '').toUpperCase() === 'DETAILS' &&
+          !boolPropOrAttr(cur, 'open')) {
+        // Walk back from el to cur; if we passed a <summary> on the way,
+        // this branch stays visible.
+        let probe = el;
+        while (probe && probe !== cur) {
+          if ((probe.tagName || '').toUpperCase() === 'SUMMARY') return true;
+          probe = probe.parentNode;
+        }
+        return false;
+      }
+      cur = cur.parentNode;
+    }
+    return true;
+  }
+
+  function isHidden(el) {
+    if (!el || el.nodeType !== 1) return false;
+    const tag = (el.tagName || '').toLowerCase();
+    if (tag === 'script' || tag === 'style' || tag === 'head' || tag === 'title' ||
+        tag === 'noscript' || tag === 'template') return true;
+    if (el.hidden) return true;
+    if (el.type === 'hidden') return true;
+    const style = el.getAttribute && el.getAttribute('style');
+    if (style && /display\s*:\s*none/i.test(style)) return true;
+    if (style && /visibility\s*:\s*hidden/i.test(style)) return true;
+    // Stylesheet-driven hiding: consult getComputedStyle so CSS rules
+    // (`.hidden_until_hover { display: none }` and the like) are seen.
+    if (currentWindow && currentWindow.getComputedStyle) {
+      try {
+        const cs = currentWindow.getComputedStyle(el);
+        if (cs && (cs.display === 'none' || cs.visibility === 'hidden')) return true;
+      } catch (_) {}
+    }
+    return false;
+  }
+
+  function visibleTextOf(el, opts) {
+    if (!el) return '';
+    if (el.nodeType === 3) {
+      let tc = el.textContent || '';
+      // CSS whitespace collapsing: runs of whitespace (incl. newlines)
+      // become a single space, except inside <pre>/<textarea> contexts
+      // where the caller signals to preserve whitespace via opts.pre.
+      if (!(opts && opts.pre)) tc = tc.replace(/[ \t\r\n\f]+/g, ' ');
+      const tt = opts && opts.textTransform;
+      if (tt === 'uppercase') tc = tc.toUpperCase();
+      else if (tt === 'lowercase') tc = tc.toLowerCase();
+      else if (tt === 'capitalize') tc = tc.replace(/(?:^|\s)\S/g, c => c.toUpperCase());
+      return tc;
+    }
+    // DocumentFragment / ShadowRoot / Document: descend into children.
+    if (el.nodeType === 9 || el.nodeType === 11) {
+      const parts = [];
+      for (const child of el.childNodes || []) parts.push(visibleTextOf(child, opts));
+      return parts.join('');
+    }
+    if (el.nodeType !== 1) return '';
+    if (isHidden(el)) return '';
+    const tag = (el.tagName || '').toLowerCase();
+    let childOpts = opts;
+    const pre = (opts && opts.pre) || tag === 'pre' || tag === 'textarea';
+    const style = el.getAttribute && el.getAttribute('style');
+    let tt = opts && opts.textTransform;
+    if (style) {
+      const m = /text-transform\s*:\s*(uppercase|lowercase|capitalize|none)/i.exec(style);
+      if (m) tt = m[1].toLowerCase() === 'none' ? null : m[1].toLowerCase();
+    }
+    if (pre !== !!(opts && opts.pre) || tt !== (opts && opts.textTransform)) {
+      childOpts = {pre, textTransform: tt};
+    }
+    const parts = [];
+    for (const child of el.childNodes) parts.push(visibleTextOf(child, childOpts));
+    let out = parts.join('');
+    const block = ['p','div','section','article','header','footer','nav','aside',
+                   'h1','h2','h3','h4','h5','h6','ul','ol','li','tr','td','th',
+                   'pre','address','blockquote','dl','dt','dd','fieldset','form',
+                   'hr','table','br'];
+    if (block.includes(tag)) {
+      // Only mark block boundaries when the block actually contributes
+      // text — otherwise empty wrappers (e.g. shadow hosts) break inline
+      // adjacency between their siblings.
+      if (tag === 'br' || /[^\s]/.test(out)) out = '\n' + out + '\n';
+    }
+    return out;
+  }
+
+  function buildXPath(el) {
+    if (!el || el.nodeType !== 1) return '';
+    // Elements rooted in a ShadowRoot have no XPath in the host document;
+    // Capybara expects the same sentinel as real browsers' driver code.
+    let probe = el;
+    while (probe) {
+      if (probe.nodeType === 11 && probe.host) return '(: Shadow DOM element - no XPath :)';
+      probe = probe.parentNode;
+    }
+    const segments = [];
+    let cur = el;
+    while (cur && cur.nodeType === 1) {
+      const tag = (cur.tagName || '').toLowerCase();
+      let index = 1;
+      let sib = cur.previousSibling;
+      while (sib) {
+        if (sib.nodeType === 1 && (sib.tagName || '').toLowerCase() === tag) index++;
+        sib = sib.previousSibling;
+      }
+      segments.unshift(tag + '[' + index + ']');
+      cur = cur.parentNode;
+      if (cur && cur.nodeType === 9) break;
+    }
+    return '/' + segments.join('/');
+  }
+
+  function boolPropOrAttr(el, name) {
+    if (!el) return false;
+    if (el[name] === true) return true;
+    if (el[name] !== undefined && el[name] !== null && el[name] !== false) return true;
+    if (el.hasAttribute && el.hasAttribute(name.toLowerCase())) return true;
+    return false;
+  }
+  function isMultipleSelect(el) { return boolPropOrAttr(el, 'multiple'); }
+
+  // True when a link's load should be handled by Turbo's FrameController:
+  // it lives inside a `<turbo-frame>` ancestor, none of its closer
+  // ancestors / submitters opted out via `data-turbo="false"` or
+  // `data-turbo-frame="_top"`. Used to decide whether the runtime
+  // should do its own Rack navigate after a click whose default got
+  // preventDefaulted.
+  function isFrameScopedLink(el) {
+    const frame = el.closest && el.closest('turbo-frame');
+    if (!frame) return false;
+    const turboFrameAttr = el.getAttribute && el.getAttribute('data-turbo-frame');
+    if (turboFrameAttr === '_top') return false;
+    const turboAttr = el.closest && el.closest('[data-turbo]');
+    if (turboAttr && turboAttr.getAttribute('data-turbo') === 'false') return false;
+    return true;
+  }
+
+  function makeEvent(type, opts) {
+    const init = Object.assign({bubbles: true, cancelable: true}, opts || {});
+    const Ctor = (currentWindow && currentWindow.MouseEvent && /click|mouse|dblclick|contextmenu/.test(type))
+      ? currentWindow.MouseEvent
+      : (currentWindow && currentWindow.KeyboardEvent && /key/.test(type))
+        ? currentWindow.KeyboardEvent
+        : (currentWindow && currentWindow.FocusEvent && /focus|blur/.test(type))
+          ? currentWindow.FocusEvent
+          : currentWindow.Event;
+    return new Ctor(type, init);
+  }
+
+  // Resolve the form an input/button is bound to, honouring the HTML5
+  // `form="<id>"` attribute. happy-dom's `el.form` only returns an
+  // ancestor form, so we look up by id when the attribute is set.
+  function formForControl(el) {
+    if (!el) return null;
+    const fid = el.getAttribute && el.getAttribute('form');
+    if (fid) {
+      const byId = currentDocument.getElementById(fid);
+      if (byId && (byId.tagName || '').toUpperCase() === 'FORM') return byId;
+    }
+    return el.form || (el.closest && el.closest('form'));
+  }
+
+  function countSubmittableTextInputs(form) {
+    let n = 0;
+    for (const el of form.querySelectorAll('input')) {
+      const t = (el.type || (el.getAttribute && el.getAttribute('type')) || 'text').toLowerCase();
+      if (/^(text|email|number|search|tel|url|password|date|time|datetime-local|month|week|color|range)$/.test(t)) {
+        n++;
+      }
+    }
+    return n;
+  }
+
+  function fieldsFromForm(form, submitter) {
+    const out = [];
+    // Build the list in document order. happy-dom's `form.elements` does
+    // not always include form-attribute associated controls, so collect
+    // both the directly contained controls and any document-wide controls
+    // bound via `form="<id>"`, then sort them by source position.
+    const formId = form.getAttribute && form.getAttribute('id');
+    const els = new Set();
+    for (const el of form.querySelectorAll('input,textarea,select,button')) {
+      if (!el.hasAttribute('form') || el.getAttribute('form') === formId) {
+        els.add(el);
+      }
+    }
+    if (formId) {
+      for (const el of currentDocument.querySelectorAll(
+          `input[form="${cssEscape(formId)}"], textarea[form="${cssEscape(formId)}"], ` +
+          `select[form="${cssEscape(formId)}"], button[form="${cssEscape(formId)}"]`)) {
+        els.add(el);
+      }
+    }
+    const ordered = Array.from(els);
+    ordered.sort((a, b) => {
+      const pos = a.compareDocumentPosition && a.compareDocumentPosition(b);
+      if (pos & 0x04) return -1;   // a precedes b
+      if (pos & 0x02) return 1;    // b precedes a
+      return 0;
+    });
+    for (const el of ordered) {
+      if (!el.name) continue;
+      if (boolPropOrAttr(el, 'disabled')) continue;
+      const tag = (el.tagName || '').toUpperCase();
+      const type = (el.type || (el.getAttribute && el.getAttribute('type')) || '').toLowerCase();
+      if (tag === 'BUTTON' || type === 'submit' || type === 'image' || type === 'reset') {
+        if (el !== submitter) continue;
+        if (type === 'reset') continue;
+        out.push([el.name, el.value || '']);
+        continue;
+      }
+      if (type === 'checkbox' || type === 'radio') {
+        // `checked` is the IDL property reflecting live state. Don't fall
+        // back to `hasAttribute('checked')` here — that's the *default*
+        // state used by form reset, and Stimulus controllers commonly
+        // toggle the property directly (`el.checked = false`) without
+        // touching the attribute. Reading the attribute would cause the
+        // serializer to submit unchecked boxes as if they were on.
+        if (el.checked === true) {
+          const v = el.getAttribute && el.getAttribute('value');
+          out.push([el.name, v == null ? 'on' : v]);
+        }
+        continue;
+      }
+      if (tag === 'SELECT') {
+        const opts = Array.from(el.options || []);
+        if (opts.length === 0) continue; // unfillable, do not submit
+        if (isMultipleSelect(el)) {
+          for (const opt of opts) {
+            if (boolPropOrAttr(opt, 'selected')) out.push([el.name, opt.value || '']);
+          }
+          continue;
+        }
+        const sel = opts.find(o => boolPropOrAttr(o, 'selected')) || opts[0];
+        out.push([el.name, sel.value || '']);
+        continue;
+      }
+      if (type === 'file') {
+        const files = el.__csim_files || [];
+        if (files.length === 0) {
+          // Empty file inputs still appear in multipart bodies as empty
+          // file parts in real browsers. The Ruby side decides whether to
+          // emit them based on enctype.
+          out.push([el.name, {file: true, paths: []}]);
+        } else {
+          out.push([el.name, {file: true, paths: files.slice()}]);
+        }
+        continue;
+      }
+      let v = el.value == null ? '' : String(el.value);
+      if (tag === 'TEXTAREA') {
+        // Strip the single leading newline that HTML5 stripped from the
+        // initial textarea content — only when the driver has not been
+        // asked to set the value (otherwise the user's own leading
+        // newline must round-trip).
+        if (!el.__csim_user_set) {
+          if (v.startsWith('\r\n')) v = v.slice(2);
+          else if (v.startsWith('\n')) v = v.slice(1);
+        }
+        // Submit with CRLF line endings per HTML5.
+        v = v.replace(/\r?\n/g, '\r\n');
+      }
+      out.push([el.name, v]);
+    }
+    return out;
+  }
+
+  function submitDescriptor(form, submitter, options) {
+    // happy-dom auto-dispatches a `submit` event when an INPUT/BUTTON of
+    // type=submit is clicked (via form.requestSubmit). When we land here
+    // through that path, dispatching another submit event creates a
+    // duplicate without the `submitter` field — Turbo's FormSubmitObserver
+    // sees the second one and intercepts even when the original submitter
+    // had `data-turbo="false"`. Skip our dispatch in that case and rely on
+    // the prevented flag the click path captured. Keep dispatching for
+    // direct `submit(id)` calls and implicit-submit-on-Enter where no
+    // upstream submit event has fired yet.
+    const skipDispatch = options && options.skipDispatch;
+    const alreadyPrevented = !!(options && options.prevented);
+    if (!skipDispatch) {
+      const evt = makeEvent('submit', {submitter: submitter || undefined});
+      if (!form.dispatchEvent(evt)) return {action: 'none'};
+    } else if (alreadyPrevented) {
+      return {action: 'none'};
+    }
+    // The button's formaction/formmethod/formenctype override the form's
+    // attributes when present (HTML5 spec).
+    const fa = (submitter && submitter.getAttribute && submitter.getAttribute('formaction'));
+    const fm = (submitter && submitter.getAttribute && submitter.getAttribute('formmethod'));
+    const fe = (submitter && submitter.getAttribute && submitter.getAttribute('formenctype'));
+    return {
+      action: 'submit',
+      url: fa || form.getAttribute('action') || '',
+      method: (fm || form.getAttribute('method') || 'GET').toUpperCase(),
+      enctype: fe || form.getAttribute('enctype') || 'application/x-www-form-urlencoded',
+      fields: fieldsFromForm(form, submitter)
+    };
+  }
+
+  function unwrapScriptArgs(args) {
+    return args.map((a) => {
+      if (a && typeof a === 'object' && '__csim_handle' in a) return lookup(a.__csim_handle);
+      return a;
+    });
+  }
+  function wrapScriptResult(value) {
+    if (value && typeof value === 'object' && value.nodeType === 1) {
+      return {__csim_handle: track(value)};
+    }
+    if (Array.isArray(value)) return value.map(wrapScriptResult);
+    return value;
+  }
+
+  function attachInlineHandlers(root) {
+    const all = root.querySelectorAll('*');
+    for (const el of all) {
+      if (!el.attributes) continue;
+      for (const attr of Array.from(el.attributes)) {
+        if (!attr.name || !attr.name.startsWith('on')) continue;
+        const eventName = attr.name.slice(2);
+        const body = attr.value || '';
+        if (!body) continue;
+        try {
+          const fn = new Function('event', body);
+          el.addEventListener(eventName, function (event) {
+            try { fn.call(this, event); }
+            catch (_) {}
+          });
+        } catch (_) {}
+      }
+    }
+  }
+
+  // Walk the document for focusable elements (anchors with href, form
+  // controls that aren't disabled or hidden, anything with a non-negative
+  // tabindex) and advance the active element to the next one in tab
+  // order. happy-dom doesn't ship Tab navigation, so each `send_keys(:tab)`
+  // call would otherwise be a no-op for `document.activeElement`.
+  function advanceFocus(_from, reverse) {
+    if (!currentDocument) return;
+    const cands = Array.from(currentDocument.querySelectorAll(
+      'a[href], button, input:not([type=hidden]), select, textarea, [tabindex]'
+    )).filter((el) => {
+      if (el.disabled) return false;
+      const ti = el.getAttribute('tabindex');
+      if (ti && parseInt(ti, 10) < 0) return false;
+      // Hidden elements can't take focus.
+      if (typeof el.offsetParent !== 'undefined' && el.offsetParent === null && el.tagName !== 'BODY') {
+        // happy-dom returns null for everything (no layout), so don't
+        // exclude on offsetParent alone — fall through.
+      }
+      return true;
+    });
+    const positiveTab = (el) => {
+      const ti = parseInt(el.getAttribute('tabindex') || '0', 10);
+      return ti > 0 ? ti : null;
+    };
+    const indexed = cands.filter((el) => positiveTab(el) !== null)
+      .map((el, i) => ({el, ti: positiveTab(el), i}))
+      .sort((a, b) => a.ti - b.ti || a.i - b.i)
+      .map((x) => x.el);
+    const natural = cands.filter((el) => positiveTab(el) === null);
+    const ordered = indexed.concat(natural);
+    if (reverse) ordered.reverse();
+    if (ordered.length === 0) return;
+    const cur = currentDocument.activeElement;
+    const at = ordered.indexOf(cur);
+    const next = ordered[(at >= 0 && at + 1 < ordered.length) ? at + 1 : 0];
+    if (next && typeof next.focus === 'function') {
+      next.focus();
+      activeHandleId = track(next);
+    }
+  }
+
+  // ---- send_keys helpers ------------------------------------------------
+  function isModifier(name) {
+    return name === 'Shift' || name === 'Control' || name === 'Alt' || name === 'Meta';
+  }
+  function isSpecialKey(name) {
+    return name.length > 1 && /^[A-Z]/.test(name);
+  }
+  function modifierProp(name) {
+    return ({Shift: 'shiftKey', Control: 'ctrlKey', Alt: 'altKey', Meta: 'metaKey'})[name];
+  }
+  function keyForEvent(name, opts) {
+    if (isSpecialKey(name)) return name;
+    if (opts && opts.shiftKey) return name.toUpperCase();
+    return name;
+  }
+  function keyCodeFor(name) {
+    if (isModifier(name)) return ({Shift: 16, Control: 17, Alt: 18, Meta: 91})[name];
+    if (name === 'Enter') return 13;
+    if (name === 'Tab') return 9;
+    if (name === 'Backspace') return 8;
+    if (name === 'Delete') return 46;
+    if (name === 'Escape') return 27;
+    if (name === ' ') return 32;
+    if (name === 'ArrowLeft') return 37;
+    if (name === 'ArrowUp') return 38;
+    if (name === 'ArrowRight') return 39;
+    if (name === 'ArrowDown') return 40;
+    if (name === 'Home') return 36;
+    if (name === 'End') return 35;
+    if (name === 'PageUp') return 33;
+    if (name === 'PageDown') return 34;
+    if (name.length === 1) {
+      const c = name.toUpperCase().charCodeAt(0);
+      if (c >= 48 && c <= 57) return c;        // 0-9
+      if (c >= 65 && c <= 90) return c;        // A-Z
+      return name.charCodeAt(0);
+    }
+    return 0;
+  }
+  function keyCodeName(name) {
+    if (isModifier(name)) return name === 'Meta' ? 'MetaLeft' : (name + 'Left');
+    if (name === 'Enter') return 'Enter';
+    if (name === 'Tab') return 'Tab';
+    if (name === 'Backspace') return 'Backspace';
+    if (name === 'Delete') return 'Delete';
+    if (name === 'Escape') return 'Escape';
+    if (name === ' ') return 'Space';
+    if (/^Arrow/.test(name)) return name;
+    if (name.length === 1) {
+      const ch = name.toUpperCase();
+      if (ch >= '0' && ch <= '9') return 'Digit' + ch;
+      if (ch >= 'A' && ch <= 'Z') return 'Key' + ch;
+    }
+    return name;
+  }
+
+  function drainTimers(ms) {
+    if (typeof globalThis.__csim_runTimers === 'function') {
+      try { globalThis.__csim_runTimers(ms); } catch (_) {}
+    }
+  }
+
+  // happy-dom has no layout engine, so getBoundingClientRect always returns
+  // (0,0,0,0). We approximate the box for click-offset routing by reading
+  // computed `top`/`left`/`width`/`height` (in px) from the element and
+  // each ancestor. Falls back to inline `style.*` if the computed value is
+  // unset. Anything beyond simple px positioning yields 0, which is a
+  // truthful signal that we cannot resolve geometry for the element.
+  function pxValue(v) {
+    if (v == null) return 0;
+    const m = String(v).match(/^(-?\d+(?:\.\d+)?)/);
+    if (!m) return 0;
+    const n = parseFloat(m[1]);
+    return isFinite(n) ? n : 0;
+  }
+  function readPx(el, computed, prop) {
+    let v = computed && computed[prop];
+    if (!v || v === 'auto') v = el.style && el.style[prop];
+    return pxValue(v);
+  }
+  function simRect(el) {
+    const win = currentWindow;
+    if (!el || !win) return {x: 0, y: 0, width: 0, height: 0};
+    let cs = null;
+    try { cs = win.getComputedStyle(el); } catch (_) {}
+    const width  = readPx(el, cs, 'width');
+    const height = readPx(el, cs, 'height');
+    let x = 0, y = 0, cur = el;
+    while (cur && cur.nodeType === 1) {
+      let ccs = null;
+      try { ccs = win.getComputedStyle(cur); } catch (_) {}
+      x += readPx(cur, ccs, 'left');
+      y += readPx(cur, ccs, 'top');
+      cur = cur.parentElement;
+    }
+    return {x, y, width, height};
+  }
+
+  // Translate an offset-style click descriptor (`offsetX`, `offsetY`,
+  // `w3cOffset`) into absolute clientX/clientY using the simulated rect.
+  // Mutates `m` in place. With no offset given, click lands at the
+  // element's center; rect collapses to (0,0,0,0) for elements we cannot
+  // resolve, so the click defaults to the document origin in that case.
+  function applyClickOffset(el, m) {
+    const hasOffset = ('offsetX' in m) || ('offsetY' in m);
+    const w3c = !!m.w3cOffset;
+    delete m.w3cOffset;
+    const ox = m.offsetX; delete m.offsetX;
+    const oy = m.offsetY; delete m.offsetY;
+    if ('clientX' in m && 'clientY' in m) return;
+    const r = simRect(el);
+    const baseX = r.x + (w3c || !hasOffset ? r.width  / 2 : 0);
+    const baseY = r.y + (w3c || !hasOffset ? r.height / 2 : 0);
+    m.clientX = baseX + (Number(ox) || 0);
+    m.clientY = baseY + (Number(oy) || 0);
+  }
+
+  globalThis.__csim = {
+    loadHTML(html, url) {
+      resetState();
+      // Wipe globals that scripts may have published on the previous Window
+      // so that re-loading e.g. jQuery on the next page starts from a clean
+      // slate. Without this, jQuery's `isReady` carries over and ready
+      // callbacks never fire on subsequent visits.
+      const STALE = ['jQuery', '$', 'jquery', 'JQuery'];
+      for (const k of STALE) {
+        try { delete globalThis[k]; } catch (_) { globalThis[k] = undefined; }
+      }
+      const win = new Window({url: url || 'http://www.example.com/'});
+      patchWindowGlobals(win);
+      installFetchShim(win);
+      installCustomElementUpgrade(win);
+      installDocumentEvaluate(win.document);
+      installHistoryTracking(win);
+      currentWindow = win;
+      currentDocument = win.document;
+      // Prefer happy-dom's incremental innerHTML parser — it preserves
+      // form-attribute ordering and other quirks the spec relies on. Some
+      // real-world Rails/Turbo pages trip an internal "insertBefore: new
+      // node is a parent of the node to insert to" DOMException there;
+      // when that happens, fall back to DOMParser, which builds a fresh
+      // Document and we adopt its <head>/<body>. The DOMParser path
+      // reorders some form-associated controls so we only use it when
+      // the primary path fails outright.
+      const raw = html || '<html><body></body></html>';
+      try {
+        win.document.documentElement.innerHTML = stripDoctype(raw);
+      } catch (_parserErr) {
+        const parsed = new win.DOMParser().parseFromString(raw, 'text/html');
+        const dstHead = win.document.head;
+        const dstBody = win.document.body;
+        while (dstHead.firstChild) dstHead.removeChild(dstHead.firstChild);
+        while (dstBody.firstChild) dstBody.removeChild(dstBody.firstChild);
+        if (parsed.head) {
+          for (const child of Array.from(parsed.head.childNodes)) dstHead.appendChild(child);
+        }
+        if (parsed.body) {
+          for (const child of Array.from(parsed.body.childNodes)) dstBody.appendChild(child);
+          for (const attr of Array.from(parsed.body.attributes || [])) {
+            try { dstBody.setAttribute(attr.name, attr.value); } catch (_) {}
+          }
+        }
+        if (parsed.documentElement) {
+          for (const attr of Array.from(parsed.documentElement.attributes || [])) {
+            try { win.document.documentElement.setAttribute(attr.name, attr.value); } catch (_) {}
+          }
+        }
+      }
+      // Mirror onto globalThis so user scripts (eval/Function) can reach the
+      // active document without naming the window explicitly. The Proxy
+      // mirrors property writes — `window.Turbo = ...` (a common Rails
+      // turbo-rails pattern) needs `globalThis.Turbo` to appear too,
+      // because in a real browser `globalThis === window`.
+      globalThis.window = new Proxy(win, {
+        set(target, key, value) {
+          try { target[key] = value; } catch (_) {}
+          try { globalThis[key] = value; } catch (_) {}
+          return true;
+        },
+        get(target, key) {
+          return target[key];
+        },
+        has(target, key) {
+          return key in target;
+        }
+      });
+      globalThis.document = win.document;
+      globalThis.location = win.location;
+      globalThis.history = win.history;
+      globalThis.alert = win.alert;
+      globalThis.confirm = win.confirm;
+      globalThis.prompt = win.prompt;
+      globalThis.fetch  = win.fetch.bind(win);
+      globalThis.Response = win.Response;
+      globalThis.Request  = win.Request;
+      globalThis.Headers  = win.Headers;
+      // Module bundles eval at the top level (globalThis), not inside the
+      // window. Mirror the page-level globals user code typically expects
+      // so Turbo / Stimulus / arbitrary libraries find them without
+      // having to namespace through `window`.
+      globalThis.requestAnimationFrame = win.requestAnimationFrame;
+      globalThis.cancelAnimationFrame  = win.cancelAnimationFrame;
+      globalThis.MutationObserver = win.MutationObserver;
+      globalThis.IntersectionObserver = win.IntersectionObserver || function () {
+        return {observe() {}, unobserve() {}, disconnect() {}, takeRecords() { return []; }};
+      };
+      globalThis.ResizeObserver = win.ResizeObserver || function () {
+        return {observe() {}, unobserve() {}, disconnect() {}};
+      };
+      globalThis.CustomEvent = win.CustomEvent;
+      globalThis.Event       = win.Event;
+      globalThis.EventTarget = win.EventTarget;
+      globalThis.HTMLElement = win.HTMLElement;
+      globalThis.Element     = win.Element;
+      globalThis.Node        = win.Node;
+      globalThis.DOMParser   = win.DOMParser;
+      globalThis.FormData    = win.FormData;
+      globalThis.URL         = win.URL || globalThis.URL;
+      globalThis.URLSearchParams = win.URLSearchParams || globalThis.URLSearchParams;
+      globalThis.AbortController = win.AbortController;
+      globalThis.AbortSignal     = win.AbortSignal;
+      globalThis.navigator = win.navigator;
+      globalThis.customElements = win.customElements;
+      globalThis.HTMLElement = win.HTMLElement;
+      // mini_racer has no host module loader, so dynamic `import()` is
+      // rewritten to `globalThis.__csim_import` by the bundler. The
+      // registry is populated by per-module assignments emitted in the
+      // bundle body, but those run *after* the static-import evaluation
+      // phase — and that is the same phase where library code (e.g.
+      // stimulus-loading's `eagerLoadControllersFrom`) calls dynamic
+      // `import()`. To handle that ordering, every call before drain
+      // is queued; we resolve the queue once the bundle has finished
+      // evaluating and the registry is populated.
+      globalThis.__csim_modules = {};
+      globalThis.__csim_pending_imports = [];
+      globalThis.__csim_import = function (specifier) {
+        const mod = globalThis.__csim_modules[specifier];
+        if (mod) return Promise.resolve(mod);
+        return new Promise(function (resolve, reject) {
+          globalThis.__csim_pending_imports.push({specifier, resolve, reject});
+        });
+      };
+      globalThis.__csim_drain_imports = function () {
+        const queue = globalThis.__csim_pending_imports;
+        globalThis.__csim_pending_imports = [];
+        for (const {specifier, resolve, reject} of queue) {
+          const mod = globalThis.__csim_modules[specifier];
+          if (mod) resolve(mod);
+          else reject(new Error('capybara-simulated: dynamic import not pre-bundled: ' + specifier));
+        }
+      };
+      // Turbo's `extractForeignFrameElement` calls `CSS.escape(id)` to
+      // build a selector. happy-dom doesn't expose CSS yet — provide a
+      // minimal shim covering the identifier-safe subset.
+      globalThis.CSS = globalThis.CSS || win.CSS || {
+        escape(s) {
+          return String(s).replace(/[^a-zA-Z0-9_ -￿-]/g, (c) => '\\' + c);
+        }
+      };
+      // Bound event-target methods so libraries can do
+      // `addEventListener('DOMContentLoaded', ...)` at top level. Real
+      // browsers expose these because globalThis === window; we have to
+      // forward them explicitly.
+      globalThis.addEventListener    = win.addEventListener.bind(win);
+      globalThis.removeEventListener = win.removeEventListener.bind(win);
+      globalThis.dispatchEvent       = win.dispatchEvent.bind(win);
+      globalThis.matchMedia          = win.matchMedia ? win.matchMedia.bind(win) : (() => ({matches: false, media: '', addListener() {}, removeListener() {}, addEventListener() {}, removeEventListener() {}, dispatchEvent() { return false; }}));
+      globalThis.getComputedStyle    = win.getComputedStyle.bind(win);
+      globalThis.scrollTo            = () => {};
+      globalThis.scrollBy            = () => {};
+      globalThis.innerWidth  = win.innerWidth  || 1024;
+      globalThis.innerHeight = win.innerHeight || 768;
+      return true;
+    },
+
+    runInlineScripts() {
+      if (!currentDocument) return;
+      const scripts = currentDocument.querySelectorAll('script:not([src])');
+      const sources = [];
+      for (const s of scripts) sources.push(s.textContent || '');
+      for (const code of sources) {
+        try { (0, eval)(code); } catch (_) {}
+      }
+      attachInlineHandlers(currentDocument);
+      syncWindowGlobals();
+      fireReadyEvents();
+    },
+
+    syncWindowGlobals() { syncWindowGlobals(); },
+
+    externalScriptSources() {
+      if (!currentDocument) return [];
+      const out = [];
+      // Skip type="module" — those are handled separately via
+      // `moduleScriptDetails` so the Ruby driver can run them through
+      // esbuild instead of treating them as classic scripts.
+      for (const s of currentDocument.querySelectorAll('script[src]:not([type="module"])')) {
+        const t = (s.getAttribute('type') || '').toLowerCase();
+        if (t && t !== 'text/javascript' && t !== 'application/javascript') continue;
+        const src = s.getAttribute('src');
+        if (src) out.push(src);
+      }
+      return out;
+    },
+
+    // Collect everything the Ruby module loader needs in one round-trip:
+    // the importmap JSON (inline only — Rails always inlines it) and the
+    // ordered list of `<script type="module">` entries with either
+    // `inline` source or `src`. Returns null when the page has no module
+    // scripts so the Ruby side can short-circuit.
+    moduleScriptDetails() {
+      if (!currentDocument) return null;
+      const out = {importmap: '', entries: []};
+      const im = currentDocument.querySelector('script[type="importmap"]');
+      if (im) out.importmap = im.textContent || '';
+      const mods = currentDocument.querySelectorAll('script[type="module"]');
+      for (const s of mods) {
+        const src = s.getAttribute('src');
+        if (src) out.entries.push({src});
+        else if (s.textContent && s.textContent.trim()) out.entries.push({inline: s.textContent});
+      }
+      if (!out.importmap && out.entries.length === 0) return null;
+      return out;
+    },
+
+    pushModalHandler(handler) {
+      modalHandlers.push(handler);
+      return true;
+    },
+    popModalHandler(type, text) {
+      const sameText = (a, b) => {
+        if (a == null && b == null) return true;
+        if (typeof a === 'string' && typeof b === 'string') return a === b;
+        if (a && b && typeof a === 'object' && typeof b === 'object' && a.regexp === b.regexp) return true;
+        return false;
+      };
+      const idx = modalHandlers.findIndex((h) => h.type === type && sameText(h.text, text));
+      if (idx >= 0) modalHandlers.splice(idx, 1);
+      return true;
+    },
+
+    setModalResponses(responses) {
+      modalResponses = {
+        alert:   (responses && responses.alert)   || [],
+        confirm: (responses && responses.confirm) || [],
+        prompt:  (responses && responses.prompt)  || []
+      };
+      return true;
+    },
+
+    drainModalQueue() {
+      const out = modalQueue.slice();
+      modalQueue.length = 0;
+      return out;
+    },
+
+    evaluate(code, args) {
+      const params = unwrapScriptArgs(Array.isArray(args) ? args : []);
+      // Strip trailing semicolons / whitespace so `(...);` style scripts
+      // still parse when wrapped in `return (...)`.
+      const stripped = String(code).replace(/[;\s]+$/, '');
+      try {
+        const fn = new Function('return (' + stripped + ');');
+        return wrapScriptResult(fn.apply(currentWindow, params));
+      } catch (_) {
+        const fn = new Function(code);
+        return wrapScriptResult(fn.apply(currentWindow, params));
+      }
+    },
+    executeScript(code, args) {
+      const params = unwrapScriptArgs(Array.isArray(args) ? args : []);
+      const fn = new Function(code);
+      fn.apply(currentWindow, params);
+      return null;
+    },
+
+    // The user script receives a callback as its final argument and is
+    // expected to invoke it (synchronously or asynchronously) with the
+    // result. The Ruby side drives the virtual clock between polls until
+    // the callback fires or the wait budget runs out.
+    startAsync(code, args) {
+      const params = unwrapScriptArgs(Array.isArray(args) ? args : []);
+      asyncSlot = {done: false};
+      const slot = asyncSlot;
+      const callback = (value) => {
+        if (slot.done) return;
+        slot.done = true;
+        slot.value = value;
+      };
+      try {
+        const fn = new Function(code);
+        fn.apply(currentWindow, params.concat([callback]));
+      } catch (e) {
+        slot.done = true;
+        slot.error = String((e && e.stack) || e);
+      }
+      return true;
+    },
+    pollAsync() {
+      const slot = asyncSlot;
+      if (!slot) return {done: true, error: 'no async script in flight'};
+      if (!slot.done) return {done: false};
+      asyncSlot = null;
+      if ('error' in slot) return {done: true, error: slot.error};
+      return {done: true, value: wrapScriptResult(slot.value)};
+    },
+
+    html() {
+      if (!currentDocument || !currentDocument.documentElement) return '';
+      return String('<!doctype html>' + currentDocument.documentElement.outerHTML);
+    },
+    title() {
+      if (!currentDocument) return '';
+      // Prefer the raw `<title>` text content so leading/trailing
+      // whitespace round-trips through Capybara's title matchers.
+      const t = currentDocument.querySelector && currentDocument.querySelector('title');
+      if (t && t.textContent != null) return String(t.textContent);
+      return String(currentDocument.title || '');
+    },
+
+    findXPath(xpath, contextId) {
+      if (!currentDocument) return [];
+      const root = contextId ? lookup(contextId) : (currentDocument.documentElement || currentDocument);
+      try {
+        const nodes = evaluateXPathToNodes(xpath, root, xpathDomFacade, null, {
+          // happy-dom places elements in the XHTML namespace.
+          namespaceResolver: () => 'http://www.w3.org/1999/xhtml'
+        });
+        return nodes.map(track);
+      } catch (e) {
+        return findViaXPathFallback(xpath, root);
+      }
+    },
+    findCSS(css, contextId) {
+      if (!currentDocument) return [];
+      const root = contextId ? lookup(contextId) : currentDocument;
+      if (!root || !root.querySelectorAll) return [];
+      const matches = root.querySelectorAll(rewriteCSS(css));
+      const ids = [];
+      for (const el of matches) ids.push(track(el));
+      return ids;
+    },
+
+    tagName(id) {
+      const node = lookup(id);
+      // ShadowRoot has nodeType 11 with no tagName; Capybara's element
+      // inspect formatter expects a string here.
+      if (node && node.nodeType === 11) return 'ShadowRoot';
+      return String((node.tagName || '').toLowerCase());
+    },
+    innerHTML(id)   { return String(lookup(id).innerHTML || ''); },
+    outerHTML(id)   { return String(lookup(id).outerHTML || ''); },
+    attr(id, name) {
+      const el = lookup(id);
+      if (el.hasAttribute(name)) return el.getAttribute(name);
+      // Capybara's `node[:validationMessage]` and friends expect the IDL
+      // property when no matching HTML attribute exists — Selenium's
+      // attribute() does the same fallback. Returning null here would
+      // hide computed values (validationMessage, validity, etc.).
+      const direct = el[name];
+      if (direct === undefined) return null;
+      if (direct === null || typeof direct === 'string' || typeof direct === 'boolean' || typeof direct === 'number') {
+        return direct;
+      }
+      return null;
+    },
+    prop(id, name) {
+      const v = lookup(id)[name];
+      return v === undefined ? null : v;
+    },
+    allText(id)     { return String(lookup(id).textContent || ''); },
+    visibleText(id) {
+      const el = lookup(id);
+      // If any ancestor of `el` is hidden, the element renders nothing.
+      if (!visibleAncestorChainOk(el)) return '';
+      return String(visibleTextOf(el));
+    },
+    path(id)        { return String(buildXPath(lookup(id))); },
+    rect(id) {
+      const el = lookup(id);
+      return {x: 0, y: 0, width: 0, height: 0, top: 0, left: 0,
+              right: 0, bottom: 0, tagName: (el.tagName || '').toLowerCase()};
+    },
+
+    value(id) {
+      const el = lookup(id);
+      const tag = (el.tagName || '').toUpperCase();
+      if (tag === 'SELECT' && isMultipleSelect(el)) {
+        return Array.from(el.options).filter(o => boolPropOrAttr(o, 'selected'))
+          .map(o => String(o.value == null ? '' : o.value));
+      }
+      const type = (el.type || (el.getAttribute && el.getAttribute('type')) || '').toLowerCase();
+      if (type === 'checkbox' || type === 'radio') {
+        const v = el.getAttribute && el.getAttribute('value');
+        return v == null ? 'on' : String(v);
+      }
+      if (tag === 'TEXTAREA') {
+        // HTML spec: a single leading newline directly after <textarea> is
+        // stripped from the *initial* value. happy-dom does not apply
+        // that rule. Only strip when our driver has not written to the
+        // field yet — once `setValue` ran we treat the buffer as user
+        // content and preserve it byte-for-byte.
+        let raw = el.value == null ? '' : String(el.value);
+        if (!el.__csim_user_set) {
+          if (raw.startsWith('\r\n')) raw = raw.slice(2);
+          else if (raw.startsWith('\n')) raw = raw.slice(1);
+        }
+        return raw;
+      }
+      if ('value' in el) return el.value == null ? '' : String(el.value);
+      return null;
+    },
+
+    setValue(id, value) {
+      const el = lookup(id);
+      const tag = (el.tagName || '').toUpperCase();
+      const type = (el.type || (el.getAttribute && el.getAttribute('type')) || '').toLowerCase();
+      // contenteditable inherits — walk ancestors looking for an explicit
+      // value other than `false`.
+      let ceCur = el, ce = null;
+      while (ceCur && ceCur.nodeType === 1) {
+        const v = ceCur.getAttribute && ceCur.getAttribute('contenteditable');
+        if (v !== null && v !== undefined) { ce = v; break; }
+        ceCur = ceCur.parentNode;
+      }
+      if (ce !== null && ce !== undefined && ce !== 'false') {
+        el.textContent = String(value == null ? '' : value);
+        el.dispatchEvent(makeEvent('input'));
+        el.dispatchEvent(makeEvent('change'));
+        return true;
+      }
+      if (tag === 'SELECT' && isMultipleSelect(el) && Array.isArray(value)) {
+        for (const opt of el.options) {
+          if (value.includes(opt.value)) opt.setAttribute('selected', '');
+          else opt.removeAttribute('selected');
+        }
+      } else if (type === 'checkbox') {
+        // Real browsers fire click + change when set/unset via UI. Drive a
+        // click whenever the desired state differs from the current state
+        // so user-bound `click` handlers run. Use the IDL property only —
+        // Stimulus controllers commonly toggle `el.checked` directly,
+        // which leaves the `checked` HTML attribute stale.
+        const want = !!value;
+        const have = el.checked === true;
+        if (want !== have) {
+          el.dispatchEvent(makeEvent('click'));
+          if (el.checked) el.setAttribute('checked', '');
+          else            el.removeAttribute('checked');
+        }
+      } else if (type === 'radio') {
+        if (value) {
+          // Setting a radio also deselects every same-named peer.
+          if (el.name) {
+            for (const peer of currentDocument.querySelectorAll('input[type=radio][name="' + cssEscape(el.name) + '"]')) {
+              if (peer === el) { peer.setAttribute('checked', ''); peer.checked = true; }
+              else             { peer.removeAttribute('checked'); peer.checked = false; }
+            }
+          } else {
+            el.setAttribute('checked', '');
+            el.checked = true;
+          }
+        } else {
+          el.removeAttribute('checked');
+          el.checked = false;
+        }
+      } else if (type === 'file') {
+        el.__csim_files = Array.isArray(value) ? value : [value];
+      } else {
+        let str = String(value == null ? '' : value);
+        // Pre-formatted ISO timestamps from Ruby: trim to whatever the
+        // <input type="..."> actually accepts.
+        if (type === 'time' && /^\d{4}-\d{2}-\d{2}T(\d{2}:\d{2})/.test(str)) {
+          str = str.replace(/^\d{4}-\d{2}-\d{2}T/, '');
+        } else if (type === 'date' && /^(\d{4}-\d{2}-\d{2})/.test(str)) {
+          str = str.match(/^\d{4}-\d{2}-\d{2}/)[0];
+        }
+        if (type === 'range') {
+          // <input type=range> rounds to the nearest valid step from min.
+          const min  = parseFloat(el.getAttribute('min'))  || 0;
+          const max  = parseFloat(el.getAttribute('max'));
+          const step = parseFloat(el.getAttribute('step')) || 1;
+          const num  = parseFloat(str);
+          if (Number.isFinite(num) && step > 0) {
+            let snapped = Math.round((num - min) / step) * step + min;
+            if (Number.isFinite(max)) snapped = Math.min(snapped, max);
+            snapped = Math.max(snapped, min);
+            // Trim floating-point fuzz introduced by the rounding above.
+            const decimals = (String(step).split('.')[1] || '').length;
+            str = snapped.toFixed(decimals);
+          }
+        }
+        // HTML "implicit submission": a `\n` in a text-like input on a form
+        // with only one such control should submit the form. Strip the \n
+        // from the stored value but remember to fire submit afterwards.
+        let implicitSubmit = false;
+        if (tag === 'INPUT' && /^(text|email|number|search|tel|url|password|date|time|datetime-local|month|week|color|range)?$/.test(type) && str.endsWith('\n')) {
+          str = str.replace(/\n$/, '');
+          const form = formForControl(el);
+          if (form && countSubmittableTextInputs(form) === 1) implicitSubmit = true;
+        }
+        const maxLen = parseInt(el.getAttribute && el.getAttribute('maxlength'), 10);
+        if (Number.isFinite(maxLen) && maxLen >= 0) str = str.slice(0, maxLen);
+        el.value = str;
+        el.__csim_user_set = true;
+        el.dispatchEvent(makeEvent('input'));
+        el.dispatchEvent(makeEvent('change'));
+        if (implicitSubmit) {
+          const form = formForControl(el);
+          if (form) {
+            const desc = submitDescriptor(form, null);
+            return desc;
+          }
+        }
+        return true;
+      }
+      el.dispatchEvent(makeEvent('input'));
+      el.dispatchEvent(makeEvent('change'));
+      return true;
+    },
+
+    selectOption(id) {
+      const opt = lookup(id);
+      const select = opt.parentNode && (opt.parentNode.tagName === 'SELECT'
+        ? opt.parentNode
+        : opt.closest && opt.closest('select'));
+      if (!select) return false;
+      if (!isMultipleSelect(select)) {
+        for (const o of select.options) {
+          if (o === opt) o.setAttribute('selected', '');
+          else o.removeAttribute('selected');
+        }
+      } else {
+        opt.setAttribute('selected', '');
+      }
+      select.dispatchEvent(makeEvent('input'));
+      select.dispatchEvent(makeEvent('change'));
+      return true;
+    },
+    unselectOption(id) {
+      const opt = lookup(id);
+      const select = opt.closest && opt.closest('select');
+      if (!select || !isMultipleSelect(select)) return false;
+      opt.removeAttribute('selected');
+      select.dispatchEvent(makeEvent('input'));
+      select.dispatchEvent(makeEvent('change'));
+      return true;
+    },
+
+    visible(id)  { return visibleAncestorChainOk(lookup(id)); },
+    checked(id)  { return boolPropOrAttr(lookup(id), 'checked'); },
+    selected(id) { return boolPropOrAttr(lookup(id), 'selected'); },
+    disabled(id) {
+      const el = lookup(id);
+      const tag = (el.tagName || '').toUpperCase();
+      // Only form controls and `<option>`s actually honour the `disabled`
+      // attribute. Plain anchors etc. with stray `disabled` markers must
+      // not be reported as disabled.
+      const DISABLEABLE = new Set(['BUTTON', 'INPUT', 'SELECT', 'TEXTAREA',
+                                   'OPTGROUP', 'OPTION', 'FIELDSET']);
+      if (DISABLEABLE.has(tag) && boolPropOrAttr(el, 'disabled')) return true;
+      // An option inside a disabled <select> or <optgroup> is disabled too.
+      if (tag === 'OPTION') {
+        let p = el.parentNode;
+        while (p && p.nodeType === 1) {
+          const pt = (p.tagName || '').toUpperCase();
+          if (pt === 'OPTGROUP' && boolPropOrAttr(p, 'disabled')) return true;
+          if (pt === 'SELECT'   && boolPropOrAttr(p, 'disabled')) return true;
+          p = p.parentNode;
+        }
+      }
+      let cur = el.parentNode;
+      while (cur && cur.nodeType === 1) {
+        if ((cur.tagName || '').toUpperCase() === 'FIELDSET' && boolPropOrAttr(cur, 'disabled')) {
+          const legend = cur.querySelector && cur.querySelector('legend');
+          if (legend && legend.contains && legend.contains(el)) return false;
+          return true;
+        }
+        cur = cur.parentNode;
+      }
+      return false;
+    },
+    readonly(id) { return boolPropOrAttr(lookup(id), 'readOnly') ||
+                          boolPropOrAttr(lookup(id), 'readonly'); },
+    multiple(id) { return boolPropOrAttr(lookup(id), 'multiple'); },
+
+    focus(id)  { activeHandleId = id; lookup(id).dispatchEvent(makeEvent('focus', {bubbles: false})); return true; },
+    blur(id)   { lookup(id).dispatchEvent(makeEvent('blur', {bubbles: false})); if (activeHandleId === id) activeHandleId = null; return true; },
+    activeElement() {
+      // Honour the JS-side `document.activeElement` first — happy-dom
+      // updates it when scripts call `focus()` directly, which the
+      // tracker variable does not see. Fall back to the runtime's
+      // tracker when the document hasn't initialised yet.
+      const el = currentDocument && currentDocument.activeElement;
+      if (el) return track(el);
+      return activeHandleId;
+    },
+
+    hover(id) {
+      const el = lookup(id);
+      el.dispatchEvent(makeEvent('mouseover'));
+      el.dispatchEvent(makeEvent('mouseenter', {bubbles: false}));
+      return true;
+    },
+    trigger(id, name) { lookup(id).dispatchEvent(makeEvent(name)); return true; },
+
+    drainTimers(ms) { drainTimers(ms); return true; },
+
+    consumeHistoryPushed() {
+      const v = _historyPushed;
+      _historyPushed = false;
+      return v;
+    },
+
+    shadowRoot(id) {
+      const el = lookup(id);
+      const root = el && el.shadowRoot;
+      return root ? track(root) : null;
+    },
+
+    mouseDown(id, button, modifiers) {
+      const el = lookup(id);
+      const m = Object.assign({button: button || 0}, modifiers || {});
+      applyClickOffset(el, m);
+      el.dispatchEvent(makeEvent('mousedown', m));
+      return true;
+    },
+
+    click(id, button, modifiers, skipDown) {
+      const el = lookup(id);
+      activeHandleId = id;
+      const m = Object.assign({button: button || 0}, modifiers || {});
+      applyClickOffset(el, m);
+      // Real browsers dispatch mousedown → mouseup → click (or contextmenu
+      // for the right button). Page handlers like the Capybara test suite's
+      // `mouse_down_time` / `click_delay` rely on the down/up pair.
+      if (!skipDown) el.dispatchEvent(makeEvent('mousedown', m));
+      el.dispatchEvent(makeEvent('mouseup', m));
+      const eventType = button === 2 ? 'contextmenu' : 'click';
+      const evt = makeEvent(eventType, m);
+      // For anchor elements we used to attach a preventDefault suppressor
+      // so happy-dom's HTMLAnchorElement.dispatchEvent wouldn't call
+      // `window.open(href)` and double-navigate. The suppressor masked
+      // legitimate `preventDefault()` calls from Turbo / Stimulus link
+      // interceptors though, which made the runtime always fall through
+      // to a Ruby-side `navigate` even when Turbo had already taken
+      // responsibility for the link via a `<turbo-frame>` visit. Track
+      // whether *something else* prevented the default by sampling the
+      // event's defaultPrevented before our late capture listener
+      // re-prevents to keep happy-dom out of the way.
+      const tagU = (el.tagName || '').toUpperCase();
+      const isLink = tagU === 'A' && el.getAttribute('href') != null;
+      // happy-dom's HTMLButtonElement / HTMLInputElement.dispatchEvent
+      // auto-dispatches `submit` on the form when this is a submit-type
+      // control click. Capture whether that submit was preventDefaulted so
+      // submitDescriptor doesn't fire a redundant submit event (which
+      // would lose the `submitter` field and confuse Turbo).
+      const submitForm = (tagU === 'BUTTON' || (tagU === 'INPUT' && /^(submit|image)$/i.test(el.type || '')))
+        ? formForControl(el)
+        : null;
+      let autoSubmitFired = false;
+      let lastAutoSubmit = null;
+      let autoSubmitListener = null;
+      if (submitForm) {
+        // Capture-phase listener so it always fires before any bubble-
+        // phase handler (notably Turbo's FormSubmitObserver attached to
+        // document). The final `defaultPrevented` value is whatever later
+        // listeners chose, so read it after dispatch returns.
+        autoSubmitListener = (e) => {
+          autoSubmitFired = true;
+          lastAutoSubmit = e;
+        };
+        submitForm.addEventListener('submit', autoSubmitListener, true);
+      }
+      const proceeded = el.dispatchEvent(evt);
+      let autoSubmitPrevented = !!(lastAutoSubmit && lastAutoSubmit.defaultPrevented);
+      if (submitForm) {
+        try { submitForm.removeEventListener('submit', autoSubmitListener, true); } catch (_) {}
+      }
+      // For links, we want happy-dom's HTMLAnchorElement default
+      // (window.open / location set) NOT to fire — the Ruby driver does
+      // the navigate. preventDefault here acts only on happy-dom's
+      // default action because user listeners have already run during
+      // the dispatch above; their decisions are reflected in
+      // `proceeded` (false ⇔ defaultPrevented).
+      const externallyPrevented = isLink && !proceeded;
+      if (isLink) try { evt.preventDefault(); } catch (_) {}
+      if (!proceeded && !isLink) return {action: 'none'};
+      if (button === 2) return {action: 'none'};
+
+      const tag = (el.tagName || '').toUpperCase();
+      if (tag === 'LABEL') {
+        // happy-dom already redirects label clicks to their associated
+        // form control (toggling checkboxes/radios), so we don't need to
+        // route the click manually. We do still need to mirror the new
+        // state into the `checked` attribute (form serialisation reads
+        // it) and, for radios, deselect peers that share the same name.
+        const targetId = el.getAttribute && el.getAttribute('for');
+        let target = null;
+        if (targetId) target = currentDocument.getElementById(targetId);
+        if (!target) target = el.querySelector && el.querySelector('input,textarea,select,button');
+        if (target) {
+          if (target.checked) target.setAttribute('checked', '');
+          else                target.removeAttribute('checked');
+          if ((target.type || '').toLowerCase() === 'radio' && target.name && target.checked) {
+            for (const peer of currentDocument.querySelectorAll('input[type=radio][name="' + cssEscape(target.name) + '"]')) {
+              if (peer === target) continue;
+              peer.checked = false;
+              peer.removeAttribute('checked');
+            }
+          }
+        }
+      }
+      if (tag === 'A' && el.getAttribute('href') != null) {
+        const href = el.getAttribute('href');
+        if (!href || href.startsWith('#') || href.startsWith('javascript:')) {
+          return {action: 'none'};
+        }
+        // When the link sits inside a `<turbo-frame>` (and isn't escaping
+        // to the top with `data-turbo-frame="_top"` or `data-turbo="false"`),
+        // Turbo's FrameController intercepts the click and replaces the
+        // frame's contents asynchronously. Don't double-navigate via
+        // Rack in that case — the frame visit owns the load. Top-level
+        // Drive visits still go through Ruby navigate so the response
+        // is rendered as a fresh page.
+        if (externallyPrevented && isFrameScopedLink(el)) return {action: 'none'};
+        return {action: 'navigate', href};
+      }
+      if (tag === 'BUTTON') {
+        const btnType = (el.type || 'submit').toLowerCase();
+        if (btnType === 'submit') {
+          const form = formForControl(el);
+          if (form) return submitDescriptor(form, el, {skipDispatch: autoSubmitFired, prevented: autoSubmitPrevented});
+        }
+        if (btnType === 'reset') {
+          const form = formForControl(el);
+          if (form && form.reset) form.reset();
+        }
+      }
+      if (tag === 'INPUT') {
+        const type = (el.type || '').toLowerCase();
+        if (type === 'submit' || type === 'image') {
+          const form = formForControl(el);
+          if (form) return submitDescriptor(form, el, {skipDispatch: autoSubmitFired, prevented: autoSubmitPrevented});
+        }
+        if (type === 'reset') {
+          const form = formForControl(el);
+          if (form && form.reset) form.reset();
+        }
+        if (type === 'checkbox') {
+          // happy-dom toggles `el.checked` automatically on dispatchEvent
+          // for click on a checkbox. Sync the attribute so attribute-based
+          // queries (and form serialisation) stay consistent.
+          if (el.checked) el.setAttribute('checked', '');
+          else            el.removeAttribute('checked');
+          el.dispatchEvent(makeEvent('change'));
+        }
+        if (type === 'radio') {
+          // happy-dom selects `el` on click but does not deselect peers.
+          if (el.name) {
+            for (const peer of currentDocument.querySelectorAll('input[type=radio][name="' + cssEscape(el.name) + '"]')) {
+              if (peer === el) { peer.setAttribute('checked', ''); peer.checked = true; }
+              else             { peer.removeAttribute('checked'); peer.checked = false; }
+            }
+          } else {
+            el.setAttribute('checked', '');
+            el.checked = true;
+          }
+          el.dispatchEvent(makeEvent('change'));
+        }
+      }
+      return {action: 'none'};
+    },
+
+    doubleClick(id, modifiers) {
+      const el = lookup(id);
+      const m = Object.assign({button: 0}, modifiers || {});
+      applyClickOffset(el, m);
+      el.dispatchEvent(makeEvent('mousedown', m));
+      el.dispatchEvent(makeEvent('mouseup', m));
+      el.dispatchEvent(makeEvent('click', m));
+      el.dispatchEvent(makeEvent('mousedown', m));
+      el.dispatchEvent(makeEvent('mouseup', m));
+      el.dispatchEvent(makeEvent('click', m));
+      el.dispatchEvent(makeEvent('dblclick', m));
+      return {action: 'none'};
+    },
+    rightClick(id, modifiers, skipDown) {
+      const el = lookup(id);
+      const m = Object.assign({button: 2}, modifiers || {});
+      applyClickOffset(el, m);
+      if (!skipDown) el.dispatchEvent(makeEvent('mousedown', m));
+      el.dispatchEvent(makeEvent('mouseup', m));
+      el.dispatchEvent(makeEvent('contextmenu', m));
+      return {action: 'none'};
+    },
+
+    // Mirrors Capybara's HTML5 drop helper: build a DataTransfer holding
+    // the supplied files and/or strings, attach it to the dragenter,
+    // dragover and drop events, and dispatch them on the target. happy-dom
+    // exposes `DragEvent` as a plain `Event`, so we paste `dataTransfer`
+    // onto each event before dispatch.
+    drop(id, items) {
+      const el = lookup(id);
+      const win = currentWindow;
+      const dt = new win.DataTransfer();
+      for (const item of items || []) {
+        if (item.kind === 'file') {
+          const file = new win.File([item.contents || ''], item.name || '', {type: item.type || ''});
+          dt.items.add(file);
+        } else {
+          dt.items.add(String(item.data == null ? '' : item.data), String(item.type || ''));
+        }
+      }
+      const fire = (name) => {
+        const ev = makeEvent(name, {bubbles: true, cancelable: true});
+        try {
+          Object.defineProperty(ev, 'dataTransfer', {value: dt, writable: false, configurable: true});
+        } catch (_) {
+          ev.dataTransfer = dt;
+        }
+        el.dispatchEvent(ev);
+      };
+      fire('dragenter');
+      fire('dragover');
+      fire('drop');
+      return true;
+    },
+
+    submit(id) { return submitDescriptor(lookup(id), null); },
+
+    sendKeys(id, keys) {
+      const el = lookup(id);
+      const editable = (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA');
+      let formToSubmit = null;
+      // Modifiers held for the rest of the call after a top-level
+      // `:shift` etc. (Selenium semantics). [:shift, 'o'] combos hold
+      // the modifier just for `tail`.
+      const heldModifiers = new Set();
+      const cursor = {pos: editable ? (el.value || '').length : 0};
+
+      const fireKey = (name, opts) => {
+        const detail = Object.assign({key: keyForEvent(name, opts), code: keyCodeName(name), keyCode: keyCodeFor(name)}, opts || {});
+        for (const m of heldModifiers) detail[modifierProp(m)] = true;
+        if (opts && opts.modifiers) for (const m of opts.modifiers) detail[modifierProp(m)] = true;
+        el.dispatchEvent(makeEvent('keydown', detail));
+        if (!isSpecialKey(name)) el.dispatchEvent(makeEvent('keypress', detail));
+        applyKeyEffect(name, detail);
+        el.dispatchEvent(makeEvent('keyup', detail));
+      };
+      const applyKeyEffect = (name, detail) => {
+        if (!editable) return;
+        const cur = el.value == null ? '' : el.value;
+        const shift = !!detail.shiftKey;
+        const ctrlOrMeta = !!detail.ctrlKey || !!detail.metaKey;
+        if (ctrlOrMeta) return;  // hotkeys: skip text effect
+        if (name === 'Backspace') {
+          if (cursor.pos === 0) return;
+          el.value = cur.slice(0, cursor.pos - 1) + cur.slice(cursor.pos);
+          cursor.pos -= 1;
+          el.dispatchEvent(makeEvent('input'));
+        } else if (name === 'Delete') {
+          if (cursor.pos === cur.length) return;
+          el.value = cur.slice(0, cursor.pos) + cur.slice(cursor.pos + 1);
+          el.dispatchEvent(makeEvent('input'));
+        } else if (name === 'ArrowLeft')   cursor.pos = Math.max(0, cursor.pos - 1);
+        else   if (name === 'ArrowRight')  cursor.pos = Math.min(cur.length, cursor.pos + 1);
+        else   if (name === 'Home')        cursor.pos = 0;
+        else   if (name === 'End')         cursor.pos = cur.length;
+        else if (!isSpecialKey(name)) {
+          const ch = shift ? name.toUpperCase() : name;
+          el.value = cur.slice(0, cursor.pos) + ch + cur.slice(cursor.pos);
+          cursor.pos += ch.length;
+          el.dispatchEvent(makeEvent('input'));
+        } else if (name === 'Enter' && (el.tagName === 'INPUT')) {
+          formToSubmit = el.form || el.closest('form');
+        }
+      };
+
+      const handle = (k) => {
+        if (typeof k === 'string') {
+          for (const ch of k) fireKey(ch, {});
+          return;
+        }
+        if (!k || typeof k !== 'object') return;
+        if ('combo' in k) {
+          // Press each modifier (firing keydown), execute the tail with
+          // them held, then release in reverse order.
+          for (const mod of k.combo) {
+            heldModifiers.add(mod);
+            el.dispatchEvent(makeEvent('keydown', {key: mod, code: keyCodeName(mod), keyCode: keyCodeFor(mod), [modifierProp(mod)]: true}));
+          }
+          for (const part of k.tail) handle(part);
+          for (let i = k.combo.length - 1; i >= 0; i--) {
+            const mod = k.combo[i];
+            el.dispatchEvent(makeEvent('keyup', {key: mod, code: keyCodeName(mod), keyCode: keyCodeFor(mod), [modifierProp(mod)]: true}));
+            heldModifiers.delete(mod);
+          }
+          return;
+        }
+        if ('special' in k) {
+          const name = String(k.special);
+          if (isModifier(name)) {
+            // Top-level modifier symbol toggles a held-down state for
+            // the remainder of the call.
+            if (heldModifiers.has(name)) heldModifiers.delete(name);
+            else heldModifiers.add(name);
+            return;
+          }
+          if (name === 'Enter' && el.tagName === 'INPUT') {
+            formToSubmit = el.form || el.closest('form');
+          }
+          if (name === 'Tab') advanceFocus(el, !!heldModifiers.has('Shift'));
+          fireKey(name, {});
+        }
+      };
+
+      for (const k of keys) handle(k);
+      if (formToSubmit) return submitDescriptor(formToSubmit, null);
+      return {action: 'none'};
+    }
+  };
+
+  // Real browsers expose every property of `window` as a global. mini_racer
+  // keeps globalThis and the happy-dom Window separate, so libraries that
+  // attach to `window` (jQuery, page boot scripts) need their additions
+  // mirrored back onto globalThis for subsequent `<script>` tags to see.
+  const _SKIP_SYNC = new Set([
+    'self', 'window', 'document', 'top', 'parent', 'frames', 'opener',
+    'globalThis', 'happyDOM'
+  ]);
+  // happy-dom does not fire DOMContentLoaded / load on its own when we
+  // assign innerHTML and replay scripts in a single tick. Frameworks like
+  // jQuery hold their initialisation behind `$(document).ready(...)`, so
+  // we synthesise both events at the end of script setup.
+  function fireReadyEvents() {
+    if (!currentWindow || !currentDocument) return;
+    try {
+      currentDocument.dispatchEvent(new currentWindow.Event('DOMContentLoaded', {bubbles: true, cancelable: false}));
+    } catch (_) {}
+    try {
+      currentWindow.dispatchEvent(new currentWindow.Event('load', {bubbles: false, cancelable: false}));
+    } catch (_) {}
+  }
+
+  function syncWindowGlobals() {
+    if (!currentWindow) return;
+    for (const key of Object.keys(currentWindow)) {
+      if (_SKIP_SYNC.has(key)) continue;
+      if (key.startsWith('_')) continue;
+      try {
+        if (globalThis[key] === undefined && currentWindow[key] !== undefined) {
+          globalThis[key] = currentWindow[key];
+        }
+      } catch (_) {}
+    }
+  }
+
+  function cssEscape(s) {
+    return String(s).replace(/(["\\\]\[\(\)])/g, '\\$1');
+  }
+
+  // happy-dom's selector parser does not implement form-state pseudo
+  // classes like `:enabled`, `:read-write`, `:optional`, treating them
+  // as no-match. Rewrite them to their attribute-based equivalents,
+  // which are close enough for Capybara's form interaction selectors.
+  // We deliberately do not touch pseudos happy-dom does support
+  // (`:disabled`, `:checked`, `:not`, `:nth-child`, etc.).
+  const PSEUDO_REWRITES = [
+    [/:enabled\b/g,           ':not([disabled])'],
+    [/:read-write\b/g,        ':not([readonly])'],
+    [/:read-only\b/g,         '[readonly]'],
+    [/:optional\b/g,          ':not([required])']
+  ];
+  // happy-dom's parser also rejects CSS identifier escape sequences in
+  // `#id` / `.class` (e.g. `#\31 foo` for `#1foo`). Decode the escapes
+  // and rewrite to attribute selectors, which it accepts.
+  const CSS_IDENT_RE = /(?:\\[0-9a-fA-F]{1,6}\s?|\\.|[\w-])+/.source;
+  const ESCAPED_ID_RE = new RegExp('#(' + CSS_IDENT_RE + ')', 'g');
+  const ESCAPED_CLASS_RE = new RegExp('\\.(' + CSS_IDENT_RE + ')', 'g');
+  function unescapeIdent(s) {
+    return s.replace(/\\([0-9a-fA-F]{1,6})\s?|\\(.)/g, (_m, hex, ch) =>
+      hex ? String.fromCodePoint(parseInt(hex, 16)) : ch);
+  }
+  function rewriteCSS(css) {
+    let out = String(css || '');
+    for (const [re, repl] of PSEUDO_REWRITES) out = out.replace(re, repl);
+    if (out.indexOf('\\') !== -1) {
+      out = out.replace(ESCAPED_ID_RE, (m, ident) =>
+        ident.indexOf('\\') === -1 ? m : '[id="' + unescapeIdent(ident).replace(/"/g, '\\"') + '"]');
+      out = out.replace(ESCAPED_CLASS_RE, (m, ident) =>
+        ident.indexOf('\\') === -1 ? m : '[class~="' + unescapeIdent(ident).replace(/"/g, '\\"') + '"]');
+    }
+    return out;
+  }
+
+  function stripDoctype(html) {
+    return String(html || '').replace(/^\s*<!doctype[^>]*>\s*/i, '');
+  }
+
+  // Capybara emits XPath; happy-dom has no document.evaluate. The fallback
+  // covers a useful subset by translating to CSS, with a hand-rolled text()
+  // and contains() filter on top.
+  // history.pushState / replaceState change window.location.href without a
+  // real fetch. Wrap them to set a flag the Ruby driver inspects so it
+  // does not turn the URL change into a Rack request.
+  let _historyPushed = false;
+  function installHistoryTracking(win) {
+    if (!win.history) return;
+    const wrap = (name) => {
+      const orig = win.history[name];
+      if (typeof orig !== 'function' || orig.__csim_wrapped) return;
+      const wrapped = function () {
+        _historyPushed = true;
+        return orig.apply(win.history, arguments);
+      };
+      wrapped.__csim_wrapped = true;
+      win.history[name] = wrapped;
+    };
+    wrap('pushState');
+    wrap('replaceState');
+  }
+
+  // happy-dom does not implement `document.evaluate`. Capybara internals
+  // and user scripts both reach for it occasionally. Polyfill it on top of
+  // fontoxpath so callers see W3C XPathResult semantics.
+  function installDocumentEvaluate(doc) {
+    if (typeof doc.evaluate === 'function') return;
+    const ANY_TYPE = 0;
+    const NUMBER_TYPE = 1;
+    const STRING_TYPE = 2;
+    const BOOLEAN_TYPE = 3;
+    const UNORDERED_NODE_ITERATOR_TYPE = 4;
+    const ORDERED_NODE_ITERATOR_TYPE = 5;
+    const UNORDERED_NODE_SNAPSHOT_TYPE = 6;
+    const ORDERED_NODE_SNAPSHOT_TYPE = 7;
+    const ANY_UNORDERED_NODE_TYPE = 8;
+    const FIRST_ORDERED_NODE_TYPE = 9;
+
+    function makeResult(type, items) {
+      return {
+        resultType: type,
+        snapshotLength: items.length,
+        snapshotItem: (i) => items[i] || null,
+        get singleNodeValue() { return items[0] || null; },
+        iterateNext: (() => { let i = 0; return () => items[i++] || null; })()
+      };
+    }
+
+    doc.evaluate = function (xpath, contextNode, _resolver, type, _result) {
+      const root = contextNode || doc.documentElement || doc;
+      let nodes = [];
+      try {
+        nodes = evaluateXPathToNodes(xpath, root, xpathDomFacade, null, {
+          namespaceResolver: () => 'http://www.w3.org/1999/xhtml'
+        });
+      } catch (_) {
+        nodes = [];
+      }
+      switch (type) {
+        case FIRST_ORDERED_NODE_TYPE:
+        case ANY_UNORDERED_NODE_TYPE:
+          return makeResult(type, nodes.slice(0, 1));
+        case NUMBER_TYPE:
+        case STRING_TYPE:
+        case BOOLEAN_TYPE:
+          // We do not support primitive XPath results; callers fall back.
+          return makeResult(type, []);
+        default:
+          return makeResult(type || ORDERED_NODE_SNAPSHOT_TYPE, nodes);
+      }
+    };
+  }
+
+  // Custom DOM facade for fontoxpath that uses childNodes-based traversal
+  // so happy-dom quirks around sibling links don't break root-anchored
+  // queries. Mirrors the helper we built for linkedom.
+  const xpathDomFacade = {
+    getAllAttributes(node) {
+      if (!node || node.nodeType !== 1 || !node.attributes) return [];
+      return Array.from(node.attributes);
+    },
+    getAttribute(node, name) {
+      return node && node.getAttribute ? node.getAttribute(name) : null;
+    },
+    getChildNodes(node) {
+      if (!node) return [];
+      if (node.childNodes) return Array.from(node.childNodes);
+      if (node.nodeType === 9 && node.documentElement) return [node.documentElement];
+      return [];
+    },
+    getData(node) {
+      if (!node) return '';
+      if (node.nodeType === 2) return node.value || '';
+      return node.data || '';
+    },
+    getFirstChild(node) {
+      const cs = this.getChildNodes(node);
+      return cs.length ? cs[0] : null;
+    },
+    getLastChild(node) {
+      const cs = this.getChildNodes(node);
+      return cs.length ? cs[cs.length - 1] : null;
+    },
+    getNextSibling(node) {
+      const parent = this.getParentNode(node);
+      if (!parent) return null;
+      const cs = this.getChildNodes(parent);
+      const i = cs.indexOf(node);
+      return (i >= 0 && i + 1 < cs.length) ? cs[i + 1] : null;
+    },
+    getPreviousSibling(node) {
+      const parent = this.getParentNode(node);
+      if (!parent) return null;
+      const cs = this.getChildNodes(parent);
+      const i = cs.indexOf(node);
+      return (i > 0) ? cs[i - 1] : null;
+    },
+    getParentNode(node) {
+      return node ? node.parentNode || null : null;
+    }
+  };
+
+  function findViaXPathFallback(xpath, root) {
+    if (typeof xpath !== 'string') return [];
+    const m = xpath.match(/^\.?\/\/(?:descendant::)?([A-Za-z*][\w*]*)(?:\[(.+)\])?$/);
+    if (!m) {
+      // Last resort: take the whole thing as a tag name.
+      try {
+        const els = root.querySelectorAll(xpath);
+        const ids = [];
+        for (const el of els) ids.push(track(el));
+        return ids;
+      } catch (_) { return []; }
+    }
+    const tag = m[1];
+    const els = root.querySelectorAll(tag);
+    const ids = [];
+    for (const el of els) ids.push(track(el));
+    return ids;
+  }
+})();