xbintsc 0.5.32 → 0.5.37

package/runtime/ext_media/decode_audio.cpp

@@ -0,0 +1,308 @@
+/*
+ * xbintsc media extension — in-memory audio decoding.
+ *
+ * `AudioContext.decodeAudioData` hands over bytes, not a path, so the file
+ * oriented `MediaPlayer` cannot be reused. This unit opens the bytes through a
+ * custom `AVIOContext`, decodes the best audio stream to interleaved float PCM
+ * at the stream's own sample rate, and leaves resampling to the mixer (which
+ * already resamples an AudioBuffer whose rate differs from 48 kHz).
+ *
+ * The ABI is C (`media_api.h`): `gui.a` stays FFmpeg-free and reaches this
+ * object through the table the media bridge installs. Both archives are built
+ * against the same static CRT, so the caller may `free()` the buffer through
+ * `xt_media_backend_free_audio`.
+ */
+
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <vector>
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/channel_layout.h>
+#include <libswresample/swresample.h>
+}
+
+#include "../ext_gui/media_api.h"
+
+namespace {
+
+struct MemoryReader {
+  const unsigned char *data;
+  size_t size;
+  size_t position;
+};
+
+int read_packet(void *opaque, uint8_t *buffer, int size) {
+  auto *reader = static_cast<MemoryReader *>(opaque);
+  if (reader->position >= reader->size) return AVERROR_EOF;
+  size_t available = reader->size - reader->position;
+  int take = size < static_cast<int>(available) ? size : static_cast<int>(available);
+  if (take <= 0) return AVERROR_EOF;
+  std::memcpy(buffer, reader->data + reader->position, static_cast<size_t>(take));
+  reader->position += static_cast<size_t>(take);
+  return take;
+}
+
+int64_t seek_stream(void *opaque, int64_t offset, int whence) {
+  auto *reader = static_cast<MemoryReader *>(opaque);
+  if (whence == AVSEEK_SIZE) return static_cast<int64_t>(reader->size);
+  int64_t base;
+  if (whence == SEEK_SET) {
+    base = 0;
+  } else if (whence == SEEK_CUR) {
+    base = static_cast<int64_t>(reader->position);
+  } else if (whence == SEEK_END) {
+    base = static_cast<int64_t>(reader->size);
+  } else {
+    return AVERROR(EINVAL);
+  }
+  int64_t target = base + offset;
+  if (target < 0 || target > static_cast<int64_t>(reader->size)) return AVERROR(EINVAL);
+  reader->position = static_cast<size_t>(target);
+  return target;
+}
+
+void set_error(char *error, size_t size, const char *message) {
+  if (error != nullptr && size > 0) std::snprintf(error, size, "%s", message);
+}
+
+void set_ffmpeg_error(char *error, size_t size, const char *prefix, int code) {
+  char detail[AV_ERROR_MAX_STRING_SIZE] = {0};
+  av_strerror(code, detail, sizeof(detail));
+  if (error != nullptr && size > 0) {
+    std::snprintf(error, size, "%s: %s", prefix, detail);
+  }
+}
+
+/** The decoder pipeline for one in-memory file. Destructor releases everything,
+ * which keeps the early-return paths in `decode` readable. */
+struct Decoder {
+  MemoryReader reader{nullptr, 0, 0};
+  AVIOContext *io = nullptr;
+  AVFormatContext *format = nullptr;
+  AVCodecContext *codec = nullptr;
+  AVPacket *packet = nullptr;
+  AVFrame *frame = nullptr;
+  SwrContext *resampler = nullptr;
+  AVChannelLayout out_layout{};
+  int out_channels = 0;
+  int sample_rate = 0;
+  int stream_index = -1;
+  std::vector<float> samples;
+  bool failed = false;
+};
+
+void close_decoder(Decoder *decoder) {
+  swr_free(&decoder->resampler);
+  av_channel_layout_uninit(&decoder->out_layout);
+  if (decoder->frame != nullptr) av_frame_free(&decoder->frame);
+  if (decoder->packet != nullptr) av_packet_free(&decoder->packet);
+  if (decoder->codec != nullptr) avcodec_free_context(&decoder->codec);
+  if (decoder->format != nullptr) avformat_close_input(&decoder->format);
+  if (decoder->io != nullptr) {
+    av_freep(&decoder->io->buffer);
+    avio_context_free(&decoder->io);
+  }
+}
+
+/** Lazily configure the resampler from the first decoded frame: some files only
+ * reveal their channel layout once decoding starts. */
+bool prepare_resampler(Decoder *decoder, const AVFrame *frame, char *error, size_t error_size) {
+  if (decoder->resampler != nullptr) return true;
+  AVChannelLayout in_layout = frame->ch_layout;
+  if (in_layout.nb_channels <= 0) in_layout = decoder->codec->ch_layout;
+  int channels = in_layout.nb_channels > 0 ? in_layout.nb_channels : 1;
+  int rate = frame->sample_rate > 0 ? frame->sample_rate : decoder->codec->sample_rate;
+  if (rate <= 0) {
+    set_error(error, error_size, "audio stream has no usable sample rate");
+    return false;
+  }
+  decoder->out_channels = channels > 2 ? 2 : channels;
+  decoder->sample_rate = rate;
+  av_channel_layout_default(&decoder->out_layout, decoder->out_channels);
+  int result = swr_alloc_set_opts2(&decoder->resampler, &decoder->out_layout, AV_SAMPLE_FMT_FLT,
+                                   decoder->sample_rate, &in_layout,
+                                   static_cast<AVSampleFormat>(frame->format), rate, 0, nullptr);
+  if (result < 0 || decoder->resampler == nullptr ||
+      swr_init(decoder->resampler) < 0) {
+    set_error(error, error_size, "cannot set up audio resampling");
+    return false;
+  }
+  return true;
+}
+
+/** Convert one decoded frame and append it to `decoder->samples`. */
+bool append_frame(Decoder *decoder, const AVFrame *frame, char *error, size_t error_size) {
+  if (!prepare_resampler(decoder, frame, error, error_size)) return false;
+  int64_t delay = swr_get_delay(decoder->resampler, frame->sample_rate);
+  int capacity = static_cast<int>(av_rescale_rnd(delay + frame->nb_samples, decoder->sample_rate,
+                                                 frame->sample_rate, AV_ROUND_UP));
+  if (capacity <= 0) return true;
+  std::vector<float> converted(static_cast<size_t>(capacity) * decoder->out_channels);
+  uint8_t *out_data[1] = {reinterpret_cast<uint8_t *>(converted.data())};
+  int got = swr_convert(decoder->resampler, out_data, capacity,
+                        const_cast<const uint8_t **>(frame->extended_data), frame->nb_samples);
+  if (got < 0) {
+    set_ffmpeg_error(error, error_size, "cannot resample audio", got);
+    return false;
+  }
+  size_t count = static_cast<size_t>(got) * decoder->out_channels;
+  decoder->samples.insert(decoder->samples.end(), converted.begin(),
+                          converted.begin() + static_cast<std::ptrdiff_t>(count));
+  return true;
+}
+
+/** Drain the decoder after the last packet. */
+bool flush_decoder(Decoder *decoder, char *error, size_t error_size) {
+  int result = avcodec_send_packet(decoder->codec, nullptr);
+  if (result < 0 && result != AVERROR_EOF) {
+    set_ffmpeg_error(error, error_size, "cannot flush audio decoder", result);
+    return false;
+  }
+  while (true) {
+    result = avcodec_receive_frame(decoder->codec, decoder->frame);
+    if (result == AVERROR(EAGAIN) || result == AVERROR_EOF) return true;
+    if (result < 0) {
+      set_ffmpeg_error(error, error_size, "cannot read audio frame", result);
+      return false;
+    }
+    if (!append_frame(decoder, decoder->frame, error, error_size)) return false;
+    av_frame_unref(decoder->frame);
+  }
+}
+
+bool decode_packets(Decoder *decoder, char *error, size_t error_size) {
+  while (true) {
+    int result = av_read_frame(decoder->format, decoder->packet);
+    if (result == AVERROR_EOF) break;
+    if (result < 0) {
+      set_ffmpeg_error(error, error_size, "cannot read audio packet", result);
+      return false;
+    }
+    if (decoder->packet->stream_index != decoder->stream_index) {
+      av_packet_unref(decoder->packet);
+      continue;
+    }
+    int sent = avcodec_send_packet(decoder->codec, decoder->packet);
+    av_packet_unref(decoder->packet);
+    if (sent < 0 && sent != AVERROR(EAGAIN)) {
+      set_ffmpeg_error(error, error_size, "cannot decode audio packet", sent);
+      return false;
+    }
+    while (true) {
+      result = avcodec_receive_frame(decoder->codec, decoder->frame);
+      if (result == AVERROR(EAGAIN) || result == AVERROR_EOF) break;
+      if (result < 0) {
+        set_ffmpeg_error(error, error_size, "cannot decode audio frame", result);
+        return false;
+      }
+      if (!append_frame(decoder, decoder->frame, error, error_size)) return false;
+      av_frame_unref(decoder->frame);
+    }
+  }
+  return flush_decoder(decoder, error, error_size);
+}
+
+bool open_decoder(Decoder *decoder, int *stream_index, char *error, size_t error_size) {
+  decoder->io = avio_alloc_context(
+      static_cast<unsigned char *>(av_malloc(32768)), 32768, 0, &decoder->reader, read_packet,
+      nullptr, seek_stream);
+  if (decoder->io == nullptr) {
+    set_error(error, error_size, "cannot allocate the audio reader");
+    return false;
+  }
+  decoder->format = avformat_alloc_context();
+  if (decoder->format == nullptr) {
+    set_error(error, error_size, "cannot allocate the audio container");
+    return false;
+  }
+  decoder->format->pb = decoder->io;
+  decoder->format->flags |= AVFMT_FLAG_CUSTOM_IO;
+  int result = avformat_open_input(&decoder->format, nullptr, nullptr, nullptr);
+  if (result < 0) {
+    set_ffmpeg_error(error, error_size, "cannot open audio data", result);
+    return false;
+  }
+  result = avformat_find_stream_info(decoder->format, nullptr);
+  if (result < 0) {
+    set_ffmpeg_error(error, error_size, "cannot read audio metadata", result);
+    return false;
+  }
+  *stream_index = av_find_best_stream(decoder->format, AVMEDIA_TYPE_AUDIO, -1, -1, nullptr, 0);
+  if (*stream_index < 0) {
+    set_error(error, error_size, "audio data has no audio stream");
+    return false;
+  }
+  decoder->stream_index = *stream_index;
+  AVCodecParameters *parameters = decoder->format->streams[*stream_index]->codecpar;
+  const AVCodec *codec = avcodec_find_decoder(parameters->codec_id);
+  if (codec == nullptr) {
+    set_error(error, error_size, "no decoder for this audio codec");
+    return false;
+  }
+  decoder->codec = avcodec_alloc_context3(codec);
+  if (decoder->codec == nullptr) {
+    set_error(error, error_size, "cannot allocate the audio decoder");
+    return false;
+  }
+  result = avcodec_parameters_to_context(decoder->codec, parameters);
+  if (result < 0) {
+    set_ffmpeg_error(error, error_size, "cannot configure the audio decoder", result);
+    return false;
+  }
+  result = avcodec_open2(decoder->codec, codec, nullptr);
+  if (result < 0) {
+    set_ffmpeg_error(error, error_size, "cannot start the audio decoder", result);
+    return false;
+  }
+  decoder->packet = av_packet_alloc();
+  decoder->frame = av_frame_alloc();
+  if (decoder->packet == nullptr || decoder->frame == nullptr) {
+    set_error(error, error_size, "cannot allocate decoder buffers");
+    return false;
+  }
+  return true;
+}
+
+}  // namespace
+
+extern "C" int xt_media_backend_decode_audio(const unsigned char *data, size_t size,
+                                             XtMediaAudioBuffer *out, char *error,
+                                             size_t error_size) {
+  if (data == nullptr || size == 0 || out == nullptr) {
+    set_error(error, error_size, "empty audio data");
+    return 0;
+  }
+  std::memset(out, 0, sizeof(*out));
+  Decoder decoder;
+  decoder.reader = {data, size, 0};
+  int stream_index = -1;
+  bool ok = open_decoder(&decoder, &stream_index, error, error_size) &&
+            decode_packets(&decoder, error, error_size);
+  if (!ok || decoder.out_channels <= 0 || decoder.samples.empty()) {
+    if (ok) set_error(error, error_size, "audio data has no samples");
+    close_decoder(&decoder);
+    return 0;
+  }
+  int frames = static_cast<int>(decoder.samples.size() / decoder.out_channels);
+  size_t bytes = decoder.samples.size() * sizeof(float);
+  auto *samples = static_cast<float *>(std::malloc(bytes));
+  if (samples == nullptr) {
+    set_error(error, error_size, "cannot allocate the decoded audio buffer");
+    close_decoder(&decoder);
+    return 0;
+  }
+  std::memcpy(samples, decoder.samples.data(), bytes);
+  out->channels = decoder.out_channels;
+  out->sample_rate = decoder.sample_rate;
+  out->frames = frames;
+  out->samples = samples;
+  close_decoder(&decoder);
+  return 1;
+}
+
+extern "C" void xt_media_backend_free_audio(void *samples) { std::free(samples); }

