Get the ID of the first (leftmost) leaf in the tree

Merge this leaf with its right sibling

Create a new node */

Destroy a node and decref all Python objects */

Get arena statistics

Get a reference to the value associated with a key. # Arguments `key` - The key to look up Insert with comprehensive error handling and rollback on

Helper to print tree structure

Save operation history for debugging when a failure occurs

Legacy compatibility - verify attack failed

Standard invariant check for integer trees

Batch insert operations with rollback on any failure

Check if branch can give a key to a sibling (has more than minimum)

Standard tree with capacity 5 (for odd capacity testing)

Get a mutable reference to the value for a key. # Arguments `key` - The key to look up # Returns A mutable reference to the value if the key exist

Insert sequential data 0..count with integer values

Check if leaf has fewer than minimum required keys.

Check if branch has fewer than minimum required keys

Returns a fast iterator over all key-value pairs using unsafe arena access. This provides better performance by skipping bounds checks. # Safety This

Measure operation time and return (total_time, per_operation_time).

Generate a random key, biased towards existing keys for deletions/updates

Returns all key-value pairs as a vector (for testing/debugging).

Check if tree is in a valid state for operations

Return iterator over values.

Count total nodes in the tree

Borrow the rightmost key-value from left sibling

Borrow the leftmost key-value from right sibling

Helper function to check tree invariants

Standard tree with capacity 6 (for specific testing scenarios)

Binary search using only the keys portion of data array.

Leaf nodes don't have children.

Get the child node where a key would be found

Get value for a key with default. # Arguments `key` - The key to look up `default` - The default value to return if key is not found # Returns A r

Returns true if this leaf node is at capacity.

Returns True if the node has fewer than minimum required keys

Remove a key from the tree, returning an error if the key doesn't exist. This is equivalent to Python's `del tree[key]`.

Try to get a value, returning detailed error context on failure. # Arguments `key` - The key to look up # Returns A reference to the value if the

Remove with comprehensive error handling

Verify that B+ tree matches reference implementation

Verify tree ordering after operations

Get all leaves with their depths

Merge an underfull child with one of its siblings

Print tree structure to see actual layout

Accept a borrowed key-value pair at the beginning (from left sibling)

Accept a borrowed key-value pair at the end (from right sibling)

Get the number of allocated items

Comprehensive tree validation including ordering

Borrow the first key-value pair from this leaf (used when this is the right sibling)

Borrow the last key-value pair from this leaf (used when this is the left sibling)

Recursively check invariants for a node and its children.

Legacy compatibility - create simple tree

Create tree with custom capacity and insert 0..count sequential data

Find the leaf node that contains or would contain the given key

Binary search for key position.

Binary search for key position.

Returns the first key-value pair in the tree.

Get the number of free slots

Unsafe fast access to leaf node (no bounds checking) # Safety Caller must ensure id is valid and allocated

Insert sequential data start..end with string values

Returns True if the node is at capacity

Returns the number of elements in the tree.

Common GC operation: traverse or clear Python references in a node and its children. */

Legacy compatibility - populate tree with sequential integer data where value = key * 10

Resolve range bounds into start position, skip flag, and end information.

Run the full million-operation fuzz test

Set up test fixtures before each test method.

Split this leaf node, returning the new right node

Split this branch node, returning the new right node

Execute a stress test cycle with automatic invariant checking

Find leaf node that should contain the key */ Find leaf node that should contain the key */

Get value for key */

Get the utilization ratio (allocated / total capacity)