#ifndef SV_PROPERTY_H
#define SV_PROPERTY_H

#include "silver/engine.h"
#include "shapes.h"
#include "gc.h"
#include "utf8.h"
#include <math.h>
#include <stdlib.h>

static inline ant_value_t sv_getprop_fallback_len(
  ant_t *js, ant_value_t obj,
  const char *key, ant_offset_t key_len
) {
  char small[64];
  char *tmp = small;

  if (key_len + 1 > (ant_offset_t)sizeof(small)) {
    tmp = malloc((size_t)key_len + 1);
    if (!tmp) return js_mkerr(js, "out of memory");
  }

  memcpy(tmp, key, (size_t)key_len);
  tmp[key_len] = '\0';
  ant_value_t out = js_getprop_fallback(js, obj, tmp);

  if (tmp != small) free(tmp);
  return out;
}

static inline ant_value_t sv_key_to_property_key(ant_t *js, ant_value_t key) {
  if (vtype(key) == T_SYMBOL) return key;

  ant_value_t prim = is_object_type(key) ? js_to_primitive(js, key, 1) : key;
  if (is_err(prim)) return prim;
  if (vtype(prim) == T_SYMBOL) return prim;

  return js_tostring_val(js, prim);
}

static inline ant_value_t sv_key_to_propstr(ant_t *js, ant_value_t key) {
  return coerce_to_str(js, key);
}

static inline ant_value_t sv_mk_nullish_read_error_by_key(
  ant_t *js, ant_value_t obj, ant_value_t key
) {
  uint8_t ot = vtype(obj);
  ant_value_t key_str = sv_key_to_propstr(js, key);

  if (!is_err(key_str) && vtype(key_str) == T_STR) {
    ant_offset_t klen = 0;
    ant_offset_t koff = vstr(js, key_str, &klen);
    const char *kptr = (const char *)(uintptr_t)(koff);
    
    return js_mkerr_typed(js, JS_ERR_TYPE,
      "Cannot read properties of %s (reading '%.*s')",
      ot == T_NULL ? "null" : "undefined", (int)klen, kptr
    );
  }

  return js_mkerr_typed(js, JS_ERR_TYPE,
    "Cannot read properties of %s",
    ot == T_NULL ? "null" : "undefined"
  );
}

static inline ant_object_t *sv_array_obj_ptr(ant_value_t obj) {
  if (!is_object_type(obj)) return NULL;
  ant_object_t *ptr = js_obj_ptr(js_as_obj(obj));
  return (ptr && ptr->type_tag == T_ARR) ? ptr : NULL;
}

static inline bool sv_try_get_shape_data_prop(
  ant_t *js,
  ant_object_t *ptr,
  const char *interned,
  ant_value_t *out,
  bool *should_fallback
) {
  if (!ptr) {
    *should_fallback = true;
    return false;
  }
  if (ptr->is_exotic) {
    *should_fallback = true;
    return false;
  }
  if (!ptr->shape) return false;

  int32_t slot = ant_shape_lookup_interned(ptr->shape, interned);
  if (slot < 0) return false;

  uint32_t idx = (uint32_t)slot;
  const ant_shape_prop_t *prop = ant_shape_prop_at(ptr->shape, idx);
  if (!prop) {
    *out = js_mkundef();
    return true;
  }
  if (prop->has_getter || prop->has_setter) {
    *should_fallback = true;
    return false;
  }

  *out = (idx < ptr->prop_count) ? ant_object_prop_get_unchecked(ptr, idx) : js_mkundef();
  
  return true;
}

static inline bool sv_same_obj_identity(ant_value_t a, ant_value_t b) {
  if (!is_object_type(a) || !is_object_type(b)) return false;
  return vdata(js_as_obj(a)) == vdata(js_as_obj(b));
}

static inline ant_value_t sv_obj_proto_or_null(ant_value_t v) {
  if (!is_object_type(v)) return js_mknull();
  ant_object_t *ptr = js_obj_ptr(js_as_obj(v));
  if (!ptr) return js_mknull();
  return is_object_type(ptr->proto) ? ptr->proto : js_mknull();
}

typedef struct {
  int depth;
  bool overflow;
  ant_value_t fast;
} sv_proto_guard_t;

static inline void sv_proto_guard_init(sv_proto_guard_t *g) {
  g->depth = 0;
  g->overflow = false;
  g->fast = js_mknull();
}