package/runtime/ext_media/media_bridge.c

@@ -22,6 +22,8 @@ static const XtMediaApi kMediaApi = {
     xt_media_backend_open,
     xt_media_backend_by_id,
     xt_media_backend_shutdown,
+    xt_media_backend_decode_audio,
+    xt_media_backend_free_audio,
 };
 
 #if defined(__GNUC__) || defined(__clang__)

package/runtime/rt.h

@@ -185,6 +185,32 @@ xt_value xt_not(xt_value a);
 /* -- objects -------------------------------------------------------------- */
 xt_value xt_object_new(void);
 xt_value xt_object_new_with_proto(xt_value proto);
+
+/*
+ * Optional dynamic-property hooks.
+ *
+ * A host object that represents a *view* over external state — the GUI engine's
+ * `element.style`, `element.dataset` and `getComputedStyle()` — cannot know its
+ * property names when the prototype is built. Such an object installs these
+ * hooks; they are consulted only when ordinary property lookup/assignment finds
+ * nothing, so real properties and accessors keep precedence.
+ *
+ * `get` returns `XT_UNDEFINED` when it does not handle the key. `set`, `has`
+ * and `remove` return non-zero when they handled the operation; `keys` returns
+ * an array of the dynamically visible string keys (or `XT_UNDEFINED`).
+ * `data` is the host pointer handed to `xt_object_set_hooks`. Hooks must not
+ * store `xt_value`s outside a runtime object the collector can reach.
+ */
+typedef struct xt_object_hooks {
+  xt_value (*get)(xt_value self, xt_value key, void *data);
+  int (*set)(xt_value self, xt_value key, xt_value value, void *data);
+  int (*has)(xt_value self, xt_value key, void *data);
+  int (*remove)(xt_value self, xt_value key, void *data);
+  xt_value (*keys)(xt_value self, void *data);
+} xt_object_hooks;
+
+/** Install (or clear, with NULL) the dynamic-property hooks of `obj`. */
+xt_value xt_object_set_hooks(xt_value obj, const xt_object_hooks *hooks, void *data);
 /** The shared `Object.prototype` object (root of the ordinary object chain). */
 xt_value xt_object_prototype(void);
 /** The shared `Function.prototype` object. */
