xbintsc 0.5.6 → 0.5.21

package/runtime/ext_gui/layout_flow.cpp

@@ -44,7 +44,8 @@ float Layouter::verticalEdges(const LayoutBox *box) const {
 float Layouter::preferredContentWidth(const LayoutBox *box, float available) const {
   const XtStyle &style = *box->style;
   if (!isAuto(style.width)) return px(style.width, available, style.font_size, 0.0f);
-  if ((box->is_image || box->is_canvas) && box->intrinsic_width > 0) return box->intrinsic_width;
+  if ((box->is_image || box->is_canvas || box->is_inline_svg) && box->intrinsic_width > 0)
+    return box->intrinsic_width;
   float best = 0;
   for (const std::unique_ptr<LayoutBox> &child : box->children) {
     if (child->display == Display::None) continue;
@@ -225,8 +226,8 @@ float Layouter::layoutBlock(LayoutBox *box, float x, float y, float availableWid
     if (contentHeight < 0) contentHeight = 0;
   }
   /* Replaced elements keep their aspect ratio when only one axis is set. */
-  if ((box->is_image || box->is_canvas) && forcedContentHeight < 0 && isAuto(style.height) &&
-      box->intrinsic_width > 0 && box->intrinsic_height > 0) {
+  if ((box->is_image || box->is_canvas || box->is_inline_svg) && forcedContentHeight < 0 &&
+      isAuto(style.height) && box->intrinsic_width > 0 && box->intrinsic_height > 0) {
     contentHeight = contentWidth * box->intrinsic_height / box->intrinsic_width;
   }
   box->content_height = contentHeight;

package/runtime/ext_gui/paint.cpp

@@ -187,6 +187,16 @@ void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip) {
         image.media_id = box->media_id;
         image.transform = matrix;
         addImage(image, out, clip);
+      } else if (box->is_inline_svg && !box->svg_markup.empty() && box->content_width > 0.0f &&
+                 box->content_height > 0.0f) {
+        PaintImage image;
+        image.x = box->content_x;
+        image.y = box->content_y;
+        image.width = box->content_width;
+        image.height = box->content_height;
+        image.svg = box->svg_markup;
+        image.transform = matrix;
+        addImage(image, out, clip);
       } else if (box->is_image && !box->image_src.empty() && box->content_width > 0.0f &&
                  box->content_height > 0.0f) {
         PaintImage image;
@@ -243,6 +253,10 @@ std::string DisplayList::dump() const {
         std::snprintf(buffer, sizeof(buffer), "image x=%.1f y=%.1f w=%.1f h=%.1f media=%llu",
                       image.x, image.y, image.width, image.height,
                       (unsigned long long)image.media_id);
+      } else if (!image.svg.empty()) {
+        std::snprintf(buffer, sizeof(buffer),
+                      "image x=%.1f y=%.1f w=%.1f h=%.1f inline-svg=%zu", image.x, image.y,
+                      image.width, image.height, image.svg.size());
       } else if (image.canvas_id != 0) {
         std::snprintf(buffer, sizeof(buffer), "image x=%.1f y=%.1f w=%.1f h=%.1f canvas=%llu",
                       image.x, image.y, image.width, image.height,

package/runtime/ext_gui/paint.h

@@ -51,13 +51,17 @@ struct PaintText {
 /** An image to draw, scaled into the given rectangle (viewport-relative).
  * A non-zero `media_id` names a live `<video>` frame owned by the media
  * subsystem; a non-zero `canvas_id` names a live `<canvas>` bitmap owned by the
- * DOM; `src` is then empty and the renderer binds that subsystem's texture. */
+ * DOM; `src` is then empty and the renderer binds that subsystem's texture.
+ * A non-empty `svg` carries the serialized `<svg>` subtree of an inline SVG
+ * element, which the renderer rasterises at the drawn device size (there is no
+ * file to load). */
 struct PaintImage {
   float x = 0;
   float y = 0;
   float width = 0;
   float height = 0;
   std::string src;
+  std::string svg;
   uint64_t media_id = 0;
   uint64_t canvas_id = 0;
   Matrix2D transform;

package/runtime/ext_gui/renderer_image.cpp

@@ -12,6 +12,7 @@
 #include "canvas.h"
 #include "image.h"
 #include "media.h"
+#include "svg.h"
 
 #include "renderer_shaders.h"
 
@@ -227,6 +228,32 @@ SDL_GPUGraphicsPipeline *createImagePipeline(SDL_GPUDevice *device, SDL_Window *
   return pipeline;
 }
 
+/** Create an RGBA texture holding `image` and upload its pixels. Returns null
+ * (after reporting the SDL error) when either step fails. */
+SDL_GPUTexture *createImageTexture(SDL_GPUDevice *device, const xtgui::Image &image) {
+  SDL_GPUTextureCreateInfo info;
+  memset(&info, 0, sizeof(info));
+  info.type = SDL_GPU_TEXTURETYPE_2D;
+  info.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+  info.usage = SDL_GPU_TEXTUREUSAGE_SAMPLER;
+  info.width = (Uint32)image.width;
+  info.height = (Uint32)image.height;
+  info.layer_count_or_depth = 1;
+  info.num_levels = 1;
+  info.sample_count = SDL_GPU_SAMPLECOUNT_1;
+  SDL_GPUTexture *texture = SDL_CreateGPUTexture(device, &info);
+  if (texture == nullptr) {
+    fprintf(stderr, "xt_gui: image texture creation failed: %s\n", SDL_GetError());
+    return nullptr;
+  }
+  uint32_t bytes = (uint32_t)(image.pixels.size());
+  if (!uploadPixels(device, texture, image.width, image.height, image.pixels.data(), bytes)) {
+    SDL_ReleaseGPUTexture(device, texture);
+    return nullptr;
+  }
+  return texture;
+}
+
 /** Decode `src` (cached) and upload it as an RGBA texture. Vector sources are
  * rasterised at the drawn pixel size and cached by that size; bitmaps decode at
  * their intrinsic size and are cached by path. */
@@ -246,30 +273,29 @@ SDL_GPUTexture *ensureImageTexture(SDL_GPUDevice *device, const std::string &src
     return nullptr;
   }
 
-  SDL_GPUTextureCreateInfo info;
-  memset(&info, 0, sizeof(info));
-  info.type = SDL_GPU_TEXTURETYPE_2D;
-  info.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
-  info.usage = SDL_GPU_TEXTUREUSAGE_SAMPLER;
-  info.width = (Uint32)image->width;
-  info.height = (Uint32)image->height;
-  info.layer_count_or_depth = 1;
-  info.num_levels = 1;
-  info.sample_count = SDL_GPU_SAMPLECOUNT_1;
-  SDL_GPUTexture *texture = SDL_CreateGPUTexture(device, &info);
-  if (texture == nullptr) {
-    fprintf(stderr, "xt_gui: image texture creation failed: %s\n", SDL_GetError());
-    g_image_textures.emplace(key, nullptr);
-    return nullptr;
-  }
+  SDL_GPUTexture *texture = createImageTexture(device, *image);
+  g_image_textures.emplace(key, texture);
+  return texture;
+}
 
-  uint32_t bytes = (uint32_t)(image->pixels.size());
-  if (!uploadPixels(device, texture, image->width, image->height, image->pixels.data(), bytes)) {
-    SDL_ReleaseGPUTexture(device, texture);
+/** Rasterise the serialized subtree of an inline `<svg>` at the drawn pixel
+ * size and upload it. The markup is the cache key: a static document therefore
+ * rasterises once per drawn size, and an edited one gets a fresh texture. */
+SDL_GPUTexture *ensureInlineSvgTexture(SDL_GPUDevice *device, const std::string &markup,
+                                       int pixel_width, int pixel_height) {
+  std::string key = "inline-svg@" + std::to_string(pixel_width) + "x" +
+                    std::to_string(pixel_height) + ":" + markup;
+  auto found = g_image_textures.find(key);
+  if (found != g_image_textures.end()) return found->second;
+
+  xtgui::Image image;
+  if (!xtgui::xt_svg_markup_render(markup, pixel_width, pixel_height, &image)) {
+    fprintf(stderr, "xt_gui: could not rasterise inline SVG\n");
     g_image_textures.emplace(key, nullptr);
     return nullptr;
   }
 
+  SDL_GPUTexture *texture = createImageTexture(device, image);
   g_image_textures.emplace(key, texture);
   return texture;
 }
@@ -298,18 +324,20 @@ void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
   for (size_t index = 0; index < list.images.size(); index++) {
     const xtgui::PaintImage &image = list.images[index];
     if (image.width <= 0.0f || image.height <= 0.0f) continue;
+    /* Draw-time device pixels: an SVG (file or inline) is rasterised at this
+     * size so it stays crisp on HiDPI and when scaled. */
+    int pixel_width = (int)(image.width * scale + 0.5f);
+    int pixel_height = (int)(image.height * scale + 0.5f);
+    if (pixel_width < 1) pixel_width = 1;
+    if (pixel_height < 1) pixel_height = 1;
     SDL_GPUTexture *texture = nullptr;
     if (image.canvas_id != 0) {
       texture = ensureCanvasTexture(device, image.canvas_id);
     } else if (image.media_id != 0) {
       texture = ensureMediaTexture(device, image.media_id);
+    } else if (!image.svg.empty()) {
+      texture = ensureInlineSvgTexture(device, image.svg, pixel_width, pixel_height);
     } else {
-      /* Draw-time device pixels: an SVG is rasterised at this size so it stays
-       * crisp on HiDPI and when scaled. */
-      int pixel_width = (int)(image.width * scale + 0.5f);
-      int pixel_height = (int)(image.height * scale + 0.5f);
-      if (pixel_width < 1) pixel_width = 1;
-      if (pixel_height < 1) pixel_height = 1;
       texture = ensureImageTexture(device, image.src, pixel_width, pixel_height);
     }
     if (texture == nullptr) continue;

package/runtime/ext_gui/renderer_shaders.h

@@ -6,8 +6,8 @@
  * them, one per SDL_GPU backend:
  *
  *   - Metal: the MSL string literals below, which SDL_GPU compiles at runtime.
- *   - Vulkan: SPIR-V blobs in `renderer_shaders_data.h`, compiled from
- *     `spirv/*.{vert,frag}` by `scripts/build-gui-shaders.mjs`.
+ *   - Vulkan: SPIR-V blobs in `renderer_shaders_data.h`, compiled from the
+ *     `.vert`/`.frag` sources in `spirv/` by `scripts/build-gui-shaders.mjs`.
  *   - Direct3D 12: DXIL blobs from the same header, compiled from `shaders.hlsl`.
  *
  * `selectShader` resolves a logical program and stage to whichever of those the

package/runtime/ext_gui/stb_image.h

@@ -706,21 +706,6 @@ typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
 #define STBI_NO_SIMD
 #endif
 
-#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
-// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
-//
-// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
-// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
-// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
-// simultaneously enabling "-mstackrealign".
-//
-// See https://github.com/nothings/stb/issues/81 for more information.
-//
-// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
-// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
-#define STBI_NO_SIMD
-#endif
-
 #if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
 #define STBI_SSE2
 #include <emmintrin.h>
@@ -7805,10 +7790,9 @@ STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user
                          bug with < 92 byte PIC,PNM,HDR,TGA
       2.06  (2015-04-19) fix bug where PSD returns wrong '*comp' value
       2.05  (2015-04-19) fix bug in progressive JPEG handling, fix warning
-      2.04  (2015-04-15) try to re-enable SIMD on MinGW 64-bit
       2.03  (2015-04-12) extra corruption checking (mmozeiko)
                          stbi_set_flip_vertically_on_load (nguillemot)
-                         fix NEON support; fix mingw support
+                         fix NEON support
       2.02  (2015-01-19) fix incorrect assert, fix warning
       2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
       2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG

package/runtime/ext_gui/style_ua.cpp

@@ -40,6 +40,9 @@ void xt_style_apply_user_agent(const Node *node, XtStyle *style) {
     style->display = Display::InlineBlock;
   }
   if (tag == "img") style->display = Display::InlineBlock;
+  /* An inline `<svg>` is a replaced inline-block too: its intrinsic size comes
+   * from the SVG document and its subtree is vector art, not HTML boxes. */
+  if (tag == "svg") style->display = Display::InlineBlock;
   /* `<video>` mirrors `<img>` (a replaced inline-block; 300x150 by default from
    * layout), while `<audio>` and its `<source>`/`<track>` children have no
    * rendered box of their own. */

package/runtime/ext_gui/svg.cpp

@@ -3,9 +3,9 @@
  *
  * The heavy lifting is the vendored NanoSVG library (`nanosvg.h` +
  * `nanosvgrast.h`, zlib licence, fetched verbatim). This file is only the glue:
- * path detection, a parsed-document cache and the scale-to-fit call. NanoSVG
- * emits straight (non-premultiplied) RGBA8, which is exactly the `Image`
- * layout the rest of the engine expects.
+ * path detection, parsed-document caches (per file and per inline markup) and
+ * the scale-to-fit call. NanoSVG emits straight (non-premultiplied) RGBA8,
+ * which is exactly the `Image` layout the rest of the engine expects.
  */
 
 #include "svg.h"
@@ -31,6 +31,7 @@
 
 #include <algorithm>
 #include <cctype>
+#include <cstdint>
 #include <cstdio>
 #include <fstream>
 #include <string>
@@ -89,16 +90,13 @@ NSVGrasterizer *&rasterizer() {
   return value;
 }
 
-/** Parse `path` once and remember the result (including failures, so a missing
- * file is not retried every frame). */
-NSVGimage *parseCached(const std::string &path) {
-  auto &cache = parsedCache();
-  auto found = cache.find(path);
-  if (found != cache.end()) return found->second;
-  NSVGimage *image = nsvgParseFromFile(path.c_str(), "px", 96.0f);
-  cache.emplace(path, image);
-  return image;
-}
+/** One parsed inline-SVG document in the markup cache. `stamp` is the last use
+ * (see `parseMarkup`); `image` is null when the markup failed to parse so a
+ * broken document is not retried on every layout. */
+struct MarkupDocument {
+  NSVGimage *image = nullptr;
+  uint64_t stamp = 0;
+};
 
 float intrinsicWidth(const NSVGimage *image) {
   return image->width > 0.0f ? image->width : kDefaultWidth;
@@ -108,33 +106,53 @@ float intrinsicHeight(const NSVGimage *image) {
   return image->height > 0.0f ? image->height : kDefaultHeight;
 }
 
-}  // namespace
+/** Inline SVG markup is authored in the document and can change at any time, so
+ * unlike the per-path file cache this one is bounded: a script that animates an
+ * inline `<svg>` attribute every frame would otherwise add one parse (and its
+ * NSVGimage tree) per frame forever. */
+constexpr size_t kMaxMarkupDocuments = 256;
 
-bool xt_svg_is_svg(const std::string &path) {
-  auto &cache = detectCache();
-  auto found = cache.find(path);
-  if (found != cache.end()) return found->second;
-  bool result = hasSvgExtension(path) || prefixLooksLikeSvg(path);
-  cache.emplace(path, result);
-  return result;
+std::unordered_map<std::string, MarkupDocument> &markupCache() {
+  static std::unordered_map<std::string, MarkupDocument> cache;
+  return cache;
 }
 
-bool xt_svg_size(const std::string &path, int *width, int *height) {
-  NSVGimage *image = parseCached(path);
-  if (image == nullptr) return false;
-  float w = intrinsicWidth(image);
-  float h = intrinsicHeight(image);
-  if (w <= 0.0f || h <= 0.0f) return false;
-  if (width != nullptr) *width = (int)(w + 0.5f);
-  if (height != nullptr) *height = (int)(h + 0.5f);
-  return true;
+uint64_t nextStamp() {
+  static uint64_t counter = 0;
+  return ++counter;
 }
 
-bool xt_svg_render(const std::string &path, int width, int height, Image *out) {
-  if (out == nullptr) return false;
-  NSVGimage *image = parseCached(path);
-  if (image == nullptr) return false;
+/** Parse an inline SVG document once and remember the result. Evicts the
+ * least-recently-used entry when the table is full; nothing outside this module
+ * keeps an `NSVGimage*`, so a parse can always be dropped safely. */
+NSVGimage *parseMarkup(const std::string &markup) {
+  auto &cache = markupCache();
+  uint64_t stamp = nextStamp();
+  auto found = cache.find(markup);
+  if (found != cache.end()) {
+    found->second.stamp = stamp;
+    return found->second.image;
+  }
+  if (cache.size() >= kMaxMarkupDocuments) {
+    auto oldest = cache.begin();
+    for (auto it = cache.begin(); it != cache.end(); ++it) {
+      if (it->second.stamp < oldest->second.stamp) oldest = it;
+    }
+    if (oldest->second.image != nullptr) nsvgDelete(oldest->second.image);
+    cache.erase(oldest);
+  }
+  /* NanoSVG's XML parser NUL-terminates tags in place, so it needs its own
+   * mutable copy of the document. */
+  std::string document = markup;
+  NSVGimage *image = nsvgParse(document.data(), "px", 96.0f);
+  cache.emplace(markup, MarkupDocument{image, stamp});
+  return image;
+}
 
+/** Rasterise a parsed document at `width` x `height` device pixels, at the
+ * larger axis scale so neither axis is under-sampled. Returns false when the
+ * size is unusable or the rasteriser cannot be created. */
+bool rasterize(NSVGimage *image, int width, int height, Image *out) {
   float source_width = intrinsicWidth(image);
   float source_height = intrinsicHeight(image);
   int target_width = width > 0 ? width : (int)(source_width + 0.5f);
@@ -143,11 +161,6 @@ bool xt_svg_render(const std::string &path, int width, int height, Image *out) {
   target_width = std::min(target_width, kMaxDimension);
   target_height = std::min(target_height, kMaxDimension);
 
-  /* Rasterise at the source aspect ratio, at the larger of the two axis scales
-   * (so neither axis is under-sampled), then let the quad stretch the texture
-   * to the box — exactly how a bitmap would behave under CSS `object-fit:
-   * fill`. The common case (layout preserved the aspect ratio) makes this equal
-   * to the requested size. */
   float scale = std::max((float)target_width / source_width, (float)target_height / source_height);
   scale = std::min(scale, (float)kMaxDimension / source_width);
   scale = std::min(scale, (float)kMaxDimension / source_height);
@@ -167,12 +180,82 @@ bool xt_svg_render(const std::string &path, int width, int height, Image *out) {
   return true;
 }
 
+/** Parse `path` once and remember the result (including failures, so a missing
+ * file is not retried every frame). */
+NSVGimage *parseCached(const std::string &path) {
+  auto &cache = parsedCache();
+  auto found = cache.find(path);
+  if (found != cache.end()) return found->second;
+  NSVGimage *image = nsvgParseFromFile(path.c_str(), "px", 96.0f);
+  cache.emplace(path, image);
+  return image;
+}
+
+}  // namespace
+
+bool xt_svg_is_svg(const std::string &path) {
+  auto &cache = detectCache();
+  auto found = cache.find(path);
+  if (found != cache.end()) return found->second;
+  bool result = hasSvgExtension(path) || prefixLooksLikeSvg(path);
+  cache.emplace(path, result);
+  return result;
+}
+
+bool xt_svg_size(const std::string &path, int *width, int *height) {
+  NSVGimage *image = parseCached(path);
+  if (image == nullptr) return false;
+  float w = intrinsicWidth(image);
+  float h = intrinsicHeight(image);
+  if (w <= 0.0f || h <= 0.0f) return false;
+  if (width != nullptr) *width = (int)(w + 0.5f);
+  if (height != nullptr) *height = (int)(h + 0.5f);
+  return true;
+}
+
+bool xt_svg_render(const std::string &path, int width, int height, Image *out) {
+  if (out == nullptr) return false;
+  NSVGimage *image = parseCached(path);
+  if (image == nullptr) return false;
+  return rasterize(image, width, height, out);
+}
+
+bool xt_svg_markup_size(const std::string &markup, int *width, int *height) {
+  NSVGimage *image = parseMarkup(markup);
+  if (image == nullptr) return false;
+  float w = intrinsicWidth(image);
+  float h = intrinsicHeight(image);
+  if (w <= 0.0f || h <= 0.0f) return false;
+  if (width != nullptr) *width = (int)(w + 0.5f);
+  if (height != nullptr) *height = (int)(h + 0.5f);
+  return true;
+}
+
+bool xt_svg_markup_render(const std::string &markup, int width, int height, Image *out) {
+  if (out == nullptr) return false;
+  NSVGimage *image = parseMarkup(markup);
+  if (image == nullptr) return false;
+  return rasterize(image, width, height, out);
+}
+
+int xt_svg_markup_shapes(const std::string &markup) {
+  NSVGimage *image = parseMarkup(markup);
+  if (image == nullptr) return 0;
+  int count = 0;
+  for (const NSVGshape *shape = image->shapes; shape != nullptr; shape = shape->next) count++;
+  return count;
+}
+
 void xt_svg_shutdown() {
   for (auto &entry : parsedCache()) {
     if (entry.second != nullptr) nsvgDelete(entry.second);
   }
   parsedCache().clear();
   detectCache().clear();
+  for (auto &entry : markupCache()) {
+    if (entry.second.image != nullptr) nsvgDelete(entry.second.image);
+  }
+  markupCache().clear();
   if (rasterizer() != nullptr) {
     nsvgDeleteRasterizer(rasterizer());
     rasterizer() = nullptr;

package/runtime/ext_gui/svg.h

@@ -9,9 +9,10 @@
  * (`nanosvg.h` + `nanosvgrast.h`) — the same class of low-level, third-party
  * image library `stb_image` is (see doc/gui.md).
  *
- * Only *files* are handled: `<img src="logo.svg">`. Inline `<svg>` trees in a
- * document are still ordinary unknown elements to the HTML parser and generate
- * no boxes.
+ * Both SVG *files* (`<img src="logo.svg">`) and inline `<svg>` trees go through
+ * this module: an inline element's DOM subtree is serialized into a document by
+ * `inline_svg.{h,cpp}` and parsed with the markup entry points below, so both
+ * kinds produce the same RGBA8 `Image` at the drawn device size.
  */
 #ifndef XT_GUI_SVG_H
 #define XT_GUI_SVG_H
@@ -30,6 +31,16 @@ bool xt_svg_is_svg(const std::string &path);
  * false when the file is missing or cannot be parsed. Cached per path. */
 bool xt_svg_size(const std::string &path, int *width, int *height);
 
+/** The same two operations for an SVG *document string* rather than a file:
+ * the markup of an inline `<svg>` subtree (see `inline_svg.h`). The parse is
+ * cached by content (least-recently-used, so an animated document cannot grow
+ * the cache without bound); each rasterisation is fresh. */
+bool xt_svg_markup_size(const std::string &markup, int *width, int *height);
+bool xt_svg_markup_render(const std::string &markup, int width, int height, Image *out);
+
+/** Number of shapes NanoSVG parsed out of `markup` (diagnostics/tests). */
+int xt_svg_markup_shapes(const std::string &markup);
+
 /** Rasterise `path` to RGBA8. `width`/`height` are the requested pixel size;
  * when either is `<= 0` the intrinsic SVG size is used. The viewBox is scaled
  * uniformly at the larger of the two axis scales (preserving the SVG's aspect

package/runtime/ext_gui/window.cpp

@@ -12,6 +12,7 @@
 
 #include <algorithm>
 
+#include "inline_svg.h"
 #include "paint.h"
 #include "text.h"
 
@@ -216,6 +217,32 @@ static xt_value win_paint_count(xt_value self, xt_value env, int32_t argc, xt_va
   return xt_number((double)list.rects.size());
 }
 
+/** Diagnostic/test hook: the serialized SVG document of the first `<svg>`
+ * element matching `selector`, plus the intrinsic size and shape count the
+ * NanoSVG parse yields. Returns `undefined` when there is no such element. */
+static xt_value win_inline_svg(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr || win->document == nullptr || argc < 1) return XT_UNDEFINED;
+  xt_gui_flush_dom(win);
+  xt_value selectorValue = xt_to_string(xt_arg(argc, argv, 0));
+  const char *selector = xt_string_data(selectorValue);
+  if (selector == nullptr) return XT_UNDEFINED;
+  const xtgui::Node *node = win->document->querySelector(selector);
+  if (!xtgui::xt_inline_svg_is_root(node)) return XT_UNDEFINED;
+  std::string markup = xtgui::xt_inline_svg_serialize(node);
+  int width = 0;
+  int height = 0;
+  xtgui::xt_svg_markup_size(markup, &width, &height);
+  xt_value object = xt_object_new();
+  xt_object_set(object, xt_string_from_cstr("markup"), xt_string_from_cstr(markup.c_str()));
+  xt_object_set(object, xt_string_from_cstr("width"), xt_number(width));
+  xt_object_set(object, xt_string_from_cstr("height"), xt_number(height));
+  xt_object_set(object, xt_string_from_cstr("shapes"),
+                xt_number(xtgui::xt_svg_markup_shapes(markup)));
+  return object;
+}
+
 /** Diagnostic/test hook: advance the CSS transition clock by `ms`. */
 static xt_value win_advance(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
@@ -527,6 +554,7 @@ xt_value xt_gui_window_proto(void) {
   define_method(proto, "setBackground", (void *)win_set_background);
   define_method(proto, "paintList", (void *)win_paint_list);
   define_method(proto, "paintCount", (void *)win_paint_count);
+  define_method(proto, "inlineSvg", (void *)win_inline_svg);
   define_method(proto, "advance", (void *)win_advance);
   define_method(proto, "measureText", (void *)win_measure_text);
   define_method(proto, "fontMetrics", (void *)win_font_metrics);