static inline bool sv_proto_guard_hit_cycle(sv_proto_guard_t *g, ant_value_t cur) {
  if (!g->overflow) {
    if (++g->depth < MAX_PROTO_CHAIN_DEPTH) return false;
    g->overflow = true;
    g->fast = cur;
  }

  g->fast = sv_obj_proto_or_null(g->fast);
  g->fast = sv_obj_proto_or_null(g->fast);
  return sv_same_obj_identity(cur, g->fast);
}

static inline sv_ic_entry_t *sv_ic_slot_for_ip(sv_func_t *func, uint8_t *ip) {
  if (!func || !func->ic_slots || !ip) return NULL;
  uint16_t ic_idx = sv_get_u16(ip + 5);
  if (ic_idx == UINT16_MAX || ic_idx >= func->ic_count) return NULL;
  return &func->ic_slots[ic_idx];
}

static inline bool sv_ic_try_get_hit(
  sv_ic_entry_t *ic,
  ant_object_t *receiver,
  sv_atom_t *a,
  ant_value_t *out
) {
  if (!ic || !receiver) return false;
  if (ic->epoch != ant_ic_epoch_counter) return false;
  if (ic->cached_shape != receiver->shape) return false;

  ant_object_t *source;
  ant_shape_t *prop_shape;
  
  if (ic->cached_is_own) {
    source = receiver;
    prop_shape = receiver->shape;
  } else {
    ant_object_t *holder = ic->cached_holder;
    if (!holder || holder->is_exotic || !holder->shape) return false;
    source = holder;
    prop_shape = holder->shape;
  }
  if (ic->cached_index >= source->prop_count) return false;

  const ant_shape_prop_t *prop = ant_shape_prop_at(prop_shape, ic->cached_index);
  if (!prop) return false;
  if (prop->type != ANT_SHAPE_KEY_STRING || prop->key.interned != a->str) return false;
  if (prop->has_getter || prop->has_setter) return false;

  *out = ant_object_prop_get_unchecked(source, ic->cached_index);
  return true;
}

static inline bool sv_ic_probe_get_chain(
  ant_value_t obj,
  const char *interned,
  ant_object_t **out_holder,
  uint32_t *out_index,
  ant_value_t *out_value
) {
  ant_value_t cur = obj;
  sv_proto_guard_t guard;
  sv_proto_guard_init(&guard);
  while (is_object_type(cur)) {
    ant_object_t *ptr = js_obj_ptr(js_as_obj(cur));
    if (!ptr || ptr->is_exotic) return false;
    if (!ptr->shape) {
      ant_value_t next = ptr->proto;
      if (!is_object_type(next)) break;
      cur = next;
      if (sv_proto_guard_hit_cycle(&guard, cur)) break;
      continue;
    }

    int32_t slot = ant_shape_lookup_interned(ptr->shape, interned);
    if (slot < 0) {
      ant_value_t next = ptr->proto;
      if (!is_object_type(next)) break;
      cur = next;
      if (sv_proto_guard_hit_cycle(&guard, cur)) break;
      continue;
    }

    uint32_t idx = (uint32_t)slot;
    const ant_shape_prop_t *prop = ant_shape_prop_at(ptr->shape, idx);
    if (!prop) return false;
    if (prop->has_getter || prop->has_setter) return false;

    *out_holder = ptr;
    *out_index = idx;
    *out_value = (idx < ptr->prop_count) ? ant_object_prop_get_unchecked(ptr, idx) : js_mkundef();
    return true;
  }

  return false;
}

static inline void sv_gf_ic_note_success(sv_ic_entry_t *ic) {
  if (!ic) return;
  uintptr_t aux = ic->cached_aux;
  uint8_t warmup = sv_gf_ic_warmup(aux);
  if (warmup < 0xFFu) warmup++;
  bool active = sv_gf_ic_active(aux) || warmup >= SV_GF_IC_WARMUP_ENABLE;
  ic->cached_aux = sv_gf_ic_pack_aux(warmup, 0u, active);
}

static inline void sv_gf_ic_note_miss(sv_ic_entry_t *ic) {
  if (!ic) return;
  uintptr_t aux = ic->cached_aux;
  uint8_t warmup = sv_gf_ic_warmup(aux);
  uint8_t miss = sv_gf_ic_miss_streak(aux);
  bool active = sv_gf_ic_active(aux);

  if (miss < 0xFFu) miss++;
  if (miss >= SV_GF_IC_MISS_DISABLE) {
    warmup = 0;
    miss = 0;
    active = false;
  }

  ic->cached_aux = sv_gf_ic_pack_aux(warmup, miss, active);
}

