xbintsc 0.3.18 → 0.3.35

package/runtime/ext_gui/css_match.cpp

@@ -0,0 +1,195 @@
+/*
+ * xbintsc GUI engine — CSS selector matching against the DOM.
+ */
+
+#include "css_internal.h"
+
+#include <cstdlib>
+#include <memory>
+
+namespace xtgui {
+
+namespace {
+
+bool hasClass(const Node *node, const std::string &name) {
+  const std::string *value = node->attr("class");
+  if (value == nullptr) return false;
+  for (const std::string &token : xt_css_split_whitespace(*value)) {
+    if (token == name) return true;
+  }
+  return false;
+}
+
+bool matchAttribute(const Node *node, const AttrSelector &attr) {
+  const std::string *value = node->attr(attr.name);
+  if (value == nullptr) return false;
+  if (attr.op.empty()) return true;
+  if (attr.op == "=") return *value == attr.value;
+  if (attr.op == "~=") {
+    for (const std::string &token : xt_css_split_whitespace(*value)) {
+      if (token == attr.value) return true;
+    }
+    return false;
+  }
+  if (attr.op == "|=") {
+    return *value == attr.value || value->rfind(attr.value + "-", 0) == 0;
+  }
+  if (attr.op == "^=") return !attr.value.empty() && value->rfind(attr.value, 0) == 0;
+  if (attr.op == "$=") {
+    return !attr.value.empty() && value->size() >= attr.value.size() &&
+           value->compare(value->size() - attr.value.size(), attr.value.size(), attr.value) == 0;
+  }
+  if (attr.op == "*=") {
+    return !attr.value.empty() && value->find(attr.value) != std::string::npos;
+  }
+  return false;
+}
+
+/** Parse the `an+b` micro-syntax of `:nth-child`. */
+bool parseNth(const std::string &expression, int *a, int *b) {
+  std::string text;
+  for (char c : xt_css_lower(xt_css_trim(expression))) {
+    if (!xt_is_css_space(c)) text.push_back(c);
+  }
+  if (text == "odd") { *a = 2; *b = 1; return true; }
+  if (text == "even") { *a = 2; *b = 0; return true; }
+  size_t nPos = text.find('n');
+  if (nPos == std::string::npos) {
+    *a = 0;
+    *b = atoi(text.c_str());
+    return !text.empty();
+  }
+  std::string aPart = text.substr(0, nPos);
+  std::string bPart = text.substr(nPos + 1);
+  if (aPart.empty() || aPart == "+") *a = 1;
+  else if (aPart == "-") *a = -1;
+  else *a = atoi(aPart.c_str());
+  if (bPart.empty()) *b = 0;
+  else *b = atoi(bPart.c_str());
+  return true;
+}
+
+bool matchesNth(int index, const std::string &expression) {
+  int a = 0;
+  int b = 0;
+  if (!parseNth(expression, &a, &b)) return false;
+  if (a == 0) return index == b;
+  int diff = index - b;
+  if (a > 0) return diff >= 0 && diff % a == 0;
+  return diff <= 0 && (-diff) % (-a) == 0;
+}
+
+bool isHoverTarget(const Node *node, const Node *hover) {
+  for (const Node *current = hover; current != nullptr; current = current->parent) {
+    if (current == node) return true;
+  }
+  return false;
+}
+
+bool matchPseudo(const Node *node, const std::string &pseudo, const MatchState &state) {
+  if (pseudo == "first-child") return node->elementIndex() == 0 && node->elementSiblingCount() > 0;
+  if (pseudo == "last-child") return node->elementIndex() == node->elementSiblingCount() - 1;
+  if (pseudo == "only-child") return node->elementSiblingCount() == 1;
+  if (pseudo == "root") return node->parent != nullptr && node->parent->isDocument();
+  if (pseudo == "hover") return isHoverTarget(node, state.hover);
+  if (pseudo == "focus") return node == state.focus;
+  if (pseudo == "empty") {
+    for (const std::unique_ptr<Node> &child : node->children) {
+      if (child->isElement()) return false;
+      if (child->isText() && !xt_css_trim(child->text).empty()) return false;
+    }
+    return true;
+  }
+  if (pseudo == "disabled") return node->attr("disabled") != nullptr;
+  if (pseudo == "checked") return node->attr("checked") != nullptr;
+  if (pseudo.rfind("nth-child(", 0) == 0) {
+    return matchesNth(node->elementIndex() + 1, pseudo.substr(10, pseudo.size() - 11));
+  }
+  if (pseudo.rfind("not(", 0) == 0) {
+    std::string inner = xt_css_trim(pseudo.substr(4, pseudo.size() - 5));
+    std::vector<ComplexSelector> parsed = xt_css_parse_selector_list(inner);
+    if (parsed.empty() || parsed[0].compounds.size() != 1) return false;
+    const CompoundSelector &compound = parsed[0].compounds[0];
+    for (const AttrSelector &attr : compound.attrs) {
+      if (!matchAttribute(node, attr)) return true;
+    }
+    if (!compound.id.empty()) {
+      const std::string *id = node->attr("id");
+      if (id == nullptr || *id != compound.id) return true;
+    }
+    if (!compound.tag.empty() && node->tag != compound.tag) return true;
+    for (const std::string &name : compound.classes) {
+      if (!hasClass(node, name)) return true;
+    }
+    for (const std::string &nested : compound.pseudoClasses) {
+      if (!matchPseudo(node, nested, state)) return true;
+    }
+    return false;
+  }
+  /* Truly unknown / unsupported pseudo-classes never match. */
+  return false;
+}
+
+bool matchCompound(const Node *node, const CompoundSelector &compound, const MatchState &state) {
+  if (!node->isElement()) return false;
+  if (!compound.tag.empty() && node->tag != compound.tag) return false;
+  if (!compound.id.empty()) {
+    const std::string *id = node->attr("id");
+    if (id == nullptr || *id != compound.id) return false;
+  }
+  for (const std::string &name : compound.classes) {
+    if (!hasClass(node, name)) return false;
+  }
+  for (const AttrSelector &attr : compound.attrs) {
+    if (!matchAttribute(node, attr)) return false;
+  }
+  for (const std::string &pseudo : compound.pseudoClasses) {
+    if (!matchPseudo(node, pseudo, state)) return false;
+  }
+  return true;
+}
+
+bool matchAt(const Node *node, const ComplexSelector &selector, size_t index,
+             const MatchState &state) {
+  if (!matchCompound(node, selector.compounds[index], state)) return false;
+  if (index == 0) return true;
+  Combinator combinator = selector.combinators[index - 1];
+  if (combinator == Combinator::Child) {
+    return node->parent != nullptr && node->parent->isElement() &&
+           matchAt(node->parent, selector, index - 1, state);
+  }
+  if (combinator == Combinator::Descendant) {
+    for (const Node *parent = node->parent; parent != nullptr; parent = parent->parent) {
+      if (parent->isElement() && matchAt(parent, selector, index - 1, state)) return true;
+    }
+    return false;
+  }
+  if (node->parent == nullptr) return false;
+  if (combinator == Combinator::Adjacent) {
+    const Node *previous = nullptr;
+    for (const std::unique_ptr<Node> &sibling : node->parent->children) {
+      if (sibling.get() == node) break;
+      if (sibling->isElement()) previous = sibling.get();
+    }
+    return previous != nullptr && matchAt(previous, selector, index - 1, state);
+  }
+  /* General sibling combinator (`~`): any previous element sibling. */
+  for (const std::unique_ptr<Node> &sibling : node->parent->children) {
+    if (sibling.get() == node) break;
+    if (sibling->isElement() && matchAt(sibling.get(), selector, index - 1, state)) return true;
+  }
+  return false;
+}
+
+}  // namespace
+
+bool xt_css_match(const Node *node, const ComplexSelector &selector) {
+  return xt_css_match(node, selector, MatchState());
+}
+
+bool xt_css_match(const Node *node, const ComplexSelector &selector, const MatchState &state) {
+  if (selector.compounds.empty()) return false;
+  return matchAt(node, selector, selector.compounds.size() - 1, state);
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/css_selector.cpp

@@ -0,0 +1,207 @@
+/*
+ * xbintsc GUI engine — CSS selector list parser.
+ */
+
+#include "css_internal.h"
+
+namespace xtgui {
+
+namespace {
+
+class SelectorParser {
+ public:
+  explicit SelectorParser(const std::string &text) : text_(text) {}
+
+  std::vector<ComplexSelector> parseList() {
+    std::vector<ComplexSelector> selectors;
+    size_t start = 0;
+    int depth = 0;
+    for (size_t i = 0; i <= text_.size(); i++) {
+      char c = (i < text_.size()) ? text_[i] : ',';
+      if (c == '(' || c == '[') depth++;
+      else if (c == ')' || c == ']') depth--;
+      else if (c == ',' && depth == 0) {
+        std::string part = text_.substr(start, i - start);
+        ComplexSelector selector;
+        if (parseComplex(part, &selector) && !selector.compounds.empty()) {
+          selectors.push_back(std::move(selector));
+        }
+        start = i + 1;
+      }
+    }
+    return selectors;
+  }
+
+ private:
+  const std::string &text_;
+
+  std::string readIdent(const std::string &text, size_t *index) {
+    size_t start = *index;
+    while (*index < text.size() && xt_css_is_ident_char(text[*index])) (*index)++;
+    return text.substr(start, *index - start);
+  }
+
+  /** Parse `div.foo#bar[a="b"]:pseudo` into one compound selector. */
+  bool parseCompound(const std::string &text, size_t *index, CompoundSelector *compound) {
+    bool any = false;
+    while (*index < text.size()) {
+      char c = text[*index];
+      if (xt_is_css_space(c) || c == '>' || c == '+' || c == '~' || c == ',') break;
+      if (c == '*') {
+        (*index)++;
+        any = true;
+      } else if (c == '.') {
+        (*index)++;
+        std::string name = readIdent(text, index);
+        if (name.empty()) return false;
+        compound->classes.push_back(name);
+        any = true;
+      } else if (c == '#') {
+        (*index)++;
+        compound->id = readIdent(text, index);
+        any = true;
+      } else if (c == '[') {
+        if (!parseAttribute(text, index, compound)) return false;
+        any = true;
+      } else if (c == ':') {
+        (*index)++;
+        bool pseudoElement = false;
+        if (*index < text.size() && text[*index] == ':') {
+          pseudoElement = true;
+          (*index)++;
+        }
+        std::string name = xt_css_lower(readIdent(text, index));
+        if (name.empty()) return false;
+        if (!pseudoElement && *index < text.size() && text[*index] == '(') {
+          int depth = 0;
+          size_t start = *index;
+          while (*index < text.size()) {
+            if (text[*index] == '(') depth++;
+            else if (text[*index] == ')') {
+              depth--;
+              if (depth == 0) {
+                (*index)++;
+                break;
+              }
+            }
+            (*index)++;
+          }
+          name += text.substr(start, *index - start);
+        }
+        compound->pseudoClasses.push_back(name);
+        any = true;
+      } else if (xt_css_is_ident_start(c)) {
+        compound->tag = xt_css_lower(readIdent(text, index));
+        any = true;
+      } else {
+        return false;
+      }
+    }
+    return any;
+  }
+
+  bool parseAttribute(const std::string &text, size_t *index, CompoundSelector *compound) {
+    (*index)++;  // '['
+    while (*index < text.size() && xt_is_css_space(text[*index])) (*index)++;
+    AttrSelector attr;
+    attr.name = xt_css_lower(readIdent(text, index));
+    if (attr.name.empty()) return false;
+    while (*index < text.size() && xt_is_css_space(text[*index])) (*index)++;
+    if (*index < text.size() && text[*index] == ']') {
+      (*index)++;
+      compound->attrs.push_back(attr);
+      return true;
+    }
+    if (*index < text.size() && (text[*index] == '=' || text[*index] == '~' || text[*index] == '|' ||
+                                 text[*index] == '^' || text[*index] == '$' || text[*index] == '*')) {
+      std::string op(1, text[*index]);
+      (*index)++;
+      if (*index < text.size() && text[*index] == '=') {
+        op += '=';
+        (*index)++;
+      } else if (op != "=") {
+        /* Only `~= |= ^= $= *=` need a trailing `=`; a lone `=` is complete. */
+        return false;
+      }
+      while (*index < text.size() && xt_is_css_space(text[*index])) (*index)++;
+      std::string value;
+      if (*index < text.size() && (text[*index] == '"' || text[*index] == '\'')) {
+        char quote = text[(*index)++];
+        size_t start = *index;
+        while (*index < text.size() && text[*index] != quote) (*index)++;
+        value = text.substr(start, *index - start);
+        if (*index < text.size()) (*index)++;
+      } else {
+        value = readIdent(text, index);
+      }
+      attr.op = op;
+      attr.value = value;
+    }
+    while (*index < text.size() && xt_is_css_space(text[*index])) (*index)++;
+    if (*index >= text.size() || text[*index] != ']') return false;
+    (*index)++;
+    compound->attrs.push_back(attr);
+    return true;
+  }
+
+  bool parseComplex(const std::string &text, ComplexSelector *selector) {
+    size_t index = 0;
+    while (index < text.size() && xt_is_css_space(text[index])) index++;
+    while (index < text.size()) {
+      CompoundSelector compound;
+      if (!parseCompound(text, &index, &compound)) return false;
+      selector->compounds.push_back(std::move(compound));
+      bool hadSpace = false;
+      while (index < text.size() && xt_is_css_space(text[index])) {
+        hadSpace = true;
+        index++;
+      }
+      if (index >= text.size() || text[index] == ',') break;
+      char c = text[index];
+      if (c == '>' || c == '+' || c == '~') {
+        index++;
+        while (index < text.size() && xt_is_css_space(text[index])) index++;
+        selector->combinators.push_back(c == '>' ? Combinator::Child
+                                          : c == '+' ? Combinator::Adjacent
+                                                     : Combinator::Sibling);
+      } else if (hadSpace) {
+        selector->combinators.push_back(Combinator::Descendant);
+      } else {
+        return false;
+      }
+    }
+    if (selector->combinators.size() + 1 != selector->compounds.size()) {
+      /* Ensure the invariant holds even if parsing stopped early. */
+      selector->combinators.resize(selector->compounds.size() > 0 ? selector->compounds.size() - 1 : 0);
+    }
+    selector->specificity = computeSpecificity(*selector);
+    return true;
+  }
+
+  static int computeCompoundSpecificity(const CompoundSelector &compound) {
+    /* `:not(x)` is approximated as a class; pseudo-elements would count as a
+     * type but are not modelled yet. Good enough for a UI stylesheet. */
+    return (int)(compound.classes.size() + compound.attrs.size() + compound.pseudoClasses.size());
+  }
+
+  static int computeSpecificity(const ComplexSelector &selector) {
+    int ids = 0;
+    int classes = 0;
+    int types = 0;
+    for (const CompoundSelector &compound : selector.compounds) {
+      if (!compound.id.empty()) ids++;
+      classes += computeCompoundSpecificity(compound);
+      if (!compound.tag.empty()) types++;
+    }
+    return (ids << 20) | (classes << 10) | types;
+  }
+};
+
+}  // namespace
+
+std::vector<ComplexSelector> xt_css_parse_selector_list(const std::string &text) {
+  SelectorParser parser(text);
+  return parser.parseList();
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/css_sheet.cpp

@@ -0,0 +1,129 @@
+/*
+ * xbintsc GUI engine — CSS declaration and stylesheet parsing.
+ */
+
+#include "css_internal.h"
+
+namespace xtgui {
+
+namespace {
+
+// Strip C-style block comments before the sheet is tokenised.
+std::string stripComments(const std::string &text) {
+  std::string out;
+  out.reserve(text.size());
+  for (size_t i = 0; i < text.size(); i++) {
+    if (text[i] == '/' && i + 1 < text.size() && text[i + 1] == '*') {
+      size_t end = text.find("*/", i + 2);
+      i = (end == std::string::npos) ? text.size() : end + 1;
+      continue;
+    }
+    out.push_back(text[i]);
+  }
+  return out;
+}
+
+/** Find the first `needle` at nesting depth zero (parens/brackets/quotes). */
+size_t findTopLevel(const std::string &text, char needle, size_t from) {
+  int depth = 0;
+  char quote = 0;
+  for (size_t i = from; i < text.size(); i++) {
+    char c = text[i];
+    if (quote != 0) {
+      if (c == quote) quote = 0;
+      continue;
+    }
+    if (c == '"' || c == '\'') quote = c;
+    else if (c == '(' || c == '[') depth++;
+    else if (c == ')' || c == ']') depth--;
+    else if (c == needle && depth == 0) return i;
+  }
+  return std::string::npos;
+}
+
+std::string stripImportant(std::string value, bool *important) {
+  size_t pos = value.rfind('!');
+  if (pos == std::string::npos) return value;
+  std::string flag = xt_css_lower(xt_css_trim(value.substr(pos + 1)));
+  if (flag == "important") {
+    *important = true;
+    return xt_css_trim(value.substr(0, pos));
+  }
+  return value;
+}
+
+}  // namespace
+
+std::vector<Declaration> xt_css_parse_declarations(const std::string &text) {
+  std::vector<Declaration> declarations;
+  size_t start = 0;
+  while (start < text.size()) {
+    size_t end = findTopLevel(text, ';', start);
+    if (end == std::string::npos) end = text.size();
+    std::string part = text.substr(start, end - start);
+    start = end + 1;
+    size_t colon = findTopLevel(part, ':', 0);
+    if (colon == std::string::npos) continue;
+    Declaration declaration;
+    declaration.property = xt_css_lower(xt_css_trim(part.substr(0, colon)));
+    declaration.value = stripImportant(xt_css_trim(part.substr(colon + 1)), &declaration.important);
+    if (!declaration.property.empty() && !declaration.value.empty()) {
+      declarations.push_back(std::move(declaration));
+    }
+  }
+  return declarations;
+}
+
+StyleSheet xt_css_parse_stylesheet(const std::string &text) {
+  StyleSheet sheet;
+  std::string clean = stripComments(text);
+  size_t index = 0;
+  int order = 0;
+  while (index < clean.size()) {
+    while (index < clean.size() && xt_is_css_space(clean[index])) index++;
+    if (index >= clean.size()) break;
+    if (clean[index] == '@') {
+      size_t brace = clean.find('{', index);
+      size_t semi = clean.find(';', index);
+      if (brace != std::string::npos && (semi == std::string::npos || brace < semi)) {
+        int depth = 0;
+        size_t i = brace;
+        for (; i < clean.size(); i++) {
+          if (clean[i] == '{') depth++;
+          else if (clean[i] == '}') {
+            depth--;
+            if (depth == 0) break;
+          }
+        }
+        index = (i < clean.size()) ? i + 1 : clean.size();
+      } else {
+        index = (semi == std::string::npos) ? clean.size() : semi + 1;
+      }
+      continue;
+    }
+    size_t brace = clean.find('{', index);
+    if (brace == std::string::npos) break;
+    int depth = 0;
+    size_t close = std::string::npos;
+    for (size_t i = brace; i < clean.size(); i++) {
+      if (clean[i] == '{') depth++;
+      else if (clean[i] == '}') {
+        depth--;
+        if (depth == 0) {
+          close = i;
+          break;
+        }
+      }
+    }
+    if (close == std::string::npos) break;
+    Rule rule;
+    rule.selectors = xt_css_parse_selector_list(clean.substr(index, brace - index));
+    rule.declarations = xt_css_parse_declarations(clean.substr(brace + 1, close - brace - 1));
+    rule.order = order++;
+    if (!rule.selectors.empty() && !rule.declarations.empty()) sheet.rules.push_back(std::move(rule));
+    index = close + 1;
+  }
+  return sheet;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/document.cpp

@@ -24,6 +24,8 @@ void XtDocument::collectStyleText(const Node *node, std::string *out) const {
 
 void XtDocument::load(const std::string &html, float viewportWidth, float viewportHeight) {
   root_ = xt_html_parse(html);
+  detached_.clear();
+  dirty_ = false;
   hover_ = nullptr;
   focus_ = nullptr;
   styles_.clear();
@@ -261,4 +263,92 @@ std::string XtDocument::toDebugString() const {
   return root_ == nullptr ? std::string() : xt_dom_to_string(root_.get());
 }
 
+/* -- DOM mutation --------------------------------------------------------- */
+
+Node *XtDocument::createElement(const std::string &tag) {
+  auto node = std::make_unique<Node>(NodeType::Element);
+  node->tag = tag;
+  Node *raw = node.get();
+  detached_[raw] = std::move(node);
+  return raw;
+}
+
+Node *XtDocument::createTextNode(const std::string &text) {
+  auto node = std::make_unique<Node>(NodeType::Text);
+  node->text = text;
+  Node *raw = node.get();
+  detached_[raw] = std::move(node);
+  return raw;
+}
+
+namespace {
+
+/** Take ownership of a node that is either attached or sitting in the pool. */
+std::unique_ptr<Node> takeNode(
+    Node *node, std::unordered_map<const Node *, std::unique_ptr<Node>> &pool) {
+  if (node->parent != nullptr) return node->parent->detachChild(node);
+  auto it = pool.find(node);
+  if (it == pool.end()) return nullptr;
+  std::unique_ptr<Node> owned = std::move(it->second);
+  pool.erase(it);
+  return owned;
+}
+
+}  // namespace
+
+Node *XtDocument::appendChild(Node *parent, Node *child) {
+  if (parent == nullptr || child == nullptr) return nullptr;
+  if (!parent->isElement() || child->isDocument() || child == root_.get()) return nullptr;
+  if (child->contains(parent)) return nullptr; /* reject cycles */
+  std::unique_ptr<Node> owned = takeNode(child, detached_);
+  if (owned == nullptr) return nullptr;
+  invalidate();
+  return parent->append(std::move(owned));
+}
+
+Node *XtDocument::insertBefore(Node *parent, Node *child, Node *reference) {
+  if (reference == nullptr) return appendChild(parent, child);
+  if (parent == nullptr || child == nullptr || child == reference) return child;
+  if (!parent->isElement() || child->isDocument() || child == root_.get()) return nullptr;
+  if (child->contains(parent)) return nullptr; /* reject cycles */
+  bool reference_is_child = false;
+  for (const std::unique_ptr<Node> &entry : parent->children) {
+    if (entry.get() == reference) {
+      reference_is_child = true;
+      break;
+    }
+  }
+  if (!reference_is_child) return nullptr;
+  std::unique_ptr<Node> owned = takeNode(child, detached_);
+  if (owned == nullptr) return nullptr;
+  invalidate();
+  return parent->insertChild(std::move(owned), reference);
+}
+
+bool XtDocument::removeChild(Node *parent, Node *child) {
+  if (parent == nullptr || child == nullptr || child->parent != parent) return false;
+  std::unique_ptr<Node> owned = parent->detachChild(child);
+  if (owned == nullptr) return false;
+  detached_[child] = std::move(owned);
+  invalidate();
+  return true;
+}
+
+Node *XtDocument::replaceChild(Node *parent, Node *newChild, Node *oldChild) {
+  if (parent == nullptr || oldChild == nullptr || oldChild->parent != parent) return nullptr;
+  if (newChild == oldChild) return newChild;
+  if (newChild != nullptr && !insertBefore(parent, newChild, oldChild)) return nullptr;
+  removeChild(parent, oldChild);
+  return newChild;
+}
+
+void XtDocument::detach(Node *node) {
+  if (node == nullptr || node == root_.get()) return;
+  if (node->parent != nullptr) {
+    std::unique_ptr<Node> owned = node->parent->detachChild(node);
+    if (owned != nullptr) detached_[node] = std::move(owned);
+  }
+  invalidate();
+}
+
 }  // namespace xtgui

package/runtime/ext_gui/document.h

@@ -63,6 +63,26 @@ class XtDocument {
   const Node *querySelector(const std::string &selectorText) const;
   /** Elements matching a CSS selector, in document order. */
   std::vector<const Node *> querySelectorAll(const std::string &selectorText) const;
+
+  /* -- DOM mutation (element handles) ------------------------------------ */
+  /** Create a detached element/text node owned by the document. */
+  Node *createElement(const std::string &tag);
+  Node *createTextNode(const std::string &text);
+  /** Move `child` under `parent` (from its current parent or the detached pool). */
+  Node *appendChild(Node *parent, Node *child);
+  Node *insertBefore(Node *parent, Node *child, Node *reference);
+  bool removeChild(Node *parent, Node *child);
+  Node *replaceChild(Node *parent, Node *newChild, Node *oldChild);
+  /** Release a node from the document entirely (still owned, detached). */
+  void detach(Node *node);
+
+  /** Mark the document as needing a restyle/relayout before the next paint. */
+  void invalidate() { dirty_ = true; }
+  bool takeDirty() {
+    bool was = dirty_;
+    dirty_ = false;
+    return was;
+  }
   /** Serialized DOM, for diagnostics. */
   std::string toDebugString() const;
 
@@ -72,6 +92,9 @@ class XtDocument {
   void updateDisplay();
 
   std::unique_ptr<Node> root_;
+  /** Detached nodes (created or removed) stay alive here so handles remain valid. */
+  std::unordered_map<const Node *, std::unique_ptr<Node>> detached_;
+  bool dirty_ = false;
   StyleSheet sheet_;
   std::unordered_map<const Node *, XtStyle> styles_;   // target (cascade)
   std::unordered_map<const Node *, XtStyle> display_;  // after transitions