xbintsc 0.5.45 → 0.5.52

package/runtime/ext_gui/gui_canvas.cpp

@@ -77,7 +77,8 @@ xtgui::Canvas2D *xt_gui_canvas_get(XtGuiWindow *win, const xtgui::Node *node) {
 
 void xt_gui_canvas_forget(XtGuiWindow *win, const xtgui::Node *node) {
   if (win == nullptr || node == nullptr) return;
-  xt_gui_webgl_forget(win, node);
+  const XtWebglApi *webgl = xt_webgl_api();
+  if (webgl != nullptr) webgl->forget(win, node);
   auto found = win->canvases.find(node);
   if (found == win->canvases.end()) return;
   releaseCanvasTexture(found->second.get());
@@ -88,11 +89,17 @@ void xt_gui_canvas_sync(XtGuiWindow *win) {
   if (win == nullptr || win->document == nullptr) return;
   std::vector<const xtgui::Node *> nodes;
   collectCanvases(win->document->root(), &nodes);
+  const XtWebglApi *webgl = xt_webgl_api();
   for (const xtgui::Node *node : nodes) {
-    if (xtgui::WebGLContext *webgl = xt_gui_webgl_find(win, node)) {
-      win->document->setCanvasInfo(node, (float)webgl->width(), (float)webgl->height(),
-                                   webgl->id());
-      continue;
+    if (webgl != nullptr) {
+      if (void *context = webgl->find(win, node)) {
+        float width = 0.0f;
+        float height = 0.0f;
+        uint64_t id = 0;
+        webgl->info(context, &width, &height, &id);
+        win->document->setCanvasInfo(node, width, height, id);
+        continue;
+      }
     }
     xtgui::Canvas2D *canvas = xt_gui_canvas_find(win, node);
     if (canvas != nullptr) {
@@ -136,7 +143,8 @@ void xt_gui_canvas_bind_pending(XtGuiWindow *win, const xtgui::Node *node, xt_va
 
 void xt_gui_canvas_shutdown(XtGuiWindow *win) {
   if (win == nullptr) return;
-  xt_gui_webgl_shutdown(win);
+  const XtWebglApi *webgl = xt_webgl_api();
+  if (webgl != nullptr) webgl->shutdown(win);
   for (auto &entry : win->canvases) releaseCanvasTexture(entry.second.get());
   win->canvases.clear();
   for (auto &entry : win->offscreen_canvases) releaseCanvasTexture(entry.second.get());

package/runtime/ext_gui/gui_cursor.cpp

@@ -0,0 +1,50 @@
+/*
+ * xbintsc GUI engine — CSS `cursor` → SDL system cursor.
+ *
+ * Kept apart from `gui_events.cpp` (which owns the input dispatch) so both
+ * translation units stay under the repository's per-file line budget.
+ */
+
+#include "gui_internal.h"
+
+namespace guidev {
+
+namespace {
+
+/** Lazily created SDL system cursors for the CSS cursor values we map. */
+SDL_Cursor *g_system_cursors[9] = {};
+
+SDL_SystemCursor sdlCursorFor(xtgui::CursorShape shape) {
+  switch (shape) {
+    case xtgui::CursorShape::Pointer: return SDL_SYSTEM_CURSOR_POINTER;
+    case xtgui::CursorShape::Text: return SDL_SYSTEM_CURSOR_TEXT;
+    case xtgui::CursorShape::Move: return SDL_SYSTEM_CURSOR_MOVE;
+    case xtgui::CursorShape::Wait: return SDL_SYSTEM_CURSOR_WAIT;
+    case xtgui::CursorShape::Help: return SDL_SYSTEM_CURSOR_DEFAULT;
+    case xtgui::CursorShape::NotAllowed: return SDL_SYSTEM_CURSOR_NOT_ALLOWED;
+    case xtgui::CursorShape::Crosshair: return SDL_SYSTEM_CURSOR_CROSSHAIR;
+    case xtgui::CursorShape::Auto:
+    case xtgui::CursorShape::Default: return SDL_SYSTEM_CURSOR_DEFAULT;
+  }
+  return SDL_SYSTEM_CURSOR_DEFAULT;
+}
+
+}  // namespace
+
+/** Apply the hovered element's computed `cursor` to the window. */
+void applyCursor(XtGuiWindow *win, const xtgui::Node *node) {
+  if (win == nullptr || win->window == nullptr) return;
+  xtgui::CursorShape shape = xtgui::CursorShape::Default;
+  if (node != nullptr && win->document != nullptr) {
+    const xtgui::XtStyle *style = win->document->styleOf(node);
+    if (style != nullptr) shape = style->cursor;
+  }
+  int index = (int)shape;
+  if (index < 0 || index >= 9) index = 0;
+  if (g_system_cursors[index] == nullptr) {
+    g_system_cursors[index] = SDL_CreateSystemCursor(sdlCursorFor(shape));
+  }
+  if (g_system_cursors[index] != nullptr) SDL_SetCursor(g_system_cursors[index]);
+}
+
+}  // namespace guidev

package/runtime/ext_gui/gui_engine.h

@@ -94,7 +94,7 @@ xt_value xt_gui_audio_create(int32_t argc, xt_value *argv);
 #include "media.h"
 #include "paint.h"
 #include "renderer.h"
-#include "webgl.h"
+#include "webgl_api.h"
 
 /** One element-level event listener registered through `addEventListener`. */
 struct XtGuiNodeListener {
@@ -225,9 +225,6 @@ struct XtGuiWindow {
    * lazily by `getContext("2d")` (or by `xt_gui_canvas_sync` for a live canvas),
    * released when the node is forgotten or the document reloads. */
   std::unordered_map<const xtgui::Node *, std::unique_ptr<xtgui::Canvas2D>> canvases;
-  /** One WebGL context per `<canvas>` that asked for `getContext("webgl")`.
-   * A canvas uses either this map or `canvases`, never both. */
-  std::unordered_map<const xtgui::Node *, std::unique_ptr<xtgui::WebGLContext>> webgl_canvases;
   /** Canvases whose element handle was created before `loadHTML` (a module
    * that calls `getElementById("scene").getContext("2d")` while it
    * initialises). Keyed by canvas id; moved into `canvases` when the pending
@@ -355,20 +352,6 @@ void xt_gui_canvas_sync(XtGuiWindow *win);
 /** Release every canvas of `win` (window close / `loadHTML`). */
 void xt_gui_canvas_shutdown(XtGuiWindow *win);
 
-/** The WebGL context of a `<canvas>`, creating it on first use. `webgl2`
- * selects the WebGL 2 API/prototype; a canvas keeps the first context kind it
- * asked for, so a later request for the other one answers null. */
-xtgui::WebGLContext *xt_gui_webgl_get(XtGuiWindow *win, const xtgui::Node *node, bool webgl2);
-/** The existing WebGL context of `node`, or null (no side effects). */
-xtgui::WebGLContext *xt_gui_webgl_find(XtGuiWindow *win, const xtgui::Node *node);
-/** Drop a node's WebGL context (called when its handle is forgotten). */
-void xt_gui_webgl_forget(XtGuiWindow *win, const xtgui::Node *node);
-/** Release every WebGL context of `win`. */
-void xt_gui_webgl_shutdown(XtGuiWindow *win);
-/** Submit every live WebGL context's queued commands. Called once per frame
- * before the page's own render pass samples a canvas texture. */
-void xt_gui_webgl_submit_all();
-
 #endif /* __cplusplus */
 
 #endif /* XT_GUI_ENGINE_H */

package/runtime/ext_gui/gui_events.cpp

@@ -157,6 +157,7 @@ static void xt_gui_update_hover(XtGuiWindow *win, const xtgui::Node *node) {
     win->geometry.dirty = 1;
     win->present_dirty = 1;
   }
+  guidev::applyCursor(win, node);
 }
 
 /** Pointer payload. `node` is the hit-test result the caller already resolved,
@@ -187,10 +188,21 @@ void xt_gui_dispatch_pointer(XtGuiWindow *win, const char *type, float x, float
   if (win == NULL || !win->open) return;
   const xtgui::Node *node = xt_gui_hit_node(win, x, y);
   xt_gui_update_hover(win, node);
-  if (strcmp(type, "mousedown") == 0 && win->document != nullptr) {
-    if (win->document->setFocus(node)) {
-      win->geometry.dirty = 1;
-      win->present_dirty = 1;
+  if (win->document != nullptr) {
+    if (strcmp(type, "mousedown") == 0) {
+      if (win->document->setFocus(node)) {
+        win->geometry.dirty = 1;
+        win->present_dirty = 1;
+      }
+      if (win->document->setActive(node)) {
+        win->geometry.dirty = 1;
+        win->present_dirty = 1;
+      }
+    } else if (strcmp(type, "mouseup") == 0) {
+      if (win->document->setActive(nullptr)) {
+        win->geometry.dirty = 1;
+        win->present_dirty = 1;
+      }
     }
   }
   xt_value payload = xt_gui_pointer_payload(type, win, x, y, button, clicks, node);
@@ -475,8 +487,9 @@ void xt_gui_render_window(XtGuiWindow *win) {
   xt_gui_upload_end(&uploads);
   /* WebGL contexts record into their own command buffers; submit them first so
    * the page's render pass samples this frame's drawing-buffer contents. */
-  xt_gui_webgl_submit_all();
-  if (uploaded || !win->webgl_canvases.empty()) win->present_dirty = 1;
+  const XtWebglApi *webgl = xt_webgl_api();
+  const bool webgl_live = webgl != nullptr && webgl->submit_all();
+  if (uploaded || webgl_live) win->present_dirty = 1;
 
   /* Present only when something happened. A static document otherwise burned a
    * swapchain acquire and a full-scene draw every frame. `XT_GUI_ALWAYS_PRESENT`

package/runtime/ext_gui/gui_internal.h

@@ -24,6 +24,9 @@ extern int g_window_count;
 /** Translate one SDL event into engine callbacks (defined in gui_events.cpp). */
 void handle_event(const SDL_Event *event);
 
+/** Apply the hovered element's CSS `cursor` to the window. */
+void applyCursor(XtGuiWindow *win, const xtgui::Node *node);
+
 }  // namespace guidev
 
 #endif /* XT_GUI_INTERNAL_H */

package/runtime/ext_gui/gui_webgl.cpp

@@ -7,12 +7,21 @@
  */
 
 #include <memory>
+#include <unordered_map>
 
 #include "gui_engine.h"
 #include "gui_internal.h"
+#include "webgl_feature.h"
 
 namespace {
 
+/** WebGL contexts are owned here rather than on `XtGuiWindow` so the core
+ * window type does not need `webgl.h`. Entries are dropped by
+ * `xt_gui_webgl_shutdown` when a window closes or reloads its document. */
+std::unordered_map<XtGuiWindow *,
+                   std::unordered_map<const xtgui::Node *, std::unique_ptr<xtgui::WebGLContext>>>
+    g_webgl;
+
 bool isCanvasElement(const xtgui::Node *node) {
   return node != nullptr && node->isElement() && node->isTag("canvas");
 }
@@ -29,8 +38,10 @@ uint64_t next_webgl_id() {
 
 xtgui::WebGLContext *xt_gui_webgl_find(XtGuiWindow *win, const xtgui::Node *node) {
   if (win == nullptr || node == nullptr) return nullptr;
-  auto found = win->webgl_canvases.find(node);
-  return found == win->webgl_canvases.end() ? nullptr : found->second.get();
+  auto found = g_webgl.find(win);
+  if (found == g_webgl.end()) return nullptr;
+  auto entry = found->second.find(node);
+  return entry == found->second.end() ? nullptr : entry->second.get();
 }
 
 xtgui::WebGLContext *xt_gui_webgl_get(XtGuiWindow *win, const xtgui::Node *node, bool webgl2) {
@@ -57,7 +68,7 @@ xtgui::WebGLContext *xt_gui_webgl_get(XtGuiWindow *win, const xtgui::Node *node,
   auto context = std::make_unique<xtgui::WebGLContext>(
       next_webgl_id(), (int)(width + 0.5f), (int)(height + 0.5f), webgl2);
   xtgui::WebGLContext *raw = context.get();
-  win->webgl_canvases[node] = std::move(context);
+  g_webgl[win][node] = std::move(context);
   if (win->document != nullptr) {
     win->document->setCanvasInfo(node, (float)raw->width(), (float)raw->height(), raw->id());
   }
@@ -66,18 +77,22 @@ xtgui::WebGLContext *xt_gui_webgl_get(XtGuiWindow *win, const xtgui::Node *node,
 
 void xt_gui_webgl_forget(XtGuiWindow *win, const xtgui::Node *node) {
   if (win == nullptr || node == nullptr) return;
-  win->webgl_canvases.erase(node);
+  auto found = g_webgl.find(win);
+  if (found != g_webgl.end()) found->second.erase(node);
 }
 
 void xt_gui_webgl_shutdown(XtGuiWindow *win) {
   if (win == nullptr) return;
-  win->webgl_canvases.clear();
+  g_webgl.erase(win);
 }
 
-void xt_gui_webgl_submit_all() {
-  for (int i = 0; i < XT_GUI_MAX_WINDOWS; i++) {
-    XtGuiWindow &win = guidev::g_windows[i];
-    if (!win.open) continue;
-    for (auto &entry : win.webgl_canvases) entry.second->submit();
+bool xt_gui_webgl_submit_all() {
+  bool any = false;
+  for (auto &window : g_webgl) {
+    for (auto &entry : window.second) {
+      entry.second->submit();
+      any = true;
+    }
   }
+  return any;
 }

package/runtime/ext_gui/image_api.cpp

@@ -0,0 +1,18 @@
+/*
+ * xbintsc GUI engine — core-side registry for the optional image/SVG table.
+ *
+ * Kept in `gui.a`, free of stb_image/NanoSVG: the table is installed by the
+ * `images` feature bridge when that feature is linked, and stays null otherwise.
+ */
+
+#include "image_api.h"
+
+namespace {
+
+const XtImageApi *g_api = nullptr;
+
+}  // namespace
+
+void xt_image_api_install(const XtImageApi *api) { g_api = api; }
+
+const XtImageApi *xt_image_api() { return g_api; }

package/runtime/ext_gui/image_api.h

@@ -0,0 +1,43 @@
+/*
+ * xbintsc GUI engine — optional image/SVG decoding table.
+ *
+ * `<img>`, CSS `background-image`, `drawImage` and inline `<svg>` all need
+ * stb_image/NanoSVG, which together are a noticeable part of a DOM-only binary.
+ * The `images` link feature installs this table from a bridge; without it, the
+ * core's image/SVG entry points are no-ops and the page simply draws nothing for
+ * those sources (the element and its layout still exist).
+ */
+#ifndef XT_GUI_IMAGE_API_H
+#define XT_GUI_IMAGE_API_H
+
+#include <cstddef>
+#include <string>
+
+#include "image.h"
+
+struct XtImageApi {
+  const xtgui::Image *(*load)(const std::string &path, int target_width, int target_height);
+  bool (*size)(const std::string &path, int *width, int *height);
+  bool (*decode)(const unsigned char *data, size_t size, xtgui::Image *out);
+  bool (*is_vector)(const std::string &path);
+  void (*shutdown)();
+  bool (*svg_size)(const std::string &path, int *width, int *height);
+  bool (*svg_render)(const std::string &path, int width, int height, xtgui::Image *out);
+  bool (*svg_markup_size)(const std::string &markup, int *width, int *height);
+  bool (*svg_markup_render)(const std::string &markup, int width, int height, xtgui::Image *out);
+  int (*svg_markup_shapes)(const std::string &markup);
+  bool (*inline_is_root)(const void *node);
+  /** Serialize an inline `<svg>`; `styles` is the document's computed-style map
+   * (`const std::unordered_map<const Node*, XtStyle>*`, or null). */
+  std::string (*inline_serialize)(const void *node, const void *styles);
+  /** Set the window icon from the embedded PNG (a no-op without an icon). */
+  void (*apply_icon)(void *window);
+};
+
+/** Install the table. Called by the `images` feature bridge before `main`. */
+void xt_image_api_install(const XtImageApi *api);
+
+/** The installed table, or null when the `images` feature was not linked. */
+const XtImageApi *xt_image_api();
+
+#endif /* XT_GUI_IMAGE_API_H */

package/runtime/ext_gui/image_bitmap_browser.cpp

@@ -16,7 +16,8 @@
 
 #include "image_bitmap.h"
 #include "canvas.h"
-#include "webgl.h"
+#include "image_api.h"
+#include "webgl_api.h"
 
 namespace {
 
@@ -63,7 +64,9 @@ bool source_pixels(xt_value source, xtgui::Image *out) {
   if (node == nullptr || !node->isElement()) return false;
   if (node->isTag("img")) {
     const std::string *src = node->attr("src");
-    const xtgui::Image *image = src != nullptr ? xtgui::xt_image_load(*src) : nullptr;
+    const XtImageApi *images = xt_image_api();
+    const xtgui::Image *image =
+        src != nullptr && images != nullptr ? images->load(*src, 0, 0) : nullptr;
     if (image == nullptr) return false;
     *out = *image;
     return true;
@@ -73,16 +76,22 @@ bool source_pixels(xt_value source, xtgui::Image *out) {
       *out = canvas->image();
       return true;
     }
-    if (xtgui::WebGLContext *context = xt_gui_webgl_find(win, node)) {
-      out->width = context->width();
-      out->height = context->height();
-      out->pixels.resize((size_t)out->width * out->height * 4);
-      if (!context->read_pixels(0, 0, out->width, out->height, out->pixels.data())) {
-        return false;
+    if (const XtWebglApi *webgl = xt_webgl_api()) {
+      if (void *context = webgl->find(win, node)) {
+        float width = 0.0f;
+        float height = 0.0f;
+        uint64_t id = 0;
+        webgl->info(context, &width, &height, &id);
+        out->width = (int)width;
+        out->height = (int)height;
+        out->pixels.resize((size_t)out->width * out->height * 4);
+        if (!webgl->read_pixels(context, 0, 0, out->width, out->height, out->pixels.data())) {
+          return false;
+        }
+        /* readPixels is GL-ordered (bottom-up); bitmaps are stored top-down. */
+        flip_rows(&out->pixels, out->width, out->height);
+        return true;
       }
-      /* readPixels is GL-ordered (bottom-up); bitmaps are stored top-down. */
-      flip_rows(&out->pixels, out->width, out->height);
-      return true;
     }
     return false;
   }

package/runtime/ext_gui/image_bridge.c

@@ -0,0 +1,22 @@
+/*
+ * xbintsc GUI engine — `images` link feature registration bridge.
+ *
+ * Compiled and linked only when the compiler detects that the program may draw
+ * an image or SVG. Its constructor installs `XtImageApi` and references the
+ * stb_image/NanoSVG members, pulling them out of `gui.a`; without it they are
+ * never linked.
+ */
+
+extern void xt_image_feature_register(void);
+
+#if defined(__GNUC__) || defined(__clang__)
+__attribute__((constructor)) static void xt_image_feature_boot(void) {
+  xt_image_feature_register();
+}
+#elif defined(_MSC_VER)
+void xt_image_feature_boot(void);
+#pragma section(".CRT$XCU", read)
+__declspec(allocate(".CRT$XCU")) static void (*const xt_image_feature_ctor)(void) =
+    xt_image_feature_boot;
+void xt_image_feature_boot(void) { xt_image_feature_register(); }
+#endif

package/runtime/ext_gui/image_feature.cpp

@@ -0,0 +1,107 @@
+/*
+ * xbintsc GUI engine — `images` link feature implementation.
+ *
+ * The only core-side place that references stb_image/NanoSVG and the inline-SVG
+ * serializer. `image_bridge.c` (linked only when the feature is active) calls
+ * `xt_image_feature_register`, which installs `XtImageApi`; without it the core
+ * draws no images or SVG and those members stay out of the binary.
+ */
+
+#include "image_api.h"
+
+#include <SDL3/SDL.h>
+
+#include <cstring>
+
+#include "inline_svg.h"
+#include "svg.h"
+
+/* Embedded by the driver's icon object; a zero size means "no icon". */
+extern "C" {
+extern const unsigned char xt_app_icon_data[];
+extern const unsigned long long xt_app_icon_size;
+extern const char xt_app_icon_format[];
+}
+
+namespace {
+
+const xtgui::Image *load(const std::string &path, int target_width, int target_height) {
+  return xtgui::xt_image_load(path, target_width, target_height);
+}
+
+bool size(const std::string &path, int *width, int *height) {
+  return xtgui::xt_image_size(path, width, height);
+}
+
+bool decode(const unsigned char *data, size_t size, xtgui::Image *out) {
+  return xtgui::xt_image_decode(data, size, out);
+}
+
+bool is_vector(const std::string &path) { return xtgui::xt_image_is_vector(path); }
+
+void shutdown() { xtgui::xt_image_shutdown(); }
+
+bool svg_size(const std::string &path, int *width, int *height) {
+  return xtgui::xt_svg_size(path, width, height);
+}
+
+bool svg_render(const std::string &path, int width, int height, xtgui::Image *out) {
+  return xtgui::xt_svg_render(path, width, height, out);
+}
+
+bool svg_markup_size(const std::string &markup, int *width, int *height) {
+  return xtgui::xt_svg_markup_size(markup, width, height);
+}
+
+bool svg_markup_render(const std::string &markup, int width, int height, xtgui::Image *out) {
+  return xtgui::xt_svg_markup_render(markup, width, height, out);
+}
+
+int svg_markup_shapes(const std::string &markup) {
+  return xtgui::xt_svg_markup_shapes(markup);
+}
+
+bool inline_is_root(const void *node) {
+  return xtgui::xt_inline_svg_is_root(static_cast<const xtgui::Node *>(node));
+}
+
+std::string inline_serialize(const void *node, const void *styles) {
+  using StyleMap = std::unordered_map<const xtgui::Node *, xtgui::XtStyle>;
+  return xtgui::xt_inline_svg_serialize(static_cast<const xtgui::Node *>(node),
+                                        static_cast<const StyleMap *>(styles));
+}
+
+void apply_icon(void *window) {
+  SDL_Window *sdl_window = static_cast<SDL_Window *>(window);
+  const size_t size = (size_t)xt_app_icon_size;
+  if (sdl_window == nullptr || size == 0) return;
+  if (strcmp(xt_app_icon_format, "png") != 0) return;
+  xtgui::Image image;
+  if (!xtgui::xt_image_decode(xt_app_icon_data, size, &image)) return;
+  if (image.width <= 0 || image.height <= 0) return;
+  SDL_Surface *surface = SDL_CreateSurfaceFrom(
+      image.width, image.height, SDL_PIXELFORMAT_RGBA32, image.pixels.data(), image.width * 4);
+  if (surface == nullptr) return;
+  SDL_SetWindowIcon(sdl_window, surface);
+  SDL_DestroySurface(surface);
+}
+
+const XtImageApi kImageApi = {
+    load,
+    size,
+    decode,
+    is_vector,
+    shutdown,
+    svg_size,
+    svg_render,
+    svg_markup_size,
+    svg_markup_render,
+    svg_markup_shapes,
+    inline_is_root,
+    inline_serialize,
+    apply_icon,
+};
+
+}  // namespace
+
+extern "C" void xt_image_feature_register(void) { xt_image_api_install(&kImageApi); }

package/runtime/ext_gui/inline_svg.cpp

@@ -5,8 +5,11 @@
 #include "inline_svg.h"
 
 #include <cctype>
+#include <cstdio>
 #include <string>
 #include <unordered_map>
+#include <utility>
+#include <vector>
 
 namespace xtgui {
 namespace {
@@ -161,26 +164,99 @@ bool isHtmlAttr(const std::string &name) {
   return name == "tabindex" || name == "role" || name == "contenteditable";
 }
 
-void serializeNode(const Node *node, std::string *out);
+const std::vector<const char *> &svgStyleOrder() {
+  static const std::vector<const char *> order = {
+      "fill",          "fill-opacity",   "fill-rule",        "stroke",
+      "stroke-opacity", "stroke-width",  "stroke-dasharray", "stroke-dashoffset",
+      "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stop-color",
+      "stop-opacity",  "paint-order"};
+  return order;
+}
+
+bool isColorStyleProperty(const std::string &name) {
+  return name == "fill" || name == "stroke" || name == "stop-color";
+}
+
+const char *opacityFor(const std::string &name) {
+  if (name == "fill") return "fill-opacity";
+  if (name == "stroke") return "stroke-opacity";
+  if (name == "stop-color") return "stop-opacity";
+  return nullptr;
+}
 
-void serializeStyleText(const Node *node, std::string *out) {
+/** Build the inline `style="…"` attribute for one SVG element from the
+ * document cascade. Colours are rewritten as `#rrggbb` plus a `*-opacity`
+ * because NanoSVG's reader has no `rgba()` syntax. */
+std::string computedSvgStyle(const XtStyle &style) {
+  std::vector<std::pair<std::string, std::string>> declarations;
+  for (const char *name : svgStyleOrder()) {
+    auto found = style.svg_props.find(name);
+    if (found == style.svg_props.end()) continue;
+    const std::string &value = found->second;
+    if (isColorStyleProperty(name)) {
+      Color color = xt_css_parse_color(value);
+      if (color.valid) {
+        char hex[16];
+        std::snprintf(hex, sizeof(hex), "#%02x%02x%02x", (int)(color.r * 255.0f + 0.5f),
+                      (int)(color.g * 255.0f + 0.5f), (int)(color.b * 255.0f + 0.5f));
+        declarations.emplace_back(name, hex);
+        const char *opacity_name = opacityFor(name);
+        bool opacity_set = style.svg_props.find(opacity_name) != style.svg_props.end();
+        if (!opacity_set && color.a < 0.999f) {
+          char alpha[32];
+          std::snprintf(alpha, sizeof(alpha), "%.3f", (double)color.a);
+          declarations.emplace_back(opacity_name, alpha);
+        }
+        continue;
+      }
+    }
+    declarations.emplace_back(name, value);
+  }
+  std::string text;
+  for (const auto &declaration : declarations) {
+    if (!text.empty()) text.push_back(';');
+    text += declaration.first;
+    text.push_back(':');
+    text += declaration.second;
+  }
+  return text;
+}
+
+void serializeNode(const Node *node, const std::unordered_map<const Node *, XtStyle> *styles,
+                   std::string *out);
+
+void serializeStyleText(const Node *node, const std::unordered_map<const Node *, XtStyle> *styles,
+                        std::string *out) {
   for (const std::unique_ptr<Node> &child : node->children) {
     if (child->isText()) {
       out->append(child->text);
     } else if (child->isElement()) {
-      serializeNode(child.get(), out);
+      serializeNode(child.get(), styles, out);
     }
   }
 }
 
-void serializeNode(const Node *node, std::string *out) {
+void serializeNode(const Node *node, const std::unordered_map<const Node *, XtStyle> *styles,
+                   std::string *out) {
   if (node == nullptr || !node->isElement()) return;
+  const XtStyle *computed = nullptr;
+  if (styles != nullptr) {
+    auto found = styles->find(node);
+    if (found != styles->end()) computed = &found->second;
+  }
+  std::string injected;
+  if (computed != nullptr && !computed->svg_props.empty()) injected = computedSvgStyle(*computed);
+  const std::string *raw_style = node->attr("style");
+
   std::string tag = canonicalTag(node->tag);
   out->push_back('<');
   out->append(tag);
   if (node->isTag("svg")) out->append(" xmlns=\"http://www.w3.org/2000/svg\"");
   for (const Attr &attr : node->attrs) {
     if (isNamespaceAttr(attr.name) || isHtmlAttr(attr.name)) continue;
+    /* The computed style already includes the element's own `style="…"`
+     * declarations; emitting both would be a duplicate XML attribute. */
+    if (!injected.empty() && attr.name == "style") continue;
     /* The root's xmlns is emitted above, so a second copy would be an XML
      * duplicate-attribute error. */
     const char *name = canonicalAttr(attr.name);
@@ -190,12 +266,22 @@ void serializeNode(const Node *node, std::string *out) {
     escapeAttribute(attr.value, out);
     out->push_back('"');
   }
+  if (!injected.empty()) {
+    /* The computed declarations include the element's own inline ones; merge
+     * them so unrelated inline properties (display, opacity, …) survive. */
+    std::string merged = (raw_style != nullptr) ? *raw_style : std::string();
+    if (!merged.empty() && merged.back() != ';') merged.push_back(';');
+    merged += injected;
+    out->append(" style=\"");
+    escapeAttribute(merged, out);
+    out->push_back('"');
+  }
   out->push_back('>');
   if (node->isTag("style")) {
-    serializeStyleText(node, out);
+    serializeStyleText(node, styles, out);
   } else {
     for (const std::unique_ptr<Node> &child : node->children) {
-      if (child->isElement()) serializeNode(child.get(), out);
+      if (child->isElement()) serializeNode(child.get(), styles, out);
     }
   }
   out->append("</");
@@ -209,10 +295,11 @@ bool xt_inline_svg_is_root(const Node *node) {
   return node != nullptr && node->isElement() && node->isTag("svg");
 }
 
-std::string xt_inline_svg_serialize(const Node *node) {
+std::string xt_inline_svg_serialize(
+    const Node *node, const std::unordered_map<const Node *, XtStyle> *styles) {
   if (!xt_inline_svg_is_root(node)) return std::string();
   std::string out;
-  serializeNode(node, &out);
+  serializeNode(node, styles, &out);
   return out;
 }