static inline ant_value_t sv_getprop_by_key(ant_t *js, ant_value_t obj, ant_value_t key) {
  ant_value_t prop_key = sv_key_to_property_key(js, key);
  if (is_err(prop_key)) return prop_key;
  if (vtype(prop_key) == T_SYMBOL) return js_get_sym(js, obj, prop_key);

  ant_value_t key_str = prop_key;
  if (is_err(key_str) || vtype(key_str) != T_STR) return js_mkundef();

  ant_offset_t klen = 0;
  ant_offset_t koff = vstr(js, key_str, &klen);
  
  const char *kptr = (const char *)(uintptr_t)(koff);
  return sv_getprop_fallback_len(js, obj, kptr, klen);
}

static inline ant_value_t sv_prop_get_at(
  ant_t *js, ant_value_t obj, const char *str, uint32_t len,
  sv_func_t *func, uint8_t *ip
) {
  uint8_t t = vtype(obj);

  if (t == T_NULL || t == T_UNDEF) {
    if (func && ip) js_set_error_site_from_bc(js, func, (int)(ip - func->code), func->filename);
    return js_mkerr_typed(js, JS_ERR_TYPE,
      "Cannot read properties of %s (reading '%.*s')",
      t == T_NULL ? "null" : "undefined", (int)len, str);
  }

  ant_value_t str_prim = js_mkundef();
  ant_value_t sym_prim = js_mkundef();

  if (t == T_STR) str_prim = obj;
  else if (t == T_SYMBOL) sym_prim = obj;
  else if (t == T_OBJ) {
    ant_value_t prim = js_get_slot(obj, SLOT_PRIMITIVE);
    if (vtype(prim) == T_STR) str_prim = prim;
    else if (vtype(prim) == T_SYMBOL) sym_prim = prim;
  }

  if (vtype(str_prim) == T_STR && is_length_key(str, len)) {
    ant_offset_t byte_len = 0;
    ant_offset_t str_off = vstr(js, str_prim, &byte_len);
    const char *str_data = (const char *)(uintptr_t)(str_off);
    return tov((double)utf16_strlen(str_data, byte_len));
  }

  if (is_length_key(str, len)) {
    ant_object_t *arr_ptr = sv_array_obj_ptr(obj);
    if (arr_ptr) return tov((double)js_arr_len(js, js_as_obj(obj)));
  }

  if (vtype(sym_prim) == T_SYMBOL && len == 11 &&
      memcmp(str, "description", 11) == 0) {
    const char *desc = js_sym_desc(sym_prim);
    if (desc) return js_mkstr(js, desc, strlen(desc));
    return js_mkundef();
  }

  if (t == T_OBJ || t == T_ARR || t == T_FUNC || t == T_PROMISE) {
    ant_value_t cur = obj;
    sv_proto_guard_t guard;
    sv_proto_guard_init(&guard);
    while (is_object_type(cur)) {
      ant_object_t *ptr = js_obj_ptr(js_as_obj(cur));
      bool should_fallback = false;
      ant_value_t fast_out = js_mkundef();
      if (sv_try_get_shape_data_prop(js, ptr, str, &fast_out, &should_fallback))
        return fast_out;
      if (should_fallback) break;
      cur = ptr->proto;
      if (sv_proto_guard_hit_cycle(&guard, cur)) break;
    }
  }

  return sv_getprop_fallback_len(js, obj, str, (ant_offset_t)len);
}

static inline ant_value_t sv_prop_get(ant_t *js, ant_value_t obj, const char *str, uint32_t len) {
  return sv_prop_get_at(js, obj, str, len, NULL, NULL);
}

static inline bool sv_parse_string_index_key(ant_t *js, ant_value_t key, size_t *out_idx) {
  if (vtype(key) == T_NUM) {
    double d = tod(key);
    if (!isfinite(d) || d < 0.0) return false;
    double di = floor(d);
    if (di != d || di > (double)SIZE_MAX) return false;
    *out_idx = (size_t)di;
    return true;
  }

  if (vtype(key) != T_STR) return false;

  ant_offset_t klen = 0;
  ant_offset_t koff = vstr(js, key, &klen);
  const char *k = (const char *)(uintptr_t)(koff);
  if (klen == 0) return false;
  if (klen > 1 && k[0] == '0') return false;

  size_t idx = 0;
  for (ant_offset_t i = 0; i < klen; i++) {
    if (k[i] < '0' || k[i] > '9') return false;
    size_t digit = (size_t)(k[i] - '0');
    if (idx > (SIZE_MAX - digit) / 10) return false;
    idx = idx * 10 + digit;
  }

  *out_idx = idx;
  return true;
}

