superacli 1.1.6 → 1.1.8

package/ref-monty/crates/monty/src/types/bytes.rs

@@ -1,2356 +0,0 @@
-/// Python bytes type, wrapping a `Vec<u8>`.
-///
-/// This type provides Python bytes semantics with operations on ASCII bytes only.
-/// Unlike str methods which operate on Unicode codepoints, bytes methods only
-/// recognize ASCII characters (0-127) for case transformations and predicates.
-///
-/// # Implemented Methods
-///
-/// ## Encoding/Decoding
-/// - `decode([encoding[, errors]])` - Decode to string (UTF-8 only)
-/// - `hex([sep[, bytes_per_sep]])` - Return hex string representation
-/// - `fromhex(string)` - Create bytes from hex string (classmethod)
-///
-/// ## Simple Transformations
-/// - `lower()` - Convert ASCII uppercase to lowercase
-/// - `upper()` - Convert ASCII lowercase to uppercase
-/// - `capitalize()` - First byte uppercase, rest lowercase
-/// - `title()` - Titlecase ASCII letters
-/// - `swapcase()` - Swap ASCII case
-///
-/// ## Predicates
-/// - `isalpha()` - All bytes are ASCII letters
-/// - `isdigit()` - All bytes are ASCII digits
-/// - `isalnum()` - All bytes are ASCII alphanumeric
-/// - `isspace()` - All bytes are ASCII whitespace
-/// - `islower()` - Has cased bytes, all lowercase
-/// - `isupper()` - Has cased bytes, all uppercase
-/// - `isascii()` - All bytes are ASCII (0-127)
-/// - `istitle()` - Titlecased
-///
-/// ## Search Methods
-/// - `count(sub[, start[, end]])` - Count non-overlapping occurrences
-/// - `find(sub[, start[, end]])` - Find first occurrence (-1 if not found)
-/// - `rfind(sub[, start[, end]])` - Find last occurrence (-1 if not found)
-/// - `index(sub[, start[, end]])` - Find first occurrence (raises ValueError)
-/// - `rindex(sub[, start[, end]])` - Find last occurrence (raises ValueError)
-/// - `startswith(prefix[, start[, end]])` - Check if starts with prefix
-/// - `endswith(suffix[, start[, end]])` - Check if ends with suffix
-///
-/// ## Strip/Trim Methods
-/// - `strip([chars])` - Remove leading/trailing bytes
-/// - `lstrip([chars])` - Remove leading bytes
-/// - `rstrip([chars])` - Remove trailing bytes
-/// - `removeprefix(prefix)` - Remove prefix if present
-/// - `removesuffix(suffix)` - Remove suffix if present
-///
-/// ## Split Methods
-/// - `split([sep[, maxsplit]])` - Split on separator
-/// - `rsplit([sep[, maxsplit]])` - Split from right
-/// - `splitlines([keepends])` - Split on line boundaries
-/// - `partition(sep)` - Split into 3 parts at first sep
-/// - `rpartition(sep)` - Split into 3 parts at last sep
-///
-/// ## Replace/Padding Methods
-/// - `replace(old, new[, count])` - Replace occurrences
-/// - `center(width[, fillbyte])` - Center with fill byte
-/// - `ljust(width[, fillbyte])` - Left justify with fill byte
-/// - `rjust(width[, fillbyte])` - Right justify with fill byte
-/// - `zfill(width)` - Pad with zeros
-///
-/// ## Other Methods
-/// - `join(iterable)` - Join bytes sequences
-///
-/// # Unimplemented Methods
-/// - `expandtabs(tabsize=8)` - Tab expansion
-/// - `translate(table[, delete])` - Character translation
-/// - `maketrans(frm, to)` - Create translation table (staticmethod)
-use std::cmp::Ordering;
-use std::fmt::Write;
-
-use ahash::AHashSet;
-use smallvec::smallvec;
-
-use super::{MontyIter, PyTrait, Type, str::Str};
-use crate::{
-    args::ArgValues,
-    bytecode::{CallResult, VM},
-    defer_drop, defer_drop_mut,
-    exception_private::{ExcType, RunResult, SimpleException},
-    heap::{DropWithHeap, Heap, HeapData, HeapGuard, HeapId},
-    intern::{Interns, StaticStrings, StringId},
-    resource::{ResourceError, ResourceTracker, check_repeat_size, check_replace_size},
-    types::List,
-    value::{EitherStr, Value},
-};
-
-// =============================================================================
-// ASCII byte helper functions
-// =============================================================================
-
-/// Returns true if the byte is Python ASCII whitespace.
-///
-/// Python considers these bytes as whitespace: space, tab, newline, carriage return,
-/// vertical tab (0x0b), and form feed (0x0c). Note: Rust's `is_ascii_whitespace()`
-/// does not include vertical tab (0x0b).
-#[inline]
-fn is_py_whitespace(b: u8) -> bool {
-    matches!(b, b' ' | b'\t' | b'\n' | b'\r' | 0x0b | 0x0c)
-}
-
-/// Gets the byte at a given index, handling negative indices.
-///
-/// Returns `None` if the index is out of bounds.
-/// Negative indices count from the end: -1 is the last byte.
-pub fn get_byte_at_index(bytes: &[u8], index: i64) -> Option<u8> {
-    let len = i64::try_from(bytes.len()).ok()?;
-    let normalized = if index < 0 { index + len } else { index };
-
-    if normalized < 0 || normalized >= len {
-        return None;
-    }
-
-    let idx = usize::try_from(normalized).ok()?;
-    Some(bytes[idx])
-}
-
-/// Extracts a slice of a byte array.
-///
-/// Handles both positive and negative step values. For negative step,
-/// iterates backward from start down to (but not including) stop.
-/// The `stop` parameter uses a sentinel value of `len + 1` for negative
-/// step to indicate "go to the beginning".
-///
-/// Note: step must be non-zero (callers should validate this via `slice.indices()`).
-pub(crate) fn get_bytes_slice(bytes: &[u8], start: usize, stop: usize, step: i64) -> Vec<u8> {
-    let mut result = Vec::new();
-
-    // try_from succeeds for non-negative step; step==0 rejected upstream by slice.indices()
-    if let Ok(step_usize) = usize::try_from(step) {
-        // Positive step: iterate forward
-        let mut i = start;
-        while i < stop && i < bytes.len() {
-            result.push(bytes[i]);
-            i += step_usize;
-        }
-    } else {
-        // Negative step: iterate backward
-        // start is the highest index, stop is the sentinel
-        // stop > bytes.len() means "go to the beginning"
-        let step_abs = usize::try_from(-step).expect("step is negative so -step is positive");
-        let step_abs_i64 = i64::try_from(step_abs).expect("step magnitude fits in i64");
-        let mut i = i64::try_from(start).expect("start index fits in i64");
-        let stop_i64 = if stop > bytes.len() {
-            -1
-        } else {
-            i64::try_from(stop).expect("stop bounded by bytes.len() fits in i64")
-        };
-
-        while let Ok(i_usize) = usize::try_from(i) {
-            if i_usize >= bytes.len() || i <= stop_i64 {
-                break;
-            }
-            result.push(bytes[i_usize]);
-            i -= step_abs_i64;
-        }
-    }
-
-    result
-}
-
-/// Python bytes value stored on the heap.
-///
-/// Wraps a `Vec<u8>` and provides Python-compatible operations.
-/// See the module-level documentation for implemented and unimplemented methods.
-#[derive(Debug, Clone, PartialEq, Default, serde::Serialize, serde::Deserialize)]
-pub(crate) struct Bytes(Vec<u8>);
-
-impl Bytes {
-    /// Creates a new Bytes from a byte vector.
-    #[must_use]
-    pub fn new(bytes: Vec<u8>) -> Self {
-        Self(bytes)
-    }
-
-    /// Returns a reference to the inner byte slice.
-    #[must_use]
-    pub fn as_slice(&self) -> &[u8] {
-        &self.0
-    }
-
-    /// Creates bytes from the `bytes()` constructor call.
-    ///
-    /// - `bytes()` with no args returns empty bytes
-    /// - `bytes(int)` returns bytes of that length filled with zeros
-    /// - `bytes(string)` encodes the string as UTF-8 (simplified, no encoding param)
-    /// - `bytes(bytes)` returns a copy of the bytes
-    ///
-    /// Note: Full Python semantics for bytes() are more complex (encoding, errors params).
-    pub fn init(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
-        let heap = &mut *vm.heap;
-        let interns = vm.interns;
-        let value = args.get_zero_one_arg("bytes", heap)?;
-        defer_drop!(value, heap);
-        let new_data = match value {
-            None => Vec::new(),
-            Some(Value::Int(n)) => {
-                if *n < 0 {
-                    return Err(ExcType::value_error_negative_bytes_count());
-                }
-                let size = usize::try_from(*n).expect("bytes count validated non-negative");
-                vec![0u8; size]
-            }
-            Some(Value::InternString(string_id)) => {
-                let s = interns.get_str(*string_id);
-                s.as_bytes().to_vec()
-            }
-            Some(Value::InternBytes(bytes_id)) => {
-                let b = interns.get_bytes(*bytes_id);
-                b.to_vec()
-            }
-            Some(v @ Value::Ref(id)) => match heap.get(*id) {
-                HeapData::Str(s) => s.as_str().as_bytes().to_vec(),
-                HeapData::Bytes(b) => b.as_slice().to_vec(),
-                _ => return Err(ExcType::type_error_bytes_init(v.py_type(heap))),
-            },
-            Some(v) => return Err(ExcType::type_error_bytes_init(v.py_type(heap))),
-        };
-        let heap_id = heap.allocate(HeapData::Bytes(Self::new(new_data)))?;
-        Ok(Value::Ref(heap_id))
-    }
-}
-
-impl From<Vec<u8>> for Bytes {
-    fn from(bytes: Vec<u8>) -> Self {
-        Self(bytes)
-    }
-}
-
-impl From<&[u8]> for Bytes {
-    fn from(bytes: &[u8]) -> Self {
-        Self(bytes.to_vec())
-    }
-}
-
-impl From<Bytes> for Vec<u8> {
-    fn from(bytes: Bytes) -> Self {
-        bytes.0
-    }
-}
-
-impl std::ops::Deref for Bytes {
-    type Target = Vec<u8>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl PyTrait for Bytes {
-    fn py_type(&self, _heap: &Heap<impl ResourceTracker>) -> Type {
-        Type::Bytes
-    }
-
-    fn py_estimate_size(&self) -> usize {
-        std::mem::size_of::<Self>() + self.0.len()
-    }
-
-    fn py_len(&self, _vm: &VM<'_, '_, impl ResourceTracker>) -> Option<usize> {
-        Some(self.0.len())
-    }
-
-    fn py_getitem(&self, key: &Value, vm: &mut VM<'_, '_, impl ResourceTracker>) -> RunResult<Value> {
-        let heap = &mut *vm.heap;
-        // Check for slice first (Value::Ref pointing to HeapData::Slice)
-        if let Value::Ref(id) = key
-            && let HeapData::Slice(slice) = heap.get(*id)
-        {
-            let (start, stop, step) = slice
-                .indices(self.0.len())
-                .map_err(|()| ExcType::value_error_slice_step_zero())?;
-
-            let sliced_bytes = get_bytes_slice(&self.0, start, stop, step);
-            let heap_id = heap.allocate(HeapData::Bytes(Self::new(sliced_bytes)))?;
-            return Ok(Value::Ref(heap_id));
-        }
-
-        // Extract integer index, accepting Int, Bool (True=1, False=0), and LongInt
-        let index = key.as_index(heap, Type::Bytes)?;
-
-        // Use helper for byte indexing
-        let byte = get_byte_at_index(&self.0, index).ok_or_else(ExcType::bytes_index_error)?;
-        Ok(Value::Int(i64::from(byte)))
-    }
-
-    fn py_eq(&self, other: &Self, _vm: &mut VM<'_, '_, impl ResourceTracker>) -> Result<bool, ResourceError> {
-        Ok(self.0 == other.0)
-    }
-
-    /// Bytes don't contain nested heap references.
-    fn py_dec_ref_ids(&mut self, _stack: &mut Vec<HeapId>) {
-        // No-op: bytes don't hold Value references
-    }
-
-    fn py_cmp(
-        &self,
-        other: &Self,
-        _vm: &mut VM<'_, '_, impl ResourceTracker>,
-    ) -> Result<Option<Ordering>, ResourceError> {
-        Ok(Some(self.0.cmp(&other.0)))
-    }
-
-    fn py_bool(&self, _vm: &VM<'_, '_, impl ResourceTracker>) -> bool {
-        !self.0.is_empty()
-    }
-
-    fn py_repr_fmt(
-        &self,
-        f: &mut impl Write,
-        _vm: &VM<'_, '_, impl ResourceTracker>,
-        _heap_ids: &mut AHashSet<HeapId>,
-    ) -> std::fmt::Result {
-        bytes_repr_fmt(&self.0, f)
-    }
-
-    fn py_call_attr(
-        &mut self,
-        _self_id: HeapId,
-        vm: &mut VM<'_, '_, impl ResourceTracker>,
-        attr: &EitherStr,
-        args: ArgValues,
-    ) -> RunResult<CallResult> {
-        let Some(method) = attr.static_string() else {
-            args.drop_with_heap(vm.heap);
-            return Err(ExcType::attribute_error(Type::Bytes, attr.as_str(vm.interns)));
-        };
-
-        call_bytes_method_impl(self.as_slice(), method, args, vm).map(CallResult::Value)
-    }
-}
-
-/// Calls a bytes method on a byte slice by method name.
-///
-/// This is the entry point for bytes method calls from the VM on interned bytes.
-/// Converts the `StringId` to `StaticStrings` and delegates to `call_bytes_method_impl`.
-pub fn call_bytes_method(
-    bytes: &[u8],
-    method_id: StringId,
-    args: ArgValues,
-    vm: &mut VM<'_, '_, impl ResourceTracker>,
-) -> RunResult<Value> {
-    let Some(method) = StaticStrings::from_string_id(method_id) else {
-        args.drop_with_heap(vm.heap);
-        return Err(ExcType::attribute_error(Type::Bytes, vm.interns.get_str(method_id)));
-    };
-    call_bytes_method_impl(bytes, method, args, vm)
-}
-
-/// Calls a bytes method on a byte slice.
-///
-/// This is the unified implementation for bytes method calls, used by both
-/// heap-allocated `Bytes` (via `py_call_attr`) and interned bytes literals
-/// (`Value::InternBytes`).
-fn call_bytes_method_impl(
-    bytes: &[u8],
-    method: StaticStrings,
-    args: ArgValues,
-    vm: &mut VM<'_, '_, impl ResourceTracker>,
-) -> RunResult<Value> {
-    let heap = &mut *vm.heap;
-    let interns = vm.interns;
-    match method {
-        // Decode method
-        StaticStrings::Decode => bytes_decode(bytes, args, heap, interns),
-        // Simple transformations (no arguments)
-        StaticStrings::Lower => {
-            args.check_zero_args("bytes.lower", heap)?;
-            bytes_lower(bytes, heap)
-        }
-        StaticStrings::Upper => {
-            args.check_zero_args("bytes.upper", heap)?;
-            bytes_upper(bytes, heap)
-        }
-        StaticStrings::Capitalize => {
-            args.check_zero_args("bytes.capitalize", heap)?;
-            bytes_capitalize(bytes, heap)
-        }
-        StaticStrings::Title => {
-            args.check_zero_args("bytes.title", heap)?;
-            bytes_title(bytes, heap)
-        }
-        StaticStrings::Swapcase => {
-            args.check_zero_args("bytes.swapcase", heap)?;
-            bytes_swapcase(bytes, heap)
-        }
-        // Predicate methods (no arguments, return bool)
-        StaticStrings::Isalpha => {
-            args.check_zero_args("bytes.isalpha", heap)?;
-            Ok(Value::Bool(bytes_isalpha(bytes)))
-        }
-        StaticStrings::Isdigit => {
-            args.check_zero_args("bytes.isdigit", heap)?;
-            Ok(Value::Bool(bytes_isdigit(bytes)))
-        }
-        StaticStrings::Isalnum => {
-            args.check_zero_args("bytes.isalnum", heap)?;
-            Ok(Value::Bool(bytes_isalnum(bytes)))
-        }
-        StaticStrings::Isspace => {
-            args.check_zero_args("bytes.isspace", heap)?;
-            Ok(Value::Bool(bytes_isspace(bytes)))
-        }
-        StaticStrings::Islower => {
-            args.check_zero_args("bytes.islower", heap)?;
-            Ok(Value::Bool(bytes_islower(bytes)))
-        }
-        StaticStrings::Isupper => {
-            args.check_zero_args("bytes.isupper", heap)?;
-            Ok(Value::Bool(bytes_isupper(bytes)))
-        }
-        StaticStrings::Isascii => {
-            args.check_zero_args("bytes.isascii", heap)?;
-            Ok(Value::Bool(bytes.iter().all(|&b| b <= 127)))
-        }
-        StaticStrings::Istitle => {
-            args.check_zero_args("bytes.istitle", heap)?;
-            Ok(Value::Bool(bytes_istitle(bytes)))
-        }
-        // Search methods
-        StaticStrings::Count => bytes_count(bytes, args, heap, interns),
-        StaticStrings::Find => bytes_find(bytes, args, heap, interns),
-        StaticStrings::Rfind => bytes_rfind(bytes, args, heap, interns),
-        StaticStrings::Index => bytes_index(bytes, args, heap, interns),
-        StaticStrings::Rindex => bytes_rindex(bytes, args, heap, interns),
-        StaticStrings::Startswith => bytes_startswith(bytes, args, heap, interns),
-        StaticStrings::Endswith => bytes_endswith(bytes, args, heap, interns),
-        // Strip/trim methods
-        StaticStrings::Strip => bytes_strip(bytes, args, heap, interns),
-        StaticStrings::Lstrip => bytes_lstrip(bytes, args, heap, interns),
-        StaticStrings::Rstrip => bytes_rstrip(bytes, args, heap, interns),
-        StaticStrings::Removeprefix => bytes_removeprefix(bytes, args, heap, interns),
-        StaticStrings::Removesuffix => bytes_removesuffix(bytes, args, heap, interns),
-        // Split methods
-        StaticStrings::Split => bytes_split(bytes, args, heap, interns),
-        StaticStrings::Rsplit => bytes_rsplit(bytes, args, heap, interns),
-        StaticStrings::Splitlines => bytes_splitlines(bytes, args, vm),
-        StaticStrings::Partition => bytes_partition(bytes, args, heap, interns),
-        StaticStrings::Rpartition => bytes_rpartition(bytes, args, heap, interns),
-        // Replace/padding methods
-        StaticStrings::Replace => bytes_replace(bytes, args, heap, interns),
-        StaticStrings::Center => bytes_center(bytes, args, heap, interns),
-        StaticStrings::Ljust => bytes_ljust(bytes, args, heap, interns),
-        StaticStrings::Rjust => bytes_rjust(bytes, args, heap, interns),
-        StaticStrings::Zfill => bytes_zfill(bytes, args, heap),
-        // Join method
-        StaticStrings::Join => {
-            let iterable = args.get_one_arg("bytes.join", vm.heap)?;
-            bytes_join(bytes, iterable, vm)
-        }
-        // Hex method
-        StaticStrings::Hex => bytes_hex(bytes, args, heap, interns),
-        // fromhex is a classmethod but also accessible on instances
-        StaticStrings::Fromhex => bytes_fromhex(args, heap, interns),
-        _ => {
-            args.drop_with_heap(heap);
-            Err(ExcType::attribute_error(Type::Bytes, method.into()))
-        }
-    }
-}
-
-/// Writes a CPython-compatible repr string for bytes to a formatter.
-///
-/// Format: `b'...'` or `b"..."` depending on content.
-/// - Uses single quotes by default
-/// - Switches to double quotes if bytes contain `'` but not `"`
-/// - Escapes: `\\`, `\t`, `\n`, `\r`, `\xNN` for non-printable bytes
-pub fn bytes_repr_fmt(bytes: &[u8], f: &mut impl Write) -> std::fmt::Result {
-    // Determine quote character: use double quotes if single quote present but not double
-    let has_single = bytes.contains(&b'\'');
-    let has_double = bytes.contains(&b'"');
-    let quote = if has_single && !has_double { '"' } else { '\'' };
-
-    f.write_char('b')?;
-    f.write_char(quote)?;
-
-    for &byte in bytes {
-        match byte {
-            b'\\' => f.write_str("\\\\")?,
-            b'\t' => f.write_str("\\t")?,
-            b'\n' => f.write_str("\\n")?,
-            b'\r' => f.write_str("\\r")?,
-            b'\'' if quote == '\'' => f.write_str("\\'")?,
-            b'"' if quote == '"' => f.write_str("\\\"")?,
-            // Printable ASCII (32-126)
-            0x20..=0x7e => f.write_char(byte as char)?,
-            // Non-printable: use \xNN format
-            _ => write!(f, "\\x{byte:02x}")?,
-        }
-    }
-
-    f.write_char(quote)
-}
-
-/// Returns a CPython-compatible repr string for bytes.
-///
-/// Convenience wrapper around `bytes_repr_fmt` that returns an owned String.
-#[must_use]
-pub fn bytes_repr(bytes: &[u8]) -> String {
-    let mut result = String::new();
-    // Writing to String never fails
-    bytes_repr_fmt(bytes, &mut result).unwrap();
-    result
-}
-
-/// Implements Python's `bytes.decode([encoding[, errors]])` method.
-///
-/// Converts bytes to a string. Currently only supports UTF-8 encoding.
-fn bytes_decode(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (encoding, errors) = args.get_zero_one_two_args("bytes.decode", heap)?;
-    defer_drop!(encoding, heap);
-    defer_drop!(errors, heap); // NB we don't use errors argument yet
-
-    // Check encoding (default UTF-8)
-    let encoding = if let Some(enc) = encoding {
-        get_encoding_str(enc, heap, interns)?.to_ascii_lowercase()
-    } else {
-        "utf-8".to_owned()
-    };
-
-    // Only support UTF-8 family
-    if !matches!(encoding.as_str(), "utf-8" | "utf8" | "utf_8") {
-        return Err(ExcType::lookup_error_unknown_encoding(&encoding));
-    }
-
-    // Decode as UTF-8
-    match std::str::from_utf8(bytes) {
-        Ok(s) => {
-            let heap_id = heap.allocate(HeapData::Str(Str::from(s.to_owned())))?;
-            Ok(Value::Ref(heap_id))
-        }
-        Err(_) => Err(ExcType::unicode_decode_error_invalid_utf8()),
-    }
-}
-
-/// Helper function to extract encoding string from a value.
-fn get_encoding_str<'a>(
-    encoding: &Value,
-    heap: &'a Heap<impl ResourceTracker>,
-    interns: &'a Interns,
-) -> RunResult<&'a str> {
-    match encoding {
-        Value::InternString(id) => Ok(interns.get_str(*id)),
-        Value::Ref(id) => match heap.get(*id) {
-            HeapData::Str(s) => Ok(s.as_str()),
-            _ => Err(ExcType::type_error(
-                "decode() argument 'encoding' must be str, not bytes",
-            )),
-        },
-        // FIXME: should use proper encoding.py_type() here
-        _ => Err(ExcType::type_error("decode() argument 'encoding' must be str, not int")),
-    }
-}
-
-/// Implements Python's `bytes.count(sub[, start[, end]])` method.
-///
-/// Returns the number of non-overlapping occurrences of the subsequence.
-fn bytes_count(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (sub, start, end) = parse_bytes_sub_args("bytes.count", bytes.len(), args, heap, interns)?;
-
-    let slice = &bytes[start..end];
-    let count = if sub.is_empty() {
-        // Empty subsequence: count positions between each byte plus 1
-        slice.len() + 1
-    } else {
-        count_non_overlapping(slice, &sub)
-    };
-
-    let count_i64 = i64::try_from(count).expect("count exceeds i64::MAX");
-    Ok(Value::Int(count_i64))
-}
-
-/// Counts non-overlapping occurrences of needle in haystack.
-fn count_non_overlapping(haystack: &[u8], needle: &[u8]) -> usize {
-    let mut count = 0;
-    let mut pos = 0;
-    while pos + needle.len() <= haystack.len() {
-        if &haystack[pos..pos + needle.len()] == needle {
-            count += 1;
-            pos += needle.len();
-        } else {
-            pos += 1;
-        }
-    }
-    count
-}
-
-/// Implements Python's `bytes.find(sub[, start[, end]])` method.
-///
-/// Returns the lowest index where the subsequence is found, or -1 if not found.
-fn bytes_find(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (sub, start, end) = parse_bytes_sub_args("bytes.find", bytes.len(), args, heap, interns)?;
-
-    let slice = &bytes[start..end];
-    let result = if sub.is_empty() {
-        // Empty subsequence: always found at start position
-        Some(0)
-    } else {
-        find_subsequence(slice, &sub)
-    };
-
-    let idx = match result {
-        Some(i) => i64::try_from(start + i).expect("index exceeds i64::MAX"),
-        None => -1,
-    };
-    Ok(Value::Int(idx))
-}
-
-/// Finds the first occurrence of needle in haystack.
-fn find_subsequence(haystack: &[u8], needle: &[u8]) -> Option<usize> {
-    haystack.windows(needle.len()).position(|window| window == needle)
-}
-
-/// Implements Python's `bytes.index(sub[, start[, end]])` method.
-///
-/// Like find(), but raises ValueError if the subsequence is not found.
-fn bytes_index(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (sub, start, end) = parse_bytes_sub_args("bytes.index", bytes.len(), args, heap, interns)?;
-
-    let slice = &bytes[start..end];
-    let result = if sub.is_empty() {
-        // Empty subsequence: always found at start position
-        Some(0)
-    } else {
-        find_subsequence(slice, &sub)
-    };
-
-    match result {
-        Some(i) => {
-            let idx = i64::try_from(start + i).expect("index exceeds i64::MAX");
-            Ok(Value::Int(idx))
-        }
-        None => Err(ExcType::value_error_subsequence_not_found()),
-    }
-}
-
-/// Implements Python's `bytes.startswith(prefix[, start[, end]])` method.
-///
-/// Returns True if bytes starts with the specified prefix.
-/// Accepts bytes or a tuple of bytes as prefix. If a tuple is given, returns True
-/// if any of the prefixes match.
-fn bytes_startswith(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (prefix_arg, start, end) =
-        parse_bytes_prefix_suffix_args("bytes.startswith", bytes.len(), args, heap, interns)?;
-
-    let slice = &bytes[start..end];
-    let result = match prefix_arg {
-        PrefixSuffixArg::Single(prefix_bytes) => slice.starts_with(&prefix_bytes),
-        PrefixSuffixArg::Multiple(prefixes) => prefixes.iter().any(|p| slice.starts_with(p)),
-    };
-    Ok(Value::Bool(result))
-}
-
-/// Implements Python's `bytes.endswith(suffix[, start[, end]])` method.
-///
-/// Returns True if bytes ends with the specified suffix.
-/// Accepts bytes or a tuple of bytes as suffix. If a tuple is given, returns True
-/// if any of the suffixes match.
-fn bytes_endswith(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (suffix_arg, start, end) = parse_bytes_prefix_suffix_args("bytes.endswith", bytes.len(), args, heap, interns)?;
-
-    let slice = &bytes[start..end];
-    let result = match suffix_arg {
-        PrefixSuffixArg::Single(suffix_bytes) => slice.ends_with(&suffix_bytes),
-        PrefixSuffixArg::Multiple(suffixes) => suffixes.iter().any(|s| slice.ends_with(s)),
-    };
-    Ok(Value::Bool(result))
-}
-
-/// Argument type for prefix/suffix matching methods.
-///
-/// Represents either a single bytes value or a tuple of bytes values
-/// for matching in startswith/endswith.
-enum PrefixSuffixArg {
-    /// A single bytes value to match
-    Single(Vec<u8>),
-    /// Multiple bytes values to match (from a tuple)
-    Multiple(Vec<Vec<u8>>),
-}
-
-/// Parses arguments for bytes.startswith/endswith methods.
-///
-/// Returns (prefix/suffix_arg, start, end) where start and end are normalized indices.
-/// The prefix/suffix_arg can be a single bytes value or a tuple of bytes values.
-/// Guarantees `start <= end` to prevent slice panics.
-fn parse_bytes_prefix_suffix_args(
-    method: &str,
-    len: usize,
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<(PrefixSuffixArg, usize, usize)> {
-    let pos = args.into_pos_only(method, heap)?;
-    defer_drop!(pos, heap);
-
-    let (prefix, start, end) = match pos.as_slice() {
-        [prefix_value] => {
-            let prefix = extract_bytes_for_prefix_suffix(prefix_value, method, heap, interns)?;
-            (prefix, 0, len)
-        }
-        [prefix_value, start_value] => {
-            let prefix = extract_bytes_for_prefix_suffix(prefix_value, method, heap, interns)?;
-            let start = normalize_bytes_index(start_value.as_int(heap)?, len);
-            (prefix, start, len)
-        }
-        [prefix_value, start_value, end_value] => {
-            let prefix = extract_bytes_for_prefix_suffix(prefix_value, method, heap, interns)?;
-            let start = normalize_bytes_index(start_value.as_int(heap)?, len);
-            let end = normalize_bytes_index(end_value.as_int(heap)?, len);
-            (prefix, start, end)
-        }
-        [] => return Err(ExcType::type_error_at_least(method, 1, 0)),
-        _ => return Err(ExcType::type_error_at_most(method, 3, pos.len())),
-    };
-
-    // Ensure start <= end to prevent slice panics
-    Ok((prefix, start, end.max(start)))
-}
-
-/// Extracts bytes (or tuple of bytes) for startswith/endswith methods.
-///
-/// Returns `PrefixSuffixArg::Single` for a single bytes value, or
-/// `PrefixSuffixArg::Multiple` for a tuple of bytes values.
-fn extract_bytes_for_prefix_suffix(
-    value: &Value,
-    method: &str,
-    heap: &Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<PrefixSuffixArg> {
-    // Extract the method name (e.g., "startswith" from "bytes.startswith")
-    let method_name = method.strip_prefix("bytes.").unwrap_or(method);
-
-    match value {
-        Value::InternBytes(id) => Ok(PrefixSuffixArg::Single(interns.get_bytes(*id).to_vec())),
-        Value::InternString(_) => Err(ExcType::type_error(format!(
-            "{method_name} first arg must be bytes or a tuple of bytes, not str"
-        ))),
-        Value::Ref(id) => match heap.get(*id) {
-            HeapData::Bytes(b) => Ok(PrefixSuffixArg::Single(b.as_slice().to_vec())),
-            HeapData::Str(_) => Err(ExcType::type_error(format!(
-                "{method_name} first arg must be bytes or a tuple of bytes, not str"
-            ))),
-            HeapData::Tuple(tuple) => {
-                // Extract each element as bytes
-                let items = tuple.as_slice();
-                let mut prefixes = Vec::with_capacity(items.len());
-                for (i, item) in items.iter().enumerate() {
-                    if let Ok(b) = extract_single_bytes_for_prefix_suffix(item, heap, interns) {
-                        prefixes.push(b);
-                    } else {
-                        let item_type = item.py_type(heap);
-                        return Err(ExcType::type_error(format!(
-                            "{method_name} first arg must be bytes or a tuple of bytes, \
-                             not tuple containing {item_type} at index {i}"
-                        )));
-                    }
-                }
-                Ok(PrefixSuffixArg::Multiple(prefixes))
-            }
-            _ => Err(ExcType::type_error(format!(
-                "{method_name} first arg must be bytes or a tuple of bytes, not {}",
-                value.py_type(heap)
-            ))),
-        },
-        _ => Err(ExcType::type_error(format!(
-            "{method_name} first arg must be bytes or a tuple of bytes, not {}",
-            value.py_type(heap)
-        ))),
-    }
-}
-
-/// Extracts a single bytes value for tuple element in startswith/endswith.
-fn extract_single_bytes_for_prefix_suffix(
-    value: &Value,
-    heap: &Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Vec<u8>> {
-    match value {
-        Value::InternBytes(id) => Ok(interns.get_bytes(*id).to_vec()),
-        Value::InternString(_) => Err(ExcType::type_error("expected bytes, not str")),
-        Value::Ref(id) => match heap.get(*id) {
-            HeapData::Bytes(b) => Ok(b.as_slice().to_vec()),
-            _ => Err(ExcType::type_error("expected bytes")),
-        },
-        _ => Err(ExcType::type_error("expected bytes")),
-    }
-}
-
-/// Extracts bytes from a Value (bytes only, NOT str - matches CPython behavior).
-///
-/// CPython raises `TypeError: a bytes-like object is required, not 'str'` when
-/// a str is passed to bytes methods like find, count, index, startswith, endswith.
-fn extract_bytes_only<'a>(
-    value: &Value,
-    heap: &'a Heap<impl ResourceTracker>,
-    interns: &'a Interns,
-) -> RunResult<&'a [u8]> {
-    match value {
-        Value::InternBytes(id) => Ok(interns.get_bytes(*id)),
-        Value::InternString(_) => Err(ExcType::type_error("a bytes-like object is required, not 'str'")),
-        Value::Ref(id) => match heap.get(*id) {
-            HeapData::Bytes(b) => Ok(b.as_slice()),
-            HeapData::Str(_) => Err(ExcType::type_error("a bytes-like object is required, not 'str'")),
-            _ => Err(ExcType::type_error("a bytes-like object is required")),
-        },
-        _ => Err(ExcType::type_error("a bytes-like object is required")),
-    }
-}
-
-/// Parses arguments for bytes.find/count/index methods.
-///
-/// Returns (sub_bytes, start, end) where start and end are normalized indices.
-/// Guarantees `start <= end` to prevent slice panics.
-fn parse_bytes_sub_args(
-    method: &str,
-    len: usize,
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<(Vec<u8>, usize, usize)> {
-    let pos = args.into_pos_only(method, heap)?;
-    defer_drop!(pos, heap);
-
-    let (sub, start, end) = match pos.as_slice() {
-        [sub_value] => {
-            let sub = extract_bytes_only(sub_value, heap, interns)?;
-            (sub, 0, len)
-        }
-        [sub_value, start_value] => {
-            let sub = extract_bytes_only(sub_value, heap, interns)?;
-            let start = normalize_bytes_index(start_value.as_int(heap)?, len);
-            (sub, start, len)
-        }
-        [sub_value, start_value, end_value] => {
-            let sub = extract_bytes_only(sub_value, heap, interns)?;
-            let start = normalize_bytes_index(start_value.as_int(heap)?, len);
-            let end = normalize_bytes_index(end_value.as_int(heap)?, len);
-            (sub, start, end)
-        }
-        [] => return Err(ExcType::type_error_at_least(method, 1, 0)),
-        _ => return Err(ExcType::type_error_at_most(method, 3, pos.len())),
-    };
-
-    // Ensure start <= end to prevent slice panics (Python treats start > end as empty slice)
-    Ok((sub.to_owned(), start, end.max(start)))
-}
-
-/// Normalizes a Python-style bytes index to a valid index in range [0, len].
-fn normalize_bytes_index(index: i64, len: usize) -> usize {
-    if index < 0 {
-        let abs_index = usize::try_from(-index).unwrap_or(usize::MAX);
-        len.saturating_sub(abs_index)
-    } else {
-        usize::try_from(index).unwrap_or(len).min(len)
-    }
-}
-
-// =============================================================================
-// Simple transformations (no arguments)
-// =============================================================================
-
-/// Implements Python's `bytes.lower()` method.
-///
-/// Returns a copy of the bytes with all ASCII uppercase characters converted to lowercase.
-fn bytes_lower(bytes: &[u8], heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
-    let result: Vec<u8> = bytes.iter().map(|&b| b.to_ascii_lowercase()).collect();
-    allocate_bytes(result, heap)
-}
-
-/// Implements Python's `bytes.upper()` method.
-///
-/// Returns a copy of the bytes with all ASCII lowercase characters converted to uppercase.
-fn bytes_upper(bytes: &[u8], heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
-    let result: Vec<u8> = bytes.iter().map(|&b| b.to_ascii_uppercase()).collect();
-    allocate_bytes(result, heap)
-}
-
-/// Implements Python's `bytes.capitalize()` method.
-///
-/// Returns a copy of the bytes with the first byte capitalized (if ASCII) and
-/// the rest lowercased.
-fn bytes_capitalize(bytes: &[u8], heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
-    let mut result = Vec::with_capacity(bytes.len());
-    if let Some((&first, rest)) = bytes.split_first() {
-        result.push(first.to_ascii_uppercase());
-        for &b in rest {
-            result.push(b.to_ascii_lowercase());
-        }
-    }
-    allocate_bytes(result, heap)
-}
-
-/// Implements Python's `bytes.title()` method.
-///
-/// Returns a titlecased version of the bytes where words start with an uppercase
-/// ASCII character and the remaining characters are lowercase.
-fn bytes_title(bytes: &[u8], heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
-    let mut result = Vec::with_capacity(bytes.len());
-    let mut prev_is_cased = false;
-
-    for &b in bytes {
-        if prev_is_cased {
-            result.push(b.to_ascii_lowercase());
-        } else {
-            result.push(b.to_ascii_uppercase());
-        }
-        prev_is_cased = b.is_ascii_alphabetic();
-    }
-
-    allocate_bytes(result, heap)
-}
-
-/// Implements Python's `bytes.swapcase()` method.
-///
-/// Returns a copy of the bytes with ASCII uppercase characters converted to
-/// lowercase and vice versa.
-fn bytes_swapcase(bytes: &[u8], heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
-    let result: Vec<u8> = bytes
-        .iter()
-        .map(|&b| {
-            if b.is_ascii_uppercase() {
-                b.to_ascii_lowercase()
-            } else if b.is_ascii_lowercase() {
-                b.to_ascii_uppercase()
-            } else {
-                b
-            }
-        })
-        .collect();
-    allocate_bytes(result, heap)
-}
-
-// =============================================================================
-// Predicate methods (no arguments, return bool)
-// =============================================================================
-
-/// Implements Python's `bytes.isalpha()` method.
-///
-/// Returns True if all bytes in the bytes are ASCII letters and there is at least one byte.
-fn bytes_isalpha(bytes: &[u8]) -> bool {
-    !bytes.is_empty() && bytes.iter().all(|&b| b.is_ascii_alphabetic())
-}
-
-/// Implements Python's `bytes.isdigit()` method.
-///
-/// Returns True if all bytes in the bytes are ASCII digits and there is at least one byte.
-fn bytes_isdigit(bytes: &[u8]) -> bool {
-    !bytes.is_empty() && bytes.iter().all(|&b| b.is_ascii_digit())
-}
-
-/// Implements Python's `bytes.isalnum()` method.
-///
-/// Returns True if all bytes in the bytes are ASCII alphanumeric and there is at least one byte.
-fn bytes_isalnum(bytes: &[u8]) -> bool {
-    !bytes.is_empty() && bytes.iter().all(|&b| b.is_ascii_alphanumeric())
-}
-
-/// Implements Python's `bytes.isspace()` method.
-///
-/// Returns True if all bytes in the bytes are ASCII whitespace and there is at least one byte.
-fn bytes_isspace(bytes: &[u8]) -> bool {
-    !bytes.is_empty() && bytes.iter().all(|&b| is_py_whitespace(b))
-}
-
-/// Implements Python's `bytes.islower()` method.
-///
-/// Returns True if all cased bytes are lowercase and there is at least one cased byte.
-fn bytes_islower(bytes: &[u8]) -> bool {
-    let mut has_cased = false;
-    for &b in bytes {
-        if b.is_ascii_uppercase() {
-            return false;
-        }
-        if b.is_ascii_lowercase() {
-            has_cased = true;
-        }
-    }
-    has_cased
-}
-
-/// Implements Python's `bytes.isupper()` method.
-///
-/// Returns True if all cased bytes are uppercase and there is at least one cased byte.
-fn bytes_isupper(bytes: &[u8]) -> bool {
-    let mut has_cased = false;
-    for &b in bytes {
-        if b.is_ascii_lowercase() {
-            return false;
-        }
-        if b.is_ascii_uppercase() {
-            has_cased = true;
-        }
-    }
-    has_cased
-}
-
-/// Implements Python's `bytes.istitle()` method.
-///
-/// Returns True if the bytes are titlecased: uppercase characters follow
-/// uncased characters and lowercase characters follow cased characters.
-fn bytes_istitle(bytes: &[u8]) -> bool {
-    if bytes.is_empty() {
-        return false;
-    }
-
-    let mut prev_cased = false;
-    let mut has_cased = false;
-
-    for &b in bytes {
-        if b.is_ascii_uppercase() {
-            if prev_cased {
-                return false;
-            }
-            prev_cased = true;
-            has_cased = true;
-        } else if b.is_ascii_lowercase() {
-            if !prev_cased {
-                return false;
-            }
-            prev_cased = true;
-            has_cased = true;
-        } else {
-            prev_cased = false;
-        }
-    }
-
-    has_cased
-}
-
-// =============================================================================
-// Search methods
-// =============================================================================
-
-/// Implements Python's `bytes.rfind(sub[, start[, end]])` method.
-///
-/// Returns the highest index where the subsequence is found, or -1 if not found.
-fn bytes_rfind(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (sub, start, end) = parse_bytes_sub_args("bytes.rfind", bytes.len(), args, heap, interns)?;
-
-    let slice = &bytes[start..end];
-    let result = if sub.is_empty() {
-        // Empty subsequence: always found at end position
-        Some(slice.len())
-    } else {
-        rfind_subsequence(slice, &sub)
-    };
-
-    let idx = match result {
-        Some(i) => i64::try_from(start + i).expect("index exceeds i64::MAX"),
-        None => -1,
-    };
-    Ok(Value::Int(idx))
-}
-
-/// Finds the last occurrence of needle in haystack.
-fn rfind_subsequence(haystack: &[u8], needle: &[u8]) -> Option<usize> {
-    if needle.len() > haystack.len() {
-        return None;
-    }
-    haystack.windows(needle.len()).rposition(|window| window == needle)
-}
-
-/// Implements Python's `bytes.rindex(sub[, start[, end]])` method.
-///
-/// Like rfind(), but raises ValueError if the subsequence is not found.
-fn bytes_rindex(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (sub, start, end) = parse_bytes_sub_args("bytes.rindex", bytes.len(), args, heap, interns)?;
-
-    let slice = &bytes[start..end];
-    let result = if sub.is_empty() {
-        Some(slice.len())
-    } else {
-        rfind_subsequence(slice, &sub)
-    };
-
-    match result {
-        Some(i) => {
-            let idx = i64::try_from(start + i).expect("index exceeds i64::MAX");
-            Ok(Value::Int(idx))
-        }
-        None => Err(ExcType::value_error_subsequence_not_found()),
-    }
-}
-
-// =============================================================================
-// Strip/trim methods
-// =============================================================================
-
-/// Implements Python's `bytes.strip([chars])` method.
-///
-/// Returns a copy of the bytes with leading and trailing bytes removed.
-/// If chars is not specified, ASCII whitespace bytes are removed.
-fn bytes_strip(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let value = args.get_zero_one_arg("bytes.strip", heap)?;
-    defer_drop!(value, heap);
-    let result = match value {
-        None | Some(Value::None) => bytes_strip_whitespace_both(bytes),
-        Some(v) => bytes_strip_both(bytes, extract_bytes_only(v, heap, interns)?),
-    };
-    allocate_bytes(result.to_vec(), heap)
-}
-
-/// Implements Python's `bytes.lstrip([chars])` method.
-///
-/// Returns a copy of the bytes with leading bytes removed.
-fn bytes_lstrip(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let value = args.get_zero_one_arg("bytes.lstrip", heap)?;
-    defer_drop!(value, heap);
-    let result = match value {
-        None | Some(Value::None) => bytes_strip_whitespace_start(bytes),
-        Some(v) => bytes_strip_start(bytes, extract_bytes_only(v, heap, interns)?),
-    };
-    allocate_bytes(result.to_vec(), heap)
-}
-
-/// Implements Python's `bytes.rstrip([chars])` method.
-///
-/// Returns a copy of the bytes with trailing bytes removed.
-fn bytes_rstrip(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let value = args.get_zero_one_arg("bytes.rstrip", heap)?;
-    defer_drop!(value, heap);
-    let result = match value {
-        None | Some(Value::None) => bytes_strip_whitespace_end(bytes),
-        Some(v) => bytes_strip_end(bytes, extract_bytes_only(v, heap, interns)?),
-    };
-    allocate_bytes(result.to_vec(), heap)
-}
-
-/// Strips bytes in `chars` from both ends of the byte slice.
-fn bytes_strip_both<'a>(bytes: &'a [u8], chars: &[u8]) -> &'a [u8] {
-    let start = bytes.iter().position(|b| !chars.contains(b)).unwrap_or(bytes.len());
-    let end = bytes
-        .iter()
-        .rposition(|b| !chars.contains(b))
-        .map_or(start, |pos| pos + 1);
-    &bytes[start..end]
-}
-
-/// Strips bytes in `chars` from the start of the byte slice.
-fn bytes_strip_start<'a>(bytes: &'a [u8], chars: &[u8]) -> &'a [u8] {
-    let start = bytes.iter().position(|b| !chars.contains(b)).unwrap_or(bytes.len());
-    &bytes[start..]
-}
-
-/// Strips bytes in `chars` from the end of the byte slice.
-fn bytes_strip_end<'a>(bytes: &'a [u8], chars: &[u8]) -> &'a [u8] {
-    let end = bytes.iter().rposition(|b| !chars.contains(b)).map_or(0, |pos| pos + 1);
-    &bytes[..end]
-}
-
-/// Strips ASCII whitespace from both ends of the byte slice.
-fn bytes_strip_whitespace_both(bytes: &[u8]) -> &[u8] {
-    let start = bytes.iter().position(|b| !is_py_whitespace(*b)).unwrap_or(bytes.len());
-    let end = bytes
-        .iter()
-        .rposition(|b| !is_py_whitespace(*b))
-        .map_or(start, |pos| pos + 1);
-    &bytes[start..end]
-}
-
-/// Strips ASCII whitespace from the start of the byte slice.
-fn bytes_strip_whitespace_start(bytes: &[u8]) -> &[u8] {
-    let start = bytes.iter().position(|b| !is_py_whitespace(*b)).unwrap_or(bytes.len());
-    &bytes[start..]
-}
-
-/// Strips ASCII whitespace from the end of the byte slice.
-fn bytes_strip_whitespace_end(bytes: &[u8]) -> &[u8] {
-    let end = bytes
-        .iter()
-        .rposition(|b| !is_py_whitespace(*b))
-        .map_or(0, |pos| pos + 1);
-    &bytes[..end]
-}
-
-/// Implements Python's `bytes.removeprefix(prefix)` method.
-///
-/// If the bytes start with the prefix, return bytes[len(prefix):].
-/// Otherwise, return a copy of the original bytes.
-fn bytes_removeprefix(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let prefix_value = args.get_one_arg("bytes.removeprefix", heap)?;
-    defer_drop!(prefix_value, heap);
-    let prefix = extract_bytes_only(prefix_value, heap, interns)?;
-
-    let result = if bytes.starts_with(prefix) {
-        bytes[prefix.len()..].to_vec()
-    } else {
-        bytes.to_vec()
-    };
-    allocate_bytes(result, heap)
-}
-
-/// Implements Python's `bytes.removesuffix(suffix)` method.
-///
-/// If the bytes end with the suffix, return bytes[:-len(suffix)].
-/// Otherwise, return a copy of the original bytes.
-fn bytes_removesuffix(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let suffix_value = args.get_one_arg("bytes.removesuffix", heap)?;
-    defer_drop!(suffix_value, heap);
-    let suffix = extract_bytes_only(suffix_value, heap, interns)?;
-
-    let result = if bytes.ends_with(suffix) && !suffix.is_empty() {
-        bytes[..bytes.len() - suffix.len()].to_vec()
-    } else {
-        bytes.to_vec()
-    };
-    allocate_bytes(result, heap)
-}
-
-// =============================================================================
-// Split methods
-// =============================================================================
-
-/// Implements Python's `bytes.split([sep[, maxsplit]])` method.
-///
-/// Returns a list of the bytes split by the separator.
-fn bytes_split(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (sep, maxsplit) = parse_bytes_split_args("bytes.split", args, heap, interns)?;
-
-    let parts: Vec<&[u8]> = match &sep {
-        Some(sep) => {
-            if sep.is_empty() {
-                return Err(ExcType::value_error_empty_separator());
-            }
-            if maxsplit < 0 {
-                bytes_split_by_seq(bytes, sep)
-            } else {
-                let max = usize::try_from(maxsplit).unwrap_or(usize::MAX);
-                bytes_splitn_by_seq(bytes, sep, max + 1)
-            }
-        }
-        None => {
-            if maxsplit < 0 {
-                bytes_split_whitespace(bytes)
-            } else {
-                let max = usize::try_from(maxsplit).unwrap_or(usize::MAX);
-                bytes_splitn_whitespace(bytes, max)
-            }
-        }
-    };
-
-    let mut list_items = Vec::with_capacity(parts.len());
-    for part in parts {
-        heap.check_time()?;
-        list_items.push(allocate_bytes(part.to_vec(), heap)?);
-    }
-
-    let list = List::new(list_items);
-    let heap_id = heap.allocate(HeapData::List(list))?;
-    Ok(Value::Ref(heap_id))
-}
-
-/// Implements Python's `bytes.rsplit([sep[, maxsplit]])` method.
-///
-/// Returns a list of the bytes split by the separator, splitting from the right.
-fn bytes_rsplit(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (sep, maxsplit) = parse_bytes_split_args("bytes.rsplit", args, heap, interns)?;
-
-    let parts: Vec<&[u8]> = match &sep {
-        Some(sep) => {
-            if sep.is_empty() {
-                return Err(ExcType::value_error_empty_separator());
-            }
-            if maxsplit < 0 {
-                bytes_split_by_seq(bytes, sep)
-            } else {
-                let max = usize::try_from(maxsplit).unwrap_or(usize::MAX);
-                bytes_rsplitn_by_seq(bytes, sep, max + 1)
-            }
-        }
-        None => {
-            if maxsplit < 0 {
-                bytes_split_whitespace(bytes)
-            } else {
-                let max = usize::try_from(maxsplit).unwrap_or(usize::MAX);
-                bytes_rsplitn_whitespace(bytes, max)
-            }
-        }
-    };
-
-    let mut list_items = Vec::with_capacity(parts.len());
-    for part in parts {
-        heap.check_time()?;
-        list_items.push(allocate_bytes(part.to_vec(), heap)?);
-    }
-
-    let list = List::new(list_items);
-    let heap_id = heap.allocate(HeapData::List(list))?;
-    Ok(Value::Ref(heap_id))
-}
-
-/// Parses arguments for bytes split methods.
-fn parse_bytes_split_args(
-    method: &str,
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<(Option<Vec<u8>>, i64)> {
-    let (pos_iter, kwargs) = args.into_parts();
-    defer_drop_mut!(pos_iter, heap);
-    let kwargs_iter = kwargs.into_iter();
-    defer_drop_mut!(kwargs_iter, heap);
-
-    let sep_value = pos_iter.next();
-    defer_drop_mut!(sep_value, heap);
-    let maxsplit_value = pos_iter.next();
-    defer_drop_mut!(maxsplit_value, heap);
-
-    // Check no extra positional arguments
-    if pos_iter.len() != 0 {
-        return Err(ExcType::type_error_at_most(method, 2, 3));
-    }
-
-    // Process keyword arguments
-    for (key, value) in kwargs_iter {
-        defer_drop!(key, heap);
-        let mut value_guard = HeapGuard::new(value, heap);
-
-        let Some(keyword_name) = key.as_either_str(value_guard.heap()) else {
-            return Err(ExcType::type_error("keywords must be strings"));
-        };
-
-        let key_str = keyword_name.as_str(interns);
-        match key_str {
-            "sep" => {
-                if let Some(previous_value) = sep_value.replace(value_guard.into_inner()) {
-                    previous_value.drop_with_heap(heap);
-                    return Err(ExcType::type_error(format!(
-                        "{method}() got multiple values for argument 'sep'"
-                    )));
-                }
-            }
-            "maxsplit" => {
-                if let Some(previous_value) = maxsplit_value.replace(value_guard.into_inner()) {
-                    previous_value.drop_with_heap(heap);
-                    return Err(ExcType::type_error(format!(
-                        "{method}() got multiple values for argument 'maxsplit'"
-                    )));
-                }
-            }
-            _ => {
-                return Err(ExcType::type_error(format!(
-                    "'{key_str}' is an invalid keyword argument for {method}()"
-                )));
-            }
-        }
-    }
-
-    // Extract sep (default None)
-    let sep = if let Some(v) = sep_value {
-        if matches!(v, Value::None) {
-            None
-        } else {
-            Some(extract_bytes_only(v, heap, interns)?.to_owned())
-        }
-    } else {
-        None
-    };
-
-    // Extract maxsplit (default -1)
-    let maxsplit = if let Some(v) = maxsplit_value {
-        v.as_int(heap)?
-    } else {
-        -1
-    };
-
-    Ok((sep, maxsplit))
-}
-
-/// Splits bytes by a separator sequence.
-fn bytes_split_by_seq<'a>(bytes: &'a [u8], sep: &[u8]) -> Vec<&'a [u8]> {
-    let mut parts = Vec::new();
-    let mut start = 0;
-
-    while let Some(pos) = find_subsequence(&bytes[start..], sep) {
-        parts.push(&bytes[start..start + pos]);
-        start = start + pos + sep.len();
-    }
-    parts.push(&bytes[start..]);
-
-    parts
-}
-
-/// Splits bytes by a separator sequence, returning at most n parts.
-fn bytes_splitn_by_seq<'a>(bytes: &'a [u8], sep: &[u8], n: usize) -> Vec<&'a [u8]> {
-    let mut parts = Vec::new();
-    let mut start = 0;
-    let mut count = 0;
-
-    while count + 1 < n {
-        if let Some(pos) = find_subsequence(&bytes[start..], sep) {
-            parts.push(&bytes[start..start + pos]);
-            start = start + pos + sep.len();
-            count += 1;
-        } else {
-            break;
-        }
-    }
-    parts.push(&bytes[start..]);
-
-    parts
-}
-
-/// Splits bytes by a separator sequence from the right, returning at most n parts.
-fn bytes_rsplitn_by_seq<'a>(bytes: &'a [u8], sep: &[u8], n: usize) -> Vec<&'a [u8]> {
-    let mut parts = Vec::new();
-    let mut end = bytes.len();
-    let mut count = 0;
-
-    while count + 1 < n {
-        if let Some(pos) = rfind_subsequence(&bytes[..end], sep) {
-            parts.push(&bytes[pos + sep.len()..end]);
-            end = pos;
-            count += 1;
-        } else {
-            break;
-        }
-    }
-    parts.push(&bytes[..end]);
-    parts.reverse();
-
-    parts
-}
-
-/// Splits bytes by ASCII whitespace, filtering empty parts.
-fn bytes_split_whitespace(bytes: &[u8]) -> Vec<&[u8]> {
-    let mut parts = Vec::new();
-    let mut start = None;
-
-    for (i, &b) in bytes.iter().enumerate() {
-        if is_py_whitespace(b) {
-            if let Some(s) = start {
-                parts.push(&bytes[s..i]);
-                start = None;
-            }
-        } else if start.is_none() {
-            start = Some(i);
-        }
-    }
-
-    if let Some(s) = start {
-        parts.push(&bytes[s..]);
-    }
-
-    parts
-}
-
-/// Splits bytes by ASCII whitespace, returning at most maxsplit+1 parts.
-fn bytes_splitn_whitespace(bytes: &[u8], maxsplit: usize) -> Vec<&[u8]> {
-    let mut parts = Vec::new();
-    let mut start = None;
-    let mut count = 0;
-
-    let trimmed = bytes_strip_whitespace_start(bytes);
-    let offset = bytes.len() - trimmed.len();
-
-    for (i, &b) in trimmed.iter().enumerate() {
-        if is_py_whitespace(b) {
-            if let Some(s) = start
-                && count < maxsplit
-            {
-                parts.push(&bytes[offset + s..offset + i]);
-                count += 1;
-                start = None;
-            }
-        } else if start.is_none() {
-            start = Some(i);
-        }
-    }
-
-    if let Some(s) = start {
-        parts.push(&bytes[offset + s..]);
-    }
-
-    parts
-}
-
-/// Splits bytes by ASCII whitespace from the right, returning at most maxsplit+1 parts.
-fn bytes_rsplitn_whitespace(bytes: &[u8], maxsplit: usize) -> Vec<&[u8]> {
-    let mut parts = Vec::new();
-    let mut end = None;
-    let mut count = 0;
-
-    let trimmed = bytes_strip_whitespace_end(bytes);
-
-    for i in (0..trimmed.len()).rev() {
-        let b = trimmed[i];
-        if is_py_whitespace(b) {
-            if let Some(e) = end
-                && count < maxsplit
-            {
-                parts.push(&trimmed[i + 1..e]);
-                count += 1;
-                end = None;
-            }
-        } else if end.is_none() {
-            end = Some(i + 1);
-        }
-    }
-
-    if let Some(e) = end {
-        parts.push(&trimmed[..e]);
-    }
-
-    parts.reverse();
-    parts
-}
-
-/// Implements Python's `bytes.splitlines([keepends])` method.
-///
-/// Returns a list of the lines in the bytes, breaking at line boundaries.
-fn bytes_splitlines(bytes: &[u8], args: ArgValues, vm: &mut VM<'_, '_, impl ResourceTracker>) -> RunResult<Value> {
-    let keepends = parse_bytes_splitlines_args(args, vm)?;
-
-    let mut lines = Vec::new();
-    let mut start = 0;
-    let len = bytes.len();
-
-    while start < len {
-        vm.heap.check_time()?;
-
-        let mut end = start;
-        let mut line_end = start;
-
-        while end < len {
-            match bytes[end] {
-                b'\n' => {
-                    line_end = end;
-                    end += 1;
-                    break;
-                }
-                b'\r' => {
-                    line_end = end;
-                    end += 1;
-                    if end < len && bytes[end] == b'\n' {
-                        end += 1;
-                    }
-                    break;
-                }
-                _ => {
-                    end += 1;
-                    line_end = end;
-                }
-            }
-        }
-
-        let line = if keepends {
-            &bytes[start..end]
-        } else {
-            &bytes[start..line_end]
-        };
-        lines.push(allocate_bytes(line.to_vec(), vm.heap)?);
-        start = end;
-    }
-
-    let list = List::new(lines);
-    let heap_id = vm.heap.allocate(HeapData::List(list))?;
-    Ok(Value::Ref(heap_id))
-}
-
-/// Parses arguments for bytes.splitlines method.
-fn parse_bytes_splitlines_args(args: ArgValues, vm: &mut VM<'_, '_, impl ResourceTracker>) -> RunResult<bool> {
-    let (pos_iter, kwargs) = args.into_parts();
-    defer_drop_mut!(pos_iter, vm);
-    let kwargs = kwargs.into_iter();
-    defer_drop_mut!(kwargs, vm);
-
-    let keepends_value = pos_iter.next();
-    defer_drop_mut!(keepends_value, vm);
-
-    // Check no extra positional arguments
-    if pos_iter.len() != 0 {
-        return Err(ExcType::type_error_at_most("bytes.splitlines", 1, 2));
-    }
-
-    // Process kwargs
-    for (key, value) in kwargs {
-        defer_drop!(key, vm);
-        let mut value_guard = HeapGuard::new(value, vm);
-
-        let Some(keyword_name) = key.as_either_str(value_guard.heap().heap) else {
-            return Err(ExcType::type_error("keywords must be strings"));
-        };
-
-        let key_str = keyword_name.as_str(value_guard.heap().interns);
-        if key_str == "keepends" {
-            if let Some(previous_value) = keepends_value.replace(value_guard.into_inner()) {
-                previous_value.drop_with_heap(vm);
-                return Err(ExcType::type_error(
-                    "bytes.splitlines() got multiple values for argument 'keepends'",
-                ));
-            }
-        } else {
-            return Err(ExcType::type_error(format!(
-                "'{key_str}' is an invalid keyword argument for bytes.splitlines()"
-            )));
-        }
-    }
-
-    // Extract keepends (default false)
-    let keepends = if let Some(v) = keepends_value {
-        v.py_bool(vm)
-    } else {
-        false
-    };
-
-    Ok(keepends)
-}
-
-/// Implements Python's `bytes.partition(sep)` method.
-///
-/// Splits the bytes at the first occurrence of sep, and returns a 3-tuple.
-fn bytes_partition(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let sep_value = args.get_one_arg("bytes.partition", heap)?;
-    defer_drop!(sep_value, heap);
-    let sep = extract_bytes_only(sep_value, heap, interns)?;
-
-    if sep.is_empty() {
-        return Err(ExcType::value_error_empty_separator());
-    }
-
-    let (before, sep_found, after) = match find_subsequence(bytes, sep) {
-        Some(pos) => (bytes[..pos].to_vec(), sep.to_vec(), bytes[pos + sep.len()..].to_vec()),
-        None => (bytes.to_vec(), Vec::new(), Vec::new()),
-    };
-
-    let before_val = allocate_bytes(before, heap)?;
-    let sep_val = allocate_bytes(sep_found, heap)?;
-    let after_val = allocate_bytes(after, heap)?;
-
-    Ok(crate::types::allocate_tuple(
-        smallvec![before_val, sep_val, after_val],
-        heap,
-    )?)
-}
-
-/// Implements Python's `bytes.rpartition(sep)` method.
-///
-/// Splits the bytes at the last occurrence of sep, and returns a 3-tuple.
-fn bytes_rpartition(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let sep_value = args.get_one_arg("bytes.rpartition", heap)?;
-    defer_drop!(sep_value, heap);
-    let sep = extract_bytes_only(sep_value, heap, interns)?;
-
-    if sep.is_empty() {
-        return Err(ExcType::value_error_empty_separator());
-    }
-
-    let (before, sep_found, after) = match rfind_subsequence(bytes, sep) {
-        Some(pos) => (bytes[..pos].to_vec(), sep.to_vec(), bytes[pos + sep.len()..].to_vec()),
-        None => (Vec::new(), Vec::new(), bytes.to_vec()),
-    };
-
-    let before_val = allocate_bytes(before, heap)?;
-    let sep_val = allocate_bytes(sep_found, heap)?;
-    let after_val = allocate_bytes(after, heap)?;
-
-    Ok(crate::types::allocate_tuple(
-        smallvec![before_val, sep_val, after_val],
-        heap,
-    )?)
-}
-
-// =============================================================================
-// Replace/padding methods
-// =============================================================================
-
-/// Implements Python's `bytes.replace(old, new[, count])` method.
-///
-/// Returns a copy with all occurrences of old replaced by new.
-fn bytes_replace(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (old, new, count) = parse_bytes_replace_args("bytes.replace", args, heap, interns)?;
-
-    check_replace_size(bytes.len(), old.len(), new.len(), count, heap.tracker())?;
-
-    let result = if count < 0 {
-        bytes_replace_all(bytes, &old, &new, heap)?
-    } else {
-        let n = usize::try_from(count).unwrap_or(usize::MAX);
-        bytes_replace_n(bytes, &old, &new, n, heap)?
-    };
-
-    allocate_bytes(result, heap)
-}
-
-/// Parses arguments for bytes.replace method.
-fn parse_bytes_replace_args(
-    method: &str,
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<(Vec<u8>, Vec<u8>, i64)> {
-    let (pos_iter, kwargs) = args.into_parts();
-    defer_drop_mut!(pos_iter, heap);
-    let kwargs_iter = kwargs.into_iter();
-    defer_drop_mut!(kwargs_iter, heap);
-
-    let Some(old_value) = pos_iter.next() else {
-        return Err(ExcType::type_error_at_least(method, 2, 0));
-    };
-    defer_drop!(old_value, heap);
-
-    let Some(new_value) = pos_iter.next() else {
-        return Err(ExcType::type_error_at_least(method, 2, 1));
-    };
-    defer_drop!(new_value, heap);
-
-    let count_value = pos_iter.next();
-    defer_drop_mut!(count_value, heap);
-
-    // Check no extra positional arguments
-    if pos_iter.len() != 0 {
-        return Err(ExcType::type_error_at_most(method, 3, pos_iter.len() + 3));
-    }
-
-    // Process keyword arguments
-    for (key, value) in kwargs_iter {
-        defer_drop!(key, heap);
-        let mut value_guard = HeapGuard::new(value, heap);
-
-        let Some(keyword_name) = key.as_either_str(value_guard.heap()) else {
-            return Err(ExcType::type_error("keywords must be strings"));
-        };
-
-        let key_str = keyword_name.as_str(interns);
-        match key_str {
-            "count" => {
-                if let Some(previous_value) = count_value.replace(value_guard.into_inner()) {
-                    previous_value.drop_with_heap(heap);
-                    return Err(ExcType::type_error(format!(
-                        "{method}() got multiple values for argument 'count'"
-                    )));
-                }
-            }
-            _ => {
-                return Err(ExcType::type_error(format!(
-                    "'{key_str}' is an invalid keyword argument for {method}()"
-                )));
-            }
-        }
-    }
-
-    // Extract old bytes
-    let old = extract_bytes_only(old_value, heap, interns)?.to_owned();
-
-    // Extract new bytes
-    let new = extract_bytes_only(new_value, heap, interns)?.to_owned();
-
-    // Extract count (default -1)
-    let count = if let Some(v) = count_value { v.as_int(heap)? } else { -1 };
-
-    Ok((old, new, count))
-}
-
-/// Replaces all occurrences of `old` with `new` in bytes.
-///
-/// Checks the time limit periodically to enforce `max_duration` during
-/// potentially long replacement operations on large byte sequences.
-fn bytes_replace_all(
-    bytes: &[u8],
-    old: &[u8],
-    new: &[u8],
-    heap: &mut Heap<impl ResourceTracker>,
-) -> Result<Vec<u8>, ResourceError> {
-    if old.is_empty() {
-        // Empty pattern: insert new before each byte and at the end
-        let mut result = Vec::with_capacity(bytes.len() + new.len() * (bytes.len() + 1));
-        for &b in bytes {
-            heap.check_time()?;
-            result.extend_from_slice(new);
-            result.push(b);
-        }
-        result.extend_from_slice(new);
-        Ok(result)
-    } else {
-        let mut result = Vec::new();
-        let mut start = 0;
-        while let Some(pos) = find_subsequence(&bytes[start..], old) {
-            heap.check_time()?;
-            result.extend_from_slice(&bytes[start..start + pos]);
-            result.extend_from_slice(new);
-            start = start + pos + old.len();
-        }
-        result.extend_from_slice(&bytes[start..]);
-        Ok(result)
-    }
-}
-
-/// Replaces at most n occurrences of `old` with `new` in bytes.
-///
-/// Checks the time limit periodically to enforce `max_duration` during
-/// potentially long replacement operations on large byte sequences.
-fn bytes_replace_n(
-    bytes: &[u8],
-    old: &[u8],
-    new: &[u8],
-    n: usize,
-    heap: &mut Heap<impl ResourceTracker>,
-) -> Result<Vec<u8>, ResourceError> {
-    if old.is_empty() {
-        // Empty pattern: insert new before each byte (up to n times)
-        let mut result = Vec::new();
-        let mut count = 0;
-        for &b in bytes {
-            heap.check_time()?;
-            if count < n {
-                result.extend_from_slice(new);
-                count += 1;
-            }
-            result.push(b);
-        }
-        if count < n {
-            result.extend_from_slice(new);
-        }
-        Ok(result)
-    } else {
-        let mut result = Vec::new();
-        let mut start = 0;
-        let mut count = 0;
-        while count < n {
-            heap.check_time()?;
-            if let Some(pos) = find_subsequence(&bytes[start..], old) {
-                result.extend_from_slice(&bytes[start..start + pos]);
-                result.extend_from_slice(new);
-                start = start + pos + old.len();
-                count += 1;
-            } else {
-                break;
-            }
-        }
-        result.extend_from_slice(&bytes[start..]);
-        Ok(result)
-    }
-}
-
-/// Implements Python's `bytes.center(width[, fillbyte])` method.
-///
-/// Returns centered in a bytes of length width.
-fn bytes_center(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (width, fillbyte) = parse_bytes_justify_args("bytes.center", args, heap, interns)?;
-    let len = bytes.len();
-
-    let result = if width <= len {
-        bytes.to_vec()
-    } else {
-        check_repeat_size(width, 1, heap.tracker())?;
-        let total_pad = width - len;
-        let left_pad = total_pad / 2;
-        let right_pad = total_pad - left_pad;
-        let mut result = Vec::with_capacity(width);
-        for _ in 0..left_pad {
-            result.push(fillbyte);
-        }
-        result.extend_from_slice(bytes);
-        for _ in 0..right_pad {
-            result.push(fillbyte);
-        }
-        result
-    };
-
-    allocate_bytes(result, heap)
-}
-
-/// Implements Python's `bytes.ljust(width[, fillbyte])` method.
-///
-/// Returns left-justified in a bytes of length width.
-fn bytes_ljust(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (width, fillbyte) = parse_bytes_justify_args("bytes.ljust", args, heap, interns)?;
-    let len = bytes.len();
-
-    let result = if width <= len {
-        bytes.to_vec()
-    } else {
-        check_repeat_size(width, 1, heap.tracker())?;
-        let pad = width - len;
-        let mut result = Vec::with_capacity(width);
-        result.extend_from_slice(bytes);
-        for _ in 0..pad {
-            result.push(fillbyte);
-        }
-        result
-    };
-
-    allocate_bytes(result, heap)
-}
-
-/// Implements Python's `bytes.rjust(width[, fillbyte])` method.
-///
-/// Returns right-justified in a bytes of length width.
-fn bytes_rjust(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (width, fillbyte) = parse_bytes_justify_args("bytes.rjust", args, heap, interns)?;
-    let len = bytes.len();
-
-    let result = if width <= len {
-        bytes.to_vec()
-    } else {
-        check_repeat_size(width, 1, heap.tracker())?;
-        let pad = width - len;
-        let mut result = Vec::with_capacity(width);
-        for _ in 0..pad {
-            result.push(fillbyte);
-        }
-        result.extend_from_slice(bytes);
-        result
-    };
-
-    allocate_bytes(result, heap)
-}
-
-/// Parses arguments for bytes justify methods (center, ljust, rjust).
-fn parse_bytes_justify_args(
-    method: &str,
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<(usize, u8)> {
-    let pos = args.into_pos_only(method, heap)?;
-    defer_drop!(pos, heap);
-
-    let extract_width = |v: &Value| -> RunResult<usize> {
-        let w = v.as_int(heap)?;
-        Ok(if w < 0 {
-            0
-        } else {
-            usize::try_from(w).unwrap_or(usize::MAX)
-        })
-    };
-
-    let extract_fill = |v: &Value| -> RunResult<u8> {
-        let fill_bytes = extract_bytes_only(v, heap, interns)?;
-        if fill_bytes.len() != 1 {
-            return Err(ExcType::type_error(format!(
-                "{method}() argument 2 must be a byte string of length 1, not bytes of length {}",
-                fill_bytes.len()
-            )));
-        }
-        Ok(fill_bytes[0])
-    };
-
-    match pos.as_slice() {
-        [width_value] => Ok((extract_width(width_value)?, b' ')),
-        [width_value, fillbyte_value] => Ok((extract_width(width_value)?, extract_fill(fillbyte_value)?)),
-        [] => Err(ExcType::type_error_at_least(method, 1, 0)),
-        _ => Err(ExcType::type_error_at_most(method, 2, pos.len())),
-    }
-}
-
-/// Implements Python's `bytes.zfill(width)` method.
-///
-/// Returns a copy of the bytes left filled with ASCII '0' digits.
-fn bytes_zfill(bytes: &[u8], args: ArgValues, heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
-    let width_value = args.get_one_arg("bytes.zfill", heap)?;
-    defer_drop!(width_value, heap);
-    let width_i64 = width_value.as_int(heap)?;
-
-    let width = if width_i64 < 0 {
-        0
-    } else {
-        usize::try_from(width_i64).unwrap_or(usize::MAX)
-    };
-    let len = bytes.len();
-
-    let result = if width <= len {
-        bytes.to_vec()
-    } else {
-        check_repeat_size(width, 1, heap.tracker())?;
-        let pad = width - len;
-        let mut result = Vec::with_capacity(width);
-
-        // Handle sign prefix
-        if !bytes.is_empty() && (bytes[0] == b'+' || bytes[0] == b'-') {
-            result.push(bytes[0]);
-            result.resize(pad + 1, b'0');
-            result.extend_from_slice(&bytes[1..]);
-        } else {
-            result.resize(pad, b'0');
-            result.extend_from_slice(bytes);
-        }
-        result
-    };
-
-    allocate_bytes(result, heap)
-}
-
-// =============================================================================
-// Join method
-// =============================================================================
-
-/// Implements Python's `bytes.join(iterable)` method.
-///
-/// Joins elements of the iterable with the separator bytes.
-fn bytes_join(separator: &[u8], iterable: Value, vm: &mut VM<'_, '_, impl ResourceTracker>) -> RunResult<Value> {
-    let Ok(iter) = MontyIter::new(iterable, vm) else {
-        return Err(ExcType::type_error_join_not_iterable());
-    };
-    defer_drop_mut!(iter, vm);
-
-    let mut result = Vec::new();
-    let mut index = 0usize;
-
-    while let Some(item) = iter.for_next(vm)? {
-        defer_drop!(item, vm);
-
-        if index > 0 {
-            result.extend_from_slice(separator);
-        }
-
-        // Check item is bytes and extract its content
-        match item {
-            Value::InternBytes(id) => {
-                result.extend_from_slice(vm.interns.get_bytes(*id));
-            }
-            Value::Ref(heap_id) => {
-                if let HeapData::Bytes(b) = vm.heap.get(*heap_id) {
-                    result.extend_from_slice(b.as_slice());
-                } else {
-                    let t = item.py_type(vm.heap);
-                    return Err(ExcType::type_error(format!(
-                        "sequence item {index}: expected a bytes-like object, {t} found"
-                    )));
-                }
-            }
-            _ => {
-                let t = item.py_type(vm.heap);
-                return Err(ExcType::type_error(format!(
-                    "sequence item {index}: expected a bytes-like object, {t} found"
-                )));
-            }
-        }
-        index += 1;
-    }
-
-    allocate_bytes(result, vm.heap)
-}
-
-// =============================================================================
-// Hex method
-// =============================================================================
-
-/// Implements Python's `bytes.hex([sep[, bytes_per_sep]])` method.
-///
-/// Returns a string containing the hexadecimal representation of the bytes.
-fn bytes_hex(
-    bytes: &[u8],
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<Value> {
-    let (sep, bytes_per_sep) = parse_bytes_hex_args(args, heap, interns)?;
-
-    let hex_chars: Vec<char> = bytes
-        .iter()
-        .flat_map(|b| {
-            let hi = (b >> 4) & 0xf;
-            let lo = b & 0xf;
-            let hi_char = if hi < 10 {
-                (b'0' + hi) as char
-            } else {
-                (b'a' + hi - 10) as char
-            };
-            let lo_char = if lo < 10 {
-                (b'0' + lo) as char
-            } else {
-                (b'a' + lo - 10) as char
-            };
-            [hi_char, lo_char]
-        })
-        .collect();
-
-    let result = if let Some(sep) = sep {
-        if bytes_per_sep == 0 || bytes.is_empty() {
-            hex_chars.iter().collect()
-        } else {
-            // Insert separator every `bytes_per_sep` bytes (2*bytes_per_sep hex chars)
-            let chars_per_group = usize::try_from(bytes_per_sep.unsigned_abs()).unwrap_or(usize::MAX) * 2;
-            let mut result = String::new();
-
-            if bytes_per_sep > 0 {
-                // Positive: count from right, so partial group is at the START
-                let total_len = hex_chars.len();
-                let first_chunk_len = total_len % chars_per_group;
-                let first_chunk_len = if first_chunk_len == 0 {
-                    chars_per_group
-                } else {
-                    first_chunk_len
-                };
-
-                result.extend(&hex_chars[..first_chunk_len]);
-                for chunk in hex_chars[first_chunk_len..].chunks(chars_per_group) {
-                    result.push(sep);
-                    result.extend(chunk);
-                }
-            } else {
-                // Negative: count from left, so partial group is at the END
-                for (i, chunk) in hex_chars.chunks(chars_per_group).enumerate() {
-                    if i > 0 {
-                        result.push(sep);
-                    }
-                    result.extend(chunk);
-                }
-            }
-            result
-        }
-    } else {
-        hex_chars.iter().collect()
-    };
-
-    crate::types::str::allocate_string(result, heap)
-}
-
-/// Parses arguments for bytes.hex method.
-fn parse_bytes_hex_args(
-    args: ArgValues,
-    heap: &mut Heap<impl ResourceTracker>,
-    interns: &Interns,
-) -> RunResult<(Option<char>, i64)> {
-    let pos = args.into_pos_only("bytes.hex", heap)?;
-    defer_drop!(pos, heap);
-
-    let (sep_value, bps_value) = match pos.as_slice() {
-        [] => return Ok((None, 1)),
-        [sep_value] => (sep_value, None),
-        [sep_value, bps_value] => (sep_value, Some(bps_value)),
-        other => return Err(ExcType::type_error_at_most("bytes.hex", 2, other.len())),
-    };
-
-    let sep_bytes = match sep_value {
-        Value::InternString(id) => interns.get_str(*id).as_bytes(),
-        Value::InternBytes(id) => interns.get_bytes(*id),
-        Value::Ref(heap_id) => match heap.get(*heap_id) {
-            HeapData::Str(s) => s.as_bytes(),
-            HeapData::Bytes(b) => b.as_slice(),
-            _ => return Err(ExcType::type_error("sep must be str or bytes")),
-        },
-        _ => return Err(ExcType::type_error("sep must be str or bytes")),
-    };
-
-    let sep = match sep_bytes {
-        [b] if b.is_ascii() => *b as char,
-        _ => return Err(SimpleException::new_msg(ExcType::ValueError, "sep must be a single ASCII character").into()),
-    };
-
-    let bytes_per_sep = if let Some(bps_value) = bps_value {
-        bps_value.as_int(heap)?
-    } else {
-        1
-    };
-
-    Ok((Some(sep), bytes_per_sep))
-}
-
-// =============================================================================
-// fromhex classmethod
-// =============================================================================
-
-/// Implements Python's `bytes.fromhex(string)` classmethod.
-///
-/// Creates bytes from a hexadecimal string. Whitespace is allowed between byte pairs,
-/// but not between the two digits of a byte.
-pub fn bytes_fromhex(args: ArgValues, heap: &mut Heap<impl ResourceTracker>, interns: &Interns) -> RunResult<Value> {
-    let hex_value = args.get_one_arg("bytes.fromhex", heap)?;
-    defer_drop!(hex_value, heap);
-
-    let hex_str = match hex_value {
-        Value::InternString(id) => interns.get_str(*id),
-        Value::Ref(heap_id) => {
-            if let HeapData::Str(s) = heap.get(*heap_id) {
-                s.as_str()
-            } else {
-                return Err(ExcType::type_error("fromhex() argument must be str, not bytes"));
-            }
-        }
-        _ => {
-            let t = hex_value.py_type(heap);
-            return Err(ExcType::type_error(format!("fromhex() argument must be str, not {t}")));
-        }
-    };
-
-    // CPython allows whitespace BETWEEN byte pairs, but NOT within a pair.
-    // - "de ad" is valid (whitespace between pairs)
-    // - "d e" or "0 1" are NOT valid (whitespace within a pair)
-    // - " 01 " is valid (whitespace before/after)
-    //
-    // Error messages:
-    // - Invalid char (including whitespace in wrong place): "non-hexadecimal number found ... at position X"
-    // - Odd number of valid hex digits: "must contain an even number of hexadecimal digits"
-
-    let mut result = Vec::new();
-    let mut chars = hex_str.chars().enumerate().peekable();
-
-    loop {
-        // Skip whitespace BETWEEN byte pairs (before the high nibble)
-        while chars.peek().is_some_and(|(_, c)| c.is_whitespace()) {
-            chars.next();
-        }
-
-        // Get high nibble
-        let Some((hi_pos, hi_char)) = chars.next() else {
-            break; // End of string - we're done
-        };
-
-        let Some(hi_val) = hex_char_to_value(hi_char) else {
-            return Err(SimpleException::new_msg(
-                ExcType::ValueError,
-                format!("non-hexadecimal number found in fromhex() arg at position {hi_pos}"),
-            )
-            .into());
-        };
-
-        // Get low nibble - must be IMMEDIATELY after high nibble (no whitespace)
-        let Some((lo_pos, lo_char)) = chars.next() else {
-            // End of string after high nibble = odd number of hex digits
-            return Err(SimpleException::new_msg(
-                ExcType::ValueError,
-                "fromhex() arg must contain an even number of hexadecimal digits",
-            )
-            .into());
-        };
-
-        let Some(lo_val) = hex_char_to_value(lo_char) else {
-            // Invalid character (including whitespace) in low nibble position
-            return Err(SimpleException::new_msg(
-                ExcType::ValueError,
-                format!("non-hexadecimal number found in fromhex() arg at position {lo_pos}"),
-            )
-            .into());
-        };
-
-        result.push((hi_val << 4) | lo_val);
-    }
-
-    allocate_bytes(result, heap)
-}
-
-/// Converts a hex character to its numeric value.
-fn hex_char_to_value(c: char) -> Option<u8> {
-    match c {
-        '0'..='9' => Some(c as u8 - b'0'),
-        'a'..='f' => Some(c as u8 - b'a' + 10),
-        'A'..='F' => Some(c as u8 - b'A' + 10),
-        _ => None,
-    }
-}
-
-// =============================================================================
-// Helper function for bytes allocation
-// =============================================================================
-
-/// Allocates bytes on the heap.
-fn allocate_bytes(bytes: Vec<u8>, heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
-    let heap_id = heap.allocate(HeapData::Bytes(Bytes::new(bytes)))?;
-    Ok(Value::Ref(heap_id))
-}