string_view 0.1.0 → 0.2.1

data/ext/string_view/string_view.c

@@ -1,45 +1,25 @@
-#include "ruby.h"
-#include "ruby/encoding.h"
-#include "ruby/re.h"
-#include "simdutf_c.h"
-
-#define SV_LIKELY(x)   __builtin_expect(!!(x), 1)
-#define SV_UNLIKELY(x) __builtin_expect(!!(x), 0)
-
-#ifdef __GNUC__
-#define SV_INLINE static inline __attribute__((always_inline))
-#else
-#define SV_INLINE static inline
-#endif
+#include "string_view.h"
 
 /* ========================================================================= */
-/* Struct & TypedData                                                        */
+/* Globals                                                                   */
 /* ========================================================================= */
 
-/*
- * Stride index: maps every STRIDE_CHARS-th character to its byte offset.
- * Built lazily on first char-indexed access. Enables O(1) char→byte
- * lookup for any offset (small scalar scan within one stride).
- */
-#define STRIDE_CHARS 128
-
-typedef struct {
-    long *offsets;   /* offsets[i] = byte offset of character i*STRIDE_CHARS */
-    long  count;     /* number of entries = ceil(charlen / STRIDE_CHARS) + 1 */
-} stride_index_t;
-
-typedef struct {
-    VALUE  backing;     /* frozen String that owns the bytes */
-    const char *base;   /* cached RSTRING_PTR(backing) — avoids indirection */
-    rb_encoding *enc;   /* cached encoding — avoids rb_enc_get per call */
-    long   offset;      /* byte offset into backing */
-    long   length;      /* byte length of this view */
-    long   charlen;     /* cached character count; -1 = not yet computed */
-    int    single_byte; /* cached: 1 if char==byte (ASCII/single-byte enc), 0 if multibyte, -1 unknown */
-    stride_index_t *stride_idx; /* lazily built stride index for multibyte, NULL if not built */
-} string_view_t;
-
-static VALUE cStringView;
+VALUE cStringView;
+VALUE cStringViewStrict;
+VALUE eWouldAllocate;
+
+/* Cached method IDs — initialized once in Init_string_view */
+static ID id_index, id_rindex, id_byteindex, id_byterindex;
+static ID id_match, id_match_p, id_match_op;
+static ID id_begin, id_aref;
+static ID id_upcase, id_downcase, id_capitalize, id_swapcase;
+static ID id_strip, id_lstrip, id_rstrip;
+static ID id_chomp, id_chop, id_reverse, id_squeeze;
+static ID id_encode, id_gsub, id_sub, id_tr, id_tr_s;
+static ID id_delete, id_count, id_scan, id_split;
+static ID id_center, id_ljust, id_rjust;
+static ID id_format_op, id_plus, id_multiply;
+static ID id_unpack1, id_scrub, id_unicode_normalize;
 
 /*
  * GC callbacks.
@@ -70,10 +50,7 @@ static void sv_compact(void *ptr) {
 
 static void sv_free(void *ptr) {
     string_view_t *sv = (string_view_t *)ptr;
-    if (sv->stride_idx) {
-        xfree(sv->stride_idx->offsets);
-        xfree(sv->stride_idx);
-    }
+    sv_clear_stride_index(sv);
 }
 
 static size_t sv_memsize(const void *ptr) {
@@ -85,14 +62,20 @@ static size_t sv_memsize(const void *ptr) {
     return size;
 }
 
-static const rb_data_type_t string_view_type = {
+const rb_data_type_t string_view_type = {
     .wrap_struct_name = "StringView",
     .function = { .dmark = sv_mark, .dfree = sv_free, .dsize = sv_memsize, .dcompact = sv_compact },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE | RUBY_TYPED_EMBEDDABLE,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_EMBEDDABLE,
 };
 
-/* Forward declarations */
-static int sv_compute_single_byte(VALUE backing, rb_encoding *enc);
+/* Forward declarations for functions defined later in this file */
+static long sv_char_count(string_view_t *sv);
+static long sv_char_to_byte_offset(string_view_t *sv, long char_idx);
+static long sv_char_count_partial(string_view_t *sv, const char *p, long len);
+SV_INLINE int sv_single_byte_optimizable(string_view_t *sv);
+SV_INLINE int sv_is_7bit(string_view_t *sv);
+SV_INLINE int sv_is_utf8(string_view_t *sv);
+static long sv_utf8_char_count(const char *p, long len);
 
 /* ========================================================================= */
 /* Internal helpers                                                          */
@@ -122,10 +105,12 @@ static VALUE sv_as_shared_str(string_view_t *sv) {
     return shared;
 }
 