static inline bool sv_try_string_index_get(ant_t *js, ant_value_t obj, ant_value_t key, ant_value_t *out) {
  ant_value_t str = obj;
  if (vtype(obj) == T_OBJ) {
    ant_value_t prim = js_get_slot(obj, SLOT_PRIMITIVE);
    if (vtype(prim) == T_STR) str = prim;
  }
  if (vtype(str) != T_STR) return false;

  size_t idx = 0;
  if (!sv_parse_string_index_key(js, key, &idx)) return false;

  ant_offset_t byte_len = 0;
  ant_offset_t str_off = vstr(js, str, &byte_len);
  const char *str_data = (const char *)(uintptr_t)(str_off);
  
  uint32_t code_unit = utf16_code_unit_at(str_data, byte_len, idx);
  if (code_unit == 0xFFFFFFFF) {
    *out = js_mkundef();
    return true;
  }

  char buf[4];
  size_t out_len = 0;
  if (code_unit >= 0xD800 && code_unit <= 0xDFFF) {
    buf[0] = (char)(0xE0 | (code_unit >> 12));
    buf[1] = (char)(0x80 | ((code_unit >> 6) & 0x3F));
    buf[2] = (char)(0x80 | (code_unit & 0x3F));
    out_len = 3;
  } else out_len = (size_t)utf8_encode(code_unit, buf);
  *out = js_mkstr(js, buf, out_len);
  
  return true;
}

static inline ant_value_t sv_prop_get_field_ic(
  ant_t *js,
  ant_value_t obj,
  sv_atom_t *a,
  sv_func_t *func,
  uint8_t *ip
) {
  ant_object_t *ptr = is_object_type(obj) ? js_obj_ptr(js_as_obj(obj)) : NULL;
  sv_ic_entry_t *ic = sv_ic_slot_for_ip(func, ip);
  bool track_ic = ic && !is_length_key(a->str, a->len);

  ant_value_t hit = js_mkundef();
  if (ic && ptr && !ptr->is_exotic && track_ic &&
      sv_ic_try_get_hit(ic, ptr, a, &hit)) {
    sv_gf_ic_note_success(ic);
    return hit;
  }

  if (ic && ptr && !ptr->is_exotic && track_ic) {
    ant_object_t *holder = NULL;
    uint32_t prop_idx = 0;
    ant_value_t out = js_mkundef();
    if (sv_ic_probe_get_chain(obj, a->str, &holder, &prop_idx, &out)) {
      ic->cached_shape = ptr->shape;
      ic->cached_holder = holder;
      ic->cached_index = prop_idx;
      ic->cached_is_own = (holder == ptr);
      ic->epoch = ant_ic_epoch_counter;
      sv_gf_ic_note_success(ic);
      return out;
    }
  }

  if (track_ic) sv_gf_ic_note_miss(ic);
  return sv_prop_get_at(js, obj, a->str, a->len, func, ip);
}

static inline ant_value_t sv_op_get_field(
  sv_vm_t *vm, ant_t *js,
  sv_func_t *func, uint8_t *ip
) {
  uint32_t idx = sv_get_u32(ip + 1);
  sv_atom_t *a = &func->atoms[idx];
  ant_value_t obj = vm->stack[--vm->sp];
  ant_value_t res = sv_prop_get_field_ic(js, obj, a, func, ip);
  if (is_err(res)) return res;
  vm->stack[vm->sp++] = res;
  return js_mkundef();
}

static inline ant_value_t sv_op_get_field2(
  sv_vm_t *vm, ant_t *js,
  sv_func_t *func, uint8_t *ip
) {
  uint32_t idx = sv_get_u32(ip + 1);
  sv_atom_t *a = &func->atoms[idx];
  ant_value_t obj = vm->stack[vm->sp - 1];
  ant_value_t res = sv_prop_get_field_ic(js, obj, a, func, ip);
  if (is_err(res)) return res;
  vm->stack[vm->sp++] = res;
  return js_mkundef();
}

