visaljs 0.0.0-stage → 0.0.2

package/runtime/src/domexception.c

@@ -0,0 +1,169 @@
+/* DOMException (WebIDL §3.14.1), the domexception component (ADR 0012, layer 2), as Node has it:
+ * new DOMException(message, name | { name, cause }), with name, message and code getters on the
+ * prototype, the legacy code constants, and Error.prototype as the prototype's prototype. An
+ * instance has an own `stack`, "Name: message", which is what V8 captures (no frames, as for
+ * every error here: plan/unsupported.md). */
+#include "js_web.h"
+
+#include <string.h>
+
+#include "builtins_util.h"
+#include "internal.h"
+#include "js_atoms.h"
+#include "js_convert.h"
+#include "js_exception.h"
+#include "jscontext.h"
+#include "jsstring.h"
+
+typedef struct DOMExceptionObject {
+    JSObject obj;
+    JSValue  name;     /* strings */
+    JSValue  message;
+} DOMExceptionObject;
+
+static void dom_exception_visit(JSCell *c, JSTracer *trc) {
+    js_trace_value(trc, ((DOMExceptionObject *)c)->name);
+    js_trace_value(trc, ((DOMExceptionObject *)c)->message);
+}
+
+static const JSClass dom_exception_class = { "DOMException", sizeof(DOMExceptionObject), NULL, NULL, NULL, NULL, dom_exception_visit, NULL, NULL };
+
+/* The names with a legacy code (WebIDL's error names table). */
+static const struct { const char *name; uint8_t code; } CODES[] = {
+    { "IndexSizeError", 1 }, { "HierarchyRequestError", 3 }, { "WrongDocumentError", 4 },
+    { "InvalidCharacterError", 5 }, { "NoModificationAllowedError", 7 }, { "NotFoundError", 8 },
+    { "NotSupportedError", 9 }, { "InUseAttributeError", 10 }, { "InvalidStateError", 11 },
+    { "SyntaxError", 12 }, { "InvalidModificationError", 13 }, { "NamespaceError", 14 },
+    { "InvalidAccessError", 15 }, { "TypeMismatchError", 17 }, { "SecurityError", 18 },
+    { "NetworkError", 19 }, { "AbortError", 20 }, { "URLMismatchError", 21 },
+    { "QuotaExceededError", 22 }, { "TimeoutError", 23 }, { "InvalidNodeTypeError", 24 },
+    { "DataCloneError", 25 },
+};
+
+static DOMExceptionObject *as_dom_exception(JSValue v) {
+    return js_is_object(v) && js_as_object(v)->shape->cls == &dom_exception_class ? (DOMExceptionObject *)js_as_object(v) : NULL;
+}
+
+/* A new DOMException with Error.prototype.toString's "name: message" as its own `stack`. */
+static JSValue create(JSContext *ctx, JSValue proto, JSValue name, JSValue message) {
+    DOMExceptionObject *e = (DOMExceptionObject *)js_alloc_object(ctx, JS_CELL_OBJECT, js_shape_root(ctx, &dom_exception_class, proto, 1));
+    js_init_slot(&e->name, name);
+    js_init_slot(&e->message, message);
+    JSValue v = js_object_value(&e->obj);
+    JSValue stack = js_string_length(name) == 0 ? message
+                  : js_string_length(message) == 0 ? name
+                  : js_concat(ctx, js_concat(ctx, name, js_new_string_cstr(ctx, ": ")), message);
+    if (js_is_exception(stack)) return stack;
+    js_define_data(ctx, &e->obj, JS_ATOM(stack), stack, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    return v;
+}
+
+JSValue js_new_dom_exception(JSContext *ctx, const char *name, const char *message) {
+    JSValue n = js_new_string_cstr(ctx, name);
+    JSValue m = js_new_string_cstr(ctx, message);
+    if (js_is_exception(n) || js_is_exception(m)) return JS_EXCEPTION;
+    return create(ctx, ctx->intrinsics[JS_INTRINSIC_DOM_EXCEPTION_PROTOTYPE], n, m);
+}
+
+JSValue js_throw_dom_exception(JSContext *ctx, const char *name, const char *message) {
+    JSValue e = js_new_dom_exception(ctx, name, message);
+    return js_is_exception(e) ? e : js_throw(ctx, e);
+}
+
+/* new DOMException(message = "", options = "Error") */
+BUILTIN(dom_exception_ctor) {
+    (void)callee, (void)this_val;
+    if (js_is_undefined(new_target)) return js_throw_class_without_new(ctx, "DOMException");
+    JSValue message = js_is_undefined(ARG(0)) ? js_empty_string() : js_to_string(ctx, ARG(0));
+    if (js_is_exception(message)) return message;
+    JSValue name = js_new_string_cstr(ctx, "Error");
+    JSValue options = ARG(1);
+    bool has_cause = false;
+    JSValue cause = JS_UNDEFINED;
+    if (js_is_object(options)) {
+        JSValue n = js_get_value(ctx, options, JS_ATOM(name));
+        if (js_is_exception(n)) return n;
+        if (!js_is_undefined(n) && js_is_exception(name = js_to_string(ctx, n))) return JS_EXCEPTION;
+        int has = js_has_property(ctx, js_as_object(options), JS_ATOM(cause));
+        if (has < 0) return JS_EXCEPTION;
+        if (has) {
+            has_cause = true;
+            cause = js_get_value(ctx, options, JS_ATOM(cause));
+            if (js_is_exception(cause)) return cause;
+        }
+    } else if (!js_is_undefined(options) && js_is_exception(name = js_to_string(ctx, options))) {
+        return JS_EXCEPTION;
+    }
+    JSValue proto = js_get_prototype_from_constructor(ctx, new_target, JS_INTRINSIC_DOM_EXCEPTION_PROTOTYPE);
+    if (js_is_exception(proto)) return proto;
+    JSValue e = create(ctx, proto, name, message);
+    if (!js_is_exception(e) && has_cause) js_define_data(ctx, js_as_object(e), JS_ATOM(cause), cause, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    return e;
+}
+
+#define THIS_DOM_EXCEPTION()                                                                   \
+    DOMExceptionObject *e = as_dom_exception(this_val);                                        \
+    if (!e) return js_throw_node_error(ctx, JS_TYPE_ERROR, "ERR_INVALID_THIS", "Value of \"this\" must be of DOMException")
+
+BUILTIN(dom_exception_name) {
+    UNUSED_ARGS;
+    THIS_DOM_EXCEPTION();
+    return e->name;
+}
+
+BUILTIN(dom_exception_message) {
+    UNUSED_ARGS;
+    THIS_DOM_EXCEPTION();
+    return e->message;
+}
+
+BUILTIN(dom_exception_code) {
+    UNUSED_ARGS;
+    THIS_DOM_EXCEPTION();
+    for (size_t i = 0; i < JS_COUNTOF(CODES); i++) {
+        JSStrView v = js_string_view(ctx, e->name);
+        size_t n = strlen(CODES[i].name);
+        if (v.length != n) continue;
+        size_t k = 0;
+        while (k < n && js_view_at(v, (uint32_t)k) == (uint8_t)CODES[i].name[k]) k++;
+        if (k == n) return js_int32(CODES[i].code);
+    }
+    return js_int32(0);
+}
+
+#define CONSTANT(name, value) JS_BUILTIN_NUMBER(name, value, JS_PROP_ENUMERABLE)
+
+#define CONSTANTS                                                                              \
+    CONSTANT("INDEX_SIZE_ERR", 1), CONSTANT("DOMSTRING_SIZE_ERR", 2), CONSTANT("HIERARCHY_REQUEST_ERR", 3), \
+    CONSTANT("WRONG_DOCUMENT_ERR", 4), CONSTANT("INVALID_CHARACTER_ERR", 5), CONSTANT("NO_DATA_ALLOWED_ERR", 6), \
+    CONSTANT("NO_MODIFICATION_ALLOWED_ERR", 7), CONSTANT("NOT_FOUND_ERR", 8), CONSTANT("NOT_SUPPORTED_ERR", 9), \
+    CONSTANT("INUSE_ATTRIBUTE_ERR", 10), CONSTANT("INVALID_STATE_ERR", 11), CONSTANT("SYNTAX_ERR", 12), \
+    CONSTANT("INVALID_MODIFICATION_ERR", 13), CONSTANT("NAMESPACE_ERR", 14), CONSTANT("INVALID_ACCESS_ERR", 15), \
+    CONSTANT("VALIDATION_ERR", 16), CONSTANT("TYPE_MISMATCH_ERR", 17), CONSTANT("SECURITY_ERR", 18), \
+    CONSTANT("NETWORK_ERR", 19), CONSTANT("ABORT_ERR", 20), CONSTANT("URL_MISMATCH_ERR", 21), \
+    CONSTANT("QUOTA_EXCEEDED_ERR", 22), CONSTANT("TIMEOUT_ERR", 23), CONSTANT("INVALID_NODE_TYPE_ERR", 24), \
+    CONSTANT("DATA_CLONE_ERR", 25)
+
+static const JSBuiltin dom_exception_statics[] = { CONSTANTS };
+
+static const JSBuiltin dom_exception_proto[] = {
+    WEBIDL_ATTRIBUTE("name", dom_exception_name, NULL),
+    WEBIDL_ATTRIBUTE("message", dom_exception_message, NULL),
+    WEBIDL_ATTRIBUTE("code", dom_exception_code, NULL),
+    CONSTANTS,
+    JS_BUILTIN_SYMBOL_STRING(toStringTag, "DOMException", JS_PROP_CONFIGURABLE),
+};
+
+static void install_dom_exception(JSContext *ctx, JSObject *global) {
+    JSValue proto = js_new_object_proto(ctx, ctx->intrinsics[JS_INTRINSIC_ERROR_PROTOTYPE], 32);
+    ctx->intrinsics[JS_INTRINSIC_DOM_EXCEPTION_PROTOTYPE] = proto;
+    JSValue key = js_atom_from_cstr(ctx, "DOMException");
+    JSValue c = js_new_native(ctx, dom_exception_ctor, key, 0, JS_FN_STRICT | JS_FN_CONSTRUCTOR);
+    js_define_builtins(ctx, js_as_object(c), dom_exception_statics, JS_COUNTOF(dom_exception_statics));
+    js_define_data(ctx, js_as_object(c), JS_ATOM(prototype), proto, 0);
+    js_define_data(ctx, js_as_object(proto), JS_ATOM(constructor), c, JS_BUILTIN_METHOD_ATTRS);
+    js_define_builtins(ctx, js_as_object(proto), dom_exception_proto, JS_COUNTOF(dom_exception_proto));
+    js_define_data(ctx, global, key, c, JS_BUILTIN_METHOD_ATTRS);
+}
+
+const JSComponent js_component_domexception = { "domexception", install_dom_exception };

package/runtime/src/elements.c

@@ -0,0 +1,312 @@
+/* Indexed properties (ADR 0005): dense JSValue storage with EMPTY holes, or a
+ * sparse table; objects start on the static empty store. */
+#include "elements.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "internal.h"
+#include "jscontext.h"
+
+static JSSparseElements *as_sparse(JSElements *e) { return (JSSparseElements *)e; }
+static bool is_sparse(JSObject *o) { return o->elements->kind == JS_ELEMENTS_SPARSE; }
+
+/* ---- Dense ---------------------------------------------------------------- */
+
+static JSElements *alloc_dense(JSContext *ctx, uint32_t capacity) {
+    JSElements *e = (JSElements *)js_alloc_cell(ctx, JS_CELL_ELEMENTS, sizeof(JSElements) + (size_t)capacity * sizeof(JSValue));
+    e->kind = JS_ELEMENTS_DENSE;
+    e->capacity = capacity;  /* zero-filled: every slot a hole */
+    return e;
+}
+
+/* Makes dense capacity for index i, copying the present elements. */
+static void grow_dense(JSContext *ctx, JSObject *o, uint32_t i) {
+    JSElements *old = o->elements;
+    uint32_t cap = old->capacity < 4 ? 4 : old->capacity + old->capacity / 2;  /* ×1.5 */
+    if (cap <= i) cap = i + 1;
+    JSElements *e = alloc_dense(ctx, cap);
+    old = o->elements;  /* unchanged, but re-read after the allocation */
+    memcpy(e->data, old->data, (size_t)old->length * sizeof(JSValue));
+    e->length = old->length;
+    o->elements = e;
+}
+
+/* ---- Sparse ------------------------------------------------------------------ */
+
+static uint32_t index_hash(uint32_t i) {
+    return (uint32_t)(((uint64_t)i * UINT64_C(0x9E3779B97F4A7C15)) >> 32);
+}
+
+static JSSparseEntry *sparse_find(JSSparseElements *s, uint32_t i) {
+    for (uint32_t h = index_hash(i) & (s->cap - 1);; h = (h + 1) & (s->cap - 1)) {
+        JSSparseEntry *e = &s->entries[h];
+        if (e->state == 0) return NULL;
+        if (e->state == 1 && e->index == i) return e;
+    }
+}
+
+static void sparse_rehash(JSSparseElements *s, uint32_t cap) {
+    JSSparseEntry *old = s->entries;
+    uint32_t old_cap = s->cap;
+    s->entries = calloc(cap, sizeof *s->entries);
+    if (!s->entries) js_fatal("out of memory (sparse elements)");
+    s->cap = cap;
+    s->tombstones = 0;
+    for (uint32_t k = 0; k < old_cap; k++) {
+        if (old[k].state != 1) continue;
+        uint32_t h = index_hash(old[k].index) & (cap - 1);
+        while (s->entries[h].state) h = (h + 1) & (cap - 1);
+        s->entries[h] = old[k];
+    }
+    free(old);
+}
+
+static JSSparseEntry *sparse_insert(JSSparseElements *s, uint32_t i) {
+    if (2 * (s->count + s->tombstones + 1) > s->cap) sparse_rehash(s, s->count * 4 + 16 > s->cap ? s->cap * 2 : s->cap);
+    uint32_t h = index_hash(i) & (s->cap - 1);
+    while (s->entries[h].state == 1) h = (h + 1) & (s->cap - 1);
+    if (s->entries[h].state == 2) s->tombstones--;
+    JSSparseEntry *e = &s->entries[h];
+    *e = (JSSparseEntry){ i, 1, 0, 0, JS_UNDEFINED };
+    s->count++;
+    return e;
+}
+
+/* Replaces the object's elements with a sparse table of the same contents. */
+static JSSparseElements *to_sparse(JSContext *ctx, JSObject *o) {
+    if (is_sparse(o)) return as_sparse(o->elements);
+    JSSparseElements *s = (JSSparseElements *)js_alloc_cell(ctx, JS_CELL_ELEMENTS, sizeof(JSSparseElements));
+    s->cell.flags |= JS_CELL_FINALIZABLE;
+    js_block_of(s)->has_finalizable = 1;
+    s->kind = JS_ELEMENTS_SPARSE;
+    s->cap = 16;
+    s->entries = calloc(s->cap, sizeof *s->entries);
+    if (!s->entries) js_fatal("out of memory (sparse elements)");
+    JSElements *d = o->elements;
+    for (uint32_t i = 0; i < d->length; i++) {
+        if (js_is_empty(d->data[i])) continue;
+        JSSparseEntry *e = sparse_insert(s, i);
+        e->attrs = JS_PROP_DEFAULT;
+        e->value = d->data[i];
+    }
+    o->elements = (JSElements *)s;
+    return s;
+}
+
+void js_elements_finalize(JSRuntime *rt, JSCell *c) {
+    (void)rt;
+    JSElements *e = (JSElements *)c;
+    if (e->kind == JS_ELEMENTS_SPARSE) free(as_sparse(e)->entries);
+}
+
+/* ---- Operations -------------------------------------------------------------- */
+
+static JSPropertyDescriptor entry_descriptor(uint8_t attrs, JSValue v) {
+    if (attrs & JS_PROP_ACCESSOR) {
+        JSAccessorPair *p = (JSAccessorPair *)js_as_cell(v);
+        return (JSPropertyDescriptor){ JS_DESC_GET | JS_DESC_SET | JS_DESC_ENUMERABLE | JS_DESC_CONFIGURABLE,
+                                       (uint8_t)(attrs & (JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE)), JS_UNDEFINED, p->get, p->set };
+    }
+    return js_data_descriptor(v, attrs);
+}
+
+int js_elements_get_own(JSContext *ctx, JSObject *o, uint32_t i, JSPropertyDescriptor *out) {
+    (void)ctx;
+    JSElements *d = o->elements;
+    if (d->kind == JS_ELEMENTS_DENSE) {
+        if (i >= d->length || js_is_empty(d->data[i])) return 0;
+        *out = js_data_descriptor(d->data[i], JS_PROP_DEFAULT);
+        return 1;
+    }
+    JSSparseEntry *e = sparse_find(as_sparse(d), i);
+    if (!e) return 0;
+    *out = entry_descriptor(e->attrs, e->value);
+    return 1;
+}
+
+int js_elements_try_store(JSContext *ctx, JSObject *o, uint32_t i, JSValue v) {
+    JSElements *d = o->elements;
+    if (d->kind == JS_ELEMENTS_DENSE) {
+        if (i >= d->length || js_is_empty(d->data[i])) return 0;
+        js_store(ctx, &d->cell, &d->data[i], v);
+        return 1;
+    }
+    JSSparseEntry *e = sparse_find(as_sparse(d), i);
+    if (!e || (e->attrs & (JS_PROP_WRITABLE | JS_PROP_ACCESSOR)) != JS_PROP_WRITABLE) return 0;
+    js_store(ctx, &d->cell, &e->value, v);
+    return 1;
+}
+
+static int reject(JSContext *ctx, bool throw_on_fail, const char *what, uint32_t i) {
+    if (!throw_on_fail) return 0;
+    if (strcmp(what, "redefine") == 0) js_discard(js_throw_type_error(ctx, "Cannot redefine property: %u", i));  /* V8's wording */
+    else js_discard(js_throw_type_error(ctx, "Cannot %s property '%u'", what, i));
+    return -1;
+}
+
+static JSValue new_accessor(JSContext *ctx, JSValue get, JSValue set) {
+    JSAccessorPair *p = (JSAccessorPair *)js_alloc_cell(ctx, JS_CELL_ACCESSOR, sizeof(JSAccessorPair));
+    js_init_slot(&p->get, get);
+    js_init_slot(&p->set, set);
+    return js_cell(&p->cell);
+}
+
+static bool same_value(JSContext *ctx, JSValue a, JSValue b) {
+    if (js_is_number(a) && js_is_number(b)) {
+        double x = js_as_number(a), y = js_as_number(b);
+        if (x != x) return y != y;
+        return x == y && (x != 0 || (1 / x == 1 / y));
+    }
+    if (js_is_string(a) && js_is_string(b)) return js_string_equals(ctx, a, b);
+    return js_same_bits(a, b);
+}
+
+/* ValidateAndApplyPropertyDescriptor for an element (same rules as named properties). */
+int js_elements_define(JSContext *ctx, JSObject *o, uint32_t i, const JSPropertyDescriptor *desc, bool throw_on_fail) {
+    bool accessor_desc = (desc->has & (JS_DESC_GET | JS_DESC_SET)) != 0;
+    JSPropertyDescriptor cur = { 0, 0, JS_UNDEFINED, JS_UNDEFINED, JS_UNDEFINED };
+    int exists = js_elements_get_own(ctx, o, i, &cur);
+    uint8_t attrs = 0;
+    bool cur_accessor = exists && !(cur.has & JS_DESC_VALUE);
+    if (exists) attrs = (uint8_t)(cur.attrs | (cur_accessor ? JS_PROP_ACCESSOR : 0));
+
+    if (!exists) {
+        if (!js_is_extensible(o)) return reject(ctx, throw_on_fail, "define", i);
+        attrs = 0;
+        if ((desc->has & JS_DESC_ENUMERABLE) && (desc->attrs & JS_PROP_ENUMERABLE)) attrs |= JS_PROP_ENUMERABLE;
+        if ((desc->has & JS_DESC_CONFIGURABLE) && (desc->attrs & JS_PROP_CONFIGURABLE)) attrs |= JS_PROP_CONFIGURABLE;
+        if (!accessor_desc && (desc->has & JS_DESC_WRITABLE) && (desc->attrs & JS_PROP_WRITABLE)) attrs |= JS_PROP_WRITABLE;
+    } else if (!(attrs & JS_PROP_CONFIGURABLE)) {
+        if ((desc->has & JS_DESC_CONFIGURABLE) && (desc->attrs & JS_PROP_CONFIGURABLE)) return reject(ctx, throw_on_fail, "redefine", i);
+        if ((desc->has & JS_DESC_ENUMERABLE) && ((desc->attrs ^ attrs) & JS_PROP_ENUMERABLE)) return reject(ctx, throw_on_fail, "redefine", i);
+        bool generic = !accessor_desc && !(desc->has & (JS_DESC_VALUE | JS_DESC_WRITABLE));
+        if (!generic && accessor_desc != cur_accessor) return reject(ctx, throw_on_fail, "redefine", i);
+        if (cur_accessor) {
+            if ((desc->has & JS_DESC_GET) && !js_same_bits(desc->get, cur.get)) return reject(ctx, throw_on_fail, "redefine", i);
+            if ((desc->has & JS_DESC_SET) && !js_same_bits(desc->set, cur.set)) return reject(ctx, throw_on_fail, "redefine", i);
+        } else if (!(attrs & JS_PROP_WRITABLE)) {
+            if ((desc->has & JS_DESC_WRITABLE) && (desc->attrs & JS_PROP_WRITABLE)) return reject(ctx, throw_on_fail, "redefine", i);
+            if ((desc->has & JS_DESC_VALUE) && !same_value(ctx, desc->value, cur.value)) return reject(ctx, throw_on_fail, "redefine", i);
+        }
+    }
+
+    /* the new attributes and value */
+    uint8_t na = attrs;
+    JSValue value = exists ? (cur_accessor ? JS_EMPTY : cur.value) : JS_UNDEFINED;
+    if (exists) {
+        if (desc->has & JS_DESC_ENUMERABLE) na = (uint8_t)((na & ~JS_PROP_ENUMERABLE) | (desc->attrs & JS_PROP_ENUMERABLE));
+        if (desc->has & JS_DESC_CONFIGURABLE) na = (uint8_t)((na & ~JS_PROP_CONFIGURABLE) | (desc->attrs & JS_PROP_CONFIGURABLE));
+    }
+    if (accessor_desc) {
+        JSValue get = desc->has & JS_DESC_GET ? desc->get : (cur_accessor ? cur.get : JS_UNDEFINED);
+        JSValue set = desc->has & JS_DESC_SET ? desc->set : (cur_accessor ? cur.set : JS_UNDEFINED);
+        value = new_accessor(ctx, get, set);
+        na = (uint8_t)((na & ~JS_PROP_WRITABLE) | JS_PROP_ACCESSOR);
+    } else if (cur_accessor && !(desc->has & (JS_DESC_VALUE | JS_DESC_WRITABLE))) {
+        value = new_accessor(ctx, cur.get, cur.set);  /* attributes only */
+    } else {
+        if (cur_accessor) {
+            na = (uint8_t)(na & ~(JS_PROP_ACCESSOR | JS_PROP_WRITABLE));
+            value = JS_UNDEFINED;
+        }
+        if (desc->has & JS_DESC_WRITABLE) na = (uint8_t)((na & ~JS_PROP_WRITABLE) | (desc->attrs & JS_PROP_WRITABLE));
+        if (desc->has & JS_DESC_VALUE) value = desc->value;
+    }
+
+    /* store: dense only for plain writable-enumerable-configurable data */
+    if (na == JS_PROP_DEFAULT && !is_sparse(o)) {
+        JSElements *d = o->elements;
+        if (i >= d->capacity) {
+            uint32_t present = d->length;  /* an upper bound on present elements */
+            if (i > d->length + JS_SPARSE_GAP && (uint64_t)present * 2 < (uint64_t)i + 1) goto sparse;
+            grow_dense(ctx, o, i);
+            d = o->elements;
+        }
+        js_store(ctx, &d->cell, &d->data[i], value);
+        if (i >= d->length) d->length = i + 1;
+        return 1;
+    }
+sparse:;
+    JSSparseElements *s = to_sparse(ctx, o);
+    JSSparseEntry *e = sparse_find(s, i);
+    if (!e) e = sparse_insert(s, i);
+    e->attrs = na;
+    js_store(ctx, &s->cell, &e->value, value);
+    return 1;
+}
+
+int js_elements_delete(JSContext *ctx, JSObject *o, uint32_t i, bool throw_on_fail) {
+    JSElements *d = o->elements;
+    if (d->kind == JS_ELEMENTS_DENSE) {
+        if (i < d->length) d->data[i] = JS_EMPTY;  /* a hole; the store stays dense */
+        return 1;
+    }
+    JSSparseEntry *e = sparse_find(as_sparse(d), i);
+    if (!e) return 1;
+    if (!(e->attrs & JS_PROP_CONFIGURABLE)) return reject(ctx, throw_on_fail, "delete", i);
+    e->state = 2;
+    e->value = JS_UNDEFINED;
+    as_sparse(d)->count--;
+    as_sparse(d)->tombstones++;
+    return 1;
+}
+
+static int cmp_u32(const void *a, const void *b) {
+    uint32_t x = *(const uint32_t *)a, y = *(const uint32_t *)b;
+    return x < y ? -1 : x > y;
+}
+
+JSValueArray *js_elements_keys(JSContext *ctx, JSObject *o) {
+    JSElements *d = o->elements;
+    if (d->kind == JS_ELEMENTS_DENSE) {
+        uint32_t n = 0;
+        for (uint32_t i = 0; i < d->length; i++) n += !js_is_empty(d->data[i]);
+        JSValueArray *keys = js_alloc_value_array(ctx, n);
+        d = o->elements;
+        for (uint32_t i = 0, k = 0; i < d->length; i++)
+            if (!js_is_empty(d->data[i])) keys->values[k++] = js_index_key(i);
+        return keys;
+    }
+    JSSparseElements *s = as_sparse(d);
+    uint32_t n = s->count;
+    uint32_t *idx = malloc((n ? n : 1) * sizeof *idx);
+    if (!idx) js_fatal("out of memory (element keys)");
+    for (uint32_t k = 0, j = 0; k < s->cap; k++)
+        if (s->entries[k].state == 1) idx[j++] = s->entries[k].index;
+    qsort(idx, n, sizeof *idx, cmp_u32);
+    JSValueArray *keys = js_alloc_value_array(ctx, n);
+    for (uint32_t k = 0; k < n; k++) keys->values[k] = js_index_key(idx[k]);
+    free(idx);
+    return keys;
+}
+
+uint32_t js_elements_truncate(JSContext *ctx, JSObject *o, uint32_t new_len) {
+    (void)ctx;
+    JSElements *d = o->elements;
+    if (d->kind == JS_ELEMENTS_DENSE) {
+        if (d->length > new_len) {
+            if (d->cell.flags & JS_CELL_STATIC) return new_len;
+            for (uint32_t i = new_len; i < d->length; i++) d->data[i] = JS_EMPTY;
+            d->length = new_len;
+        }
+        return new_len;
+    }
+    /* from the top down, stopping at a non-configurable element */
+    JSSparseElements *s = as_sparse(d);
+    uint32_t stop = new_len;
+    for (uint32_t k = 0; k < s->cap; k++) {
+        JSSparseEntry *e = &s->entries[k];
+        if (e->state == 1 && e->index >= new_len && !(e->attrs & JS_PROP_CONFIGURABLE) && e->index + 1 > stop) stop = e->index + 1;
+    }
+    for (uint32_t k = 0; k < s->cap; k++) {
+        JSSparseEntry *e = &s->entries[k];
+        if (e->state == 1 && e->index >= stop) {
+            e->state = 2;
+            e->value = JS_UNDEFINED;
+            s->count--;
+            s->tombstones++;
+        }
+    }
+    return stop;
+}

package/runtime/src/elements.h

@@ -0,0 +1,45 @@
+/* elements.h — indexed properties (ADR 0005, "Elements"). Runtime-internal. */
+#ifndef JS_ELEMENTS_H
+#define JS_ELEMENTS_H
+
+#include "js_object.h"
+
+/* SPARSE: an open-addressing table index → (attrs, value), malloc'd and
+ * owned by the cell (finalized). Values are traced by the cell's visitor. */
+typedef struct JSSparseEntry {
+    uint32_t index;
+    uint8_t  state;   /* 0 empty, 1 used, 2 deleted */
+    uint8_t  attrs;   /* JS_PROP_*; ACCESSOR: value is a JSAccessorPair */
+    uint16_t pad_;
+    JSValue  value;
+} JSSparseEntry;
+
+typedef struct JSSparseElements {  /* kind = ELEMENTS, JS_ELEMENTS_SPARSE */
+    JSCell   cell;
+    uint8_t  kind;
+    uint8_t  flags;
+    uint16_t pad_;
+    uint32_t count;      /* used entries */
+    uint32_t cap;        /* table size, a power of two */
+    uint32_t tombstones;
+    JSSparseEntry *entries;
+} JSSparseElements;
+
+/* Dense → sparse: when a write lands this far past the used slots, and the
+ * result would be less than half full (ADR 0005, initial values). */
+#define JS_SPARSE_GAP 1024
+
+int js_elements_get_own(JSContext *ctx, JSObject *o, uint32_t i, JSPropertyDescriptor *out);
+int js_elements_define(JSContext *ctx, JSObject *o, uint32_t i, const JSPropertyDescriptor *desc, bool throw_on_fail);
+int js_elements_delete(JSContext *ctx, JSObject *o, uint32_t i, bool throw_on_fail);
+/* Fast path for [[Set]]: an existing writable data element. Returns 1 if stored. */
+int js_elements_try_store(JSContext *ctx, JSObject *o, uint32_t i, JSValue v);
+/* Present indices, ascending, into a new JSValueArray of keys. */
+JSValueArray *js_elements_keys(JSContext *ctx, JSObject *o);
+/* Removes elements at indices ≥ new_len, from the top. Stops at a
+ * non-configurable one: returns its index + 1 then, else new_len. */
+uint32_t js_elements_truncate(JSContext *ctx, JSObject *o, uint32_t new_len);
+
+void js_elements_finalize(JSRuntime *rt, JSCell *c);
+
+#endif /* JS_ELEMENTS_H */