-/* Allocate a new StringView from a parent that already has cached base/enc */
-SV_INLINE VALUE sv_new_from_parent(string_view_t *parent, long offset, long length) {
+/* Allocate a new StringView from a parent that already has cached base/enc.
+ * Preserves the class of parent_obj (StringView or StringView::Strict). */
+SV_INLINE VALUE sv_new_from_parent_obj(VALUE parent_obj, string_view_t *parent, long offset, long length) {
     string_view_t *sv;
-    VALUE obj = TypedData_Make_Struct(cStringView, string_view_t,
+    VALUE klass = rb_obj_class(parent_obj);
+    VALUE obj = TypedData_Make_Struct(klass, string_view_t,
                                      &string_view_type, sv);
     RB_OBJ_WRITE(obj, &sv->backing, parent->backing);
     sv->base        = parent->base;
@@ -133,9 +118,11 @@ SV_INLINE VALUE sv_new_from_parent(string_view_t *parent, long offset, long leng
     sv->offset      = offset;
     sv->length      = length;
     sv->single_byte = parent->single_byte;
+    sv->valid_encoding = sv->single_byte == 1 ? 1 : -1;
+    sv->pooled      = 0;
     sv->charlen     = -1;
     sv->stride_idx  = NULL;
-    FL_SET_RAW(obj, FL_FREEZE);
+    /* Not frozen — see sv_initialize comment for rationale */
     return obj;
 }
 
@@ -154,6 +141,8 @@ static VALUE sv_alloc(VALUE klass) {
     sv->offset      = 0;
     sv->length      = 0;
     sv->single_byte = -1;
+    sv->valid_encoding = -1;
+    sv->pooled      = 0;
     sv->charlen     = -1;
     sv->stride_idx  = NULL;
     return obj;
@@ -169,13 +158,7 @@ static VALUE sv_initialize(int argc, VALUE *argv, VALUE self) {
 
     rb_scan_args(argc, argv, "12", &str, &voffset, &vlength);
 
-    if (!RB_TYPE_P(str, T_STRING)) {
-        rb_raise(rb_eTypeError,
-                 "no implicit conversion of %s into String",
-                 rb_obj_classname(str));
-    }
-
-    rb_str_freeze(str);
+    sv_check_frozen_string(str);
 
     long backing_len = RSTRING_LEN(str);
 
@@ -185,26 +168,20 @@ static VALUE sv_initialize(int argc, VALUE *argv, VALUE self) {
     } else {
         offset = NUM2LONG(voffset);
         length = NUM2LONG(vlength);
-
-        if (offset < 0 || length < 0 || offset + length > backing_len) {
-            rb_raise(rb_eArgError,
-                     "offset %ld, length %ld out of range for string of bytesize %ld",
-                     offset, length, backing_len);
-        }
+        sv_check_bounds(offset, length, backing_len);
     }
 
     string_view_t *sv = sv_get_struct(self);
-    rb_encoding *enc = rb_enc_get(str);
-    RB_OBJ_WRITE(self, &sv->backing, str);
-    sv->base        = RSTRING_PTR(str);
-    sv->enc         = enc;
-    sv->offset      = offset;
-    sv->length      = length;
-    sv->single_byte = sv_compute_single_byte(str, enc);
-    sv->charlen     = -1;
-    sv->stride_idx  = NULL;
+    sv_init_fields(self, sv, str, RSTRING_PTR(str), rb_enc_get(str),
+                   offset, length);
 
-    rb_obj_freeze(self);
+    /*
+     * We intentionally do NOT freeze self. StringView blocks content
+     * mutation via the immutable frozen backing and explicit FrozenError
+     * on bang methods. Not freezing allows reset! to work without
+     * violating Ruby's frozen? contract — libraries and Ruby itself
+     * use frozen? to assume immutability for hash keys and Ractor sharing.
+     */
 
     return self;
 }
@@ -236,43 +213,29 @@ static VALUE sv_inspect(VALUE self) {
                       (void *)self, content, sv->offset, sv->length);
 }
 
-static VALUE sv_frozen_p(VALUE self) {
-    return Qtrue;
-}
-
 /*
  * reset!(new_backing, byte_offset, byte_length) -> self
  */
 static VALUE sv_reset(VALUE self, VALUE new_backing, VALUE voffset, VALUE vlength) {
+    rb_check_frozen(self);
     string_view_t *sv = sv_get_struct(self);
 
-    if (!RB_TYPE_P(new_backing, T_STRING)) {
-        rb_raise(rb_eTypeError,
-                 "no implicit conversion of %s into String",
-                 rb_obj_classname(new_backing));
+    if (SV_UNLIKELY(sv->pooled)) {
+        rb_raise(rb_eRuntimeError,
+                 "can't reset a pooled StringView directly; call StringView::Pool#reset! instead");
     }
 
-    rb_str_freeze(new_backing);
+    sv_check_frozen_string(new_backing);
 
     long off = NUM2LONG(voffset);
     long len = NUM2LONG(vlength);
-    long backing_len = RSTRING_LEN(new_backing);
+    sv_check_bounds(off, len, RSTRING_LEN(new_backing));
 
-    if (off < 0 || len < 0 || off + len > backing_len) {
-        rb_raise(rb_eArgError,
-                 "offset %ld, length %ld out of range for string of bytesize %ld",
-                 off, len, backing_len);
-    }
+    /* Free old stride index before reinitializing */
+    sv_clear_stride_index(sv);
 
-    rb_encoding *enc = rb_enc_get(new_backing);
-    RB_OBJ_WRITE(self, &sv->backing, new_backing);
-    sv->base        = RSTRING_PTR(new_backing);
-    sv->enc         = enc;
-    sv->offset      = off;
-    sv->length      = len;
-    sv->single_byte = sv_compute_single_byte(new_backing, enc);
-    sv->charlen     = -1;
-    sv->stride_idx  = NULL;
+    sv_init_fields(self, sv, new_backing, RSTRING_PTR(new_backing),
+                   rb_enc_get(new_backing), off, len);
 
     return self;
 }
@@ -306,6 +269,8 @@ static VALUE sv_encoding(VALUE self) {
 
 static VALUE sv_ascii_only_p(VALUE self) {
     string_view_t *sv = sv_get_struct(self);
+    if (sv_single_byte_optimizable(sv)) return Qtrue;
+    /* single_byte resolved to 0 (multibyte) — scan to confirm non-ASCII bytes */
     const char *p = sv_ptr(sv);
     long i;
     for (i = 0; i < sv->length; i++) {
@@ -314,6 +279,94 @@ static VALUE sv_ascii_only_p(VALUE self) {
     return Qtrue;
 }
 
+SV_INLINE long sv_precise_char_len(const char *p, const char *e, rb_encoding *enc) {
+    int len = rb_enc_precise_mbclen(p, e, enc);
+    if (MBCLEN_CHARFOUND_P(len)) return MBCLEN_CHARFOUND_LEN(len);
+    return 1;
+}
+
+static int sv_compute_valid_encoding_slice(string_view_t *sv) {
+    if (sv_single_byte_optimizable(sv)) return 1;
+
+    if (SV_LIKELY(sv_is_utf8(sv))) {
+        return simdutf_validate_utf8(sv_ptr(sv), (size_t)sv->length) ? 1 : 0;
+    }
+
+    rb_encoding *enc = sv_enc(sv);
+    const char *p = sv_ptr(sv);
+    const char *e = p + sv->length;
+
+    while (p < e) {
+        int len = rb_enc_precise_mbclen(p, e, enc);
+        if (!MBCLEN_CHARFOUND_P(len)) return 0;
+        p += MBCLEN_CHARFOUND_LEN(len);
+    }
+
+    return 1;
+}
+
+SV_INLINE int sv_valid_encoding_cached(string_view_t *sv) {
+    if (SV_LIKELY(sv->valid_encoding >= 0)) return sv->valid_encoding;
+    sv->valid_encoding = sv_compute_valid_encoding_slice(sv);
+    return sv->valid_encoding;
+}
+
+static long sv_tolerant_char_count(const char *p, const char *e, rb_encoding *enc) {
+    long count = 0;
+
+    while (p < e) {
+        p += sv_precise_char_len(p, e, enc);
+        count++;
+    }
+
+    return count;
+}
+
+static long sv_tolerant_char_to_byte_offset(string_view_t *sv, long char_idx) {
+    rb_encoding *enc = sv_enc(sv);
+    const char *p = sv_ptr(sv);
+    const char *e = p + sv->length;
+    const char *start = p;
+    long i = 0;
+
+    while (i < char_idx && p < e) {
+        p += sv_precise_char_len(p, e, enc);
+        i++;
+    }
+
+    if (i < char_idx) return -1;
+    return p - start;
+}
+
+static long sv_tolerant_chars_to_bytes(string_view_t *sv, long byte_off, long n) {
+    rb_encoding *enc = sv_enc(sv);
+    const char *start = sv_ptr(sv) + byte_off;
+    const char *p = start;
+    const char *e = sv_ptr(sv) + sv->length;
+    long i = 0;
+
+    while (i < n && p < e) {
+        p += sv_precise_char_len(p, e, enc);
+        i++;
+    }
+
+    return p - start;
+}
+
+SV_INLINE void sv_check_compatible_string(string_view_t *sv, VALUE other) {
+    rb_encoding *oenc = rb_enc_get(other);
+
+    if (sv->enc == oenc) return;
+    if (rb_enc_asciicompat(sv->enc) && rb_enc_asciicompat(oenc) &&
+        (sv_is_7bit(sv) || rb_enc_str_asciionly_p(other))) {
+        return;
+    }
+
+    rb_raise(rb_eEncCompatError,
+             "incompatible character encodings: %s and %s",
+             rb_enc_name(sv->enc), rb_enc_name(oenc));
+}
+
 /* ========================================================================= */
 /* Tier 1: Searching                                                         */
 /* ========================================================================= */
@@ -324,6 +377,7 @@ static VALUE sv_include_p(VALUE self, VALUE substr) {
     const char *p = sv_ptr(sv);
     long slen = RSTRING_LEN(substr);
     if (slen == 0) return Qtrue;
+    sv_check_compatible_string(sv, substr);
     if (slen > sv->length) return Qfalse;
 
     long pos = rb_memsearch(RSTRING_PTR(substr), slen, p, sv->length, sv_enc(sv));
@@ -339,6 +393,8 @@ static VALUE sv_start_with_p(int argc, VALUE *argv, VALUE self) {
         VALUE prefix = argv[i];
         StringValue(prefix);
         long plen = RSTRING_LEN(prefix);
+        if (plen == 0) return Qtrue;
+        sv_check_compatible_string(sv, prefix);
         if (plen > sv->length) continue;
         if (memcmp(p, RSTRING_PTR(prefix), plen) == 0) return Qtrue;
     }
@@ -354,6 +410,8 @@ static VALUE sv_end_with_p(int argc, VALUE *argv, VALUE self) {
         VALUE suffix = argv[i];
         StringValue(suffix);
         long slen = RSTRING_LEN(suffix);
+        if (slen == 0) return Qtrue;
+        sv_check_compatible_string(sv, suffix);
         if (slen > sv->length) continue;
         if (memcmp(p + sv->length - slen, RSTRING_PTR(suffix), slen) == 0)
             return Qtrue;
@@ -361,16 +419,127 @@ static VALUE sv_end_with_p(int argc, VALUE *argv, VALUE self) {
     return Qfalse;
 }
 
-static VALUE sv_index(int argc, VALUE *argv, VALUE self) {
+/*
+ * index(substring[, offset]) → Integer or nil
+ *
+ * For String arguments: native zero-alloc implementation using rb_memsearch.
+ * For Regexp arguments: delegates to String#index via shared string.
+ */
+VALUE sv_index(int argc, VALUE *argv, VALUE self) {
     string_view_t *sv = sv_get_struct(self);
-    VALUE shared = sv_as_shared_str(sv);
-    return rb_funcallv(shared, rb_intern("index"), argc, argv);
+    VALUE pattern, voffset;
+    rb_scan_args(argc, argv, "11", &pattern, &voffset);
+
+    /* Regexp path: delegate via shared string */
+    if (rb_obj_is_kind_of(pattern, rb_cRegexp)) {
+        VALUE shared = sv_as_shared_str(sv);
+        return rb_funcallv(shared, id_index, argc, argv);
+    }
+
+    StringValue(pattern);
+    const char *p = sv_ptr(sv);
+    long plen = RSTRING_LEN(pattern);
+
+    /* Determine starting char offset */
+    long char_off = NIL_P(voffset) ? 0 : NUM2LONG(voffset);
+    long total_chars = sv_char_count(sv);
+
+    if (char_off < 0) char_off += total_chars;
+    if (char_off < 0 || char_off > total_chars) return Qnil;
+    if (plen == 0) return LONG2NUM(char_off);
+    sv_check_compatible_string(sv, pattern);
+
+    /* Convert char offset to byte offset */
+    long byte_off = sv_char_to_byte_offset(sv, char_off);
+    if (byte_off < 0) return Qnil;
+
+    if (plen > sv->length - byte_off) return Qnil;
+
+    long pos = rb_memsearch(RSTRING_PTR(pattern), plen,
+                             p + byte_off, sv->length - byte_off,
+                             sv_enc(sv));
+    if (pos < 0 || pos > sv->length - byte_off - plen) return Qnil;
+
+    /* Convert byte position back to character position */
+    if (sv_single_byte_optimizable(sv)) {
+        return LONG2NUM(char_off + pos);
+    }
+
+    return LONG2NUM(char_off + sv_char_count_partial(sv, p + byte_off, pos));
 }
 
-static VALUE sv_rindex(int argc, VALUE *argv, VALUE self) {
+/*
+ * rindex(substring[, offset]) → Integer or nil
+ *
+ * For String arguments: native zero-alloc reverse search.
+ * For Regexp arguments: delegates to String#rindex via shared string.
+ */
+VALUE sv_rindex(int argc, VALUE *argv, VALUE self) {
     string_view_t *sv = sv_get_struct(self);
-    VALUE shared = sv_as_shared_str(sv);
-    return rb_funcallv(shared, rb_intern("rindex"), argc, argv);
+    VALUE pattern, voffset;
+    rb_scan_args(argc, argv, "11", &pattern, &voffset);
+
+    /* Regexp path: delegate */
+    if (rb_obj_is_kind_of(pattern, rb_cRegexp)) {
+        VALUE shared = sv_as_shared_str(sv);
+        return rb_funcallv(shared, id_rindex, argc, argv);
+    }
+
+    StringValue(pattern);
+    const char *p = sv_ptr(sv);
+    long plen = RSTRING_LEN(pattern);
+    long total_chars = sv_char_count(sv);
+
+    /* Determine the maximum char position to search from */
+    long max_char;
+    if (NIL_P(voffset)) {
+        max_char = total_chars;
+    } else {
+        max_char = NUM2LONG(voffset);
+        if (max_char < 0) max_char += total_chars;
+        if (max_char < 0) return Qnil;
+        if (max_char > total_chars) max_char = total_chars;
+    }
+
+    if (plen == 0) {
+        return LONG2NUM(max_char > total_chars ? total_chars : max_char);
+    }
+    sv_check_compatible_string(sv, pattern);
+    if (plen > sv->length) return Qnil;
+
+    /* Convert max_char to a byte limit */
+    long max_byte = sv_char_to_byte_offset(sv, max_char);
+    if (max_byte < 0) max_byte = sv->length;
+
+    /* Ensure we don't search past the point where the pattern can't fit */
+    long search_end = max_byte;
+    if (search_end + plen > sv->length) {
+        search_end = sv->length - plen;
+    }
+
+    /* Reverse byte search */
+    const char *needle = RSTRING_PTR(pattern);
+    const char *s;
+    for (s = p + search_end; s >= p; ) {
+        if (memcmp(s, needle, plen) == 0) {
+            long byte_pos = s - p;
+            /* Convert byte position to char position */
+            if (sv_single_byte_optimizable(sv)) {
+                return LONG2NUM(byte_pos);
+            }
+            return LONG2NUM(sv_char_count_partial(sv, p, byte_pos));
+        }
+        /* Move back one character */
+        if (s == p) break;
+        if (sv_single_byte_optimizable(sv)) {
+            s--;
+        } else {
+            rb_encoding *enc = sv_enc(sv);
+            s = rb_enc_prev_char(p, s, p + sv->length, enc);
+            if (s == NULL) break;
+        }
+    }
+    return Qnil;
 }
 
 static VALUE sv_getbyte(VALUE self, VALUE vidx) {
@@ -381,16 +550,85 @@ static VALUE sv_getbyte(VALUE self, VALUE vidx) {
     return INT2FIX((unsigned char)sv_ptr(sv)[idx]);
 }
 
-static VALUE sv_byteindex(int argc, VALUE *argv, VALUE self) {
+/*
+ * byteindex(substring[, offset]) → Integer or nil
+ *
+ * For String arguments: native zero-alloc byte-level search.
+ * For Regexp arguments: delegates to String#byteindex via shared string.
+ */
+VALUE sv_byteindex(int argc, VALUE *argv, VALUE self) {
     string_view_t *sv = sv_get_struct(self);
-    VALUE shared = sv_as_shared_str(sv);
-    return rb_funcallv(shared, rb_intern("byteindex"), argc, argv);
+    VALUE pattern, voffset;
+    rb_scan_args(argc, argv, "11", &pattern, &voffset);
+
+    if (rb_obj_is_kind_of(pattern, rb_cRegexp)) {
+        VALUE shared = sv_as_shared_str(sv);
+        return rb_funcallv(shared, id_byteindex, argc, argv);
+    }
+
+    StringValue(pattern);
+    const char *p = sv_ptr(sv);
+    long plen = RSTRING_LEN(pattern);
+    long byte_off = NIL_P(voffset) ? 0 : NUM2LONG(voffset);
+
+    if (byte_off < 0) byte_off += sv->length;
+    if (byte_off < 0 || byte_off > sv->length) return Qnil;
+    if (plen == 0) return LONG2NUM(byte_off);
+    sv_check_compatible_string(sv, pattern);
+    if (plen > sv->length - byte_off) return Qnil;
+
+    long pos = rb_memsearch(RSTRING_PTR(pattern), plen,
+                             p + byte_off, sv->length - byte_off,
+                             sv_enc(sv));
+    if (pos < 0 || pos > sv->length - byte_off - plen) return Qnil;
+    return LONG2NUM(byte_off + pos);
 }
 
-static VALUE sv_byterindex(int argc, VALUE *argv, VALUE self) {
+/*
+ * byterindex(substring[, offset]) → Integer or nil
+ *
+ * For String arguments: native zero-alloc reverse byte-level search.
+ * For Regexp arguments: delegates to String#byterindex via shared string.
+ */
+VALUE sv_byterindex(int argc, VALUE *argv, VALUE self) {
     string_view_t *sv = sv_get_struct(self);
-    VALUE shared = sv_as_shared_str(sv);
-    return rb_funcallv(shared, rb_intern("byterindex"), argc, argv);
+    VALUE pattern, voffset;
+    rb_scan_args(argc, argv, "11", &pattern, &voffset);
+
+    if (rb_obj_is_kind_of(pattern, rb_cRegexp)) {
+        VALUE shared = sv_as_shared_str(sv);
+        return rb_funcallv(shared, id_byterindex, argc, argv);
+    }
+
+    StringValue(pattern);
+    const char *p = sv_ptr(sv);
+    long plen = RSTRING_LEN(pattern);
+    long max_byte;
+
+    if (NIL_P(voffset)) {
+        max_byte = sv->length;
+    } else {
+        max_byte = NUM2LONG(voffset);
+        if (max_byte < 0) max_byte += sv->length;
+        if (max_byte < 0) return Qnil;
+        if (max_byte > sv->length) max_byte = sv->length;
+    }
+
+    if (plen == 0) return LONG2NUM(max_byte > sv->length ? sv->length : max_byte);
+    sv_check_compatible_string(sv, pattern);
+    if (plen > sv->length) return Qnil;
+
+    long search_end = max_byte;
+    if (search_end + plen > sv->length) search_end = sv->length - plen;
+
+    const char *needle = RSTRING_PTR(pattern);
+    long i;
+    for (i = search_end; i >= 0; i--) {
+        if (memcmp(p + i, needle, plen) == 0) {
+            return LONG2NUM(i);
+        }
+    }
+    return Qnil;
 }
 
 /* ========================================================================= */
@@ -454,19 +692,19 @@ static VALUE sv_chars(VALUE self) {
 static VALUE sv_match(int argc, VALUE *argv, VALUE self) {
     string_view_t *sv = sv_get_struct(self);
     VALUE shared = sv_as_shared_str(sv);
-    return rb_funcallv(shared, rb_intern("match"), argc, argv);
+    return rb_funcallv(shared, id_match, argc, argv);
 }
 
 static VALUE sv_match_p(int argc, VALUE *argv, VALUE self) {
     string_view_t *sv = sv_get_struct(self);
     VALUE shared = sv_as_shared_str(sv);
-    return rb_funcallv(shared, rb_intern("match?"), argc, argv);
+    return rb_funcallv(shared, id_match_p, argc, argv);
 }
 
 static VALUE sv_match_operator(VALUE self, VALUE pattern) {
     string_view_t *sv = sv_get_struct(self);
     VALUE shared = sv_as_shared_str(sv);
-    return rb_funcall(shared, rb_intern("=~"), 1, pattern);
+    return rb_funcall(shared, id_match_op, 1, pattern);
 }
 
 /* ========================================================================= */
@@ -485,6 +723,11 @@ typedef struct {
     char *ptr;
 } sv_cstr_t;
 
+typedef struct {
+    sv_cstr_t *cs;
+    int base;
+} sv_inum_args_t;
+
 SV_INLINE void sv_cstr_init(sv_cstr_t *cs, string_view_t *sv) {
     const char *p = sv_ptr(sv);
     long len = sv->length;
@@ -505,6 +748,22 @@ SV_INLINE void sv_cstr_free(sv_cstr_t *cs) {
     }
 }
 
+static VALUE sv_cstr_free_ensure(VALUE arg) {
+    sv_cstr_free((sv_cstr_t *)arg);
+    return Qnil;
+}
+
+static VALUE sv_to_i_body(VALUE arg) {
+    sv_inum_args_t *args = (sv_inum_args_t *)arg;
+    return rb_cstr_to_inum(args->cs->ptr, args->base, 0);
+}
+
+static VALUE sv_to_f_body(VALUE arg) {
+    sv_cstr_t *cs = (sv_cstr_t *)arg;
+    double d = rb_cstr_to_dbl(cs->ptr, 0);
+    return DBL2NUM(d);
+}
+
 /*
  * to_i([base]) — parse integer directly from byte pointer, zero allocations.
  * Uses rb_cstr_to_inum which parses from a NUL-terminated C string.
@@ -515,10 +774,12 @@ static VALUE sv_to_i(int argc, VALUE *argv, VALUE self) {
     if (argc > 0) base = NUM2INT(argv[0]);
 
     sv_cstr_t cs;
+    sv_inum_args_t args;
     sv_cstr_init(&cs, sv);
-    VALUE result = rb_cstr_to_inum(cs.ptr, base, 0);
-    sv_cstr_free(&cs);
-    return result;
+    args.cs = &cs;
+    args.base = base;
+    return rb_ensure(sv_to_i_body, (VALUE)&args,
+                     sv_cstr_free_ensure, (VALUE)&cs);
 }
 
 /*
@@ -528,9 +789,8 @@ static VALUE sv_to_f(VALUE self) {
     string_view_t *sv = sv_get_struct(self);
     sv_cstr_t cs;
     sv_cstr_init(&cs, sv);
-    double d = rb_cstr_to_dbl(cs.ptr, 0);
-    sv_cstr_free(&cs);
-    return DBL2NUM(d);
+    return rb_ensure(sv_to_f_body, (VALUE)&cs,
+                     sv_cstr_free_ensure, (VALUE)&cs);
 }
 
 /*
@@ -539,10 +799,12 @@ static VALUE sv_to_f(VALUE self) {
 static VALUE sv_hex(VALUE self) {
     string_view_t *sv = sv_get_struct(self);
     sv_cstr_t cs;
+    sv_inum_args_t args;
     sv_cstr_init(&cs, sv);
-    VALUE result = rb_cstr_to_inum(cs.ptr, 16, 0);
-    sv_cstr_free(&cs);
-    return result;
+    args.cs = &cs;
+    args.base = 16;
+    return rb_ensure(sv_to_i_body, (VALUE)&args,
+                     sv_cstr_free_ensure, (VALUE)&cs);
 }
 
 /*
@@ -551,16 +813,52 @@ static VALUE sv_hex(VALUE self) {
 static VALUE sv_oct(VALUE self) {
     string_view_t *sv = sv_get_struct(self);
     sv_cstr_t cs;
+    sv_inum_args_t args;
     sv_cstr_init(&cs, sv);
-    VALUE result = rb_cstr_to_inum(cs.ptr, 8, 0);
-    sv_cstr_free(&cs);
-    return result;
+    args.cs = &cs;
+    args.base = 8;
+    return rb_ensure(sv_to_i_body, (VALUE)&args,
+                     sv_cstr_free_ensure, (VALUE)&cs);
 }
 
 /* ========================================================================= */
 /* Tier 1: Comparison                                                        */
 /* ========================================================================= */
 
+/*
+ * Returns 1 if all bytes in the view are < 128 (7-bit ASCII).
+ * Uses the single_byte cache when available.
+ */
+SV_INLINE int sv_is_7bit(string_view_t *sv) {
+    const unsigned char *p = (const unsigned char *)sv_ptr(sv);
+    long i;
+    for (i = 0; i < sv->length; i++) {
+        if (p[i] > 127) return 0;
+    }
+    return 1;
+}
+
+/*
+ * Check encoding compatibility for equality, mirroring Ruby's String#==.
+ * Two encodings are compatible for comparison if:
+ *   - They are the same encoding, OR
+ *   - Both are ASCII-compatible and at least one side is 7-bit
+ *     (e.g. UTF-8 "hello" == US-ASCII "hello")
+ */
+SV_INLINE int sv_enc_compatible_for_eq(
+    rb_encoding *enc1, int is_7bit_1,
+    rb_encoding *enc2, int is_7bit_2)
+{
+    if (enc1 == enc2) return 1;
+    if (!rb_enc_asciicompat(enc1) || !rb_enc_asciicompat(enc2)) return 0;
+    return is_7bit_1 || is_7bit_2;
+}
+
+SV_INLINE int sv_is_string_view(VALUE obj) {
+    VALUE klass = rb_obj_class(obj);
+    return klass == cStringView || klass == cStringViewStrict;
+}
+
 static VALUE sv_eq(VALUE self, VALUE other) {
     string_view_t *sv = sv_get_struct(self);
     const char *p = sv_ptr(sv);
@@ -568,13 +866,26 @@ static VALUE sv_eq(VALUE self, VALUE other) {
     /* Fast path: String is the most common comparison target */
     if (SV_LIKELY(RB_TYPE_P(other, T_STRING))) {
         if (sv->length != RSTRING_LEN(other)) return Qfalse;
+        rb_encoding *oenc = rb_enc_get(other);
+        if (sv->enc != oenc) {
+            int sv_7bit = sv_is_7bit(sv);
+            int o_7bit = rb_enc_str_asciionly_p(other);
+            if (!sv_enc_compatible_for_eq(sv->enc, sv_7bit, oenc, o_7bit))
+                return Qfalse;
+        }
         return memcmp(p, RSTRING_PTR(other), sv->length) == 0 ? Qtrue : Qfalse;
     }
 
-    /* Check for StringView via class pointer (faster than rb_obj_is_kind_of) */
-    if (rb_obj_class(other) == cStringView) {
+    /* Check for StringView or StringView::Strict */
+    if (sv_is_string_view(other)) {
         string_view_t *o = sv_get_struct(other);
         if (sv->length != o->length) return Qfalse;
+        if (sv->enc != o->enc) {
+            int sv_7bit = sv_is_7bit(sv);
+            int o_7bit = sv_is_7bit(o);
+            if (!sv_enc_compatible_for_eq(sv->enc, sv_7bit, o->enc, o_7bit))
+                return Qfalse;
+        }
         return memcmp(p, sv_ptr(o), sv->length) == 0 ? Qtrue : Qfalse;
     }
 
@@ -590,7 +901,7 @@ static VALUE sv_cmp(VALUE self, VALUE other) {
     if (SV_LIKELY(RB_TYPE_P(other, T_STRING))) {
         op = RSTRING_PTR(other);
         olen = RSTRING_LEN(other);
-    } else if (rb_obj_class(other) == cStringView) {
+    } else if (sv_is_string_view(other)) {
         string_view_t *o = sv_get_struct(other);
         op = sv_ptr(o);
         olen = o->length;
@@ -610,15 +921,22 @@ static VALUE sv_cmp(VALUE self, VALUE other) {
 }
 
 static VALUE sv_eql_p(VALUE self, VALUE other) {
-    if (rb_obj_class(other) != cStringView) return Qfalse;
+    if (!sv_is_string_view(other)) return Qfalse;
     return sv_eq(self, other);
 }
 
 static VALUE sv_hash(VALUE self) {
     string_view_t *sv = sv_get_struct(self);
     const char *p = sv_ptr(sv);
+    /*
+     * Mirror CRuby's rb_str_hash: normalize encoding index to 0 for
+     * 7-bit content so that e.g. UTF-8 "hello" and US-ASCII "hello"
+     * produce the same hash (they compare equal via sv_eq).
+     */
+    int e = rb_enc_to_index(sv->enc);
+    if (e && sv_is_7bit(sv)) e = 0;
     st_index_t h = rb_memhash(p, sv->length);
-    h ^= (st_index_t)rb_enc_get_index(sv->backing);
+    h ^= (st_index_t)e;
     return ST2FIX(h);
 }
 
@@ -636,13 +954,17 @@ static VALUE sv_hash(VALUE self) {
  * Compute single-byte flag from encoding + coderange.
  * Called once at construction time and cached in sv->single_byte.
  */
-static int sv_compute_single_byte(VALUE backing, rb_encoding *enc) {
+int sv_compute_single_byte(VALUE backing, rb_encoding *enc) {
     if (rb_enc_mbmaxlen(enc) == 1) return 1;
     int cr = ENC_CODERANGE(backing);
     if (cr == ENC_CODERANGE_7BIT) return 1;
-    /* For VALID (known multibyte) we know it's not single-byte */
-    if (cr == ENC_CODERANGE_VALID) return 0;
-    /* UNKNOWN: we don't know yet — return -1 (will be resolved lazily) */
+    /*
+     * For VALID and UNKNOWN: the coderange reflects the entire backing
+     * string, not this slice. A view over an ASCII-only prefix of a
+     * multibyte string would incorrectly get single_byte=0 here.
+     * Return -1 (unknown) and let sv_single_byte_optimizable resolve
+     * it lazily by scanning the actual slice bytes.
+     */
     return -1;
 }
 
@@ -801,22 +1123,11 @@ static long sv_char_to_byte_offset(string_view_t *sv, long char_idx) {
         return char_idx;
     }
 
-    if (SV_LIKELY(sv_is_utf8(sv))) {
+    if (SV_LIKELY(sv_is_utf8(sv)) && sv_valid_encoding_cached(sv)) {
         return sv_utf8_char_to_byte_offset_indexed(sv, char_idx);
     }
 
-    rb_encoding *enc = sv_enc(sv);
-    const char *p = sv_ptr(sv);
-    const char *e = p + sv->length;
-    const char *start = p;
-    long i;
-
-    for (i = 0; i < char_idx && p < e; i++) {
-        p += rb_enc_fast_mbclen(p, e, enc);
-    }
-
-    if (i < char_idx) return -1;
-    return p - start;
+    return sv_tolerant_char_to_byte_offset(sv, char_idx);
 }
 
 static long sv_char_count(string_view_t *sv) {
@@ -826,12 +1137,11 @@ static long sv_char_count(string_view_t *sv) {
     long count;
     if (sv_single_byte_optimizable(sv)) {
         count = sv->length;
-    } else if (SV_LIKELY(sv_is_utf8(sv))) {
+    } else if (SV_LIKELY(sv_is_utf8(sv)) && sv_valid_encoding_cached(sv)) {
         count = sv_utf8_char_count(sv_ptr(sv), sv->length);
     } else {
-        rb_encoding *enc = sv_enc(sv);
-        const char *p = sv_ptr(sv);
-        count = rb_enc_strlen(p, p + sv->length, enc);
+        count = sv_tolerant_char_count(sv_ptr(sv), sv_ptr(sv) + sv->length,
+                                       sv_enc(sv));
     }
 
     sv->charlen = count;
@@ -844,20 +1154,20 @@ static long sv_chars_to_bytes(string_view_t *sv, long byte_off, long n) {
         return n < remaining ? n : remaining;
     }
 
-    if (SV_LIKELY(sv_is_utf8(sv))) {
+    if (SV_LIKELY(sv_is_utf8(sv)) && sv_valid_encoding_cached(sv)) {
         return sv_utf8_chars_to_bytes(sv_ptr(sv), sv->length, byte_off, n);
     }
 
-    rb_encoding *enc = sv_enc(sv);
-    const char *p = sv_ptr(sv) + byte_off;
-    const char *e = sv_ptr(sv) + sv->length;
-    long i;
-    const char *start = p;
+    return sv_tolerant_chars_to_bytes(sv, byte_off, n);
+}
 
-    for (i = 0; i < n && p < e; i++) {
-        p += rb_enc_fast_mbclen(p, e, enc);
+static long sv_char_count_partial(string_view_t *sv, const char *p, long len) {
+    if (len <= 0) return 0;
+    if (sv_single_byte_optimizable(sv)) return len;
+    if (SV_LIKELY(sv_is_utf8(sv)) && sv_valid_encoding_cached(sv)) {
+        return sv_utf8_char_count(p, len);
     }
-    return p - start;
+    return sv_tolerant_char_count(p, p + len, sv_enc(sv));
 }
 
 static VALUE sv_aref(int argc, VALUE *argv, VALUE self) {
@@ -879,8 +1189,8 @@ static VALUE sv_aref(int argc, VALUE *argv, VALUE self) {
             long total = sv->length;
             if (idx < 0) idx += total;
             if (SV_UNLIKELY(idx < 0 || idx > total || len < 0)) return Qnil;
-            if (idx + len > total) len = total - idx;
-            return sv_new_from_parent(sv,
+            if (len > total - idx) len = total - idx;
+            return sv_new_from_parent_obj(self, sv,
                                        sv->offset + idx,
                                        len);
         }
@@ -901,12 +1211,12 @@ static VALUE sv_aref(int argc, VALUE *argv, VALUE self) {
 
         /* Clamp len to remaining characters */
         long total_chars = sv_char_count(sv);
-        if (idx + len > total_chars) len = total_chars - idx;
+        if (len > total_chars - idx) len = total_chars - idx;
 
         long byte_end = sv_char_to_byte_offset(sv, idx + len);
         long byte_len = byte_end - byte_off;
 
-        return sv_new_from_parent(sv,
+        return sv_new_from_parent_obj(self, sv,
                                    sv->offset + byte_off,
                                    byte_len);
     }
@@ -914,48 +1224,34 @@ static VALUE sv_aref(int argc, VALUE *argv, VALUE self) {
     if (rb_obj_is_kind_of(arg1, rb_cRange)) {
         long total_chars = sv_char_count(sv);
         long beg, len;
-        int excl;
-        VALUE rb_beg = rb_funcall(arg1, rb_intern("begin"), 0);
-        VALUE rb_end = rb_funcall(arg1, rb_intern("end"), 0);
-        excl = RTEST(rb_funcall(arg1, rb_intern("exclude_end?"), 0));
-
-        beg = NIL_P(rb_beg) ? 0 : NUM2LONG(rb_beg);
-        if (beg < 0) beg += total_chars;
-        if (beg < 0) return Qnil;
-
-        long e;
-        if (NIL_P(rb_end)) {
-            e = total_chars;
-        } else {
-            e = NUM2LONG(rb_end);
-            if (e < 0) e += total_chars;
-            if (!excl) e += 1;
+
+        /* rb_range_beg_len resolves negative indices and clamps to total,
+         * replacing 3 Ruby method dispatches with a single C call. */
+        switch (rb_range_beg_len(arg1, &beg, &len, total_chars, 1)) {
+        case Qfalse: return Qnil;
+        case Qnil:   return Qnil;
         }
-        if (e < beg) e = beg;
-        len = e - beg;
-        if (beg > total_chars) return Qnil;
-        if (beg + len > total_chars) len = total_chars - beg;
 
         long byte_off = sv_char_to_byte_offset(sv, beg);
         long byte_len = sv_chars_to_bytes(sv, byte_off, len);
 
-        return sv_new_from_parent(sv,
+        return sv_new_from_parent_obj(self, sv,
                                    sv->offset + byte_off,
                                    byte_len);
     }
 
     if (rb_obj_is_kind_of(arg1, rb_cRegexp)) {
         VALUE shared = sv_as_shared_str(sv);
-        VALUE m = rb_funcall(arg1, rb_intern("match"), 1, shared);
+        VALUE m = rb_funcall(arg1, id_match, 1, shared);
         if (NIL_P(m)) return Qnil;
 
-        VALUE matched = rb_funcall(m, rb_intern("[]"), 1, INT2FIX(0));
-        long match_beg = NUM2LONG(rb_funcall(m, rb_intern("begin"), 1, INT2FIX(0)));
+        VALUE matched = rb_funcall(m, id_aref, 1, INT2FIX(0));
+        long match_beg = NUM2LONG(rb_funcall(m, id_begin, 1, INT2FIX(0)));
 
         long byte_off = sv_char_to_byte_offset(sv, match_beg);
         long byte_len = RSTRING_LEN(matched);
 
-        return sv_new_from_parent(sv,
+        return sv_new_from_parent_obj(self, sv,
                                    sv->offset + byte_off,
                                    byte_len);
     }
@@ -964,14 +1260,15 @@ static VALUE sv_aref(int argc, VALUE *argv, VALUE self) {
         const char *p = sv_ptr(sv);
         long slen = RSTRING_LEN(arg1);
         if (slen == 0) {
-            return sv_new_from_parent(sv, sv->offset, 0);
+            return sv_new_from_parent_obj(self, sv, sv->offset, 0);
         }
+        sv_check_compatible_string(sv, arg1);
         if (slen > sv->length) return Qnil;
 
         long pos = rb_memsearch(RSTRING_PTR(arg1), slen, p, sv->length, sv_enc(sv));
         if (pos < 0 || pos > sv->length - slen) return Qnil;
 
-        return sv_new_from_parent(sv, sv->offset + pos, slen);
+        return sv_new_from_parent_obj(self, sv, sv->offset + pos, slen);
     }
 
     if (RB_INTEGER_TYPE_P(arg1)) {
@@ -986,7 +1283,7 @@ static VALUE sv_aref(int argc, VALUE *argv, VALUE self) {
 
         long byte_len = sv_chars_to_bytes(sv, byte_off, 1);
 
-        return sv_new_from_parent(sv,
+        return sv_new_from_parent_obj(self, sv,
                                    sv->offset + byte_off,
                                    byte_len);
     }
@@ -1013,98 +1310,376 @@ static VALUE sv_byteslice(int argc, VALUE *argv, VALUE self) {
         if (off < 0) off += sv->length;
         if (off < 0 || off > sv->length) return Qnil;
         if (len < 0) return Qnil;
-        if (off + len > sv->length) len = sv->length - off;
+        if (len > sv->length - off) len = sv->length - off;
 
-        return sv_new_from_parent(sv, sv->offset + off, len);
+        return sv_new_from_parent_obj(self, sv, sv->offset + off, len);
     }
 
     if (rb_obj_is_kind_of(arg1, rb_cRange)) {
         long beg, len;
-        VALUE rb_beg = rb_funcall(arg1, rb_intern("begin"), 0);
-        VALUE rb_end = rb_funcall(arg1, rb_intern("end"), 0);
-        int excl = RTEST(rb_funcall(arg1, rb_intern("exclude_end?"), 0));
 
-        beg = NIL_P(rb_beg) ? 0 : NUM2LONG(rb_beg);
-        if (beg < 0) beg += sv->length;
-        if (beg < 0) return Qnil;
-
-        long e;
-        if (NIL_P(rb_end)) {
-            e = sv->length;
-        } else {
-            e = NUM2LONG(rb_end);
-            if (e < 0) e += sv->length;
-            if (!excl) e += 1;
+        switch (rb_range_beg_len(arg1, &beg, &len, sv->length, 1)) {
+        case Qfalse: return Qnil;
+        case Qnil:   return Qnil;
         }
-        if (e < beg) e = beg;
-        len = e - beg;
-        if (beg > sv->length) return Qnil;
-        if (beg + len > sv->length) len = sv->length - beg;
 
-        return sv_new_from_parent(sv, sv->offset + beg, len);
+        return sv_new_from_parent_obj(self, sv, sv->offset + beg, len);
     }
 
     {
         long idx = NUM2LONG(arg1);
         if (idx < 0) idx += sv->length;
         if (idx < 0 || idx >= sv->length) return Qnil;
-        return sv_new_from_parent(sv, sv->offset + idx, 1);
+        return sv_new_from_parent_obj(self, sv, sv->offset + idx, 1);
     }
 }
 
+/* ========================================================================= */
+/* Tier 1.5: Zero-copy transforms — returns StringView via offset adjustment */
+/* ========================================================================= */
+
+/*
+ * Helper: check if a byte is ASCII whitespace.
+ * Matches Ruby's strip behavior for ASCII-compatible encodings:
+ * space, tab, newline, vertical tab, form feed, carriage return, NUL.
+ */
+SV_INLINE int sv_is_ascii_whitespace(unsigned char c) {
+    return c == ' ' || (c >= '\t' && c <= '\r') || c == '\0';
+}
+
+/*
+ * strip → StringView
+ * Returns a new StringView with leading and trailing ASCII whitespace removed.
+ * Zero allocations for the byte content — only a new StringView struct.
+ */
+static VALUE sv_strip(int argc, VALUE *argv, VALUE self) {
+    rb_check_arity(argc, 0, 0);
+    string_view_t *sv = sv_get_struct(self);
+    const unsigned char *p = (const unsigned char *)sv_ptr(sv);
+    long len = sv->length;
+
+    /* Skip leading whitespace */
+    long left = 0;
+    while (left < len && sv_is_ascii_whitespace(p[left])) left++;
+
+    /* Skip trailing whitespace */
+    long right = len;
+    while (right > left && sv_is_ascii_whitespace(p[right - 1])) right--;
+
+    if (left == 0 && right == len) return self;
+    return sv_new_from_parent_obj(self, sv, sv->offset + left, right - left);
+}
+
+/*
+ * lstrip → StringView
+ * Returns a new StringView with leading ASCII whitespace removed.
+ */
+static VALUE sv_lstrip(int argc, VALUE *argv, VALUE self) {
+    rb_check_arity(argc, 0, 0);
+    string_view_t *sv = sv_get_struct(self);
+    const unsigned char *p = (const unsigned char *)sv_ptr(sv);
+    long len = sv->length;
+
+    long left = 0;
+    while (left < len && sv_is_ascii_whitespace(p[left])) left++;
+
+    if (left == 0) return self;
+    return sv_new_from_parent_obj(self, sv, sv->offset + left, len - left);
+}
+
+/*
+ * rstrip → StringView
+ * Returns a new StringView with trailing ASCII whitespace removed.
+ */
+static VALUE sv_rstrip(int argc, VALUE *argv, VALUE self) {
+    rb_check_arity(argc, 0, 0);
+    string_view_t *sv = sv_get_struct(self);
+    const unsigned char *p = (const unsigned char *)sv_ptr(sv);
+    long len = sv->length;
+
+    long right = len;
+    while (right > 0 && sv_is_ascii_whitespace(p[right - 1])) right--;
+
+    if (right == len) return self;
+    return sv_new_from_parent_obj(self, sv, sv->offset, right);
+}
+
+/*
+ * chomp([separator]) → StringView
+ * Returns a new StringView with the trailing record separator removed.
+ * Default separator is $/ (typically "\n").
+ * Handles "\n", "\r\n", and "\r" when separator is "\n".
+ */
+static VALUE sv_chomp(int argc, VALUE *argv, VALUE self) {
+    rb_check_arity(argc, 0, 1);
+    string_view_t *sv = sv_get_struct(self);
+    const unsigned char *p = (const unsigned char *)sv_ptr(sv);
+    long len = sv->length;
+
+    if (len == 0) return self;
+
+    if (argc == 0 || NIL_P(argv[0])) {
+        /* Default: remove trailing \n, \r\n, or \r */
+        /* Use $/ (input record separator) when no arg given */
+        VALUE rs;
+        if (argc == 0) {
+            rs = rb_rs; /* global $/ */
+            if (NIL_P(rs)) return self; /* $/ is nil, no chomp */
+        } else {
+            return self; /* chomp(nil) returns self */
+        }
+
+        /* Fast path for default $/ which is "\n" */
+        if (RB_TYPE_P(rs, T_STRING) && RSTRING_LEN(rs) == 1 && RSTRING_PTR(rs)[0] == '\n') {
+            if (p[len - 1] == '\n') {
+                long newlen = len - 1;
+                if (newlen > 0 && p[newlen - 1] == '\r') newlen--;
+                return sv_new_from_parent_obj(self, sv, sv->offset, newlen);
+            } else if (p[len - 1] == '\r') {
+                return sv_new_from_parent_obj(self, sv, sv->offset, len - 1);
+            }
+            return self;
+        }
+
+        /* Non-default $/ — use the separator */
+        if (!RB_TYPE_P(rs, T_STRING)) return self;
+        const char *sep = RSTRING_PTR(rs);
+        long seplen = RSTRING_LEN(rs);
+        if (seplen == 0) {
+            /* Paragraph mode: remove trailing \n+ */
+            long right = len;
+            while (right > 0 && p[right - 1] == '\n') right--;
+            if (right == len) return self;
+            return sv_new_from_parent_obj(self, sv, sv->offset, right);
+        }
+        if (seplen > len) return self;
+        if (memcmp(p + len - seplen, sep, seplen) == 0) {
+            return sv_new_from_parent_obj(self, sv, sv->offset, len - seplen);
+        }
+        return self;
+    }
+
+    /* Explicit separator argument */
+    VALUE sep_val = argv[0];
+    if (NIL_P(sep_val)) return self;
+    StringValue(sep_val);
+    const char *sep = RSTRING_PTR(sep_val);
+    long seplen = RSTRING_LEN(sep_val);
+
+    if (seplen == 0) {
+        /* Paragraph mode: remove all trailing newlines */
+        long right = len;
+        while (right > 0 && p[right - 1] == '\n') right--;
+        if (right == len) return self;
+        return sv_new_from_parent_obj(self, sv, sv->offset, right);
+    }
+
+    /* Special handling for "\n": also removes \r\n and \r */
+    if (seplen == 1 && sep[0] == '\n') {
+        if (p[len - 1] == '\n') {
+            long newlen = len - 1;
+            if (newlen > 0 && p[newlen - 1] == '\r') newlen--;
+            return sv_new_from_parent_obj(self, sv, sv->offset, newlen);
+        } else if (p[len - 1] == '\r') {
+            return sv_new_from_parent_obj(self, sv, sv->offset, len - 1);
+        }
+        return self;
+    }
+
+    if (seplen > len) return self;
+    if (memcmp(p + len - seplen, sep, seplen) == 0) {
+        return sv_new_from_parent_obj(self, sv, sv->offset, len - seplen);
+    }
+    return self;
+}
+
+/*
+ * chop → StringView
+ * Returns a new StringView with the last character removed.
+ * If the string ends with \r\n, both characters are removed.
+ */
+static VALUE sv_chop(int argc, VALUE *argv, VALUE self) {
+    rb_check_arity(argc, 0, 0);
+    string_view_t *sv = sv_get_struct(self);
+    long len = sv->length;
+
+    if (len == 0) return self;
+
+    const unsigned char *p = (const unsigned char *)sv_ptr(sv);
+
+    /* Check for \r\n at the end */
+    if (len >= 2 && p[len - 1] == '\n' && p[len - 2] == '\r') {
+        return sv_new_from_parent_obj(self, sv, sv->offset, len - 2);
+    }
+
+    /* Remove last character (respecting encoding) */
+    if (sv_single_byte_optimizable(sv)) {
+        return sv_new_from_parent_obj(self, sv, sv->offset, len - 1);
+    }
+
+    /* Multibyte: find start of last character */
+    rb_encoding *enc = sv_enc(sv);
+    const char *start = sv_ptr(sv);
+    const char *end = start + len;
+    const char *prev = rb_enc_prev_char(start, end, end, enc);
+    if (prev == NULL) prev = start;
+    long newlen = (long)(prev - start);
+
+    return sv_new_from_parent_obj(self, sv, sv->offset, newlen);
+}
+
+/*
+ * delete_prefix(prefix) → StringView
+ * Returns a new StringView with the given prefix removed, or self if
+ * the string doesn't start with the prefix.
+ */
+static VALUE sv_delete_prefix(VALUE self, VALUE prefix) {
+    string_view_t *sv = sv_get_struct(self);
+    StringValue(prefix);
+    const char *p = sv_ptr(sv);
+    long plen = RSTRING_LEN(prefix);
+
+    if (plen == 0) return self;
+    sv_check_compatible_string(sv, prefix);
+    if (plen > sv->length) return self;
+    if (memcmp(p, RSTRING_PTR(prefix), plen) != 0) return self;
+
+    return sv_new_from_parent_obj(self, sv, sv->offset + plen, sv->length - plen);
+}
+
+/*
+ * delete_suffix(suffix) → StringView
+ * Returns a new StringView with the given suffix removed, or self if
+ * the string doesn't end with the suffix.
+ */
+static VALUE sv_delete_suffix(VALUE self, VALUE suffix) {
+    string_view_t *sv = sv_get_struct(self);
+    StringValue(suffix);
+    const char *p = sv_ptr(sv);
+    long slen = RSTRING_LEN(suffix);
+
+    if (slen == 0) return self;
+    sv_check_compatible_string(sv, suffix);
+    if (slen > sv->length) return self;
+    if (memcmp(p + sv->length - slen, RSTRING_PTR(suffix), slen) != 0) return self;
+
+    return sv_new_from_parent_obj(self, sv, sv->offset, sv->length - slen);
+}
+
+/*
+ * chr → StringView
+ * Returns the first character as a StringView.
+ */
+static VALUE sv_chr(VALUE self) {
+    string_view_t *sv = sv_get_struct(self);
+
+    if (sv->length == 0) return self;
+
+    if (sv_single_byte_optimizable(sv)) {
+        return sv_new_from_parent_obj(self, sv, sv->offset, 1);
+    }
+
+    rb_encoding *enc = sv_enc(sv);
+    const char *p = sv_ptr(sv);
+    const char *e = p + sv->length;
+    int clen = rb_enc_fast_mbclen(p, e, enc);
+
+    return sv_new_from_parent_obj(self, sv, sv->offset, clen);
+}
+
+/*
+ * ord → Integer
+ * Returns the codepoint of the first character.
+ */
+static VALUE sv_ord(VALUE self) {
+    string_view_t *sv = sv_get_struct(self);
+
+    if (sv->length == 0) {
+        rb_raise(rb_eArgError, "empty string");
+    }
+
+    rb_encoding *enc = sv_enc(sv);
+    const char *p = sv_ptr(sv);
+    const char *e = p + sv->length;
+    unsigned int c = rb_enc_codepoint_len(p, e, NULL, enc);
+    return UINT2NUM(c);
+}
+
+/*
+ * valid_encoding? → true/false
+ * Returns whether the view's bytes are valid in its encoding.
+ */
+static VALUE sv_valid_encoding_p(VALUE self) {
+    string_view_t *sv = sv_get_struct(self);
+    return sv_valid_encoding_cached(sv) ? Qtrue : Qfalse;
+}
+
+/*
+ * b → StringView
+ * Returns a new StringView that references the same bytes but with
+ * ASCII-8BIT encoding. Since we share the same backing bytes, this is
+ * only valid when the backing is also binary-compatible, which it always
+ * is — we just reinterpret the bytes.
+ *
+ * Note: We need to create a new backing with binary encoding since
+ * the encoding is tied to the backing string.
+ * Actually, the encoding is cached in sv->enc, so we can create a
+ * lightweight view with different encoding. But the backing string
+ * has its own encoding... For true zero-alloc we store enc separately.
+ */
+
 /* ========================================================================= */
 /* Tier 3: Transform delegation                                              */
 /* ========================================================================= */
 
-#define SV_DELEGATE_FUNCALL(cname, rbname)                              \
+#define SV_DELEGATE_FUNCALL(cname, cached_id)                           \
     static VALUE sv_##cname(int argc, VALUE *argv, VALUE self) {        \
         string_view_t *sv = sv_get_struct(self);                        \
         VALUE shared = sv_as_shared_str(sv);                            \
         if (rb_block_given_p()) {                                       \
-            return rb_funcall_with_block(shared, rb_intern(rbname),     \
+            return rb_funcall_with_block(shared, cached_id,             \
                                          argc, argv, rb_block_proc()); \
         }                                                               \
-        return rb_funcallv(shared, rb_intern(rbname), argc, argv);      \
-    }
-
-SV_DELEGATE_FUNCALL(upcase,    "upcase")
-SV_DELEGATE_FUNCALL(downcase,  "downcase")
-SV_DELEGATE_FUNCALL(capitalize,"capitalize")
-SV_DELEGATE_FUNCALL(swapcase,  "swapcase")
-SV_DELEGATE_FUNCALL(strip,     "strip")
-SV_DELEGATE_FUNCALL(lstrip,    "lstrip")
-SV_DELEGATE_FUNCALL(rstrip,    "rstrip")
-SV_DELEGATE_FUNCALL(chomp,     "chomp")
-SV_DELEGATE_FUNCALL(chop,      "chop")
-SV_DELEGATE_FUNCALL(reverse,   "reverse")
-SV_DELEGATE_FUNCALL(squeeze,   "squeeze")
-SV_DELEGATE_FUNCALL(encode,    "encode")
-SV_DELEGATE_FUNCALL(gsub,      "gsub")
-SV_DELEGATE_FUNCALL(sub,       "sub")
-SV_DELEGATE_FUNCALL(tr,        "tr")
-SV_DELEGATE_FUNCALL(tr_s,      "tr_s")
-SV_DELEGATE_FUNCALL(sv_delete, "delete")
-SV_DELEGATE_FUNCALL(count,     "count")
-SV_DELEGATE_FUNCALL(scan,      "scan")
-SV_DELEGATE_FUNCALL(split,     "split")
-SV_DELEGATE_FUNCALL(center,    "center")
-SV_DELEGATE_FUNCALL(ljust,     "ljust")
-SV_DELEGATE_FUNCALL(rjust,     "rjust")
-SV_DELEGATE_FUNCALL(format_op, "%")
-SV_DELEGATE_FUNCALL(plus,      "+")
-SV_DELEGATE_FUNCALL(multiply,  "*")
-SV_DELEGATE_FUNCALL(unpack1,   "unpack1")
-SV_DELEGATE_FUNCALL(scrub,     "scrub")
-SV_DELEGATE_FUNCALL(unicode_normalize, "unicode_normalize")
+        return rb_funcallv(shared, cached_id, argc, argv);              \
+    }
+
+SV_DELEGATE_FUNCALL(upcase,    id_upcase)
+SV_DELEGATE_FUNCALL(downcase,  id_downcase)
+SV_DELEGATE_FUNCALL(capitalize,id_capitalize)
+SV_DELEGATE_FUNCALL(swapcase,  id_swapcase)
+SV_DELEGATE_FUNCALL(reverse,   id_reverse)
+SV_DELEGATE_FUNCALL(squeeze,   id_squeeze)
+SV_DELEGATE_FUNCALL(encode,    id_encode)
+SV_DELEGATE_FUNCALL(gsub,      id_gsub)
+SV_DELEGATE_FUNCALL(sub,       id_sub)
+SV_DELEGATE_FUNCALL(tr,        id_tr)
+SV_DELEGATE_FUNCALL(tr_s,      id_tr_s)
+SV_DELEGATE_FUNCALL(delete_str,id_delete)
+/*
+ * count(set, ...) → Integer
+ * Delegates to String#count via shared string.
+ * (Character set parsing is complex — reuse Ruby's implementation.)
+ */
+SV_DELEGATE_FUNCALL(count,     id_count)
+SV_DELEGATE_FUNCALL(scan,      id_scan)
+SV_DELEGATE_FUNCALL(split,     id_split)
+SV_DELEGATE_FUNCALL(center,    id_center)
+SV_DELEGATE_FUNCALL(ljust,     id_ljust)
+SV_DELEGATE_FUNCALL(rjust,     id_rjust)
+SV_DELEGATE_FUNCALL(format_op, id_format_op)
+SV_DELEGATE_FUNCALL(plus,      id_plus)
+SV_DELEGATE_FUNCALL(multiply,  id_multiply)
+SV_DELEGATE_FUNCALL(unpack1,   id_unpack1)
+SV_DELEGATE_FUNCALL(scrub,     id_scrub)
+SV_DELEGATE_FUNCALL(unicode_normalize, id_unicode_normalize)
 
 /* ========================================================================= */
 /* Bang methods — always raise FrozenError                                   */
 /* ========================================================================= */
 
 static VALUE sv_frozen_error(int argc, VALUE *argv, VALUE self) {
-    VALUE str = sv_to_s(self);
-    rb_raise(rb_eFrozenError, "can't modify frozen StringView: \"%s\"",
-             StringValueCStr(str));
+    (void)argc; (void)argv;
+    rb_raise(rb_eFrozenError, "can't modify frozen StringView");
     return Qnil;
 }
 
@@ -1115,6 +1690,46 @@ static VALUE sv_frozen_error(int argc, VALUE *argv, VALUE self) {
 void Init_string_view(void) {
     enc_utf8 = rb_utf8_encoding();
 
+    /* Cache method IDs — avoids rb_intern hash lookup on every call */
+    id_index       = rb_intern("index");
+    id_rindex      = rb_intern("rindex");
+    id_byteindex   = rb_intern("byteindex");
+    id_byterindex  = rb_intern("byterindex");
+    id_match       = rb_intern("match");
+    id_match_p     = rb_intern("match?");
+    id_match_op    = rb_intern("=~");
+    id_begin       = rb_intern("begin");
+    id_aref        = rb_intern("[]");
+    id_upcase      = rb_intern("upcase");
+    id_downcase    = rb_intern("downcase");
+    id_capitalize  = rb_intern("capitalize");
+    id_swapcase    = rb_intern("swapcase");
+    id_strip       = rb_intern("strip");
+    id_lstrip      = rb_intern("lstrip");
+    id_rstrip      = rb_intern("rstrip");
+    id_chomp       = rb_intern("chomp");
+    id_chop        = rb_intern("chop");
+    id_reverse     = rb_intern("reverse");
+    id_squeeze     = rb_intern("squeeze");
+    id_encode      = rb_intern("encode");
+    id_gsub        = rb_intern("gsub");
+    id_sub         = rb_intern("sub");
+    id_tr          = rb_intern("tr");
+    id_tr_s        = rb_intern("tr_s");
+    id_delete      = rb_intern("delete");
+    id_count       = rb_intern("count");
+    id_scan        = rb_intern("scan");
+    id_split       = rb_intern("split");
+    id_center      = rb_intern("center");
+    id_ljust       = rb_intern("ljust");
+    id_rjust       = rb_intern("rjust");
+    id_format_op   = rb_intern("%");
+    id_plus        = rb_intern("+");
+    id_multiply    = rb_intern("*");
+    id_unpack1     = rb_intern("unpack1");
+    id_scrub       = rb_intern("scrub");
+    id_unicode_normalize = rb_intern("unicode_normalize");
+
     cStringView = rb_define_class("StringView", rb_cObject);
     rb_include_module(cStringView, rb_mComparable);
 
@@ -1122,11 +1737,10 @@ void Init_string_view(void) {
     rb_define_method(cStringView, "initialize", sv_initialize, -1);
 
     rb_define_method(cStringView, "to_s",       sv_to_s,       0);
+    rb_define_method(cStringView, "materialize", sv_to_s,      0);
     rb_define_private_method(cStringView, "to_str", sv_to_str, 0);
     rb_define_method(cStringView, "inspect",    sv_inspect,    0);
-    rb_define_method(cStringView, "frozen?",    sv_frozen_p,   0);
     rb_define_method(cStringView, "reset!",     sv_reset,      3);
-    rb_define_alias(cStringView,  "materialize", "to_s");
 
     rb_define_method(cStringView, "bytesize",    sv_bytesize,    0);
     rb_define_method(cStringView, "length",      sv_length,      0);
@@ -1176,6 +1790,11 @@ void Init_string_view(void) {
     rb_define_method(cStringView, "rstrip",      sv_rstrip,     -1);
     rb_define_method(cStringView, "chomp",       sv_chomp,      -1);
     rb_define_method(cStringView, "chop",        sv_chop,       -1);
+    rb_define_method(cStringView, "delete_prefix", sv_delete_prefix, 1);
+    rb_define_method(cStringView, "delete_suffix", sv_delete_suffix, 1);
+    rb_define_method(cStringView, "chr",         sv_chr,         0);
+    rb_define_method(cStringView, "ord",         sv_ord,         0);
+    rb_define_method(cStringView, "valid_encoding?", sv_valid_encoding_p, 0);
     rb_define_method(cStringView, "reverse",     sv_reverse,    -1);
     rb_define_method(cStringView, "squeeze",     sv_squeeze,    -1);
     rb_define_method(cStringView, "encode",      sv_encode,     -1);
@@ -1183,7 +1802,7 @@ void Init_string_view(void) {
     rb_define_method(cStringView, "sub",         sv_sub,        -1);
     rb_define_method(cStringView, "tr",          sv_tr,         -1);
     rb_define_method(cStringView, "tr_s",        sv_tr_s,       -1);
-    rb_define_method(cStringView, "delete",      sv_sv_delete,  -1);
+    rb_define_method(cStringView, "delete",      sv_delete_str, -1);
     rb_define_method(cStringView, "count",       sv_count,      -1);
     rb_define_method(cStringView, "scan",        sv_scan,       -1);
     rb_define_method(cStringView, "split",       sv_split,      -1);
@@ -1214,4 +1833,10 @@ void Init_string_view(void) {
     rb_define_method(cStringView, "gsub!",       sv_frozen_error, -1);
     rb_define_method(cStringView, "sub!",        sv_frozen_error, -1);
     rb_define_method(cStringView, "slice!",      sv_frozen_error, -1);
+    rb_define_method(cStringView, "delete_prefix!", sv_frozen_error, -1);
+    rb_define_method(cStringView, "delete_suffix!", sv_frozen_error, -1);
+
+    Init_string_view_strict();
+    Init_string_view_pool();
+    Init_string_view_core_ext();
 }