static inline bool sv_try_put_field_fast(
  ant_t *js,
  ant_value_t obj,
  sv_atom_t *a,
  ant_value_t val,
  uint32_t *out_index
) {
  if (!is_object_type(obj)) return false;

  ant_object_t *ptr = js_obj_ptr(js_as_obj(obj));
  if (!ptr || ptr->is_exotic || !ptr->shape) return false;
  if (ptr->type_tag == T_ARR && is_length_key(a->str, a->len)) return false;

  int32_t slot = ant_shape_lookup_interned(ptr->shape, a->str);
  if (slot < 0) return false;

  uint32_t prop_idx = (uint32_t)slot;
  if (prop_idx >= ptr->prop_count) return false;

  const ant_shape_prop_t *prop = ant_shape_prop_at(ptr->shape, prop_idx);
  if (!prop) return false;
  if (prop->has_getter || prop->has_setter) return false;
  if ((prop->attrs & ANT_PROP_ATTR_WRITABLE) == 0) return false;

  ant_object_prop_set_unchecked(ptr, prop_idx, val);
  gc_write_barrier(js, ptr, val);
  if (out_index) *out_index = prop_idx;
  return true;
}

static inline bool sv_is_proto_atom(const sv_atom_t *a) {
  return a && a->len == STR_PROTO_LEN && memcmp(a->str, STR_PROTO, STR_PROTO_LEN) == 0;
}

static inline void sv_ic_set_add_transition(
  sv_ic_entry_t *ic,
  ant_shape_t *from,
  ant_shape_t *to,
  uint32_t slot,
  uint32_t epoch
) {
  if (!ic) return;

  if (ic->add_from_shape != from) {
    if (ic->add_from_shape) ant_shape_release(ic->add_from_shape);
    ic->add_from_shape = NULL;
    if (from) {
      ant_shape_retain(from);
      ic->add_from_shape = from;
    }
  }

  if (ic->add_to_shape != to) {
    if (ic->add_to_shape) ant_shape_release(ic->add_to_shape);
    ic->add_to_shape = NULL;
    if (to) {
      ant_shape_retain(to);
      ic->add_to_shape = to;
    }
  }

  ic->add_slot = slot;
  ic->add_epoch = epoch;
}

