@salve-software/react-native-nitro-jsdom 1.1.0 → 2.1.0

package/android/CMakeLists.txt

@@ -52,6 +52,7 @@ add_library(${PACKAGE_NAME} SHARED
   ../cpp/quickjs/bindings/StyleBindings.cpp
   ../cpp/quickjs/bindings/ElementBindings.cpp
   ../cpp/quickjs/bindings/DocumentBindings.cpp
+  ../cpp/quickjs/bindings/DOMParserBindings.cpp
   ../cpp/quickjs/bindings/EventBindings.cpp
   ../cpp/quickjs/bindings/TimerBindings.cpp
   ../cpp/quickjs/bindings/WindowBindings.cpp
@@ -60,6 +61,7 @@ add_library(${PACKAGE_NAME} SHARED
   ../cpp/quickjs/bindings/UrlBindings.cpp
   ../cpp/quickjs/bindings/AbortBindings.cpp
   ../cpp/quickjs/bindings/TextEncodingBindings.cpp
+  ../cpp/quickjs/bindings/IntlBindings.cpp
   ../cpp/quickjs/bindings/FormBindings.cpp
   ../cpp/quickjs/bindings/BlobBindings.cpp
   ../cpp/quickjs/bindings/CSSOMBindings.cpp
@@ -69,6 +71,10 @@ add_library(${PACKAGE_NAME} SHARED
   ../cpp/quickjs/bindings/TemplateBindings.cpp
   ../cpp/quickjs/bindings/SlotBindings.cpp
   ../cpp/quickjs/bindings/XmlSerializerBindings.cpp
+  ../cpp/quickjs/bindings/LayoutStubBindings.cpp
+  ../cpp/quickjs/bindings/TreeWalkerBindings.cpp
+  ../cpp/quickjs/bindings/EventTargetBindings.cpp
+  ../cpp/quickjs/bindings/WindowNamedPropertiesBindings.cpp
   ${QUICKJS_SOURCES}
 )
 

package/cpp/HybridHtmlSandbox.cpp

@@ -43,10 +43,13 @@ void HybridHtmlSandbox::initialize(const std::string& html, bool runScripts, con
   _runtime->bindDocument(_document.get());
 
   if (runScripts) {
-    for (const auto& script : _document->getScriptContents()) {
+    auto* rctx = _runtime->contextState();
+    for (const auto& [scriptEl, script] : _document->getScriptContents()) {
+      rctx->current_script = scriptEl;
       try {
         _runtime->evaluate(script);
       } catch (...) { }
+      rctx->current_script = nullptr;
     }
   }
 
@@ -55,10 +58,14 @@ void HybridHtmlSandbox::initialize(const std::string& html, bool runScripts, con
   // or window.addEventListener(...) — the common embedded-widget bootstrap
   // pattern — see them. There's no real subresource loading in this sandbox,
   // so both fire back-to-back with nothing in between.
+  _runtime->contextState()->ready_state = "interactive";
   try {
-    _runtime->evaluate(
-        "document.dispatchEvent(new Event('DOMContentLoaded', { bubbles: true, cancelable: true }));"
-        "document.dispatchEvent(new Event('load'));");
+    _runtime->evaluate("document.dispatchEvent(new Event('DOMContentLoaded', { bubbles: true }));");
+  } catch (...) { }
+
+  _runtime->contextState()->ready_state = "complete";
+  try {
+    _runtime->evaluate("document.dispatchEvent(new Event('load'));");
   } catch (...) { }
 
   _initialized = true;
@@ -107,7 +114,7 @@ void HybridHtmlSandbox::setConsoleCallback(
 
 void HybridHtmlSandbox::setDialogCallbacks(
     const std::optional<std::variant<nitro::NullType, std::function<void(const std::string&)>>>& onAlert,
-    const std::optional<std::variant<nitro::NullType, std::function<std::shared_ptr<Promise<bool>>(const std::string&)>>>& onConfirm,
+    const std::optional<std::variant<nitro::NullType, std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const std::string&)>>>& onConfirm,
     const std::optional<std::variant<nitro::NullType, std::function<std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>(const std::string&, const std::optional<std::string>&)>>>& onPrompt) {
   if (!_runtime) return;
 
@@ -125,10 +132,10 @@ void HybridHtmlSandbox::setDialogCallbacks(
   if (!onConfirm.has_value() || std::holds_alternative<nitro::NullType>(onConfirm.value())) {
     _runtime->setConfirmCallback(nullptr);
   } else {
-    auto fn = std::get<std::function<std::shared_ptr<Promise<bool>>(const std::string&)>>(onConfirm.value());
+    auto fn = std::get<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const std::string&)>>(onConfirm.value());
     _runtime->setConfirmCallback([fn](const std::string& message) -> bool {
       try {
-        return fn(message)->await().get();
+        return fn(message)->await().get()->await().get();
       } catch (...) {
         return false;
       }

package/cpp/HybridHtmlSandbox.hpp

@@ -30,7 +30,7 @@ public:
 
   void setDialogCallbacks(
     const std::optional<std::variant<nitro::NullType, std::function<void(const std::string& /* message */)>>>& onAlert,
-    const std::optional<std::variant<nitro::NullType, std::function<std::shared_ptr<Promise<bool>>(const std::string& /* message */)>>>& onConfirm,
+    const std::optional<std::variant<nitro::NullType, std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const std::string& /* message */)>>>& onConfirm,
     const std::optional<std::variant<nitro::NullType, std::function<std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>(const std::string& /* message */, const std::optional<std::string>& /* defaultValue */)>>>& onPrompt
   ) override;
 

package/cpp/lexbor/LexborDocument.cpp

@@ -6,6 +6,9 @@
 #include <lexbor/dom/dom.h>
 #include <lexbor/dom/interfaces/character_data.h>
 #include <lexbor/dom/interfaces/document_type.h>
+#include <lexbor/dom/interfaces/element.h>
+#include <lexbor/ns/ns.h>
+#include <lexbor/tag/tag.h>
 #include <stdexcept>
 #include <cctype>
 #include <cstring>
@@ -196,9 +199,9 @@ void* LexborDocument::documentElement() const {
 
 // ── Script extraction ────────────────────────────────────────────────────────
 
-std::vector<std::string> LexborDocument::getScriptContents() const {
+std::vector<std::pair<void*, std::string>> LexborDocument::getScriptContents() const {
   auto scriptEls = querySelectorAll_el("script");
-  std::vector<std::string> contents;
+  std::vector<std::pair<void*, std::string>> contents;
   contents.reserve(scriptEls.size());
 
   for (void* el : scriptEls) {
@@ -214,7 +217,7 @@ std::vector<std::string> LexborDocument::getScriptContents() const {
     size_t len = 0;
     lxb_char_t* text = lxb_dom_node_text_content(node, &len);
     if (text && len > 0) {
-      contents.emplace_back(reinterpret_cast<char*>(text), len);
+      contents.emplace_back(el, std::string(reinterpret_cast<char*>(text), len));
       lxb_dom_document_destroy_text(node->owner_document, text);
     }
   }
@@ -230,6 +233,65 @@ void* LexborDocument::createElement(const std::string& tag) {
       reinterpret_cast<const lxb_char_t*>(tag.data()), tag.size(), nullptr);
 }
 
+void* LexborDocument::createElementNS(const std::string& nsUri, const std::string& qualifiedName) {
+  if (!_document) return nullptr;
+  auto* dom_doc = lxb_dom_interface_document(static_cast<lxb_html_document_t*>(_document));
+
+  std::string prefix;
+  std::string localName = qualifiedName;
+  auto colon = qualifiedName.find(':');
+  if (colon != std::string::npos) {
+    prefix = qualifiedName.substr(0, colon);
+    localName = qualifiedName.substr(colon + 1);
+  }
+
+  bool known_tag = lxb_tag_data_by_name(dom_doc->tags,
+      reinterpret_cast<const lxb_char_t*>(localName.data()), localName.size()) != nullptr;
+
+  if (!known_tag) {
+    return lxb_dom_element_create(dom_doc,
+        reinterpret_cast<const lxb_char_t*>(localName.data()), localName.size(),
+        nsUri.empty() ? nullptr : reinterpret_cast<const lxb_char_t*>(nsUri.data()), nsUri.size(),
+        prefix.empty() ? nullptr : reinterpret_cast<const lxb_char_t*>(prefix.data()), prefix.size(),
+        nullptr, 0, true);
+  }
+
+  // Known tag + arbitrary ns crashes Lexbor's HTML interface dispatch, so
+  // resolve the ns id via a throwaway unknown-tag element first (safe path).
+  static const char* kNsProbeTag = "x-nitrojsdom-ns-probe";
+  lxb_dom_element_t* probe = lxb_dom_element_create(dom_doc,
+      reinterpret_cast<const lxb_char_t*>(kNsProbeTag), strlen(kNsProbeTag),
+      nsUri.empty() ? nullptr : reinterpret_cast<const lxb_char_t*>(nsUri.data()), nsUri.size(),
+      nullptr, 0, nullptr, 0, true);
+  if (!probe) return nullptr;
+  lxb_ns_id_t resolved_ns = probe->node.ns;
+  lxb_dom_element_destroy(probe);
+
+  lxb_dom_element_t* element = lxb_dom_document_create_element(dom_doc,
+      reinterpret_cast<const lxb_char_t*>(localName.data()), localName.size(), nullptr);
+  if (!element) return nullptr;
+  element->node.ns = resolved_ns;
+
+  if (!prefix.empty()) {
+    const lxb_ns_prefix_data_t* ns_prefix = lxb_ns_prefix_append(dom_doc->prefix,
+        reinterpret_cast<const lxb_char_t*>(prefix.data()), prefix.size());
+    if (ns_prefix) element->node.prefix = ns_prefix->prefix_id;
+  }
+
+  return element;
+}
+
+std::string LexborDocument::namespaceURI(void* node) const {
+  if (!_document || !node) return "";
+  auto* dom_doc = lxb_dom_interface_document(static_cast<lxb_html_document_t*>(_document));
+  auto* n = static_cast<lxb_dom_node_t*>(node);
+  if (n->ns == LXB_NS__UNDEF) return "";
+  size_t len = 0;
+  const lxb_char_t* uri = lxb_ns_by_id(dom_doc->ns, static_cast<lxb_ns_id_t>(n->ns), &len);
+  if (!uri || len == 0) return "";
+  return std::string(reinterpret_cast<const char*>(uri), len);
+}
+
 void* LexborDocument::createTextNode(const std::string& text) {
   if (!_document) return nullptr;
   auto* dom_doc = lxb_dom_interface_document(static_cast<lxb_html_document_t*>(_document));

package/cpp/lexbor/LexborDocument.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace margelo::nitro::nitrojsdom {
@@ -29,8 +30,8 @@ public:
   void* head() const;
   void* documentElement() const;
 
-  // ── Script extraction ────────────────────────────────────────────────────
-  std::vector<std::string> getScriptContents() const;
+  // ── Script extraction — (element, text content) pairs; void* = lxb_dom_element_t* ──
+  std::vector<std::pair<void*, std::string>> getScriptContents() const;
 
   // ── Node creation ─────────────────────────────────────────────────────────
   void* createElement(const std::string& tag);
@@ -38,6 +39,20 @@ public:
   void* createComment(const std::string& text);
   void* createDocumentFragment();
 
+  // ── Namespaces (createElementNS / Element.namespaceURI) ───────────────────
+  // qualifiedName may be "prefix:localName" or a bare "localName". nsUri may be
+  // empty for the null namespace. Lexbor registers arbitrary namespace URIs
+  // dynamically (lxb_ns_append), so any URI works, not just HTML/SVG/MathML.
+  // Note: lxb_tag_append_lower lowercases local_name internally, so
+  // mixed-case foreign tag/attribute names (e.g. SVG's "viewBox",
+  // "linearGradient") come back lowercased — a lexbor limitation, not
+  // something this binding can work around.
+  void* createElementNS(const std::string& nsUri, const std::string& qualifiedName);
+
+  // Returns the namespace URI for a node, or "" if the node has no namespace
+  // (LXB_NS__UNDEF) — callers should map "" to JS null.
+  std::string namespaceURI(void* node) const;
+
   // ── Shadow DOM ─────────────────────────────────────────────────────────────
   // mode: 0 = open, 1 = closed (matches lxb_dom_shadow_root_mode_t).
   void* createShadowRoot(void* hostElement, int mode);

package/cpp/quickjs/DOMBindings.cpp

@@ -7,6 +7,7 @@
 #include "bindings/DOMExceptionBindings.hpp"
 #include "bindings/ElementBindings.hpp"
 #include "bindings/DocumentBindings.hpp"
+#include "bindings/DOMParserBindings.hpp"
 #include "bindings/EventBindings.hpp"
 #include "bindings/TimerBindings.hpp"
 #include "bindings/WindowBindings.hpp"
@@ -15,6 +16,7 @@
 #include "bindings/UrlBindings.hpp"
 #include "bindings/AbortBindings.hpp"
 #include "bindings/TextEncodingBindings.hpp"
+#include "bindings/IntlBindings.hpp"
 #include "bindings/FormBindings.hpp"
 #include "bindings/BlobBindings.hpp"
 #include "bindings/CSSOMBindings.hpp"
@@ -24,6 +26,10 @@
 #include "bindings/TemplateBindings.hpp"
 #include "bindings/SlotBindings.hpp"
 #include "bindings/XmlSerializerBindings.hpp"
+#include "bindings/LayoutStubBindings.hpp"
+#include "bindings/TreeWalkerBindings.hpp"
+#include "bindings/EventTargetBindings.hpp"
+#include "bindings/WindowNamedPropertiesBindings.hpp"
 #include <lexbor/html/html.h>
 #include <lexbor/dom/dom.h>
 
@@ -36,13 +42,14 @@ namespace margelo::nitro::nitrojsdom {
 
 void DOMBindings::install(QuickJSRuntime* runtime, LexborDocument* document) {
   JSContext* ctx = static_cast<JSContext*>(runtime->context());
-  (void)document;
+  register_document(ctx, document); // so doc_for_node() resolves nodes back to the primary document
 
   DOMExceptionBindings::install(ctx); // no dependencies; other modules throw DOMException instances
   LiveCollectionBindings::install(ctx);
   ElementBindings::install(ctx);   // registers the Element class + proto
   ShadowRootBindings::install(ctx); // needs Element's proto + js_node_class_id's proto
   DocumentBindings::install(ctx);  // creates globalThis.document
+  DOMParserBindings::install(ctx); // adds document.implementation + globalThis.DOMParser; needs globalThis.document
   CookieBindings::install(ctx);    // needs globalThis.document to exist
   TemplateBindings::install(ctx);  // needs Element's proto
   CustomElementsBindings::install(ctx); // needs Element/ShadowRoot protos + globalThis.document
@@ -53,11 +60,15 @@ void DOMBindings::install(QuickJSRuntime* runtime, LexborDocument* document) {
   UrlBindings::install(ctx);
   AbortBindings::install(ctx);
   TextEncodingBindings::install(ctx);
+  IntlBindings::install(ctx);
   BlobBindings::install(ctx);      // uses TextEncoder/TextDecoder + btoa, so must run after both
   FetchBindings::install(ctx);     // XHR bootstrap uses `new Event(...)`, so must run after EventBindings
   FormBindings::install(ctx);      // uses globalThis.Element + globalThis.Event, so must run after both
   SlotBindings::install(ctx);      // uses Event/dispatchEvent + Element/ShadowRoot protos, so must run after EventBindings/ShadowRootBindings
   XmlSerializerBindings::install(ctx); // pure serialization, no ordering requirement beyond ElementBindings
+  LayoutStubBindings::install(ctx); // needs Element's proto + globalThis.document to exist
+  TreeWalkerBindings::install(ctx); // needs Element's proto (Node traversal props) + globalThis.document to exist
+  EventTargetBindings::install(ctx); // no dependencies
 
   // ── localStorage / sessionStorage ──────────────────────────────────────────
   {
@@ -80,6 +91,8 @@ void DOMBindings::install(QuickJSRuntime* runtime, LexborDocument* document) {
       rctx->mutation_observers->install(ctx, doc_node);
     }
   }
+
+  WindowNamedPropertiesBindings::install(ctx); // must run last, after localStorage/sessionStorage exist
 }
 
 } // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/DOMBindingsInternal.cpp

@@ -126,6 +126,40 @@ LexborDocument* get_doc(JSContext* ctx) {
   return rctx ? rctx->document : nullptr;
 }
 
+LexborDocument* doc_for_node(JSContext* ctx, void* node) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx) return nullptr;
+  if (node) {
+    auto* dom_node = static_cast<lxb_dom_node_t*>(node);
+    auto it = rctx->document_registry.find(dom_node->owner_document);
+    if (it != rctx->document_registry.end()) return it->second;
+  }
+  return rctx->document;
+}
+
+void register_document(JSContext* ctx, LexborDocument* doc) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx || !doc) return;
+  auto* html_doc = static_cast<lxb_html_document_t*>(doc->documentHtmlPtr());
+  if (!html_doc) return;
+  void* dom_doc = lxb_dom_interface_document(html_doc);
+  rctx->document_registry[dom_doc] = doc;
+}
+
+void register_document_wrapper(JSContext* ctx, LexborDocument* doc, JSValue wrapper) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx || !doc) return;
+  rctx->document_wrappers[doc] = new JSValue(JS_DupValue(ctx, wrapper));
+}
+
+JSValue get_document_wrapper(JSContext* ctx, LexborDocument* doc) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx || !doc) return JS_UNDEFINED;
+  auto it = rctx->document_wrappers.find(doc);
+  if (it == rctx->document_wrappers.end()) return JS_UNDEFINED;
+  return JS_DupValue(ctx, *static_cast<JSValue*>(it->second));
+}
+
 void define_prop(JSContext* ctx, JSValue obj, const char* name, GetterFn getter, SetterFn setter) {
   JSAtom atom = JS_NewAtom(ctx, name);
   JSValue get_fn = JS_NewCFunction2(ctx, (JSCFunction*)getter, name, 0, JS_CFUNC_getter, 0);
@@ -136,6 +170,39 @@ void define_prop(JSContext* ctx, JSValue obj, const char* name, GetterFn getter,
   JS_FreeAtom(ctx, atom);
 }
 
+void define_node_type_constants(JSContext* ctx, JSValue obj) {
+  static const struct { const char* name; int32_t value; } kNodeTypeConstants[] = {
+    { "ELEMENT_NODE",                1  },
+    { "ATTRIBUTE_NODE",              2  },
+    { "TEXT_NODE",                   3  },
+    { "CDATA_SECTION_NODE",          4  },
+    { "ENTITY_REFERENCE_NODE",       5  },
+    { "ENTITY_NODE",                 6  },
+    { "PROCESSING_INSTRUCTION_NODE", 7  },
+    { "COMMENT_NODE",                8  },
+    { "DOCUMENT_NODE",               9  },
+    { "DOCUMENT_TYPE_NODE",          10 },
+    { "DOCUMENT_FRAGMENT_NODE",      11 },
+    { "NOTATION_NODE",               12 },
+  };
+  for (const auto& c : kNodeTypeConstants) {
+    JS_DefinePropertyValueStr(ctx, obj, c.name, JS_NewInt32(ctx, c.value), JS_PROP_ENUMERABLE);
+  }
+}
+
+JSValue build_doctype_object(JSContext* ctx, LexborDocument* doc, void* doctype) {
+  JSValue obj = JS_NewObject(ctx);
+  std::string name = doc->doctypeName(doctype);
+  JS_SetPropertyStr(ctx, obj, "name", JS_NewStringLen(ctx, name.data(), name.size()));
+  std::string publicId = doc->doctypePublicId(doctype);
+  JS_SetPropertyStr(ctx, obj, "publicId", JS_NewStringLen(ctx, publicId.data(), publicId.size()));
+  std::string systemId = doc->doctypeSystemId(doctype);
+  JS_SetPropertyStr(ctx, obj, "systemId", JS_NewStringLen(ctx, systemId.data(), systemId.size()));
+  JS_SetPropertyStr(ctx, obj, "nodeType", JS_NewInt32(ctx, 10));
+  JS_SetPropertyStr(ctx, obj, "nodeName", JS_NewStringLen(ctx, name.data(), name.size()));
+  return obj;
+}
+
 JSValue js_illegal_constructor(JSContext* ctx, JSValue, int, JSValue*) {
   return JS_ThrowTypeError(ctx, "Illegal constructor");
 }

package/cpp/quickjs/DOMBindingsInternal.hpp

@@ -56,6 +56,34 @@ std::string serialize_node(lxb_dom_node_t* node);
 RuntimeContext* get_ctx(JSContext* ctx);
 LexborDocument* get_doc(JSContext* ctx);
 
+// Resolves the LexborDocument that owns `node`'s tree — the sandbox's
+// primary document, or a secondary document created via
+// DOMParser.parseFromString()/document.implementation.createHTMLDocument()
+// (see DOMParserBindings). Any binding that *creates* a new node relative to
+// an existing one (textContent/innerHTML setters, insertAdjacentHTML,
+// before/after/replaceWith/append/prepend's string-to-text-node coercion,
+// matches()/closest()) must resolve the document this way instead of using
+// get_doc(ctx) directly — otherwise a node from a secondary document would
+// have children created in the *primary* document's memory arena, which is
+// undefined behavior once either document is destroyed. Falls back to the
+// primary document if `node`'s owner isn't registered (shouldn't happen).
+LexborDocument* doc_for_node(JSContext* ctx, void* node);
+
+// Registers `doc` in the runtime's document registry so doc_for_node() can
+// resolve nodes created inside it back to `doc`. Call once, right after the
+// document is constructed/parsed.
+void register_document(JSContext* ctx, LexborDocument* doc);
+
+// Registers `wrapper` (the JS Document object returned to script) as the
+// canonical JS object for `doc`, so get_document_wrapper() can hand back the
+// same reference later (e.g. from node.ownerDocument) instead of building a
+// new, unequal one. Call once, alongside register_document().
+void register_document_wrapper(JSContext* ctx, LexborDocument* doc, JSValue wrapper);
+
+// Returns the JSValue registered via register_document_wrapper() for `doc`,
+// or JS_UNDEFINED if none was registered.
+JSValue get_document_wrapper(JSContext* ctx, LexborDocument* doc);
+
 // ── Node wrapper cache ────────────────────────────────────────────────────────
 
 void invalidate_node_cache(JSContext* ctx, RuntimeContext* rctx, void* node);
@@ -75,6 +103,17 @@ using SetterFn = JSValue (*)(JSContext*, JSValue, JSValue);
 
 void define_prop(JSContext* ctx, JSValue obj, const char* name, GetterFn getter, SetterFn setter = nullptr);
 
+// Sets the WHATWG DOM Node.ELEMENT_NODE-style numeric constants (ELEMENT_NODE,
+// TEXT_NODE, COMMENT_NODE, ...) as read-only enumerable properties on `obj`.
+// Values match lxb_dom_node_type_t, which already mirrors the DOM spec numbering.
+void define_node_type_constants(JSContext* ctx, JSValue obj);
+
+// Builds the plain {name, publicId, systemId, nodeType, nodeName} object used
+// to represent a document's DocumentType node (see doc->doctype()). Shared by
+// DocumentBindings (which layers its own identity cache on top) and
+// DOMParserBindings (which doesn't cache — see its call site).
+JSValue build_doctype_object(JSContext* ctx, LexborDocument* doc, void* doctype);
+
 // ── Global constructor helper (instanceof support) ────────────────────────────
 
 JSValue js_illegal_constructor(JSContext* ctx, JSValue this_val, int argc, JSValue* argv);

package/cpp/quickjs/QuickJSRuntime.cpp

@@ -2,6 +2,7 @@
 #include "DOMBindings.hpp"
 #include "DOMBindingsInternal.hpp"
 #include "MutationObservers.hpp"
+#include "bindings/EventBindings.hpp"
 #include "../lexbor/LexborDocument.hpp"
 #include "quickjs.h"
 #include <stdexcept>
@@ -98,6 +99,14 @@ QuickJSRuntime::~QuickJSRuntime() {
       delete stored;
       _ctxState->doctype_wrapper = nullptr;
     }
+
+    // Free cached secondary-document wrappers
+    for (auto& kv : _ctxState->document_wrappers) {
+      JSValue* stored = static_cast<JSValue*>(kv.second);
+      JS_FreeValue(ctx, *stored);
+      delete stored;
+    }
+    _ctxState->document_wrappers.clear();
   }
 
   if (_context) JS_FreeContext(reinterpret_cast<JSContext*>(_context));
@@ -243,6 +252,7 @@ void QuickJSRuntime::drainEventLoop() {
           }
           JS_FreeValue(ctx, str_val);
         }
+        EventBindings::dispatchErrorEvent(ctx, err, ex);
         JS_FreeValue(ctx, ex);
         throw std::runtime_error(err);
       }
@@ -266,6 +276,7 @@ void QuickJSRuntime::drainEventLoop() {
         }
         JS_FreeValue(ctx, str_val);
       }
+      EventBindings::dispatchUnhandledRejectionEvent(ctx, *stored);
       JS_FreeValue(ctx, *stored);
       delete stored;
       _ctxState->pending_rejection = nullptr;
@@ -394,6 +405,7 @@ void QuickJSRuntime::fireTimer(Timer* t) {
       }
       JS_FreeValue(ctx, str_val);
     }
+    EventBindings::dispatchErrorEvent(ctx, err, ex);
     JS_FreeValue(ctx, ex);
     throw std::runtime_error(err);
   }
@@ -440,6 +452,7 @@ std::string QuickJSRuntime::evaluate(const std::string& script) {
       JS_FreeValue(ctx, str_val);
     }
 
+    EventBindings::dispatchErrorEvent(ctx, err, ex);
     JS_FreeValue(ctx, ex);
     QJS_LOG("QuickJS exception: %s", err.c_str());
     throw std::runtime_error(err);

package/cpp/quickjs/QuickJSRuntime.hpp

@@ -39,6 +39,7 @@ struct EventListener {
   void* node;              // lxb_dom_node_t*
   std::string event_type;
   void* callback;          // JSValue* (heap-allocated, owned)
+  bool is_handler_property { false };
 };
 
 // ── RuntimeContext ─────────────────────────────────────────────────────────────
@@ -75,6 +76,10 @@ struct RuntimeContext {
   bool pretend_to_be_visual { false };
   double time_origin_ms { 0 };
 
+  void* active_element { nullptr };
+  void* current_script { nullptr };
+  std::string ready_state { "loading" };
+
   // node pointer → heap-allocated JSValue* (DupValue'd strong ref)
   // Ensures the same native node always returns the same JS wrapper object.
   std::unordered_map<void*, void*> node_wrapper_cache;
@@ -91,6 +96,30 @@ struct RuntimeContext {
   // back-pointer to an attached shadow root, so we track it ourselves.
   std::unordered_map<void*, void*> element_shadow_roots;
 
+  // Secondary documents created via DOMParser.parseFromString() /
+  // document.implementation.createHTMLDocument() (see DOMParserBindings).
+  // Owned here rather than by their JS wrapper's finalizer: QuickJS class
+  // finalizers only receive a JSRuntime*, not the JSContext needed to safely
+  // touch document_registry below, so they're freed together with the rest
+  // of the sandbox instead of individually via GC.
+  std::vector<std::unique_ptr<LexborDocument>> extra_documents;
+
+  // Raw lexbor document pointer (lxb_dom_document_t*) -> the LexborDocument
+  // wrapper that owns it (primary sandbox document, or one of
+  // extra_documents). Lets node-scoped bindings that create new nodes
+  // (textContent/innerHTML setters, insertAdjacentHTML, matches()/closest())
+  // resolve the *correct* owning document instead of assuming the sandbox's
+  // primary `document` — which would otherwise create nodes in the wrong
+  // document's memory arena when called on a DOMParser-produced element.
+  // See doc_for_node() in DOMBindingsInternal.
+  std::unordered_map<void*, LexborDocument*> document_registry;
+
+  // LexborDocument* -> its JS wrapper (JSValue*, heap-allocated, owned).
+  // Lets node.ownerDocument return the same JS object DOMParser.
+  // parseFromString()/createHTMLDocument() already handed the caller,
+  // instead of building a second, unequal wrapper for the same document.
+  std::unordered_map<LexborDocument*, void*> document_wrappers;
+
   ~RuntimeContext() = default;
 };
 

package/cpp/quickjs/bindings/AbortBindings.cpp

@@ -86,6 +86,20 @@ const char* kAbortBootstrapScript = R"JS(
     setTimeout(function() { s._abort(makeTimeoutError()); }, ms);
     return s;
   };
+  AbortSignal.any = function(signals) {
+    var s = new AbortSignal();
+    var list = [];
+    for (var i = 0; i < signals.length; i++) list.push(signals[i]);
+    for (var j = 0; j < list.length; j++) {
+      if (list[j].aborted) { s._abort(list[j].reason); break; }
+    }
+    if (!s.aborted) {
+      list.forEach(function(signal) {
+        signal.addEventListener('abort', function() { s._abort(signal.reason); });
+      });
+    }
+    return s;
+  };
 
   globalThis.AbortSignal = AbortSignal;
 

package/cpp/quickjs/bindings/BlobBindings.cpp

@@ -20,6 +20,16 @@ const char* kBlobBootstrapScript = R"JS(
     return Array.prototype.slice.call(new TextEncoder().encode(String(part)));
   }
 
