xbintsc 0.5.38 → 0.5.41

package/runtime/ext_gui/dom_api_webgl_source.cpp

@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "dom_api_webgl_rt.h"
+#include "canvas.h"
 #include "image.h"
 #include "image_bitmap.h"
 #include "webgl.h"
@@ -100,6 +101,23 @@ bool webgl_read_source(xt_value source, int *width, int *height, std::vector<uin
       return true;
     }
   }
+  if (XT_IS_OBJECT(source)) {
+    xt_value canvas_id = xt_object_get_cstr(source, "__xt_gui_canvas");
+    if (XT_IS_NUMBER(canvas_id)) {
+      xtgui::Canvas2D *canvas = xtgui::xt_canvas_by_id((uint64_t)xt_to_number(canvas_id));
+      if (canvas == nullptr || canvas->image().width <= 0) return false;
+      const xtgui::Image &image = canvas->image();
+      *width = image.width;
+      *height = image.height;
+      if (premultiply) {
+        webgl_convert_pixels(image.pixels.data(), image.width * image.height, GL_RGBA, true,
+                             rgba);
+      } else {
+        *rgba = image.pixels;
+      }
+      return true;
+    }
+  }
   XtGuiWindow *win = nullptr;
   xtgui::Node *node = resolve_node(source, &win);
   const xtgui::Image *image = nullptr;

package/runtime/ext_gui/gradient_values.cpp

@@ -392,7 +392,7 @@ bool parseRadialGradient(const std::string &body, BackgroundLayer *layer) {
   return true;
 }
 