@@ -250,6 +276,23 @@ xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv);
 xt_value xt_typed_array_ctor_by_name(xt_value name, int32_t argc, xt_value *argv);
 xt_value xt_typed_array_static_by_name(xt_value name, xt_value method, int32_t argc, xt_value *argv);
 xt_value xt_typed_array_prototype(xt_value name);
+/** Bulk access to the bytes an `ArrayBuffer` (or a typed array's backing
+ * store) holds, for decoders and encoders that cannot afford one property read
+ * per byte. `offset` and `count` are clamped to the buffer and the number of
+ * bytes actually transferred is returned. Extensions pass the backing buffer
+ * plus a view's `byteOffset`/`byteLength`; see `runtime/ext_gui/audio.cpp`. */
+uint32_t xt_array_buffer_copy_bytes_out(xt_value buffer, uint32_t offset, uint8_t *dst,
+                                        uint32_t count);
+uint32_t xt_array_buffer_copy_bytes_in(xt_value buffer, uint32_t offset, const uint8_t *src,
+                                       uint32_t count);
+/** Allocate a zero-filled `ArrayBuffer` of `byte_length` bytes (the native
+ * counterpart of `new ArrayBuffer(n)`). */
+xt_value xt_array_buffer_alloc(uint32_t byte_length);
+/** Typed-array view internals for extensions: whether `value` is a view, the
+ * `ArrayBuffer` it views, and the byte offset of the view inside it. */
+int xt_is_typed_array(xt_value value);
+xt_value xt_typed_array_backing_buffer(xt_value value);
+uint32_t xt_typed_array_view_offset(xt_value value);
 /** Error-family construction and prototype lookup by constructor name. */
 xt_value xt_error_ctor_by_name(xt_value name, int32_t argc, xt_value *argv);
 xt_value xt_error_prototype(xt_value name);