static inline ant_value_t sv_op_put_field(
  sv_vm_t *vm, ant_t *js,
  sv_func_t *func, uint8_t *ip
) {
  uint32_t idx = sv_get_u32(ip + 1);
  sv_atom_t *a = &func->atoms[idx];
  ant_value_t val = vm->stack[--vm->sp];
  ant_value_t obj = vm->stack[--vm->sp];
  ant_object_t *ptr = is_object_type(obj) ? js_obj_ptr(js_as_obj(obj)) : NULL;
  sv_ic_entry_t *ic = sv_ic_slot_for_ip(func, ip);

  if (ic && ptr && !ptr->is_exotic && ptr->shape && ic->epoch == ant_ic_epoch_counter &&
      ic->cached_shape == ptr->shape && ic->cached_holder == ptr &&
      ic->cached_index < ptr->prop_count) {
    const ant_shape_prop_t *prop = ant_shape_prop_at(ptr->shape, ic->cached_index);
    if (prop &&
        prop->type == ANT_SHAPE_KEY_STRING &&
        prop->key.interned == a->str &&
        !prop->has_getter &&
        !prop->has_setter &&
        (prop->attrs & ANT_PROP_ATTR_WRITABLE) != 0) {
      ant_object_prop_set_unchecked(ptr, ic->cached_index, val);
      gc_write_barrier(js, ptr, val);
      return val;
    }
  }

  if (ic && ptr && !ptr->is_exotic && ptr->shape &&
      !ptr->frozen && !ptr->sealed && ptr->extensible &&
      ptr->type_tag != T_ARR &&
      !sv_is_proto_atom(a) &&
      ic->add_epoch == ant_ic_epoch_counter &&
      ic->add_from_shape == ptr->shape &&
      ic->add_to_shape) {
    if (ant_shape_lookup_interned(ptr->shape, a->str) < 0) {
      ant_shape_t *old_shape = ptr->shape;
      ant_shape_retain(ic->add_to_shape);
      ptr->shape = ic->add_to_shape;
      ant_shape_release(old_shape);
      if (ic->add_slot >= ptr->prop_count &&
          !js_obj_ensure_prop_capacity(ptr, ic->add_slot + 1)) {
        return js_mkerr(js, "oom");
      }
      ant_object_prop_set_unchecked(ptr, ic->add_slot, val);
      gc_write_barrier(js, ptr, val);
      ic->cached_shape = ptr->shape;
      ic->cached_holder = ptr;
      ic->cached_index = ic->add_slot;
      ic->epoch = ant_ic_epoch_counter;
      return val;
    }
  }

  uint32_t fast_idx = 0;
  if (sv_try_put_field_fast(js, obj, a, val, &fast_idx)) {
    if (ic && ptr && ptr->shape) {
      ic->cached_shape = ptr->shape;
      ic->cached_holder = ptr;
      ic->cached_index = fast_idx;
      ic->epoch = ant_ic_epoch_counter;
    }
    return val;
  }

  ant_shape_t *old_shape = NULL;
  if (ptr && ptr->shape) {
    old_shape = ptr->shape;
    ant_shape_retain(old_shape);
  }

  ant_value_t out = setprop_interned(js, obj, a->str, a->len, val);
  if (is_err(out)) {
    if (old_shape) ant_shape_release(old_shape);
    return out;
  }

  if (ic && ptr && !ptr->is_exotic && ptr->shape) {
    int32_t slot = ant_shape_lookup_interned(ptr->shape, a->str);
    if (slot >= 0) {
      uint32_t prop_idx = (uint32_t)slot;
      const ant_shape_prop_t *prop = ant_shape_prop_at(ptr->shape, prop_idx);
      if (prop &&
          prop->type == ANT_SHAPE_KEY_STRING &&
          prop->key.interned == a->str &&
          !prop->has_getter &&
          !prop->has_setter &&
          (prop->attrs & ANT_PROP_ATTR_WRITABLE) != 0 &&
          prop_idx < ptr->prop_count) {
        ic->cached_shape = ptr->shape;
        ic->cached_holder = ptr;
        ic->cached_index = prop_idx;
        ic->epoch = ant_ic_epoch_counter;
        if (old_shape &&
            old_shape != ptr->shape &&
            !sv_is_proto_atom(a) &&
            !ptr->frozen &&
            !ptr->sealed &&
            ptr->extensible &&
            ptr->type_tag != T_ARR &&
            prop->attrs == ANT_PROP_ATTR_DEFAULT) {
          sv_ic_set_add_transition(ic, old_shape, ptr->shape, prop_idx, ant_ic_epoch_counter);
        }
      }
    }
  }

  if (old_shape) ant_shape_release(old_shape);

  return out;
}

static inline ant_value_t sv_op_get_elem(
  sv_vm_t *vm, ant_t *js,
  sv_func_t *func, uint8_t *ip
) {
  ant_value_t key = vm->stack[--vm->sp];
  ant_value_t obj = vm->stack[--vm->sp];
  uint8_t ot = vtype(obj);

  if (ot == T_NULL || ot == T_UNDEF) {
    if (func && ip) js_set_error_site_from_bc(js, func, (int)(ip - func->code), func->filename);
    return sv_mk_nullish_read_error_by_key(js, obj, key);
  }

  if (vtype(obj) == T_ARR && vtype(key) == T_NUM) {
    double d = tod(key);
    if (d >= 0 && d == (uint32_t)d) {
      vm->stack[vm->sp++] = js_arr_get(js, obj, (uint32_t)d);
      return js_mkundef();
    }
  }

  ant_value_t str_elem = js_mkundef();
  if (sv_try_string_index_get(js, obj, key, &str_elem)) {
    vm->stack[vm->sp++] = str_elem;
    return js_mkundef();
  }

  ant_value_t res = sv_getprop_by_key(js, obj, key);
  if (is_err(res)) return res;
  vm->stack[vm->sp++] = res;
  return js_mkundef();
}