-/** Parse one layer, appending it when it is a supported gradient. */
+/** Parse one layer, appending it when it is a supported gradient or image. */
 bool parseLayer(const std::string &part, BackgroundLayer *layer) {
   std::string body;
   if (findCall(part, "linear-gradient", &body) ||
@@ -403,6 +403,17 @@ bool parseLayer(const std::string &part, BackgroundLayer *layer) {
       findCall(part, "repeating-radial-gradient", &body)) {
     return parseRadialGradient(body, layer);
   }
+  if (findCall(part, "url", &body)) {
+    std::string source = xt_css_trim(body);
+    if (source.size() >= 2 && (source.front() == '"' || source.front() == '\'') &&
+        source.back() == source.front()) {
+      source = source.substr(1, source.size() - 2);
+    }
+    if (source.empty()) return false;
+    layer->kind = BackgroundKind::Image;
+    layer->image_src = source;
+    return true;
+  }
   return false;
 }
 

package/runtime/ext_gui/gui.cpp

@@ -194,6 +194,7 @@ void xt_gui_quit_window(XtGuiWindow *win) {
   win->document_object = XT_UNDEFINED;
   win->document.reset();
   win->html.clear();
+  win->display_list.clear();
   if (g_device != NULL) {
     xt_gui_geometry_destroy(g_device, &win->geometry);
     xt_gui_geometry_destroy(g_device, &win->text_geometry);
@@ -253,6 +254,10 @@ static XtGuiWindow *create_window_record(const char *title, int width, int heigh
   record->window = window;
   record->open = 1;
   record->ready = 0;
+  record->present_dirty = 1;
+  record->expose_pending = 0;
+  record->present_deferred = 0;
+  record->sync_dirty = 1;
   record->width = width;
   record->height = height;
   record->html.clear();

package/runtime/ext_gui/gui_canvas.cpp

@@ -15,6 +15,7 @@
 #include "document.h"
 #include "gui_engine.h"
 #include "gui_internal.h"
+#include "perf.h"
 
 namespace {
 
@@ -25,6 +26,7 @@ bool isCanvasElement(const xtgui::Node *node) {
 /** Canvas children are fallback content, so a canvas element ends the walk. */
 void collectCanvases(const xtgui::Node *node, std::vector<const xtgui::Node *> *out) {
   if (node == nullptr) return;
+  xtgui::g_perf_frame.syncNodes += 1;
   if (isCanvasElement(node)) {
     out->push_back(node);
     return;
@@ -137,6 +139,8 @@ void xt_gui_canvas_shutdown(XtGuiWindow *win) {
   xt_gui_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());
+  win->offscreen_canvases.clear();
   /* `pending_canvases` survives `loadHTML`: a module that asked for a context
    * before the page existed still needs its bitmap when the parsed element
    * binds. They are released with the window record. */

package/runtime/ext_gui/gui_engine.h

@@ -92,6 +92,7 @@ xt_value xt_gui_audio_create(int32_t argc, xt_value *argv);
 #include "canvas.h"
 #include "document.h"
 #include "media.h"
+#include "paint.h"
 #include "renderer.h"
 #include "webgl.h"
 
@@ -159,6 +160,10 @@ struct XtGuiWindow {
   XtGuiGeometry geometry;
   XtGuiGeometry text_geometry;
   XtGuiGeometry image_geometry;
+  /** The frame's display list. Kept on the window so its payload vectors keep
+   * their capacity across frames instead of being reallocated from zero on
+   * every repaint. */
+  xtgui::DisplayList display_list;
   float background[4];
   int width;
   int height;
@@ -188,6 +193,28 @@ struct XtGuiWindow {
   std::vector<XtGuiWindowListener> window_listeners;
   /** Set by a DOM mutation; consumed by the frame loop before repainting. */
   int struct_dirty = 0;
+  /** Set when something may have changed on screen (a mutation, a scroll, an
+   * animation frame, a new video/canvas frame, an expose event, …). The frame
+   * loop skips acquiring a swapchain and recording a render pass while it is
+   * clear, so a static page does no GPU work at all; `XT_GUI_ALWAYS_PRESENT=1`
+   * disables the gate. */
+  int present_dirty = 1;
+  /** Set when the window system asked for a redraw (map/expose/restore) since
+   * the last frame. Several such events coalesce into one present, so the frame
+   * loop charges at most one `exposes` counter per frame — that way
+   * `presents - exposes - deferred` is the work the page caused, and a present
+   * can be attributed to the compositor rather than to the document (a window
+   * server delivers its first `Expose` whenever it maps the window, which no
+   * test can schedule). */
+  int expose_pending = 0;
+  /** Set when a frame could not get a swapchain image and left its present
+   * pending (see `xt_gui_render_window`). The present that finally happens
+   * carries that earlier frame's work, so it is charged to `deferred`. */
+  int present_deferred = 0;
+  /** Set when the media/canvas tables must be reconciled with the document
+   * without a restyle (a replaced document, for example): the frame loop then
+   * runs the DOM walk once even though no style changed. */
+  int sync_dirty = 0;
   /** Callbacks queued for the next frame, plus the id counter. */
   std::vector<XtGuiAnimationFrame> animation_frames;
   /** One decoder per `<video>`/`<audio>` element, keyed by the element node. The
@@ -206,6 +233,9 @@ struct XtGuiWindow {
    * initialises). Keyed by canvas id; moved into `canvases` when the pending
    * handle binds to the parsed element. */
   std::unordered_map<uint64_t, std::unique_ptr<xtgui::Canvas2D>> pending_canvases;
+  /** `new OffscreenCanvas(w, h)` bitmaps, keyed by their canvas id. They are
+   * not part of the DOM; they exist until the window closes. */
+  std::unordered_map<uint64_t, std::unique_ptr<xtgui::Canvas2D>> offscreen_canvases;
   /** The batch currently running: its callbacks have been swapped out of
    * `animation_frames`, and a collection triggered by one of them must still
    * see the rest. Kept on the record (not a local) so the GC root provider can

package/runtime/ext_gui/gui_events.cpp

@@ -7,6 +7,7 @@
 #include "listener_options.h"
 
 #include "paint.h"
+#include "perf.h"
 
 #include <algorithm>
 #include <stdio.h>
@@ -69,6 +70,7 @@ void xt_gui_flush_dom(XtGuiWindow *win) {
   xt_gui_window_viewport(win, &width, &height);
   win->document->restyle(width, height);
   win->geometry.dirty = 1;
+  win->present_dirty = 1;
 }
 
 /* -- page scroll ---------------------------------------------------------- */
@@ -115,6 +117,7 @@ void xt_gui_scroll_to(XtGuiWindow *win, float x, float y) {
   win->scroll_x = x;
   win->scroll_y = y;
   win->geometry.dirty = 1;
+  win->present_dirty = 1;
   xt_gui_emit(win, "scroll");
 }
 
@@ -145,14 +148,21 @@ std::string xt_gui_hit_test(XtGuiWindow *win, float x, float y) {
   return node == nullptr ? std::string() : xtgui::xt_dom_describe(node);
 }
 
-/** Update the hovered element from the pointer position; marks paint dirty. */
-static void xt_gui_update_hover(XtGuiWindow *win, float x, float y) {
+/** Update the hovered element from an already resolved target node; marks paint
+ * dirty when the hover state (and therefore the styles) changed. */
+static void xt_gui_update_hover(XtGuiWindow *win, const xtgui::Node *node) {
   if (win->document == nullptr) return;
-  if (win->document->setHover(xt_gui_hit_node(win, x, y))) win->geometry.dirty = 1;
+  if (win->document->setHover(node)) {
+    win->geometry.dirty = 1;
+    win->present_dirty = 1;
+  }
 }
 
+/** Pointer payload. `node` is the hit-test result the caller already resolved,
+ * so one event does not walk the layout tree three times. */
 static xt_value xt_gui_pointer_payload(const char *type, XtGuiWindow *win, float x, float y,
-                                       int button, int clicks) {
+                                       int button, int clicks, const xtgui::Node *node) {
+  (void)win;
   xt_value payload = xt_object_new();
   xt_object_set(payload, xt_string_from_cstr("type"), xt_string_from_cstr(type));
   xt_object_set(payload, xt_string_from_cstr("x"), xt_number(x));
@@ -161,9 +171,12 @@ static xt_value xt_gui_pointer_payload(const char *type, XtGuiWindow *win, float
   xt_object_set(payload, xt_string_from_cstr("clientY"), xt_number(y));
   xt_object_set(payload, xt_string_from_cstr("button"), xt_number(button));
   xt_object_set(payload, xt_string_from_cstr("clicks"), xt_number(clicks));
-  std::string target = xt_gui_hit_test(win, x, y);
-  if (!target.empty()) {
-    xt_object_set(payload, xt_string_from_cstr("target"), xt_string_from_cstr(target.c_str()));
+  if (node != nullptr) {
+    std::string target = xtgui::xt_dom_describe(node);
+    if (!target.empty()) {
+      xt_object_set(payload, xt_string_from_cstr("target"),
+                    xt_string_from_cstr(target.c_str()));
+    }
   }
   return payload;
 }
@@ -171,22 +184,25 @@ static xt_value xt_gui_pointer_payload(const char *type, XtGuiWindow *win, float
 void xt_gui_dispatch_pointer(XtGuiWindow *win, const char *type, float x, float y, int button,
                              int clicks) {
   if (win == NULL || !win->open) return;
-  xt_gui_update_hover(win, x, y);
   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;
+    if (win->document->setFocus(node)) {
+      win->geometry.dirty = 1;
+      win->present_dirty = 1;
+    }
   }
-  xt_value payload = xt_gui_pointer_payload(type, win, x, y, button, clicks);
+  xt_value payload = xt_gui_pointer_payload(type, win, x, y, button, clicks, node);
   if (node != nullptr) xt_gui_emit_dom_event(win, type, node, payload);
   xt_gui_emit_payload(win, type, payload);
 }
 
 void xt_gui_dispatch_wheel(XtGuiWindow *win, float x, float y, float delta_x, float delta_y) {
   if (win == NULL || !win->open) return;
-  xt_value payload = xt_gui_pointer_payload("wheel", win, x, y, -1, 0);
+  const xtgui::Node *node = xt_gui_hit_node(win, x, y);
+  xt_value payload = xt_gui_pointer_payload("wheel", win, x, y, -1, 0, node);
   xt_object_set(payload, xt_string_from_cstr("deltaX"), xt_number(delta_x));
   xt_object_set(payload, xt_string_from_cstr("deltaY"), xt_number(delta_y));
-  const xtgui::Node *node = xt_gui_hit_node(win, x, y);
   if (node != nullptr) xt_gui_emit_dom_event(win, "wheel", node, payload);
   xt_gui_emit_payload(win, "wheel", payload);
   /* Default action: scroll the page (content that fits does not move). */
@@ -234,12 +250,26 @@ void handle_event(const SDL_Event *event) {
     win->height = event->window.data2;
     if (win->document != NULL) win->document->restyle((float)win->width, (float)win->height);
     win->geometry.dirty = 1;
+    win->present_dirty = 1;
     /* Web 'resize', so a document can re-measure on a window change in every
      * host (a browser already fires one). */
     xt_gui_emit(win, "resize");
     xt_gui_media_lists_notify(win);
     return;
   }
+  /* A window the compositor revealed (uncovered, restored, shown) must be
+   * redrawn even though nothing in the document changed: the frame loop only
+   * presents on demand. The request is charged to `exposes` (below) so
+   * `stats()` can separate it from a present the page caused. */
+  if (event->type == SDL_EVENT_WINDOW_EXPOSED || event->type == SDL_EVENT_WINDOW_SHOWN ||
+      event->type == SDL_EVENT_WINDOW_RESTORED) {
+    XtGuiWindow *win = xt_gui_find_by_window_id(event->window.windowID);
+    if (win != NULL) {
+      win->present_dirty = 1;
+      win->expose_pending = 1;
+    }
+    return;
+  }
 
   if (event->type == SDL_EVENT_MOUSE_MOTION) {
     XtGuiWindow *win = xt_gui_find_by_window_id(event->motion.windowID);
@@ -309,6 +339,13 @@ void xt_gui_run_animation_frames(XtGuiWindow *win, double timestamp_ms) {
 
 void xt_gui_render_window(XtGuiWindow *win) {
   if (win == NULL || !win->open || win->window == NULL || g_device == NULL) return;
+  xtgui::xt_perf_frame_begin();
+  /* The events were dispatched before the frame began. A redraw the window
+   * system asked for is charged to `exposes` once this frame actually presents
+   * (several expose events coalesce into one present); the flag is consumed
+   * here because only this frame may claim it. */
+  bool window_requested = win->expose_pending != 0;
+  win->expose_pending = 0;
   float viewport_width = 0;
   float viewport_height = 0;
   xt_gui_window_viewport(win, &viewport_width, &viewport_height);
@@ -318,77 +355,164 @@ void xt_gui_render_window(XtGuiWindow *win) {
   double delta = win->last_frame_ms > 0.0 ? now - win->last_frame_ms : 0.0;
   win->last_frame_ms = now;
   /* Animation-frame callbacks run before layout, so any DOM mutation they make
-   * is picked up by this same frame. */
+   * is picked up by this same frame. A page that asked for a frame expects it
+   * to be presented even when its callback changed nothing visible. */
+  if (!win->animation_frames.empty()) win->present_dirty = 1;
   xt_gui_run_animation_frames(win, now);
   /* A callback may have closed the window (directly or through the
    * auto-close guard): `xt_gui_quit_window` released the document and the GPU
    * geometry, so there is nothing left to lay out or paint. */
-  if (!win->open) return;
-  /* Reconcile decoders with the live DOM first, so this frame's layout sees the
-   * current sources and intrinsic sizes, then advance playback and fire the
-   * DOM media events. */
-  xt_gui_media_sync(win);
+  if (!win->open) {
+    xtgui::xt_perf_frame_end();
+    return;
+  }
+  /* Reconcile the decoder/canvas tables with the live DOM only when the
+   * document changed (or on the first frame): walking the whole tree every
+   * frame was a per-frame cost proportional to the element count even when a
+   * page had no `<video>` or `<canvas>` at all. */
+  bool dom_changed = win->struct_dirty != 0 || win->sync_dirty != 0 || !win->ready ||
+                     (win->document != nullptr && win->document->dirty());
+  if (dom_changed) {
+    xt_gui_media_sync(win);
+    xt_gui_canvas_sync(win);
+    win->sync_dirty = 0;
+  }
+  /* Playback advances every frame (it raises the media DOM events), but only a
+   * decoder that produced a frame asks to present. */
   xt_gui_media_tick(win, now);
-  /* Publish canvas bitmaps to the document (and create contexts for a canvas
-   * that has none) before this frame's layout. */
-  xt_gui_canvas_sync(win);
-  if (win->document != nullptr && win->document->advance(delta)) win->geometry.dirty = 1;
+  if (win->document != nullptr && win->document->advance(delta)) {
+    win->geometry.dirty = 1;
+    win->present_dirty = 1;
+    xtgui::g_perf_frame.transitionFrames += 1;
+  }
 
   /* A DOM mutation from a handler invalidates the tree: restyle/relayout
    * before (re)building the geometry. */
-  xt_gui_flush_dom(win);
+  {
+    xtgui::PerfScope scope(&xtgui::g_perf_frame_ms.restyle);
+    xt_gui_flush_dom(win);
+  }
 
   /* Rebuild the geometry only when the document or viewport changed. */
   bool can_paint = xt_gui_renderer_ensure(g_device, win->window);
+  /* One command buffer for every upload this frame — geometry, glyph atlas,
+   * image textures, video frames and canvas bitmaps — so K animated canvases
+   * cost one submit, not K. */
+  XtGuiUploadBatch uploads;
+  xt_gui_upload_begin(&uploads, g_device);
   if (can_paint && win->geometry.dirty && win->document != nullptr) {
-    xtgui::DisplayList list;
-    xtgui::xt_paint_build(win->document->layout().root(), list, viewport_width, viewport_height);
-    xt_paint_translate(list, -win->scroll_x, -win->scroll_y);
-    xt_gui_geometry_upload(g_device, &win->geometry, list);
-    float density = SDL_GetWindowPixelDensity(win->window);
-    float text_scale = density > 0.0f ? density : 1.0f;
-    xt_gui_text_upload(g_device, &win->text_geometry, list, text_scale);
-    xt_gui_image_upload(g_device, &win->image_geometry, list, text_scale);
-    xt_gui_build_runs(&win->geometry, &win->text_geometry, &win->image_geometry, list);
+    {
+      xtgui::PerfScope scope(&xtgui::g_perf_frame_ms.paint);
+      /* Reuse the window's list: `clear()` keeps the payload vectors' capacity,
+       * so a repaint does not reallocate every array from zero. */
+      xtgui::DisplayList &list = win->display_list;
+      list.clear();
+      xtgui::xt_paint_build(win->document->layout().root(), list, viewport_width, viewport_height);
+      xt_paint_translate(list, -win->scroll_x, -win->scroll_y);
+      xtgui::g_perf_frame.paints += 1;
+      xtgui::g_perf_frame.paintOps += (uint64_t)list.ops.size();
+      {
+        xtgui::PerfScope upload_scope(&xtgui::g_perf_frame_ms.upload);
+        xt_gui_geometry_upload(g_device, &win->geometry, list, &uploads);
+        float density = SDL_GetWindowPixelDensity(win->window);
+        float text_scale = density > 0.0f ? density : 1.0f;
+        xt_gui_text_upload(g_device, &win->text_geometry, list, text_scale, &uploads);
+        xt_gui_image_upload(g_device, &win->image_geometry, list, text_scale, &uploads);
+        xt_gui_build_runs(&win->geometry, &win->text_geometry, &win->image_geometry, list);
+      }
+      xtgui::g_perf_frame.drawRuns += (uint64_t)win->geometry.runs.size();
+    }
     win->geometry.dirty = 0;
   }
 
   /* Upload any new video frame before the render command buffer is recorded,
    * so the draw samples the frame that just arrived. */
-  xt_gui_media_upload_frames(g_device);
+  bool uploaded = xt_gui_media_upload_frames(g_device, &uploads);
   /* Canvases are CPU-drawn: push any new bitmap without a relayout. */
-  xt_gui_canvas_upload_frames(g_device);
+  if (xt_gui_canvas_upload_frames(g_device, &uploads)) uploaded = true;
+  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();
-  SDL_GPUCommandBuffer *cmd = SDL_AcquireGPUCommandBuffer(g_device);
-  if (cmd == NULL) return;
-  SDL_GPUTexture *swapchain = NULL;
-  SDL_AcquireGPUSwapchainTexture(cmd, win->window, &swapchain, NULL, NULL);
+  if (uploaded || !win->webgl_canvases.empty()) 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`
+   * forces the old behaviour for debugging a missed invalidation. */
+  static int always_present = -1;
+  if (always_present < 0) {
+    const char *value = SDL_getenv("XT_GUI_ALWAYS_PRESENT");
+    always_present = (value != nullptr && value[0] != '\0' && strcmp(value, "0") != 0) ? 1 : 0;
+  }
+  if (win->ready && win->present_dirty == 0 && always_present == 0) {
+    xtgui::g_perf_frame.skippedFrames += 1;
+    xtgui::xt_perf_frame_end();
+    return;
+  }
+  win->present_dirty = 0;
+
   bool firstFrame = false;
-  if (swapchain != NULL) {
-    SDL_GPUColorTargetInfo target;
-    memset(&target, 0, sizeof(target));
-    target.texture = swapchain;
-    target.clear_color.r = win->background[0];
-    target.clear_color.g = win->background[1];
-    target.clear_color.b = win->background[2];
-    target.clear_color.a = win->background[3];
-    target.load_op = SDL_GPU_LOADOP_CLEAR;
-    target.store_op = SDL_GPU_STOREOP_STORE;
-    SDL_GPURenderPass *pass = SDL_BeginGPURenderPass(cmd, &target, 1, NULL);
-    if (can_paint) {
-      float density = SDL_GetWindowPixelDensity(win->window);
-      if (density <= 0.0f) density = 1.0f;
-      xt_gui_renderer_draw(cmd, pass, &win->geometry, &win->text_geometry, &win->image_geometry,
-                           viewport_width, viewport_height, density);
+  {
+    /* Scoped: the timing must be recorded before `xt_perf_frame_end` copies
+     * the frame's phase timings. */
+    xtgui::PerfScope draw_scope(&xtgui::g_perf_frame_ms.draw);
+    SDL_GPUCommandBuffer *cmd = SDL_AcquireGPUCommandBuffer(g_device);
+    if (cmd != NULL) {
+      SDL_GPUTexture *swapchain = NULL;
+      SDL_AcquireGPUSwapchainTexture(cmd, win->window, &swapchain, NULL, NULL);
+      if (swapchain != NULL) {
+        /* Attribute the present: a redraw the window system asked for, one a
+         * starved frame had to defer, or this frame's own work. Both foreign
+         * kinds carry work that was *not* done in this frame. */
+        if (window_requested) {
+          xtgui::g_perf_frame.exposes += 1;
+        } else if (win->present_deferred != 0) {
+          xtgui::g_perf_frame.deferred += 1;
+        }
+        win->present_deferred = 0;
+        xtgui::g_perf_frame.presents += 1;
+        SDL_GPUColorTargetInfo target;
+        memset(&target, 0, sizeof(target));
+        target.texture = swapchain;
+        target.clear_color.r = win->background[0];
+        target.clear_color.g = win->background[1];
+        target.clear_color.b = win->background[2];
+        target.clear_color.a = win->background[3];
+        target.load_op = SDL_GPU_LOADOP_CLEAR;
+        target.store_op = SDL_GPU_STOREOP_STORE;
+        SDL_GPURenderPass *pass = SDL_BeginGPURenderPass(cmd, &target, 1, NULL);
+        if (can_paint) {
+          float density = SDL_GetWindowPixelDensity(win->window);
+          if (density <= 0.0f) density = 1.0f;
+          xt_gui_renderer_draw(cmd, pass, &win->geometry, &win->text_geometry,
+                               &win->image_geometry, viewport_width, viewport_height, density);
+        }
+        SDL_EndGPURenderPass(pass);
+        firstFrame = !win->ready;
+        win->ready = 1;
+      } else {
+        /* No swapchain image this frame: SDL's non-blocking acquire skips a
+         * frame (rather than blocking) when the GPU still holds the image, and
+         * a minimized or hidden window has none at all. Dropping the frame here
+         * would leave the window showing the previous frame until something
+         * else dirtied the page, so keep the invalidation pending and present
+         * it on the next frame — the paint, the uploads and the run list are
+         * already built and retained, so the retry only re-records the draws. */
+        win->present_dirty = 1;
+        win->present_deferred = 1;
+        xtgui::g_perf_frame.starvedFrames += 1;
+      }
+      SDL_SubmitGPUCommandBuffer(cmd);
+    } else {
+      /* No command buffer from the device: same treatment as a starved frame —
+       * keep the invalidation so the page is shown once the device recovers. */
+      win->present_dirty = 1;
+      win->present_deferred = 1;
+      xtgui::g_perf_frame.starvedFrames += 1;
     }
-    SDL_EndGPURenderPass(pass);
-    firstFrame = !win->ready;
-    win->ready = 1;
   }
-  SDL_SubmitGPUCommandBuffer(cmd);
   /* The first presented frame marks the window ready. Emitting after the
    * submit lets a `ready` handler safely close/destroy the window. */
   if (firstFrame) xt_gui_emit(win, "ready");
+  xtgui::xt_perf_frame_end();
 }

package/runtime/ext_gui/gui_media.cpp

@@ -19,6 +19,8 @@
 
 #include "gui_internal.h"
 
+#include "perf.h"
+
 #include <cstring>
 #include <string>
 #include <unordered_set>
@@ -113,6 +115,7 @@ bool booleanAttr(const xtgui::Node *node, const char *name) {
 
 void collectMedia(const xtgui::Node *node, std::vector<const xtgui::Node *> *out) {
   if (node == nullptr) return;
+  xtgui::g_perf_frame.syncNodes += 1;
   if (isMediaElement(node)) {
     out->push_back(node);
     return;  // a media element's children are `<source>`/`<track>`, not media

package/runtime/ext_gui/image.cpp

@@ -64,9 +64,71 @@ std::string normalizePath(const std::string &input) {
   return out;
 }
 
+/** Decode a `data:` URL's base64 payload (the only encoding the engine emits
+ * and the common one a page assigns). */
+bool decodeDataUrl(const std::string &url, std::vector<unsigned char> *out) {
+  const size_t comma = url.find(',');
+  if (comma == std::string::npos) return false;
+  const std::string header = url.substr(0, comma);
+  if (header.find(";base64") == std::string::npos) return false;
+  static const signed char kDecode[128] = {
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+      52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
+      -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+      15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+      -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+      41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1};
+  out->clear();
+  out->reserve((url.size() - comma) * 3 / 4 + 4);
+  uint32_t accumulator = 0;
+  int bits = 0;
+  for (size_t i = comma + 1; i < url.size(); i++) {
+    const unsigned char c = (unsigned char)url[i];
+    if (c == '=' || c == '\n' || c == '\r' || c == ' ') continue;
+    if (c >= 128) return false;
+    const int value = kDecode[c];
+    if (value < 0) return false;
+    accumulator = (accumulator << 6) | (uint32_t)value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out->push_back((unsigned char)((accumulator >> bits) & 0xFF));
+    }
+  }
+  return !out->empty();
+}
+
 }  // namespace
 
 const Image *xt_image_load(const std::string &raw_path, int target_width, int target_height) {
+  /* A `data:` URL carries its bytes inline (a canvas used as a CSS
+   * `background-image` reaches this path through `toDataURL()`). */
+  if (raw_path.rfind("data:", 0) == 0) {
+    auto &cache = imageCache();
+    auto found = cache.find(raw_path);
+    if (found != cache.end()) {
+      return found->second.width > 0 ? &found->second : nullptr;
+    }
+    Image image;
+    std::vector<unsigned char> bytes;
+    if (decodeDataUrl(raw_path, &bytes)) {
+      int width = 0;
+      int height = 0;
+      int channels = 0;
+      unsigned char *data = stbi_load_from_memory(bytes.data(), (int)bytes.size(), &width, &height,
+                                                  &channels, 4);
+      if (data != nullptr) {
+        image.width = width;
+        image.height = height;
+        image.pixels.assign(data, data + (size_t)width * (size_t)height * 4);
+        stbi_image_free(data);
+      }
+    }
+    auto inserted = cache.emplace(raw_path, std::move(image));
+    return inserted.first->second.width > 0 ? &inserted.first->second : nullptr;
+  }
   std::string path = normalizePath(raw_path);
   bool svg = xt_svg_is_svg(path);
   /* Raster formats always decode at their intrinsic resolution, so their cache
@@ -102,6 +164,13 @@ const Image *xt_image_load(const std::string &raw_path, int target_width, int ta
 }
 
 bool xt_image_size(const std::string &raw_path, int *width, int *height) {
+  if (raw_path.rfind("data:", 0) == 0) {
+    const Image *image = xt_image_load(raw_path);
+    if (image == nullptr) return false;
+    if (width != nullptr) *width = image->width;
+    if (height != nullptr) *height = image->height;
+    return true;
+  }
   std::string path = normalizePath(raw_path);
   if (xt_svg_is_svg(path)) return xt_svg_size(path, width, height);
   auto &cache = sizeCache();

package/runtime/ext_gui/image_bitmap_browser.cpp

@@ -15,6 +15,7 @@
 #include <vector>
 
 #include "image_bitmap.h"
+#include "canvas.h"
 #include "webgl.h"
 
 namespace {
@@ -47,6 +48,16 @@ bool source_pixels(xt_value source, xtgui::Image *out) {
     return true;
   }
 
+  if (XT_IS_OBJECT(source)) {
+    xt_value canvas_id = xt_object_get_cstr(source, "__xt_gui_canvas");
+    if (XT_IS_NUMBER(canvas_id)) {
+      xtgui::Canvas2D *canvas = xtgui::xt_canvas_by_id((uint64_t)xt_to_number(canvas_id));
+      if (canvas == nullptr || canvas->image().width <= 0) return false;
+      *out = canvas->image();
+      return true;
+    }
+  }
+
   XtGuiWindow *win = nullptr;
   xtgui::Node *node = domapi::resolve_node(source, &win);
   if (node == nullptr || !node->isElement()) return false;

package/runtime/ext_gui/layout.cpp

@@ -20,6 +20,7 @@
 
 #include "image.h"
 #include "inline_svg.h"
+#include "perf.h"
 #include "style_internal.h"
 
 namespace xtgui {
@@ -172,6 +173,8 @@ std::string dumpBox(const LayoutBox *box, int depth) {
 void LayoutTree::compute(const Node *root, const std::unordered_map<const Node *, XtStyle> &styles,
                          float viewportWidth, float viewportHeight, const MediaSizeMap *media,
                          const CanvasInfoMap *canvases) {
+  PerfScope perf_scope(&g_perf_frame_ms.layout);
+  g_perf_frame.layouts += 1;
   root_.reset();
   index_.clear();
   root_style_ = xt_style_initial();
@@ -214,6 +217,7 @@ void LayoutTree::compute(const Node *root, const std::unordered_map<const Node *
     const LayoutBox *box = stack.back();
     stack.pop_back();
     if (box->node != nullptr) index_[box->node] = box;
+    g_perf_frame.layoutBoxes += 1;
     for (const std::unique_ptr<LayoutBox> &child : box->children) stack.push_back(child.get());
   }
 }