xbintsc 0.5.32 → 0.5.37

package/runtime/ext_gui/audio_mixer.h

@@ -0,0 +1,238 @@
+/*
+ * xbintsc GUI engine — the Web Audio mixer.
+ *
+ * `audio.cpp` owns the JavaScript-facing objects (AudioContext, AudioNode,
+ * AudioParam, AudioBuffer); this unit owns the graph those objects describe and
+ * turns it into interleaved 48 kHz stereo float PCM. It knows nothing about
+ * `xt_value`, the DOM or the garbage collector, which is what lets the SDL
+ * audio callback render on its own thread without touching a runtime value.
+ *
+ * Rendering follows the Web Audio model: 128-frame render quanta, multiple
+ * inputs summed at every node, and an AudioParam timeline evaluated per sample.
+ * A node's quantum is cached for the quantum serial, so a node feeding two
+ * destinations (fan-out) is computed once and a cycle renders silence instead
+ * of recursing forever.
+ *
+ * Threading: the graph is mutated from the page thread (create/connect/start)
+ * and read from the SDL audio thread (render). Every public method takes the
+ * same mutex, so a mutation never interleaves with a render. No callback ever
+ * touches an `xt_value`.
+ */
+#ifndef XT_GUI_AUDIO_MIXER_H
+#define XT_GUI_AUDIO_MIXER_H
+
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include <vector>
+
+struct SDL_AudioStream;
+
+namespace xtgui {
+
+/** Mix rate of every context (SDL converts to the device rate). */
+constexpr int kAudioMixRate = 48000;
+constexpr int kAudioMixChannels = 2;
+/** Web Audio's render quantum, in frames. */
+constexpr int kAudioQuantum = 128;
+
+enum AudioNodeKind {
+  kAudioDestination,
+  kAudioGain,
+  kAudioOscillator,
+  kAudioBufferSource,
+  kAudioBiquad,
+  kAudioCompressor,
+  kAudioStereoPanner,
+  kAudioConstantSource,
+  kAudioDelay,
+};
+
+enum AudioOscType { kAudioOscSine, kAudioOscSquare, kAudioOscSawtooth, kAudioOscTriangle };
+
+enum AudioBiquadType {
+  kAudioBiquadLowpass,
+  kAudioBiquadHighpass,
+  kAudioBiquadBandpass,
+  kAudioBiquadLowshelf,
+  kAudioBiquadHighshelf,
+  kAudioBiquadPeaking,
+  kAudioBiquadNotch,
+  kAudioBiquadAllpass,
+};
+
+/** One decoded/created AudioBuffer's samples, in planar float.
+ *
+ * A buffer source takes a reference to one of these when it starts. Decoding
+ * (or an AudioBuffer handed to `start`) copies the samples once, so playback
+ * never reads a runtime value and a buffer can be collected while it plays. */
+struct AudioClip {
+  std::vector<std::vector<float>> channels;
+  int sample_rate = kAudioMixRate;
+  uint32_t length = 0;
+
+  double duration() const {
+    return sample_rate > 0 ? static_cast<double>(length) / sample_rate : 0.0;
+  }
+};
+
+/** One AudioParam: a base value plus the scheduled automation events.
+ *
+ * Events are evaluated on demand at a sample time, which keeps scheduling and
+ * rendering independent: a page may schedule seconds ahead, and a source may
+ * start with a nonzero `when`. */
+class AudioParamState {
+ public:
+  void reset(double value);
+  /** The `value` setter: takes effect at `time` and overrides older events. */
+  void set_value(double value, double time);
+  void set_value_at_time(double value, double time);
+  void linear_ramp(double value, double time);
+  void exponential_ramp(double value, double time);
+  void set_target(double value, double time, double time_constant);
+  void cancel_scheduled(double time);
+  void cancel_and_hold(double time);
+  double value_at(double time) const;
+
+ private:
+  enum EventKind { kEventSet, kEventLinear, kEventExponential, kEventTarget };
+  struct Event {
+    double time;
+    EventKind kind;
+    double value;
+    double time_constant;
+  };
+
+  double evaluate(size_t index, double time) const;
+  void insert(Event event);
+
+  double base_ = 0.0;
+  std::vector<Event> events_;
+};
+
+/** One graph node. Only the fields a node's kind uses are meaningful. */
+struct AudioNode {
+  uint64_t id = 0;
+  AudioNodeKind kind = kAudioGain;
+  std::vector<uint64_t> inputs;
+  AudioParamState params[5];
+  int param_count = 0;
+
+  /* Per-quantum cache: 2 * kAudioQuantum interleaved floats. */
+  std::vector<float> quantum;
+  uint64_t serial = 0;
+  bool rendering = false;
+
+  /* Oscillator. */
+  AudioOscType osc_type = kAudioOscSine;
+  double phase = 0.0;
+
+  /* Sources (oscillator and buffer). */
+  bool started = false;
+  bool began = false;
+  bool ended = false;
+  double start_time = 0.0;
+  double stop_time = -1.0;
+  std::shared_ptr<AudioClip> clip;
+  double clip_offset = 0.0;
+  double clip_duration = 0.0;
+  double clip_pos = 0.0;
+  bool loop = false;
+  double loop_start = 0.0;
+  double loop_end = 0.0;
+
+  /* Biquad filter state, one set per channel. */
+  AudioBiquadType biquad_type = kAudioBiquadLowpass;
+  double x1[2] = {0.0, 0.0};
+  double x2[2] = {0.0, 0.0};
+  double y1[2] = {0.0, 0.0};
+  double y2[2] = {0.0, 0.0};
+
+  /* Compressor envelope, in dB of gain reduction. */
+  double compressor_env = 0.0;
+
+  /* Delay line, one ring per channel. `delay_size` is 0 until the JS factory
+   * has supplied `maxDelayTime`. */
+  std::vector<float> delay[2];
+  size_t delay_size = 0;
+  size_t delay_write = 0;
+  double delay_max = 1.0;
+};
+
+/** One AudioContext's graph, its device stream and its clock. */
+class AudioMixer {
+ public:
+  explicit AudioMixer(bool offline);
+  ~AudioMixer();
+
+  AudioMixer(const AudioMixer &) = delete;
+  AudioMixer &operator=(const AudioMixer &) = delete;
+
+  bool offline() const { return offline_; }
+
+  /* -- graph ------------------------------------------------------------- */
+  uint64_t create_node(AudioNodeKind kind);
+  void connect(uint64_t source, uint64_t target);
+  void disconnect(uint64_t source, uint64_t target);
+  void disconnect_all(uint64_t source);
+  void set_osc_type(uint64_t node, AudioOscType type);
+  void set_biquad_type(uint64_t node, AudioBiquadType type);
+  /** Allocate a delay line long enough for `seconds` (constructor argument of
+   * `createDelay`). */
+  void set_delay_max(uint64_t node, double seconds);
+  void set_buffer(uint64_t node, std::shared_ptr<AudioClip> clip, bool loop, double loop_start,
+                  double loop_end);
+  void start_source(uint64_t node, double when, double offset, double duration);
+  void stop_source(uint64_t node, double when);
+
+  /* -- AudioParam -------------------------------------------------------- */
+  double param_value(uint64_t node, int index);
+  void param_set(uint64_t node, int index, double value);
+  void param_set_at(uint64_t node, int index, double value, double time);
+  void param_linear_ramp(uint64_t node, int index, double value, double time);
+  void param_exponential_ramp(uint64_t node, int index, double value, double time);
+  void param_set_target(uint64_t node, int index, double value, double time, double time_constant);
+  void param_cancel(uint64_t node, int index, double time, bool hold);
+
+  /* -- clock and device -------------------------------------------------- */
+  double current_time();
+  /** Best effort: a headless host has no device and playback stays silent. */
+  bool start_device();
+  void suspend_device();
+  void resume_device();
+  void close_device();
+  bool has_device();
+  /** Drop the graph; called by `AudioContext.close()`. */
+  void shutdown();
+
+  /** Render `frames` stereo frames (interleaved) from the graph. Safe to call
+   * from the audio callback and from `render_offline`. */
+  void render(float *out, int frames);
+  /** Synchronous render for the offline diagnostic hook: no device involved. */
+  void render_offline(float *out, int frames);
+
+ private:
+  AudioNode *node_locked(uint64_t id);
+  const float *pull_locked(AudioNode *node);
+  void render_quantum_locked();
+  void render_locked(float *out, int frames);
+
+  std::mutex mutex_;
+  std::unordered_map<uint64_t, std::shared_ptr<AudioNode>> nodes_;
+  uint64_t next_node_id_ = 1;
+  uint64_t destination_id_ = 0;
+  uint64_t serial_ = 0;
+  uint64_t frames_rendered_ = 0;
+  std::vector<float> pending_;
+  size_t pending_offset_ = 0;
+
+  const bool offline_;
+  bool running_ = true;
+  SDL_AudioStream *stream_ = nullptr;
+  bool device_tried_ = false;
+};
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_AUDIO_MIXER_H */

package/runtime/ext_gui/audio_param.cpp

@@ -0,0 +1,104 @@
+/*
+ * xbintsc GUI engine — AudioParam automation curves.
+ *
+ * A param is a base value plus a time-ordered event list. Every accessor on the
+ * page's AudioParam (value, setValueAtTime, the ramps, setTargetAtTime,
+ * cancel*) appends an event; the mixer evaluates the list per sample so the
+ * curve keeps moving even when no JS calls happen between frames.
+ *
+ * The timeline belongs to the mixer and is only reached with the mixer's lock
+ * held, so it needs no lock of its own.
+ */
+
+#include "audio_mixer.h"
+
+#include <cmath>
+
+namespace xtgui {
+
+void AudioParamState::reset(double value) {
+  base_ = value;
+  events_.clear();
+}
+
+void AudioParamState::insert(Event event) {
+  for (size_t i = 0; i < events_.size(); i++) {
+    if (std::fabs(events_[i].time - event.time) < 1e-12) {
+      events_[i] = event;
+      return;
+    }
+    if (events_[i].time > event.time) {
+      events_.insert(events_.begin() + static_cast<std::ptrdiff_t>(i), event);
+      return;
+    }
+  }
+  events_.push_back(event);
+}
+
+void AudioParamState::set_value(double value, double time) {
+  if (events_.empty()) base_ = value;
+  insert({time, kEventSet, value, 0.0});
+}
+
+void AudioParamState::set_value_at_time(double value, double time) {
+  insert({time, kEventSet, value, 0.0});
+}
+
+void AudioParamState::linear_ramp(double value, double time) {
+  insert({time, kEventLinear, value, 0.0});
+}
+
+void AudioParamState::exponential_ramp(double value, double time) {
+  insert({time, kEventExponential, value, 0.0});
+}
+
+void AudioParamState::set_target(double value, double time, double time_constant) {
+  insert({time, kEventTarget, value, time_constant});
+}
+
+void AudioParamState::cancel_scheduled(double time) {
+  while (!events_.empty() && events_.back().time >= time) events_.pop_back();
+}
+
+void AudioParamState::cancel_and_hold(double time) {
+  double value = value_at(time);
+  cancel_scheduled(time);
+  insert({time, kEventSet, value, 0.0});
+}
+
+double AudioParamState::evaluate(size_t index, double time) const {
+  const Event &event = events_[index];
+  if (event.kind == kEventSet) return event.value;
+  if (event.kind == kEventTarget) {
+    double start = index > 0 ? evaluate(index - 1, events_[index - 1].time) : base_;
+    if (event.time_constant <= 0.0) return event.value;
+    double decay = std::exp(-(time - event.time) / event.time_constant);
+    return event.value + (start - event.value) * decay;
+  }
+  /* A ramp that has already ended holds its target value. */
+  return event.value;
+}
+
+double AudioParamState::value_at(double time) const {
+  if (events_.empty() || time < events_.front().time) return base_;
+  size_t index = 0;
+  while (index + 1 < events_.size() && events_[index + 1].time <= time) index++;
+  if (index + 1 < events_.size()) {
+    const Event &next = events_[index + 1];
+    if ((next.kind == kEventLinear || next.kind == kEventExponential) && time < next.time) {
+      double start_time = events_[index].time;
+      double start_value = evaluate(index, start_time);
+      double span = next.time - start_time;
+      double fraction = span > 0.0 ? (time - start_time) / span : 1.0;
+      if (next.kind == kEventLinear) {
+        return start_value + (next.value - start_value) * fraction;
+      }
+      double from = std::fabs(start_value) < 1e-9 ? 1e-6 : start_value;
+      double to = std::fabs(next.value) < 1e-9 ? 1e-6 : next.value;
+      return from * std::pow(to / from, fraction);
+    }
+  }
+  return evaluate(index, time);
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/audio_param_object.cpp

@@ -0,0 +1,155 @@
+/*
+ * xbintsc GUI engine — the JavaScript AudioParam object.
+ *
+ * The automation timeline itself lives in the mixer (`audio_param.cpp`); this
+ * unit is the object a page holds: a live `value` accessor plus the scheduling
+ * methods, each forwarding to the native node slot it names. Splitting it out of
+ * `audio.cpp` keeps both translation units within the file-size budget.
+ */
+
+#include "audio_internal.h"
+
+#include <cstdint>
+#include <memory>
+
+namespace {
+
+using namespace xtgui;
+
+double number_prop(xt_value object, const char *name) {
+  xt_value value = xt_object_get_cstr(object, name);
+  return XT_IS_NUMBER(value) ? xt_to_number(value) : 0.0;
+}
+
+xt_value fn_of(void *fn) { return xt_closure_new(fn, 0, NULL); }
+
+struct ParamRef {
+  std::shared_ptr<AudioMixer> mixer;
+  uint64_t node = 0;
+  int index = 0;
+};
+
+bool param_ref(xt_value object, ParamRef *out) {
+  out->mixer = audio_mixer_by_id(audio_context_id(object));
+  out->node = static_cast<uint64_t>(number_prop(object, "__xt_audio_node"));
+  out->index = static_cast<int>(number_prop(object, "__xt_audio_param"));
+  return out->mixer != nullptr && out->node != 0;
+}
+
+xt_value param_value_get(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  ParamRef ref;
+  if (!param_ref(self, &ref)) return xt_number(0);
+  return xt_number(ref.mixer->param_value(ref.node, ref.index));
+}
+
+xt_value param_value_set(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value value = xt_arg(argc, argv, 0);
+  if (!XT_IS_NUMBER(value)) value = xt_number(xt_to_number(value));
+  ParamRef ref;
+  if (param_ref(self, &ref)) {
+    ref.mixer->param_set(ref.node, ref.index, xt_to_number(value));
+  }
+  return value;
+}
+
+xt_value param_set_value_at_time(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  ParamRef ref;
+  if (param_ref(self, &ref)) {
+    double value = xt_to_number(xt_arg(argc, argv, 0));
+    double time = argc > 1 ? xt_to_number(argv[1]) : ref.mixer->current_time();
+    ref.mixer->param_set_at(ref.node, ref.index, value, time);
+  }
+  return self;
+}
+
+xt_value param_linear_ramp(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  ParamRef ref;
+  if (param_ref(self, &ref)) {
+    double value = xt_to_number(xt_arg(argc, argv, 0));
+    double time = argc > 1 ? xt_to_number(argv[1]) : ref.mixer->current_time();
+    ref.mixer->param_linear_ramp(ref.node, ref.index, value, time);
+  }
+  return self;
+}
+
+xt_value param_exponential_ramp(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  ParamRef ref;
+  if (param_ref(self, &ref)) {
+    double value = xt_to_number(xt_arg(argc, argv, 0));
+    double time = argc > 1 ? xt_to_number(argv[1]) : ref.mixer->current_time();
+    ref.mixer->param_exponential_ramp(ref.node, ref.index, value, time);
+  }
+  return self;
+}
+
+xt_value param_set_target(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  ParamRef ref;
+  if (param_ref(self, &ref)) {
+    double value = xt_to_number(xt_arg(argc, argv, 0));
+    double time = argc > 1 ? xt_to_number(argv[1]) : ref.mixer->current_time();
+    double constant = argc > 2 ? xt_to_number(argv[2]) : 0.0;
+    ref.mixer->param_set_target(ref.node, ref.index, value, time, constant);
+  }
+  return self;
+}
+
+xt_value param_cancel(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  ParamRef ref;
+  if (param_ref(self, &ref)) {
+    double time = argc > 0 ? xt_to_number(argv[0]) : 0.0;
+    ref.mixer->param_cancel(ref.node, ref.index, time, false);
+  }
+  return self;
+}
+
+xt_value param_cancel_and_hold(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  ParamRef ref;
+  if (param_ref(self, &ref)) {
+    double time = argc > 0 ? xt_to_number(argv[0]) : 0.0;
+    ref.mixer->param_cancel(ref.node, ref.index, time, true);
+  }
+  return self;
+}
+
+void set_prop(xt_value target, const char *name, xt_value value) {
+  xt_object_set(target, xt_string_from_cstr(name), value);
+}
+
+void set_method(xt_value target, const char *name, void *fn) { set_prop(target, name, fn_of(fn)); }
+
+void set_number(xt_value target, const char *name, double value) {
+  set_prop(target, name, xt_number(value));
+}
+
+}  // namespace
+
+namespace xtgui {
+
+xt_value audio_param_build(uint64_t context, uint64_t node, int index) {
+  xt_value param = xt_object_new();
+  set_number(param, "__xt_audio_ctx", static_cast<double>(context));
+  set_number(param, "__xt_audio_node", static_cast<double>(node));
+  set_number(param, "__xt_audio_param", index);
+  xt_object_define_getter(param, xt_string_from_cstr("value"), fn_of((void *)param_value_get));
+  xt_object_define_setter(param, xt_string_from_cstr("value"), fn_of((void *)param_value_set));
+  set_method(param, "setValueAtTime", (void *)param_set_value_at_time);
+  set_method(param, "linearRampToValueAtTime", (void *)param_linear_ramp);
+  set_method(param, "exponentialRampToValueAtTime", (void *)param_exponential_ramp);
+  set_method(param, "setTargetAtTime", (void *)param_set_target);
+  set_method(param, "cancelScheduledValues", (void *)param_cancel);
+  set_method(param, "cancelAndHoldAtTime", (void *)param_cancel_and_hold);
+  set_number(param, "defaultValue", 0.0);
+  return param;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/browser.cpp

@@ -29,7 +29,6 @@ namespace {
 xt_value g_navigator = XT_UNDEFINED;
 xt_value g_local_storage = XT_UNDEFINED;
 xt_value g_location = XT_UNDEFINED;
-xt_value g_media_list = XT_UNDEFINED;
 xt_value g_document_global = XT_UNDEFINED;
 /** Type name -> the constructor value handed out for it (built on first use). */
 std::unordered_map<std::string, xt_value> g_types;
@@ -156,35 +155,28 @@ xt_value win_location_get(xt_value self, xt_value env, int32_t argc, xt_value *a
   return g_location;
 }
 
-xt_value media_list_build(const std::string &query, bool matches);
-
-/** `matchMedia(query)` -> a MediaQueryList-shaped object evaluated against the
- * current window's viewport, using the same evaluator as `@media` rules. The
- * list is a snapshot (there is no live change event), which matches the
- * engine's restyle-on-resize model. */
+/** `matchMedia(query)` -> a live `MediaQueryList` evaluated against the current
+ * viewport with the same evaluator as `@media` rules. The list is cached per
+ * window and query, and `change` listeners fire when a resize flips it. */
 xt_value win_match_media(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
   std::string query;
   if (argc >= 1) query = cstr(xt_arg(argc, argv, 0));
   XtGuiWindow *win = xt_gui_window_from_this(self);
-  if (win == NULL) {
-    xt_value handle = xt_gui_ensure_window();
-    win = xt_gui_window_from_this(handle);
-  }
-  float width = 0.0f;
-  float height = 0.0f;
-  if (win != NULL) xt_gui_window_viewport(win, &width, &height);
-  return media_list_build(query, xtgui::xt_css_media_matches(query, width, height));
+  if (win == NULL) win = xt_gui_window_from_this(xt_gui_ensure_window());
+  if (win == NULL) return xt_object_new();
+  return xt_browser_media_list(win->object, query);
 }
 
-/** `getComputedStyle(el)`: the engine exposes the element's style handle, which
- * answers `getPropertyValue` for everything the page set. */
+/** `getComputedStyle(el, pseudoElt)`: a live view of the *cascaded* style, so
+ * stylesheet rules (not only the inline `style` attribute) are visible. The
+ * optional pseudo-element selector ("::before"/"::after") resolves against the
+ * generated-content box; any other pseudo-element yields empty values, like a
+ * browser does for one the engine did not generate. */
 xt_value win_get_computed_style(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
   (void)self;
   (void)env;
-  xt_value element = xt_arg(argc, argv, 0);
-  xt_value style = xt_get(element, xt_string_from_cstr("style"));
-  return XT_IS_OBJECT(style) ? style : xt_object_new();
+  return domapi::computed_style_handle(xt_arg(argc, argv, 0), xt_arg(argc, argv, 1));
 }
 
 xt_value win_alert(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
@@ -196,19 +188,13 @@ xt_value win_alert(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
 }
 
 xt_value win_confirm(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
-  (void)self;
   (void)env;
-  (void)argc;
-  (void)argv;
-  return XT_FALSE;
+  return xt_browser_confirm(xt_gui_window_from_this(self), argc, argv);
 }
 
 xt_value win_prompt(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
-  (void)self;
   (void)env;
-  (void)argc;
-  (void)argv;
-  return XT_UNDEFINED;
+  return xt_browser_prompt(xt_gui_window_from_this(self), argc, argv);
 }
 
 /* -- host objects --------------------------------------------------------- */
@@ -253,18 +239,6 @@ xt_value location_build(void) {
   return location;
 }
 
-xt_value media_list_build(const std::string &query, bool matches) {
-  xt_value list = xt_object_new();
-  set_prop(list, "media", xt_string_from_cstr(query.c_str()));
-  set_prop(list, "matches", matches ? XT_TRUE : XT_FALSE);
-  set_method(list, "addListener", (void *)noop);
-  set_method(list, "removeListener", (void *)noop);
-  set_method(list, "addEventListener", (void *)noop);
-  set_method(list, "removeEventListener", (void *)noop);
-  set_method(list, "dispatchEvent", (void *)noop);
-  return list;
-}
-
 /* -- localStorage --------------------------------------------------------- */
 
 xt_value storage_get_item(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
@@ -338,7 +312,12 @@ xt_value host_type_construct(xt_value self, xt_value env, int32_t argc, xt_value
 /** The prototype a DOM type name should inherit, so `el instanceof Element`
  * holds for every element handle the engine hands out. */
 xt_value type_proto(const std::string &name) {
-  if (name == "Event" || name == "CustomEvent" || name == "ProgressEvent") {
+  if (name == "AbortController") return domapi::abort_controller_proto();
+  if (name == "AbortSignal") return domapi::abort_signal_proto();
+  if (name == "Event" || name == "CustomEvent" || name == "ProgressEvent" ||
+      name == "UIEvent" || name == "MouseEvent" || name == "PointerEvent" ||
+      name == "WheelEvent" || name == "KeyboardEvent" || name == "FocusEvent" ||
+      name == "InputEvent" || name == "SubmitEvent") {
     return domapi::event_proto();
   }
   if (name == "AudioContext" || name == "webkitAudioContext") return xt_gui_audio_proto();
@@ -357,6 +336,17 @@ xt_value type_proto(const std::string &name) {
   if (name == "WebGLQuery") return domapi::webgl_object_proto("query");
   if (name == "WebGLSync") return domapi::webgl_object_proto("sync");
   if (name == "WebGLTransformFeedback") return domapi::webgl_object_proto("transformfeedback");
+  if (name == "Path2D") return domapi::path2d_proto();
+  if (name == "ImageBitmap") {
+    /* A bitmap is a plain immutable object, not a DOM node: a node proto would
+     * expose the element width/height accessors and answer 0. */
+    static xt_value bitmap_proto = XT_UNDEFINED;
+    if (!XT_IS_OBJECT(bitmap_proto)) {
+      bitmap_proto = xt_object_new();
+      xt_gc_add_root(&bitmap_proto);
+    }
+    return bitmap_proto;
+  }
   return domapi::node_proto();
 }
 
@@ -384,9 +374,15 @@ xt_value host_type_construct(xt_value self, xt_value env, int32_t argc, xt_value
   if (name == "AudioContext" || name == "webkitAudioContext") {
     return xt_gui_audio_create(argc, argv);
   }
-  if (name == "Event" || name == "CustomEvent" || name == "ProgressEvent") {
+  if (name == "AbortController") return domapi::abort_controller_new();
+  if (name == "AbortSignal") return domapi::abort_signal_new(false);
+  if (name == "Event" || name == "CustomEvent" || name == "ProgressEvent" ||
+      name == "UIEvent" || name == "MouseEvent" || name == "PointerEvent" ||
+      name == "WheelEvent" || name == "KeyboardEvent" || name == "FocusEvent" ||
+      name == "InputEvent" || name == "SubmitEvent") {
     return domapi::event_construct(xt_arg(argc, argv, 0), xt_arg(argc, argv, 1));
   }
+  if (name == "Path2D") return domapi::path2d_create(xt_arg(argc, argv, 0));
   xt_value target = xt_object_new_with_proto(type_proto(name));
   set_prop(target, "constructor", type_value(name));
   return target;
@@ -428,10 +424,6 @@ void ensure_singletons(void) {
     g_location = location_build();
     xt_gc_add_root(&g_location);
   }
-  if (!XT_IS_OBJECT(g_media_list)) {
-    g_media_list = media_list_build("", false);
-    xt_gc_add_root(&g_media_list);
-  }
 }
 
 }  // namespace
@@ -464,9 +456,8 @@ void xt_browser_install_window(xt_value proto) {
   set_method(proto, "confirm", (void *)win_confirm);
   set_method(proto, "prompt", (void *)win_prompt);
   set_method(proto, "escape", (void *)xt_browser_escape);
-  set_method(proto, "focus", (void *)noop);
-  set_method(proto, "blur", (void *)noop);
-  set_method(proto, "scrollTo", (void *)noop);
+  /* Page scroll and window focus/blur live in `browser_navigation.cpp`. */
+  xt_browser_install_window_navigation(proto);
 }
 
 /** `window` / `self`. */
@@ -528,7 +519,7 @@ xt_value xt_browser_type(int32_t argc, xt_value *argv) {
   if (argc < 1) return XT_UNDEFINED;
   std::string name = cstr(xt_arg(argc, argv, 0));
   if (name == "XRWebGLLayer" || name == "XRWebGLBinding" || name == "OffscreenCanvas" ||
-      name == "ImageBitmap" || name == "ImageData" || name == "Response" ||
+      name == "ImageData" || name == "Response" ||
       name == "ReadableStream" || name == "Request" || name == "Headers" ||
       name == "DOMParser") {
     return XT_UNDEFINED;
@@ -571,3 +562,7 @@ xt_value xt_browser_alert(int32_t argc, xt_value *argv) {
 xt_value xt_browser_prompt(int32_t argc, xt_value *argv) {
   return win_prompt(XT_UNDEFINED, XT_UNDEFINED, argc, argv);
 }
+
+xt_value xt_browser_confirm_global(int32_t argc, xt_value *argv) {
+  return win_confirm(XT_UNDEFINED, XT_UNDEFINED, argc, argv);
+}