static inline ant_value_t sv_op_get_elem2(
  sv_vm_t *vm, ant_t *js,
  sv_func_t *func, uint8_t *ip
) {
  ant_value_t key = vm->stack[--vm->sp];
  ant_value_t obj = vm->stack[vm->sp - 1];

  uint8_t ot = vtype(obj);
  if (ot == T_NULL || ot == T_UNDEF) {
    if (func && ip) js_set_error_site_from_bc(js, func, (int)(ip - func->code), func->filename);
    return sv_mk_nullish_read_error_by_key(js, obj, key);
  }

  if (vtype(obj) == T_ARR && vtype(key) == T_NUM) {
    double d = tod(key);
    if (d >= 0 && d == (uint32_t)d) {
      vm->stack[vm->sp++] = js_arr_get(js, obj, (uint32_t)d);
      return js_mkundef();
    }
  }

  ant_value_t str_elem = js_mkundef();
  if (sv_try_string_index_get(js, obj, key, &str_elem)) {
    vm->stack[vm->sp++] = str_elem;
    return js_mkundef();
  }

  ant_value_t res = sv_getprop_by_key(js, obj, key);
  if (is_err(res)) return res;
  vm->stack[vm->sp++] = res;
  return js_mkundef();
}

static inline ant_value_t sv_op_put_elem(sv_vm_t *vm, ant_t *js) {
  ant_value_t val = vm->stack[--vm->sp];
  ant_value_t key = vm->stack[--vm->sp];
  ant_value_t obj = vm->stack[--vm->sp];
  ant_value_t prop_key = sv_key_to_property_key(js, key);
  if (is_err(prop_key)) return prop_key;
  return js_setprop(js, obj, prop_key, val);
}

static inline bool sv_try_define_field_fast(
  ant_t *js,
  ant_value_t obj,
  const char *interned_key,
  ant_value_t val
) {
  if (!interned_key || !is_object_type(obj)) return false;

  ant_value_t as_obj = js_as_obj(obj);
  ant_object_t *ptr = js_obj_ptr(as_obj);
  if (!ptr || ptr->is_exotic || !ptr->shape) return false;
  if (ptr->type_tag == T_ARR) return false;
  if (ptr->frozen || ptr->sealed || !ptr->extensible) return false;

  int32_t slot = ant_shape_lookup_interned(ptr->shape, interned_key);
  if (slot >= 0) {
    uint32_t idx = (uint32_t)slot;
    if (idx >= ptr->prop_count) return false;
    const ant_shape_prop_t *prop = ant_shape_prop_at(ptr->shape, idx);
    if (!prop) return false;
    if (prop->type != ANT_SHAPE_KEY_STRING || prop->key.interned != interned_key) return false;
    if (prop->has_getter || prop->has_setter) return false;
    if (prop->attrs != ANT_PROP_ATTR_DEFAULT) return false;
    ant_object_prop_set_unchecked(ptr, idx, val);
    gc_write_barrier(js, ptr, val);
    return true;
  }

  return !is_err(mkprop_interned_exact(js, as_obj, interned_key, val, 0));
}

static inline void sv_op_define_field(
  sv_vm_t *vm, ant_t *js,
  sv_func_t *func, uint8_t *ip
) {
  uint32_t idx = sv_get_u32(ip + 1);
  sv_atom_t *a = &func->atoms[idx];
  ant_value_t val = vm->stack[--vm->sp];
  ant_value_t obj = vm->stack[vm->sp - 1];
  if (!sv_try_define_field_fast(js, obj, a->str, val))
    js_define_own_prop(js, obj, a->str, a->len, val);
}

static inline ant_value_t sv_op_get_length(sv_vm_t *vm, ant_t *js) {
  ant_value_t obj = vm->stack[--vm->sp];

  if (vtype(obj) == T_ARR) {
    vm->stack[vm->sp++] = tov((double)(uint32_t)js_arr_len(js, obj));
    return js_mkundef();
  }
  
  if (vtype(obj) == T_STR) {
    ant_flat_string_t *flat = ant_str_flat_ptr(obj);
    if (flat) {
      const char *str_data = flat->bytes;
      ant_offset_t byte_len = flat->len;
      vm->stack[vm->sp++] = tov((double)(uint32_t)(
        str_is_ascii(str_data) 
          ? byte_len 
          : utf16_strlen(str_data, byte_len)
      ));
      return js_mkundef();
    }

    ant_offset_t byte_len = 0;
    ant_offset_t off = vstr(js, obj, &byte_len);
    const char *str_data = (const char *)(uintptr_t)(off);
    vm->stack[vm->sp++] = tov((double)(uint32_t)utf16_strlen(str_data, byte_len));
    return js_mkundef();
  }

  ant_value_t res = js_getprop_fallback(js, obj, "length");
  if (is_err(res)) return res;
  
  vm->stack[vm->sp++] = res;
  return js_mkundef();
}

#endif