xbintsc 0.5.31 → 0.5.36

package/runtime/ext_gui/gui.cpp

@@ -19,6 +19,7 @@
 #include "paint.h"
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 namespace guidev {
@@ -98,11 +99,32 @@ static void xt_gui_gc_scan_roots(void) {
 
 /* -- initialisation ------------------------------------------------------- */
 
-static int ensure_init(void) {  if (g_sdl_initialized) return 1;
-  xt_gc_register_root_provider(xt_gui_gc_scan_roots);
+/**
+ * Exit status for "this host cannot run a GUI program": no video driver, or no
+ * GPU device the SDL_GPU backends accept. It is deliberately distinct from a
+ * failed program so a CI script (or a user) can skip the run instead of
+ * reporting a crash. 77 is the autotools "skip" convention; `ci.yml` treats it
+ * that way for the provisional macOS job.
+ */
+const int kGuiUnavailableExit = 77;
+
+/** Report a window that could not be created as a JavaScript `Error`. Returning
+ * `undefined` used to surface one line later as `Cannot read properties of
+ * undefined (reading 'on')`, which hid the real diagnostic. */
+static void throw_gui_error(const char *message) {
+  xt_value text = xt_string_from_cstr(message);
+  xt_throw(xt_error_ctor_by_name(xt_string_from_cstr("Error"), 1, &text));
+}
+
+static void ensure_init(void) {
+  if (g_sdl_initialized) return;
   if (!SDL_Init(SDL_INIT_VIDEO)) {
     fprintf(stderr, "xt_gui: SDL_Init failed: %s\n", SDL_GetError());
-    return 0;
+    fprintf(stderr,
+            "xt_gui: the GUI extension needs a display (or a virtual one such as Xvfb); "
+            "exiting with status %d.\n",
+            kGuiUnavailableExit);
+    exit(kGuiUnavailableExit);
   }
   /* Accept every shader format so the same code runs on Metal, Vulkan and
    * D3D12; the backend only needs the one it supports. The engine ships MSL,
@@ -113,11 +135,17 @@ static int ensure_init(void) {  if (g_sdl_initialized) return 1;
   g_device = SDL_CreateGPUDevice(formats, false, NULL);
   if (g_device == NULL) {
     fprintf(stderr, "xt_gui: SDL_CreateGPUDevice failed: %s\n", SDL_GetError());
+    fprintf(stderr,
+            "xt_gui: the GUI extension needs a Metal (macOS), Vulkan or D3D12 device; "
+            "this host does not provide a usable one. Exiting with status %d.\n",
+            kGuiUnavailableExit);
     SDL_Quit();
-    return 0;
+    exit(kGuiUnavailableExit);
   }
+  /* Registered only once a window can exist: a failed init has nothing to
+   * mark, and a caller that cannot retry never needs a second provider. */
+  xt_gc_register_root_provider(xt_gui_gc_scan_roots);
   g_sdl_initialized = 1;
-  return 1;
 }
 
 /* -- window lookup -------------------------------------------------------- */
@@ -254,15 +282,18 @@ xt_value xt_gui_ensure_window(void) {
   for (int i = g_window_count - 1; i >= 0; i--) {
     if (g_windows[i].open) return g_windows[i].object;
   }
-  if (!ensure_init()) return XT_UNDEFINED;
+  ensure_init();
   XtGuiWindow *record = create_window_record("xbintsc gui", 800, 600, true);
-  if (record == NULL) return XT_UNDEFINED;
+  if (record == NULL) {
+    throw_gui_error("xbintsc gui: could not open the implicit window (see the diagnostic above)");
+    return XT_UNDEFINED;
+  }
   g_implicit_window = 1;
   return record->object;
 }
 
 extern "C" xt_value xt_gui_create_window(int32_t argc, xt_value *argv) {
-  if (!ensure_init()) return XT_UNDEFINED;
+  ensure_init();
 
   const char *title = "xbintsc gui";
   int width = 800;
@@ -304,7 +335,11 @@ extern "C" xt_value xt_gui_create_window(int32_t argc, xt_value *argv) {
   }
 
   XtGuiWindow *record = create_window_record(title, width, height, high_density);
-  return record != NULL ? record->object : XT_UNDEFINED;
+  if (record == NULL) {
+    throw_gui_error("xbintsc gui: could not open a window (see the diagnostic above)");
+    return XT_UNDEFINED;
+  }
+  return record->object;
 }
 
 /* -- run() / quit() ------------------------------------------------------- */

package/runtime/ext_gui/gui_canvas.cpp

@@ -65,11 +65,17 @@ xtgui::Canvas2D *xt_gui_canvas_get(XtGuiWindow *win, const xtgui::Node *node) {
   auto canvas = std::make_unique<xtgui::Canvas2D>(width, height);
   xtgui::Canvas2D *raw = canvas.get();
   win->canvases[node] = std::move(canvas);
+  /* A context obtained after the first frame must reach the display list
+   * immediately, so `paintList`/the next paint sees its size and texture id. */
+  if (win->document != nullptr) {
+    win->document->setCanvasInfo(node, (float)width, (float)height, raw->id());
+  }
   return raw;
 }
 
 void xt_gui_canvas_forget(XtGuiWindow *win, const xtgui::Node *node) {
   if (win == nullptr || node == nullptr) return;
+  xt_gui_webgl_forget(win, node);
   auto found = win->canvases.find(node);
   if (found == win->canvases.end()) return;
   releaseCanvasTexture(found->second.get());
@@ -81,8 +87,46 @@ void xt_gui_canvas_sync(XtGuiWindow *win) {
   std::vector<const xtgui::Node *> nodes;
   collectCanvases(win->document->root(), &nodes);
   for (const xtgui::Node *node : nodes) {
-    xtgui::Canvas2D *canvas = xt_gui_canvas_get(win, node);
-    if (canvas == nullptr) continue;
+    if (xtgui::WebGLContext *webgl = xt_gui_webgl_find(win, node)) {
+      win->document->setCanvasInfo(node, (float)webgl->width(), (float)webgl->height(),
+                                   webgl->id());
+      continue;
+    }
+    xtgui::Canvas2D *canvas = xt_gui_canvas_find(win, node);
+    if (canvas != nullptr) {
+      win->document->setCanvasInfo(node, (float)canvas->width(), (float)canvas->height(),
+                                   canvas->id());
+      continue;
+    }
+    /* No context yet: the attributes still define the intrinsic box, but there
+     * is nothing to paint (a canvas with no context is transparent). */
+    int width = canvasAttributeSize(node, "width", 300);
+    int height = canvasAttributeSize(node, "height", 150);
+    win->document->setCanvasInfo(node, (float)width, (float)height, 0);
+  }
+}
+
+void xt_gui_canvas_bind_pending(XtGuiWindow *win, const xtgui::Node *node, xt_value handle) {
+  if (win == nullptr || node == nullptr) return;
+  xt_value pending = xt_object_get_cstr(handle, "__xt_gui_pending_canvas");
+  if (!XT_IS_NUMBER(pending)) return;
+  uint64_t id = (uint64_t)xt_to_number(pending);
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_pending_canvas"), XT_UNDEFINED);
+  auto found = win->pending_canvases.find(id);
+  if (found == win->pending_canvases.end()) return;
+  if (!isCanvasElement(node)) {
+    win->pending_canvases.erase(found);
+    return;
+  }
+  xtgui::Canvas2D *canvas = found->second.get();
+  /* The parsed element's width/height attributes win over the default 300x150
+   * a pre-load context started with. */
+  int width = canvasAttributeSize(node, "width", canvas->width());
+  int height = canvasAttributeSize(node, "height", canvas->height());
+  if (width != canvas->width() || height != canvas->height()) canvas->resize(width, height);
+  win->canvases[node] = std::move(found->second);
+  win->pending_canvases.erase(found);
+  if (win->document != nullptr) {
     win->document->setCanvasInfo(node, (float)canvas->width(), (float)canvas->height(),
                                  canvas->id());
   }
@@ -90,6 +134,10 @@ void xt_gui_canvas_sync(XtGuiWindow *win) {
 
 void xt_gui_canvas_shutdown(XtGuiWindow *win) {
   if (win == nullptr) return;
+  xt_gui_webgl_shutdown(win);
   for (auto &entry : win->canvases) releaseCanvasTexture(entry.second.get());
   win->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

@@ -45,6 +45,9 @@ xt_value xt_browser_local_storage(int32_t argc, xt_value *argv);
 xt_value xt_browser_missing(int32_t argc, xt_value *argv);
 /** A DOM type name (`Image`, `HTMLCanvasElement`, …) as a constructor value. */
 xt_value xt_browser_type(int32_t argc, xt_value *argv);
+/** `createImageBitmap(source)`, exposed as a global *value*: returns the
+ * closure the compiler stores for the bare identifier. */
+xt_value xt_browser_create_image_bitmap(int32_t argc, xt_value *argv);
 xt_value xt_browser_request_animation_frame(int32_t argc, xt_value *argv);
 xt_value xt_browser_cancel_animation_frame(int32_t argc, xt_value *argv);
 xt_value xt_browser_match_media(int32_t argc, xt_value *argv);
@@ -63,11 +66,13 @@ void xt_browser_schedule_frame(void);
 /** Whether `run()` currently owns the frame loop (the pump then stays idle). */
 int xt_gui_run_active(void);
 
-/* Web Audio objects (`audio.cpp`). */
-/** `AudioContext.prototype` — also the `instanceof AudioContext` target. */
+/* Web Audio objects (`audio.cpp`).
+ * `AudioContext.prototype` — also the `instanceof AudioContext` target. */
 xt_value xt_gui_audio_proto(void);
-/** `new AudioContext(...)`: it has no mixer backend yet, so the graph records
- * its shape and parameters but nothing is rendered to the sound device. */
+/** `new AudioContext(...)`: builds a real graph (mixer in `audio_mixer.cpp`)
+ * and decodes through `audio_decode.cpp` + the optional media backend. The
+ * device opens on the first `start()`/`resume()`; a headless host stays silent
+ * while the graph still renders. */
 xt_value xt_gui_audio_create(int32_t argc, xt_value *argv);
 
 #ifdef __cplusplus
@@ -84,6 +89,7 @@ xt_value xt_gui_audio_create(int32_t argc, xt_value *argv);
 #include "document.h"
 #include "media.h"
 #include "renderer.h"
+#include "webgl.h"
 
 /** One element-level event listener registered through `addEventListener`. */
 struct XtGuiNodeListener {
@@ -162,6 +168,14 @@ 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
+   * handle binds to the parsed element. */
+  std::unordered_map<uint64_t, std::unique_ptr<xtgui::Canvas2D>> pending_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
@@ -243,12 +257,30 @@ xtgui::Canvas2D *xt_gui_canvas_get(XtGuiWindow *win, const xtgui::Node *node);
 xtgui::Canvas2D *xt_gui_canvas_find(XtGuiWindow *win, const xtgui::Node *node);
 /** Drop a node's canvas (called when its handle is forgotten). */
 void xt_gui_canvas_forget(XtGuiWindow *win, const xtgui::Node *node);
+/** Move a pre-load canvas into the live table when its pending element handle
+ * binds. `handle` is the DOM handle that was used for `getContext("2d")`. */
+void xt_gui_canvas_bind_pending(XtGuiWindow *win, const xtgui::Node *node, xt_value handle);
+
 /** Publish live canvases to the document (sizes + render ids) so layout and
  * paint see them; creates a context for a canvas that has none yet. */
 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

@@ -272,7 +272,7 @@ void xt_gui_render_window(XtGuiWindow *win) {
   bool can_paint = xt_gui_renderer_ensure(g_device, win->window);
   if (can_paint && win->geometry.dirty && win->document != nullptr) {
     xtgui::DisplayList list;
-    xtgui::xt_paint_build(win->document->layout().root(), list);
+    xtgui::xt_paint_build(win->document->layout().root(), list, viewport_width, viewport_height);
     xt_gui_geometry_upload(g_device, &win->geometry, list);
     float density = SDL_GetWindowPixelDensity(win->window);
     float text_scale = density > 0.0f ? density : 1.0f;
@@ -287,6 +287,9 @@ void xt_gui_render_window(XtGuiWindow *win) {
   xt_gui_media_upload_frames(g_device);
   /* Canvases are CPU-drawn: push any new bitmap without a relayout. */
   xt_gui_canvas_upload_frames(g_device);
+  /* 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;

package/runtime/ext_gui/gui_media.cpp

@@ -8,7 +8,7 @@
  *   - the renderer (`renderer_image.cpp`), which owns the GPU textures.
  *
  * It also provides the SDL audio sink the decoder writes PCM to, which keeps
- * SDL out of `media.a`.
+ * SDL out of `media.a`/`media.lib`.
  *
  * The frame loop calls `xt_gui_media_sync` (open/close decoders so the next
  * layout sees the current sources and intrinsic sizes) and `xt_gui_media_tick`

package/runtime/ext_gui/gui_webgl.cpp

@@ -0,0 +1,83 @@
+/*
+ * xbintsc GUI engine — `<canvas>` WebGL lifetime.
+ *
+ * A WebGL context is owned by the window, keyed by its DOM element (the same
+ * shape as the 2D canvas and video tables). Its colour texture is what the
+ * page's image pipeline samples, so no pixels pass through the CPU.
+ */
+
+#include <memory>
+
+#include "gui_engine.h"
+#include "gui_internal.h"
+
+namespace {
+
+bool isCanvasElement(const xtgui::Node *node) {
+  return node != nullptr && node->isElement() && node->isTag("canvas");
+}
+
+uint64_t next_webgl_id() {
+  static uint64_t counter = 0;
+  counter++;
+  /* Keep WebGL ids out of the Canvas2D id space so the renderer can tell the
+   * two kinds of canvas apart from the id alone. */
+  return (1ULL << 32) | counter;
+}
+
+}  // namespace
+
+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();
+}
+
+xtgui::WebGLContext *xt_gui_webgl_get(XtGuiWindow *win, const xtgui::Node *node, bool webgl2) {
+  if (win == nullptr || !isCanvasElement(node)) return nullptr;
+  xtgui::WebGLContext *existing = xt_gui_webgl_find(win, node);
+  if (existing != nullptr) return existing->is_webgl2() == webgl2 ? existing : nullptr;
+  if (win->canvases.find(node) != win->canvases.end()) return nullptr;  // already a 2D canvas
+  /* WebGL shaders reach SDL_GPU as SPIR-V (Vulkan, translated by glslang) or as
+   * MSL (Metal, the same module cross-compiled by SPIRV-Cross). A device whose
+   * backend consumes neither format — Direct3D 12 needs DXIL — has no WebGL
+   * context in this build, so `getContext("webgl")` answers null instead of
+   * handing out a context whose draws could never create a pipeline. */
+  if (guidev::g_device == nullptr ||
+      (SDL_GetGPUShaderFormats(guidev::g_device) &
+       (SDL_GPU_SHADERFORMAT_SPIRV | SDL_GPU_SHADERFORMAT_MSL)) == 0) {
+    return nullptr;
+  }
+  const std::string *width_attr = node->attr("width");
+  const std::string *height_attr = node->attr("height");
+  float width = 300.0f;
+  float height = 150.0f;
+  if (width_attr != nullptr) xtgui::xt_css_parse_number(*width_attr, &width);
+  if (height_attr != nullptr) xtgui::xt_css_parse_number(*height_attr, &height);
+  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);
+  if (win->document != nullptr) {
+    win->document->setCanvasInfo(node, (float)raw->width(), (float)raw->height(), raw->id());
+  }
+  return raw;
+}
+
+void xt_gui_webgl_forget(XtGuiWindow *win, const xtgui::Node *node) {
+  if (win == nullptr || node == nullptr) return;
+  win->webgl_canvases.erase(node);
+}
+
+void xt_gui_webgl_shutdown(XtGuiWindow *win) {
+  if (win == nullptr) return;
+  win->webgl_canvases.clear();
+}
+
+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();
+  }
+}

package/runtime/ext_gui/image_bitmap.cpp

@@ -0,0 +1,28 @@
+/*
+ * xbintsc GUI engine — `ImageBitmap` pixel storage.
+ */
+
+#include "image_bitmap.h"
+
+#include <unordered_map>
+
+namespace xtgui {
+namespace {
+
+std::unordered_map<uint64_t, Image> g_bitmaps;
+uint64_t g_next_bitmap = 1;
+
+}  // namespace
+
+uint64_t xt_image_bitmap_add(const Image &image) {
+  const uint64_t id = g_next_bitmap++;
+  g_bitmaps[id] = image;
+  return id;
+}
+
+const Image *xt_image_bitmap_get(uint64_t id) {
+  auto found = g_bitmaps.find(id);
+  return found == g_bitmaps.end() ? nullptr : &found->second;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/image_bitmap.h

@@ -0,0 +1,26 @@
+/*
+ * xbintsc GUI engine — `ImageBitmap` storage.
+ *
+ * `createImageBitmap(source)` returns a settled promise of an immutable
+ * bitmap. The pixels stay in C++ so `texImage2D` can consume them without
+ * materialising a JavaScript array; the handle object carries the numeric id
+ * under `__xt_bitmap`.
+ */
+#ifndef XT_GUI_IMAGE_BITMAP_H
+#define XT_GUI_IMAGE_BITMAP_H
+
+#include <cstdint>
+
+#include "image.h"
+
+namespace xtgui {
+
+/** Store a decoded bitmap and return its process-wide id. */
+uint64_t xt_image_bitmap_add(const Image &image);
+
+/** Look up a bitmap; null when the id is unknown. */
+const Image *xt_image_bitmap_get(uint64_t id);
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_IMAGE_BITMAP_H */

package/runtime/ext_gui/image_bitmap_browser.cpp

@@ -0,0 +1,136 @@
+/*
+ * xbintsc GUI engine — `createImageBitmap`.
+ *
+ * The browser entry point returns a promise (as it does on the web), so code
+ * that writes `const bitmap = await createImageBitmap(canvas)` works unchanged.
+ * The pixels are kept in `image_bitmap.cpp`; `texImage2D` reads the same
+ * registry through the bitmap's `__xt_bitmap` id.
+ */
+
+#include "gui_engine.h"
+#include "dom_api_internal.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "image_bitmap.h"
+#include "webgl.h"
+
+namespace {
+
+void flip_rows(std::vector<unsigned char> *pixels, int width, int height) {
+  const size_t stride = (size_t)width * 4;
+  std::vector<unsigned char> row(stride);
+  for (int y = 0; y < height / 2; y++) {
+    unsigned char *top = pixels->data() + (size_t)y * stride;
+    unsigned char *bottom = pixels->data() + (size_t)(height - 1 - y) * stride;
+    memcpy(row.data(), top, stride);
+    memcpy(top, bottom, stride);
+    memcpy(bottom, row.data(), stride);
+  }
+}
+
+bool source_pixels(xt_value source, xtgui::Image *out) {
+  /* ImageData / another bitmap-like object: width, height, data. */
+  xt_value width_value = xt_object_get_cstr(source, "width");
+  xt_value height_value = xt_object_get_cstr(source, "height");
+  xt_value data = xt_object_get_cstr(source, "data");
+  if (XT_IS_OBJECT(data) && XT_IS_NUMBER(width_value) && XT_IS_NUMBER(height_value)) {
+    const int width = (int)xt_to_number(width_value);
+    const int height = (int)xt_to_number(height_value);
+    const std::vector<uint8_t> bytes = domapi::webgl_bytes(data);
+    if (width <= 0 || height <= 0 || bytes.size() < (size_t)width * height * 4) return false;
+    out->width = width;
+    out->height = height;
+    out->pixels.assign(bytes.begin(), bytes.begin() + (size_t)width * height * 4);
+    return true;
+  }
+
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = domapi::resolve_node(source, &win);
+  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;
+    if (image == nullptr) return false;
+    *out = *image;
+    return true;
+  }
+  if (node->isTag("canvas")) {
+    if (xtgui::Canvas2D *canvas = xt_gui_canvas_find(win, node)) {
+      *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;
+      }
+      /* readPixels is GL-ordered (bottom-up); bitmaps are stored top-down. */
+      flip_rows(&out->pixels, out->width, out->height);
+      return true;
+    }
+    return false;
+  }
+  if (node->isTag("video")) {
+    xtgui::MediaPlayer *player = xt_gui_media_player(win, node);
+    const xtgui::Image *frame = player != nullptr ? player->frame() : nullptr;
+    if (frame == nullptr || frame->width <= 0 || frame->height <= 0) return false;
+    *out = *frame;
+    return true;
+  }
+  return false;
+}
+
+xt_value bitmap_object(const xtgui::Image &image) {
+  const uint64_t id = xtgui::xt_image_bitmap_add(image);
+  xt_value name = xt_string_from_cstr("ImageBitmap");
+  xt_value constructor = xt_browser_type(1, &name);
+  xt_value prototype = xt_object_get_cstr(constructor, "prototype");
+  xt_value bitmap = XT_IS_OBJECT(prototype) ? xt_object_new_with_proto(prototype)
+                                            : xt_object_new();
+  xt_object_set(bitmap, xt_string_from_cstr("width"), xt_number(image.width));
+  xt_object_set(bitmap, xt_string_from_cstr("height"), xt_number(image.height));
+  xt_object_set(bitmap, xt_string_from_cstr("__xt_bitmap"), xt_number((double)id));
+  return bitmap;
+}
+
+}  // namespace
+
+namespace {
+
+xt_value create_bitmap(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_reject(xt_string_from_cstr("TypeError"));
+  xtgui::Image image;
+  if (!source_pixels(xt_arg(argc, argv, 0), &image)) {
+    return xt_promise_reject(xt_string_from_cstr("InvalidStateError"));
+  }
+  return xt_promise_resolve(bitmap_object(image));
+}
+
+/** The closure ABI the runtime calls for a first-class function value. */
+xt_value create_bitmap_call(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)self;
+  (void)env;
+  return create_bitmap(argc, argv);
+}
+
+xt_value g_create_bitmap = XT_UNDEFINED;
+
+}  // namespace
+
+/* `createImageBitmap` is a *global value*: the compiler calls this getter once
+ * and stores the returned closure, which is then called like any function. */
+xt_value xt_browser_create_image_bitmap(int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  if (!XT_IS_OBJECT(g_create_bitmap)) {
+    g_create_bitmap = xt_closure_new((void *)create_bitmap_call, 0, nullptr);
+    xt_gc_add_root(&g_create_bitmap);
+  }
+  return g_create_bitmap;
+}
+

package/runtime/ext_gui/layout.cpp

@@ -123,6 +123,21 @@ std::unique_ptr<LayoutBox> buildBoxTree(const Node *node,
     if (box->intrinsic_height <= 0.0f) box->intrinsic_height = 150.0f;
   }
   if (box->is_inline_svg) return box;
+
+  /* `::before` / `::after` boxes are emitted around the DOM children. Only a
+   * pseudo-element with `content` generates a box (CSS: a `::before` rule with
+   * no content has no effect). Replaced elements never generate them. */
+  auto appendPseudo = [&](Node *pseudo) {
+    if (pseudo == nullptr || box->is_image || box->is_canvas || box->is_media) return;
+    auto pseudoStyle = styles.find(pseudo);
+    if (pseudoStyle == styles.end() || !pseudoStyle->second.has_content) return;
+    std::unique_ptr<LayoutBox> pseudoBox = buildBoxTree(pseudo, styles, style, media, canvases);
+    if (pseudoBox != nullptr) {
+      pseudoBox->parent = box.get();
+      box->children.push_back(std::move(pseudoBox));
+    }
+  };
+  if (node->isElement() && !node->is_pseudo) appendPseudo(node->pseudo_before);
   for (const std::unique_ptr<Node> &child : node->children) {
     std::unique_ptr<LayoutBox> childBox =
         buildBoxTree(child.get(), styles, style, media, canvases);
@@ -131,6 +146,7 @@ std::unique_ptr<LayoutBox> buildBoxTree(const Node *node,
       box->children.push_back(std::move(childBox));
     }
   }
+  if (node->isElement() && !node->is_pseudo) appendPseudo(node->pseudo_after);
   return box;
 }
 
@@ -211,15 +227,20 @@ namespace {
 
 const LayoutBox *hitTestBox(const LayoutBox *box, float x, float y) {
   if (box == nullptr || box->display == Display::None) return nullptr;
+  if (box->style != nullptr && !box->style->visible) return nullptr;
   /* Later siblings paint on top, so probe them first. */
   for (auto it = box->children.rbegin(); it != box->children.rend(); ++it) {
     if (const LayoutBox *hit = hitTestBox(it->get(), x, y)) return hit;
   }
+  if (box->style != nullptr && !box->style->pointer_events) return nullptr;
   float local_x = x;
   float local_y = y;
   if (box->has_transform) box->inverse.apply(x, y, &local_x, &local_y);
   if (local_x >= box->x && local_x < box->x + box->width && local_y >= box->y &&
       local_y < box->y + box->height) {
+    /* A generated box is part of its originating element: events must target
+     * the real element handle, not the synthetic node. */
+    if (box->node != nullptr && box->node->is_pseudo && box->parent != nullptr) return box->parent;
     return box;
   }
   return nullptr;