+  function normalizeBlobType(type) {
+    if (type === undefined || type === null) return '';
+    var s = String(type);
+    for (var i = 0; i < s.length; i++) {
+      var code = s.charCodeAt(i);
+      if (code < 0x20 || code > 0x7e) return '';
+    }
+    return s.toLowerCase();
+  }
+
   function Blob(parts, options) {
     var bytes = [];
     if (parts) {
@@ -29,7 +39,7 @@ const char* kBlobBootstrapScript = R"JS(
     }
     this._bytes = bytes;
     this.size = bytes.length;
-    this.type = (options && options.type) ? String(options.type) : '';
+    this.type = normalizeBlobType(options && options.type);
   }
   Blob.prototype.slice = function(start, end, contentType) {
     var sliced = this._bytes.slice(start, end);
@@ -55,6 +65,23 @@ const char* kBlobBootstrapScript = R"JS(
   };
   globalThis.Blob = Blob;
 
+  function File(parts, name, options) {
+    Blob.call(this, parts, options);
+    var lastModified;
+    if (options && options.lastModified !== undefined) {
+      var n = Number(options.lastModified);
+      lastModified = (isNaN(n) || !isFinite(n)) ? 0 : Math.trunc(n);
+    } else {
+      lastModified = Date.now();
+    }
+
+    Object.defineProperty(this, 'name', { value: String(name), enumerable: true, configurable: true });
+    Object.defineProperty(this, 'lastModified', { value: lastModified, enumerable: true, configurable: true });
+  }
+  File.prototype = Object.create(Blob.prototype);
+  File.prototype.constructor = File;
+  globalThis.File = File;
+
   function FileReader() {
     this.readyState = 0;
     this.result = null;

package/cpp/quickjs/bindings/BlobBindings.hpp

@@ -4,9 +4,9 @@
 
 namespace margelo::nitro::nitrojsdom {
 
-// Registers globalThis.Blob and globalThis.FileReader. Pure JS on top of
-// TextEncoder/TextDecoder and btoa, so must run after TextEncodingBindings
-// and WindowBindings.
+// Registers globalThis.Blob, globalThis.File, and globalThis.FileReader.
+// Pure JS on top of TextEncoder/TextDecoder and btoa, so must run after
+// TextEncodingBindings and WindowBindings.
 struct BlobBindings {
   static void install(JSContext* ctx);
 };