package/runtime/rt_internal.h

@@ -141,6 +141,10 @@ typedef struct {
    * Deliberately not a property: `Object.keys`, `for...in` and JSON.stringify
    * must not see it, while `error.stack` returns it through `xt_get`. */
   xt_value error_stack;
+  /* Optional dynamic-property view (host objects such as `element.style`); see
+   * `xt_object_hooks` in `rt.h`. NULL for ordinary objects. */
+  const xt_object_hooks *hooks;
+  void *hook_data;
 } xt_object;
 
 typedef struct {

package/runtime/xt_array_buffer.c

@@ -60,6 +60,8 @@ xt_value xt_array_buffer_ctor(int32_t argc, xt_value *argv) {
   return buffer;
 }
 
+xt_value xt_array_buffer_alloc(uint32_t byte_length) { return xt_ab_new(byte_length); }
+
 int xt_is_array_buffer(xt_value value) { return xt_ab_is_buffer(value); }
 
 uint32_t xt_array_buffer_byte_length(xt_value value) {
@@ -79,6 +81,34 @@ void xt_array_buffer_set_byte(xt_value buffer, uint32_t index, uint8_t value) {
   xt_set(data, xt_number((double)index), xt_number((double)value));
 }
 
+/* Bulk byte access. A decoder (WAV, image, …) would otherwise pay one hidden
+ * property read per byte, which is far too slow for a multi-megabyte file. The
+ * backing store is an `xt_array` of numbers; reading its `items` directly is
+ * the same representation `xt_ab_new` writes. */
+uint32_t xt_array_buffer_copy_bytes_out(xt_value buffer, uint32_t offset, uint8_t *dst,
+                                        uint32_t count) {
+  xt_array *data = xt_as_array(xt_ab_data(buffer));
+  if (data == NULL || dst == NULL) return 0;
+  if (offset >= data->length) return 0;
+  if (count > data->length - offset) count = data->length - offset;
+  for (uint32_t i = 0; i < count; i++) {
+    dst[i] = (uint8_t)(int32_t)xt_to_number(data->items[offset + i]);
+  }
+  return count;
+}
+
+uint32_t xt_array_buffer_copy_bytes_in(xt_value buffer, uint32_t offset, const uint8_t *src,
+                                       uint32_t count) {
+  xt_array *data = xt_as_array(xt_ab_data(buffer));
+  if (data == NULL || src == NULL) return 0;
+  if (offset >= data->length) return 0;
+  if (count > data->length - offset) count = data->length - offset;
+  for (uint32_t i = 0; i < count; i++) {
+    data->items[offset + i] = xt_number((double)src[i]);
+  }
+  return count;
+}
+
 static xt_value xt_ab_slice(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
   xt_value data = xt_ab_data(thisValue);

package/runtime/xt_builtins.c

@@ -406,27 +406,6 @@ xt_value xt_in(xt_value key, xt_value value) {
   return XT_FALSE;
 }
 
-xt_value xt_delete(xt_value value, xt_value key) {
-  if (XT_IS_OBJECT(value)) {
-    xt_object *obj = (xt_object *)XT_GET_PTR(value);
-    xt_value k = xt_to_property_key(key);
-    for (uint32_t i = 0; i < obj->count; i++) {
-      if (xt_property_key_equals(obj->properties[i].key, k)) {
-        for (uint32_t j = i + 1; j < obj->count; j++) obj->properties[j - 1] = obj->properties[j];
-        obj->count--;
-        xt_object_shape_changed(obj);
-        break;
-      }
-    }
-    return XT_TRUE;
-  }
-  if (XT_IS_ARRAY(value)) {
-    if (!xt_is_symbol(key)) xt_array_set(value, key, XT_UNDEFINED);
-    return XT_TRUE;
-  }
-  return XT_TRUE;
-}
-
 xt_value xt_rest_args(int32_t argc, xt_value *argv, int32_t start) {
   if (start < 0) start = 0;
   int32_t count = argc - start;

package/runtime/xt_containers/access.inc

@@ -105,8 +105,7 @@ static xt_value xt_array_iterator_method(void) {
   return xt_array_iterator_method_value;
 }
 
-xt_value xt_get(xt_value target, xt_value key) {
-  if (target == XT_UNDEFINED || target == XT_NULL) xt_throw_read_of_nullish(target, key);
+xt_value xt_get(xt_value target, xt_value key) {  if (target == XT_UNDEFINED || target == XT_NULL) xt_throw_read_of_nullish(target, key);
   if (XT_IS_ARRAY(target)) {
     /* `arr.length` must read the array's length, never an element. */
     if (XT_IS_STRING(key)) {
@@ -289,6 +288,8 @@ xt_value xt_get_ic(xt_value target, xt_value key, int64_t *cache) {
   if (obj->header.kind != XT_OBJECT_KIND_OBJECT && obj->header.kind != XT_OBJECT_KIND_ERROR) {
     return xt_get(target, key);
   }
+  /* A host view answers keys dynamically, outside the shape cache. */
+  if (obj->hooks != NULL) return xt_get(target, key);
   if (!XT_IS_STRING(key) && !xt_is_symbol(key)) return xt_get(target, key);
   xt_shape *shape = obj->shape;
   uintptr_t cachedShape = (uintptr_t)cache[0];
@@ -387,3 +388,94 @@ xt_value xt_set(xt_value target, xt_value key, xt_value value) {
   }
   return value;
 }
+
+/* ------------------------------------------------------------------------- */
+/* Dynamic host-view properties                                               */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_object_set_hooks(xt_value value, const xt_object_hooks *hooks, void *data) {
+  xt_object *obj = xt_as_object(value);
+  if (!obj) return value;
+  if (obj->header.kind != XT_OBJECT_KIND_OBJECT && obj->header.kind != XT_OBJECT_KIND_ERROR) {
+    return value;
+  }
+  obj->hooks = hooks;
+  obj->hook_data = data;
+  return value;
+}
+
+void xt_object_append_dynamic_keys(xt_object *obj, xt_value value, xt_value result) {
+  if (obj->hooks == NULL || obj->hooks->keys == NULL) return;
+  xt_value dynamic = obj->hooks->keys(value, obj->hook_data);
+  xt_array *list = xt_as_array(dynamic);
+  if (list == NULL) return;
+  for (uint32_t i = 0; i < list->length; i++) {
+    xt_value key = list->items[i];
+    if (!XT_IS_STRING(key)) continue;
+    if (xt_object_find(obj, key) != NULL) continue;
+    xt_array_push(result, key);
+  }
+}
+/* `delete obj[key]`: remove a real property (arrays clear the element) and let
+ * a host view delete its dynamic key. */
+xt_value xt_delete(xt_value value, xt_value key) {
+  if (XT_IS_OBJECT(value)) {
+    xt_object *obj = (xt_object *)XT_GET_PTR(value);
+    xt_value k = xt_to_property_key(key);
+    for (uint32_t i = 0; i < obj->count; i++) {
+      if (xt_property_key_equals(obj->properties[i].key, k)) {
+        for (uint32_t j = i + 1; j < obj->count; j++) obj->properties[j - 1] = obj->properties[j];
+        obj->count--;
+        xt_object_shape_changed(obj);
+        break;
+      }
+    }
+    /* A host view (`element.style`, `element.dataset`) owns no real property for
+     * its keys, so `delete` must reach it even when the bag stayed empty. */
+    if (obj->hooks != NULL && obj->hooks->remove != NULL) {
+      obj->hooks->remove(value, k, obj->hook_data);
+    }
+    return XT_TRUE;
+  }
+  if (XT_IS_ARRAY(value)) {
+    if (!xt_is_symbol(key)) xt_array_set(value, key, XT_UNDEFINED);
+    return XT_TRUE;
+  }
+  return XT_TRUE;
+}
+xt_value xt_object_has_own(xt_value value, xt_value key) {
+  if (XT_IS_ARRAY(value)) {
+    xt_array *array = (xt_array *)XT_GET_PTR(value);
+    xt_value propertyKey = xt_to_property_key(key);
+    if (XT_IS_STRING(propertyKey)) {
+      xt_string *k = xt_as_string(propertyKey);
+      if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return XT_TRUE;
+      uint32_t index = 0;
+      if (xt_key_is_array_index(k, &index)) return xt_bool(index < array->length);
+    }
+    return xt_bool(XT_IS_OBJECT(array->extra) &&
+                   xt_object_find((xt_object *)XT_GET_PTR(array->extra), propertyKey));
+  }
+  if (XT_IS_STRING(value)) {
+    xt_string *string = xt_as_string(value);
+    if (xt_is_symbol(key)) return XT_FALSE;
+    xt_string *k = xt_as_string(xt_to_string(key));
+    if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return XT_TRUE;
+    uint32_t index = 0;
+    return xt_bool(xt_key_is_array_index(k, &index) && index < xt_string_utf16_length(string));
+  }
+  xt_object *obj = xt_as_object(value);
+  if (!obj) return XT_FALSE;
+  /* Map/Set/Date/RegExp/Promise/Symbol use their own struct layout and have no
+   * property bag; interpreting them as `xt_object` would read past the end. */
+  if (obj->header.kind != XT_OBJECT_KIND_OBJECT && obj->header.kind != XT_OBJECT_KIND_ERROR) {
+    return XT_FALSE;
+  }
+  xt_value propertyKey = xt_to_property_key(key);
+  if (xt_object_find(obj, propertyKey) != NULL) return XT_TRUE;
+  if (obj->hooks != NULL && obj->hooks->has != NULL &&
+      obj->hooks->has(value, propertyKey, obj->hook_data)) {
+    return XT_TRUE;
+  }
+  return XT_FALSE;
+}

package/runtime/xt_containers/objects.inc

@@ -170,6 +170,9 @@ xt_value xt_object_new_with_proto(xt_value proto) {
   obj->prototype = proto;
   obj->frozen = 0;
   obj->is_array_base = 0;
+  obj->error_stack = XT_UNDEFINED;
+  obj->hooks = NULL;
+  obj->hook_data = NULL;
   return XT_FROM_PTR(XT_TAG_OBJECT, obj);
 }
 
@@ -191,6 +194,10 @@ static xt_property *xt_object_find(xt_object *obj, xt_value key) {
   return NULL;
 }
 
+/* Defined in `access.inc`: append the dynamic keys of a host view whose
+ * `xt_object_hooks::keys` returns them. */
+static void xt_object_append_dynamic_keys(xt_object *obj, xt_value value, xt_value result);
+
 /*
  * JavaScript enumerates own string keys in a canonical order: array-index
  * keys (the canonical decimal form of an integer in [0, 2^32 - 2]) first, in
@@ -313,6 +320,13 @@ xt_value xt_object_get(xt_value value, xt_value key) {
     if (!XT_IS_OBJECT(cur->prototype)) break;
     cur = (xt_object *)XT_GET_PTR(cur->prototype);
   }
+  /* A host view (`element.style`, `element.dataset`, computed style) answers the
+   * keys it owns dynamically. Only a miss reaches this point, so prototype
+   * methods and real properties win. */
+  if (obj->hooks != NULL && obj->hooks->get != NULL) {
+    xt_value dynamic = obj->hooks->get(value, k, obj->hook_data);
+    if (!XT_IS_UNDEFINED(dynamic)) return dynamic;
+  }
   return XT_UNDEFINED;
 }
 
@@ -368,6 +382,11 @@ xt_value xt_object_set(xt_value value, xt_value key, xt_value newValue) {
     }
     ancestor = xt_object_prototype_of(ancestor->prototype, ancestor);
   }
+  /* A host view handles the assignment itself (e.g. `style.width = "50%"` or
+   * `dataset.foo = "1"`); it never stores a shadowing data property. */
+  if (obj->hooks != NULL && obj->hooks->set != NULL) {
+    if (obj->hooks->set(value, k, newValue, obj->hook_data)) return newValue;
+  }
   xt_property *inserted = xt_object_insert_property(obj, k);
   inserted->value = newValue;
   return newValue;
@@ -446,36 +465,6 @@ int xt_object_is_frozen(xt_value value) {
   return obj ? obj->frozen : 0;
 }
 
-xt_value xt_object_has_own(xt_value value, xt_value key) {
-  if (XT_IS_ARRAY(value)) {
-    xt_array *array = (xt_array *)XT_GET_PTR(value);
-    xt_value propertyKey = xt_to_property_key(key);
-    if (XT_IS_STRING(propertyKey)) {
-      xt_string *k = xt_as_string(propertyKey);
-      if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return XT_TRUE;
-      uint32_t index = 0;
-      if (xt_key_is_array_index(k, &index)) return xt_bool(index < array->length);
-    }
-    return xt_bool(XT_IS_OBJECT(array->extra) &&
-                   xt_object_find((xt_object *)XT_GET_PTR(array->extra), propertyKey));
-  }
-  if (XT_IS_STRING(value)) {
-    xt_string *string = xt_as_string(value);
-    if (xt_is_symbol(key)) return XT_FALSE;
-    xt_string *k = xt_as_string(xt_to_string(key));
-    if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return XT_TRUE;
-    uint32_t index = 0;
-    return xt_bool(xt_key_is_array_index(k, &index) && index < xt_string_utf16_length(string));
-  }
-  xt_object *obj = xt_as_object(value);
-  if (!obj) return XT_FALSE;
-  /* Map/Set/Date/RegExp/Promise/Symbol use their own struct layout and have no
-   * property bag; interpreting them as `xt_object` would read past the end. */
-  if (obj->header.kind != XT_OBJECT_KIND_OBJECT && obj->header.kind != XT_OBJECT_KIND_ERROR) {
-    return XT_FALSE;
-  }
-  return xt_bool(xt_object_find(obj, xt_to_property_key(key)) != NULL);
-}
 
 xt_value xt_object_from_entries(xt_value entries) {
   xt_value result = xt_object_new();
@@ -495,7 +484,13 @@ xt_value xt_object_has(xt_value value, xt_value key) {
   if (obj->header.kind != XT_OBJECT_KIND_OBJECT && obj->header.kind != XT_OBJECT_KIND_ERROR) {
     return XT_FALSE;
   }
-  return xt_bool(xt_object_find(obj, xt_to_property_key(key)) != NULL);
+  xt_value propertyKey = xt_to_property_key(key);
+  if (xt_object_find(obj, propertyKey) != NULL) return XT_TRUE;
+  if (obj->hooks != NULL && obj->hooks->has != NULL &&
+      obj->hooks->has(value, propertyKey, obj->hook_data)) {
+    return XT_TRUE;
+  }
+  return XT_FALSE;
 }
 
 /* `Object.getOwnPropertySymbols`: the symbol-keyed own properties, in
@@ -531,6 +526,9 @@ xt_value xt_object_keys(xt_value value) {
     for (uint32_t i = 0; i < obj->count; i++) {
       if (XT_IS_STRING(obj->properties[i].key)) xt_array_push(result, obj->properties[i].key);
     }
+    /* Dynamic keys of a host view (`element.dataset`, ...), appended without
+     * repeating a real property that was just pushed. */
+    xt_object_append_dynamic_keys(obj, value, result);
     return result;
   }
   if (XT_IS_ARRAY(value)) {