diff --git a/.github/workflows/clojure.yml b/.github/workflows/clojure.yml
index 22bfe20..f85c990 100644
--- a/.github/workflows/clojure.yml
+++ b/.github/workflows/clojure.yml
@@ -2,18 +2,60 @@ name: Clojure CI
 
 on:
   push:
-    branches: [ master ]
+    branches: ["*"]
   pull_request:
-    branches: [ master ]
+    branches: ["master"]
 
-jobs:
-  build:
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
+jobs:
+  test:
+    name: Test
     runs-on: ubuntu-latest
+    timeout-minutes: 30
 
     steps:
-    - uses: actions/checkout@v2
-    - name: Install dependencies
-      run: lein deps
-    - name: Run tests
-      run: lein test
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: "25.0.2"
+
+      - name: Install Clojure tooling
+        uses: DeLaGuardo/setup-clojure@13.5.2
+        with:
+          cli: latest
+          lein: latest
+          bb: latest
+
+      - name: Cache Clojure dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.m2/repository
+            ~/.gitlibs
+            ~/.lein
+          key: ${{ runner.os }}-clojure-${{ hashFiles('project.clj', 'deps.edn') }}
+          restore-keys: |
+            ${{ runner.os }}-clojure-
+
+      - name: Show tool versions
+        run: |
+          java --version
+          clojure -Sdescribe
+          lein version
+          bb --version
+
+      - name: Run Leiningen tests
+        run: lein test
+
+      - name: Run tools.deps tests
+        run: clojure -M:test
diff --git a/.gitignore b/.gitignore
index 46d8b9a..9347919 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 /target
 /classes
 /checkouts
+/plans
 pom.xml
 pom.xml.asc
 *.jar
@@ -8,3 +9,12 @@ pom.xml.asc
 /.lein-*
 /.nrepl-port
 *~
+# Benchmark results (local records)
+/bench-results/
+/doc/api/
+
+# Claude Code
+/.claude/
+.DS_Store
+/.cpcache
+/AGENTS.md
diff --git a/CHANGES.md b/CHANGES.md
new file mode 100644
index 0000000..1444b58
--- /dev/null
+++ b/CHANGES.md
@@ -0,0 +1,113 @@
+# Changelog
+
+## [0.2.0] - 2026-04-08
+
+### New Collection Types
+
+- **Rope** (`rope`) — persistent chunked sequence for O(log n) structural editing
+  (concat, split, splice, insert, remove). Backed by a weight-balanced tree of
+  chunk vectors with a formal Chunk Size Invariant. Up to 1968x faster than
+  `PersistentVector` on repeated random edits at 500K elements; 3-10x faster
+  on concatenation; 1.3-1.7x faster on reduce at scale. Includes
+  structure-sharing subrange views via `rope-sub`, transient support for batch construction,
+  parallel `r/fold`, `java.util.List` interop, and lexicographic `Comparable`.
+- **Range Map** (`range-map`) — non-overlapping `[lo, hi)` ranges with automatic carve-out on insert
+- **Segment Tree** (`segment-tree`, `sum-tree`, `min-tree`, `max-tree`) — O(log n) range aggregation with any associative operation
+- **Priority Queue** (`priority-queue`) — O(log n) push/peek/pop with min and max access
+- **Ordered Multiset** (`ordered-multiset`) — sorted bag allowing duplicate elements
+- **Fuzzy Set/Map** (`fuzzy-set`, `fuzzy-map`) — nearest-neighbor lookup by distance with configurable tiebreaking
+
+### New Operations
+
+- **Set algebra**: `union`, `intersection`, `difference`, `subset?`, `superset?`, `disjoint?`
+- **Positional**: `rank`, `slice`, `median`, `percentile`
+- **Navigation**: `nearest` (floor/ceiling with keyword tests `:<=`, `:>=`, `:<`, `:>`), `subrange`, `split-key`, `split-at`
+- **Interval**: `overlapping`, `span`
+- **Range map**: `ranges`, `span`, `gaps`, `assoc-coalescing`, `get-entry`, `range-remove`
+- **Segment tree**: `query`, `aggregate`, `update-val`, `update-fn`
+- **Priority queue**: `push`, `push-all`, `peek-min`, `peek-min-val`, `pop-min`, `peek-max`, `peek-max-val`, `pop-max`
+- **Multiset**: `multiplicity`, `disj-one`, `disj-all`, `distinct-elements`, `element-frequencies`
+- **Fuzzy**: `fuzzy-nearest`, `fuzzy-exact-contains?`, `fuzzy-exact-get`
+- **Rope**: `rope-concat`, `rope-concat-all`, `rope-split`, `rope-sub`, `rope-insert`, `rope-remove`, `rope-splice`, `rope-chunks`, `rope-chunks-reverse`, `rope-chunk-count`, `rope-str`
+- **Map**: `assoc-new`, `ordered-merge-with`
+- **Comparator**: `general-compare` — opt-in total order over all values including non-Comparable types (Namespace, Var, etc.). ~20% slower lookups on Comparable types vs default.
+
+### Specialized Constructors
+
+- Rope: `rope`
+- Type-specific: `long-ordered-set`, `long-ordered-map`, `double-ordered-set`, `double-ordered-map`, `string-ordered-set`, `string-ordered-map`
+- Custom comparator: `ordered-set-by`, `ordered-map-by`, `ordered-set-with`, `ordered-map-with`, `ordered-multiset-by`, `fuzzy-set-by`, `fuzzy-map-by`, `segment-tree-by`, `segment-tree-with`
+- Exported comparators: `long-compare`, `double-compare`, `string-compare`, `general-compare`, `compare-by`
+
+### Interface Implementations
+
+- `clojure.lang.Sorted` — native `subseq`/`rsubseq` on ordered-set and ordered-map
+- `clojure.core.reducers/CollFold` — chunked parallel fold; ordered-set/map, rope, and compatible tree-backed types split into larger chunks before delegating to `r/fold`
+- `clojure.lang.IEditableCollection` / `ITransientCollection` — transient support for `Rope` with mutable tail buffer for efficient batch construction
+- `clojure.core.protocols/CollReduce` — implemented directly on all collection deftypes for correct fast-path reduction
+- `clojure.lang.IHashEq` — correct `hash` for use in hash-based collections
+- `java.io.Serializable` — Java serialization support
+- `IReduceInit`/`IReduce` — direct tree traversal for fast `reduce`
+- Direct `ISeq` implementations (`KeySeq`, `EntrySeq`) replace lazy-seq wrappers
+
+### EDN Tagged Literals
+
+Round-trip serialization via `data_readers.clj`: `#ordered/set`, `#ordered/map`, `#ordered/interval-set`, `#ordered/interval-map`, `#ordered/range-map`, `#ordered/priority-queue`, `#ordered/multiset`, `#ordered/rope`. Collections with custom comparators (including `general-compare`) print in opaque `#<Type ...>` form to avoid non-round-trippable tagged literals.
+
+### Performance
+
+- **Parallel set operations** via ForkJoinPool with operation-specific root thresholds (`65,536–131,072`), `65,536` recursive thresholds, and `64` sequential cutoff
+- **Primitive node types** (`LongKeyNode`, `DoubleKeyNode`) — unboxed key storage
+- **Primitive lookup fast path** — `long-ordered-set` bypasses `Comparator` dispatch
+- **Interval overlap** — `intersects?` reduced from up to 12 comparisons to 2 (closed-interval identity: `a0 <= b1 AND a1 <= b0`)
+- **Reduction refactor** — unary reducers (nodes, keys, entries) share a single enumerator-based kernel; kv reducers remain separate to avoid packing overhead. All support `reduced` short-circuiting.
+- Fold benchmarking includes a non-trivial frequency-map workload comparing `ordered-set` fold against `hash-set` reduce, `sorted-set` fold/reduce, and `data.avl` fold/reduce
+- Benchmark/test infrastructure shares common workload generators, reference helpers, and competitor builders via `test-utils` and `bench-utils`
+
+See [benchmarks](doc/benchmarks.md) for current numbers and analysis.
+
+### Build
+
+- Namespace root is now `ordered-collections.*` / `ordered_collections.*` rather than `com.dean.ordered-collections.*`
+- Source/test tree lives under `src/ordered_collections` and `test/ordered_collections`
+- `lein stats` — babashka-based project statistics report (clj-kondo analysis, git churn, codebase metrics)
+
+### Bug Fixes
+
+- `SortedSet.tailSet` now returns elements >= x (was exclusive)
+- `SortedSet.subSet` now returns elements >= from, < to
+- Interval tree construction uses sequential reduce (parallel fold lost dynamic binding for node allocator at >2048 elements)
+- `segment-tree` range queries are generic over ordered keys rather than assuming integer-only query bounds
+- `general-compare` collections print opaque (`#<OrderedSet ...>`) rather than emitting tagged literals that cannot round-trip through EDN
+- Priority queue uses direct seq adapters instead of lazy `map` wrappers; stronger coverage for duplicate-priority ordering and boundary cases
+
+### Documentation
+
+- New [Ropes](doc/ropes.md) — rope tutorial, use cases, and design
+- New [Collections API](doc/collections-api.md) — per-type constructor and operation reference
+- [Migration guide](doc/vs-clojure-data-avl.md) corrected (`oc/rank` not `oc/rank-of`)
+- Performance documentation consolidated in `doc/benchmarks.md`; the older `perf-analysis.md` and `when-to-use.md` are removed
+- Cookbook examples refreshed for current semantics
+- Generated `doc/api` output is no longer tracked in the repository
+
+### Breaking Changes
+
+- **Removed** `mutable-ordered-set`, `mutable-ordered-map`, `mutable-interval-set`, `mutable-interval-map`
+- **Removed** `transient`/`persistent!` support (path-copying made it a no-op)
+- **Renamed** public function: `rank-of` → `rank` (returns `nil` instead of `-1` for missing elements)
+- Public namespace root and Maven/Lein artifact coordinate are now `ordered-collections`
+
+---
+
+## [0.1.2] - 2024
+
+- Documentation improvements
+- Minor bug fixes
+
+## [0.1.1] - 2024
+
+- Initial public release
+- Weight-balanced persistent binary trees
+- `ordered-set`, `ordered-map`, `interval-set`, `interval-map`
+- Efficient set operations (intersection, union, difference)
+- `nth` and `indexOf` in O(log n) time
diff --git a/README.md b/README.md
index b0051c0..6724769 100644
--- a/README.md
+++ b/README.md
@@ -1,282 +1,535 @@
-# com.dean.interval-tree
+<table border="0" cellspacing="0" cellpadding="0" style="border: none;"><tr style="border: none;"><td width="180" valign="top" style="border: none; border-color: white;">
+<img src="resources/pando.png" alt="One Tree, Many Forests" width="180"/>
+</td><td valign="top" style="border: none; border-color: white;">
 
-This library provides a collection of data structures implemented using a
-modular, extensible, foldable, weight balanced persistent binary tree:
-ordered-sets, ordered-maps, interval-sets, and interval-maps.
+# ordered-collections
 
-![tests](https://github.com/dco-dev/interval-tree/actions/workflows/clojure.yml/badge.svg)
-[![Clojars Project](https://img.shields.io/clojars/v/com.dean/interval-tree.svg)](https://clojars.org/com.dean/interval-tree)
+**Fast, modern, _ropes_ and ordered collections that do more than
+sort.**
 
-### Usage
+Drop-in replacements for `sorted-set` and `sorted-map.` With
+inherent parallelism, work-optimal set algebra, positional access,
+parallel fold, and specialized collections for problems you didn't know
+you could solve efficiently:
 
-To install, add the following dependency to your project or build file:
+</td></tr></table>
+
+- **Ropes** — concat, split, splice, insert: **10–5000x** faster than Clojure vector at scale
+- **Sets and Maps** work exactly as you're used to, but do more, up to **50x** faster
+- **Interval maps** for overlap queries ("what's scheduled at 3pm?")
+- **Range maps** for non-overlapping regions ("which subnet owns this IP?")
+- **Segment trees** for range aggregation ("total sales from day 10 to 50?")
+- **Fuzzy collections** for nearest-neighbor lookup ("snap 9.3 to the closest valid size")
+- **Priority queues**, **multisets**, and more
+
+All built from a modular, extensible, weight-balanced tree platform with shared
+foundation for splitting, joining, and parallel operations.
+
+![tests](https://github.com/dco-dev/ordered-collections/actions/workflows/clojure.yml/badge.svg)
+[![Clojars Project](https://img.shields.io/clojars/v/com.dean/ordered-collections.svg)](https://clojars.org/com.dean/ordered-collections)
+
+### Documentation
+
+- [Zorp's Sneaker Emporium](doc/zorp-example.md) — Narrative guide with extended examples
+- [Cookbook](doc/cookbook.md) — Practical patterns: leaderboards, time-series, scheduling, queues, multisets, and more
+- [Collections API](doc/collections-api.md) — Collection-by-collection constructor and operation reference
+- [Ropes](doc/ropes.md) — Rope tutorial, use cases, and design
+- [Benchmarks](doc/benchmarks.md) — Detailed performance measurements
+- [Competitive Analysis](doc/competitive-analysis.md) — Comparison with other libraries
+- [vs clojure.data.avl](doc/vs-clojure-data-avl.md) — For data.avl users considering a switch
+- [Algorithms](doc/algorithms.md) — Tree structure, rotations, split/join, interval augmentation
+- [Why Weight-Balanced Trees?](doc/why-weight-balanced-trees.md) — Comparison with red-black and AVL trees
+- [One Tree, Many Forests](doc/concept/concept.md) — Conceptual architecture and design rationale
+
+---
+
+## Quick Start
+
+Use `ordered-set` and `ordered-map` exactly like
+`clojure.core/sorted-set` and `clojure.core/sorted-map`. All the functions you know work the same way. The difference is under the
+hood — and in the new things you can do.
+
+
+```clojure
+(require '[ordered-collections.core :as oc])
+
+;; Ropes — O(log n) split, splice, concat
+
+(def r (oc/rope [:a :b :c :d :e]))     ;=> #ordered/rope [:a :b :c :d:e]
+
+(apply oc/rope-concat
+   (reverse (oc/rope-split r 2)))      ;=> #ordered/rope [:c :d :e :a :b]
+
+(oc/rope-insert r 2 [:x :y])           ;=> #ordered/rope [:a :b :x :y :c :d :e]
+
+;; Sets
+
+(def s (oc/ordered-set [3 1 4 1 5 9 2 6]))  ;=> #ordered/set [1 2 3 4 5 6 9]
+
+(s 4)           ;=> 4
+(s 7)           ;=> nil
+(conj s 0)      ;=> #{0 1 2 3 4 5 6 9}
+
+;; Maps
+
+(def m (oc/ordered-map {:b 2 :a 1 :c 3}))  ;=> #ordered/map [[:a 1] [:b 2] [:c 3]]
+
+(m :b)                  ;=> 2
+(assoc m :d 4)          ;=> {:a 1, :b 2, :c 3, :d 4}
 
 ```
-[com.dean/interval-tree "0.1.2"]
+---
+
+## Performance
+
+Across the measured workloads, `ordered-collections` is faster than
+both `clojure.core/sorted-set` and `clojure.data.avl` at every
+cardinality  Set algebra is the standout, with 28-57x wins at 500K.
+Even against unordered `clojure.core/set`the benchmarks still show
+roughly 4-19x wins.
+
+### Rope vs PersistentVector
+
+| Workload | N=10K | N=100K | N=500K |
+|---|---:|---:|---:|
+| 200 random edits | **43x** | **498x** | **1968x** |
+| Single splice | **6x** | **116x** | **584x** |
+| Concat many pieces | **3.4x** | **5.4x** | **9.5x** |
+| Chunk iteration | **58x** | **83x** | **117x** |
+| Fold (sum) | **5.6x** | **1.5x** | **1.3x** |
+| Reduce (sum) | 0.4x | **1.7x** | **1.3x** |
+| Random nth (1000) | 0.7x | 0.5x | 0.4x |
+
+The rope wins on 6 of 7 workloads at scale and the advantage grows with
+collection size. Concat improves with N because the rope collects chunks in
+O(k) while the vector copies O(n) elements. Reduce beats vectors at N ≥ 100K
+thanks to 256-element chunk locality. Random access is slower (O(log n) vs
+O(1)) but bounded. See [Ropes](doc/ropes.md) for the full tutorial.
+
+### Set algebra
+
+#### vs clojure.core/sorted-set
+
+| Operation | N=10K | N=100K | N=500K |
+|-----------|------:|-------:|-------:|
+| Union | **15.4x** | **26.4x** | **56.6x** |
+| Intersection | **9.0x** | **17.0x** | **36.2x** |
+| Difference | **9.6x** | **22.1x** | **50.2x** |
+
+#### vs clojure.data.avl
+
+| Operation | N=10K | N=100K | N=500K |
+|-----------|------:|-------:|-------:|
+| Union | **10.9x** | **20.5x** | **42.1x** |
+| Intersection | **7.2x** | **13.0x** | **28.1x** |
+| Difference | **7.2x** | **12.7x** | **32.0x** |
+
+#### vs clojure.core/set
+
+| Operation | N=10K | N=100K | N=500K |
+|-----------|------:|-------:|-------:|
+| Union | **4.2x** | **7.2x** | **16.3x** |
+| Intersection | **3.8x** | **6.1x** | **12.9x** |
+| Difference | **4.4x** | **7.6x** | **18.6x** |
+
+### Set equality
+
+| | vs hash-set | vs sorted-set | vs data.avl |
+|--|------------:|--------------:|------------:|
+| N=10K | **2.8x** | **12.0x** | **14.1x** |
+| N=100K | **2.3x** | **9.3x** | **9.5x** |
+
+### Other operations
+
+| Operation | vs sorted-set | vs data.avl |
+|-----------|---------------|-------------|
+| Construction | **3.0x / 2.8x / 3.1x** | **1.5x / 1.3x / 1.7x** |
+| Lookup | 1.1x / 1.1x / 1.1x | 1.0x / 1.0x / 1.0x |
+| Split | — | **6.8x / 7.2x / 7.8x** |
+| Fold | **2.5x / 4.1x / 4.1x** | **5.8x / 5.9x / 8.8x** |
+
+*Benchmarked on a 2023 MacBook Pro (M2). See [Benchmarks](doc/benchmarks.md) for full results.*
+
+---
+
+## How It Works
+
+The core is a **weight-balanced binary tree**.  Each node knows its
+subtree size, enabling O(log n) positional access and efficient parallel
+decomposition.
+
+**Split and join** are the fundamental primitives — splitting at a key
+produces two trees in O(log n); joining is also O(log n). Set
+operations, subrange extraction, and parallel fold all reduce to
+split/join. Set operations use Adams' divide-and-conquer algorithm
+(1992) extended with the parallel forkl-join based approach from
+Blelloch, Ferizovic & Sun (2016).
+
+Collection constructors provide the comparator and node-construction hooks, so
+the same tree algorithms can back generic, primitive-specialized, and augmented
+variants.
+
+**Augmented trees** extend the basic structure: interval trees store
+max-endpoint per subtree for O(log n + k) overlap queries; segment trees
+store aggregates for O(log n) range queries.
+
+See [Algorithms](doc/algorithms.md) for implementation details and [Why
+Weight-Balanced Trees?](doc/why-weight-balanced-trees.md) for comparison
+with red-black and AVL trees.
+
+---
+
+## Collections
+
+The fundamental collection types currently implemented are:
+`ordered-set`, `ordered-map`, `rope`, `interval-set`, `interval-map`,
+`range-map`, `segment-tree`, `priority-queue`, `ordered-multiset`, `fuzzy-set`,
+and `fuzzy-map`.
+
+| Constructor | Description |
+|-------------|-------------|
+| **Ordered Set** | |
+| `(oc/ordered-set coll)` | Sorted set (drop-in for `sorted-set`) |
+| `(oc/ordered-set-by pred coll)` | Sorted set with custom comparator |
+| `(oc/long-ordered-set coll)` | Sorted set optimized for Long keys |
+| `(oc/string-ordered-set coll)` | Sorted set optimized for String keys |
+| **Ordered Map** | |
+| `(oc/ordered-map coll)` | Sorted map (drop-in for `sorted-map`) |
+| `(oc/ordered-map-by pred coll)` | Sorted map with custom comparator |
+| `(oc/long-ordered-map coll)` | Sorted map optimized for Long keys |
+| `(oc/string-ordered-map coll)` | Sorted map optimized for String keys |
+| **Interval Collections** | |
+| `(oc/interval-set coll)` | Set supporting interval overlap queries |
+| `(oc/interval-map coll)` | Map supporting interval overlap queries |
+| **Range Map** | |
+| `(oc/range-map)` | Non-overlapping ranges (Guava TreeRangeMap) |
+| **Segment Tree** | |
+| `(oc/segment-tree f identity coll)` | O(log n) range aggregate queries |
+| `(oc/segment-tree-by pred f identity coll)` | Segment tree with custom ordering predicate |
+| `(oc/segment-tree-with cmp f identity coll)` | Segment tree with custom Comparator |
+| **Priority Queue** | |
+| `(oc/priority-queue pairs)` | Priority queue from `[priority value]` pairs |
+| **Ordered Multiset** | |
+| `(oc/ordered-multiset coll)` | Sorted multiset (allows duplicates) |
+| **Rope** | |
+| `(oc/rope coll)` | Persistent sequence for structural editing |
+| `(oc/rope-concat a b)` | Concatenate two ropes — O(log n) |
+| `(oc/rope-splice r start end items)` | Replace a range — O(log n) |
+| **Fuzzy Collections** | |
+| `(oc/fuzzy-set coll)` | Returns closest element to query |
+| `(oc/fuzzy-map coll)` | Returns value for closest key to query |
+
+---
+
+## Ropes
+
+A rope is a persistent sequence optimized for **structural editing** —
+concatenation, splitting, splicing, and insertion in the middle of large
+sequences. Where `PersistentVector` is O(n) for mid-sequence edits,
+the rope is O(log n).
+
+```clojure
+(def r (oc/rope (range 100000)))
+
+;; Splice into the middle — O(log n), not O(n)
+(def edited (oc/rope-splice r 50000 50010 [:new :data]))
+
+;; Split — O(log n)
+(let [[left right] (oc/rope-split r 50000)]
+  [(count left) (count right)])  ;=> [50000 50000]
+
+;; Concatenate — O(log n)
+(oc/rope-concat (oc/rope [1 2 3]) (oc/rope [4 5 6]))
+;=> #ordered/rope [1 2 3 4 5 6]
 ```
 
-#### Public API
+---
 
-The public api resides in the top-level `com.dean.interval-tree.core` namespace:
+## Capabilities
 
-```clj
-(require '[com.dean.interval-tree.core :as dean])
+Operations that `sorted-set` and `sorted-map` don't provide — at any collection size.
+For the full collection-by-collection surface area, see [Collections API](doc/collections-api.md).
+
+### Positional Access & Rank
+
+```clojure
+(def s (oc/ordered-set [50 30 20 40 10]))
+
+(nth s 2)              ;=> 30     O(log n)
+(oc/rank s 30)         ;=> 2      O(log n)
+(oc/median s)          ;=> 30     O(log n)
+(oc/percentile s 90)   ;=> 50     O(log n)
+(oc/slice s 1 4)       ;=> (20 30 40)
 ```
 
-The basic operation of this library is as a drop-in replacement for
-`clojure.core/sorted-set` and `clojure.core/sorted-map`.
+### Nearest / Floor / Ceiling
+
+```clojure
+(def s (oc/ordered-set [200 200 400 300 500]))
+
+(oc/nearest s :<= 350)  ;=> 300  (floor)
+(oc/nearest s :>= 350)  ;=> 400  (ceiling)
+(oc/nearest s :< 300)   ;=> 200  (predecessor)
+(oc/nearest s :> 300)   ;=> 400  (successor)
+```
 
-#### Constructors
+### Split & Subrange
 
-* `(dean/ordered-set   coll)`
-* `(dean/ordered-set-by   pred coll)`
-* `(dean/ordered-map   coll)`
-* `(dean/ordered-map-by   pred coll)`
-* `(dean/interval-set  coll)`
-* `(dean/interval-map  coll)`
+```clojure
+(def s (oc/ordered-set [5 4 3 1 2]))
 
-### Topics
+(oc/split-key 3 s)  ;=> [#{1 2} 3 #{4 5}]    O(log n)
+(oc/split-at 2 s)   ;=> [#{1 2} #{3 4 5}]     O(log n)
 
-#### What is an Interval Map?
+;; subrange returns a collection, not a seq
+(oc/subrange s :>= 2 :<= 4)  ;=> #{2 3 4}
+```
 
-Imagine you'd like to associate values with members of a set of
-intervals over some continuous domain such as time or real numbers.
-An example of this is shown below. An interval map answers the question,
-which intervals overlap at some point on the domain. At 3.14159, in this
-case, would be `x4` and `x7`.  The interval map is sparse itself, of
-course, and would only need to contain the 8 constituent intervals.
+### Interval Queries
 
 ```
- x8:                         +-----+
- x7:                   +-----------------------------------+
- x6:                                                       +
- x5:                                     +-----------+
- x4: +-----------------------------+
- x3:                                                 +-----+
- x2:                         +-----------------+
- x1:       +-----------+
-
-     0=====1=====2=====3=====4=====5=====6=====7=====8=====9
+ meeting: +-------+
+   lunch:       +-------+
+  review:                 +-------+
+         9==10==11==12==13==14==15==16==17
 ```
 
-This corresponds to the following example code:
+```clojure
+(def schedule
+  (oc/interval-map
+    {[9 12] "meeting" [14 17] "review" [11 15] "lunch"}))
 
-```clj
+(schedule 11)       ;=> ("meeting" "lunch")       point query
+(schedule [10 14])  ;=> ("meeting" "lunch" "review")  range query
+(oc/span schedule)  ;=> [9 17]
+```
 
-(def x (dean/interval-map {[1 3] :x1
-                           [4 7] :x2
-                           [8 9] :x3
-                           [0 5] :x4
-                           [6 8] :x5
-                           [9 9] :x6
-                           [3 9] :x7
-                           [4 5] :x8}))
+### Range Maps
 
-(x 3.141592654) ;; =>  [:x4 :x7]
-(x [5 5])       ;; =>  [:x4 :x7 :x8 :x2]
+Non-overlapping ranges — each point maps to exactly one value. Inserting
+a new range automatically carves out whatever it overlaps.
 
-(get x 9)       ;; =>  [:x7 :x3 :x6]
-(get x 9.00001) ;; =>  nil
-(get x [1 4])   ;; =>  [:x4 :x1 :x7 :x8 :x2]
+```clojure
+(def tiers
+  (-> (oc/range-map)
+      (assoc [0 100] :bronze)
+      (assoc [100 500] :silver)
+      (assoc [500 5000] :gold)))
 
+(tiers 250)                      ;=> :silver
+(oc/get-entry tiers 250)         ;=> [[100 500] :silver]
 ```
 
-#### Efficient Set Operations
+Insert a flash-sale range — bronze and silver are automatically split:
 
-This library implements a diverse collection of efficent set operations
-on foldably parallel ordered sets:
+```clojure
+(oc/ranges (assoc tiers [50 200] :flash))
 
+;; => ([[0 50]    :bronze]        ← auto-trimmed
+;;     [[50 200]  :flash]         ← inserted
+;;     [[200 500] :silver]        ← auto-trimmed
+;;     [[500 5000] :gold])
 ```
-  (def foo (shuffle (range 500000)))
-  (def bar (shuffle (range 1000000)))
 
-  (def s0 (shuffle (range 0 1000000 2)))
-  (def s1 (shuffle (range 0 1000000 3)))
+### Segment Trees
 
-;;
-;;; dean/ordered-set
-;;
+```clojure
+(def sales (oc/sum-tree {1 100, 2 200, 3 150, 4 300, 5 250}))
 
-  (time (def x (ordered-set foo)))         ;; 500K: "Elapsed time: 564.248517 msecs"
-  (time (def y (ordered-set bar)))         ;;   1M: "Elapsed time: 1187.734211 msecs"
+(oc/query sales 2 4)     ;=> 650    O(log n)
+(oc/aggregate sales)      ;=> 1000   O(1)
 
-  (time (def s (dean/intersection
-                 (ordered-set s0)
-                 (ordered-set s1))))       ;; 833K: "Elapsed time: 1242.961445 msecs"
+;; Update and re-query
 
-  (time (r/fold + + y))                    ;;   1M: "Elapsed time: 54.363545 msecs"
+(def sales' (assoc sales 3 500))
+(oc/query sales' 2 4)     ;=> 1000
 
+;; Also: min-tree, max-tree, or any associative operation
 
-;;
-;;; clojure.core/sorted-set
-;;
+(def peaks (oc/segment-tree max 0 {1 100, 2 200, 3 150}))
+(oc/query peaks 1 3)      ;=> 200
+```
 
-  (time (def v (into (sorted-set) foo)))   ;; 500K: "Elapsed time: 839.188189 msecs"
-  (time (def w (into (sorted-set) bar)))   ;;   1M: "Elapsed time: 1974.798286 msecs"
+### Fuzzy Lookup
 
-  (time (def s (clojure.set/intersection
-                 (into (sorted-set) s0)
-                 (into (sorted-set) s1)))) ;; 833K: "Elapsed time: 1589.786106 msecs"
+```clojure
+(def sizes (oc/fuzzy-set [6 7 8 9 10 11 12 13]))
+(sizes 9.3)                    ;=> 9
+(oc/fuzzy-nearest sizes 9.3)   ;=> [9 0.30]
 
-  (time (r/fold + + w))                    ;;   1M: "Elapsed time: 167.916539 msecs"
+(def tiers (oc/fuzzy-map {0 :bronze 500 :silver 1000 :gold}))
+(tiers 480)                    ;=> :silver
 ```
 
-### Testing
+### Priority Queue & Multiset
 
-Testing is accomplished with the standard `lein test`
-```
-$ time lein test
+```clojure
+;; Priority queue (min-heap)
 
-lein test com.dean.interval-tree.interval-map-test
+(def pq (oc/priority-queue [[3 :medium] [1 :urgent] [5 :low]]))
+(peek pq)       ;=> [1 :urgent]
+(peek (pop pq)) ;=> [3 :medium]
 
-lein test com.dean.interval-tree.interval-set-test
+;; Multiset (sorted bag, allows duplicates)
 
-lein test com.dean.interval-tree.interval-test
+(def ms (oc/ordered-multiset [3 1 4 1 5 9 2 6 5 3 5]))
+(oc/multiplicity ms 5)  ;=> 3
+```
 
-lein test com.dean.interval-tree.ordered-map-test
+### Parallel Fold
 
-lein test com.dean.interval-tree.ordered-set-test
+All collection types implement `CollFold` for efficient `r/fold`:
 
-lein test com.dean.interval-tree.tree-test
+```clojure
+(require '[clojure.core.reducers :as r])
 
-Ran 30 tests containing 98214 assertions.
-0 failures, 0 errors.
+(def combinef (fn ([] {}) ([m1 m2] (merge-with + m1 m2))))
+(def reducef  (fn [m x] (update m (mod x 100) (fnil inc 0))))
 
-real     5m34.487s
-user    10m21.397s
-sys      0m5.047s
+(r/fold combinef reducef (oc/ordered-set (range 1000000)))
+
+;; 1M-element frequency-map workload from the benchmark suite:
+;; ~6.9x faster than hash-set reduce, ~4.5x faster than sorted-set fold,
+;; ~3.4x faster than data.avl fold
 ```
+---
 
-### Modularity
+## Testing
 
-This data structure library is designed around the following concepts of
-modularity and extensibility.
+```
+$ lein test
 
-#### Clojure/Java Interfaces
+Ran 454 tests containing 466,000+ assertions.
+0 failures, 0 errors.
+```
 
-The top level collections are built on the standard Clojure/Java
-interfaces, so, for example, working with an `ordered-set` is
-identical to working with Clojure's `sorted-set`, using all of the same
-standard collection functions, for the 99% case: meta, nth, seq, rseq,
-assoc(-in), get(-in), invoke, compare, to-array, empty, .indexOf,
-.lastIndexof, size, iterator-seq, first, last, =, count, empty,
-contains, conj. disj, cons, fold, and many old friends will just
-work, using an efficient implementation that takes full advantage of the
-capabilities of our underlying tree index.
+The test suite includes generative tests via `test.check` and equivalence
+tests against `sorted-set`, `sorted-map`, and `clojure.data.avl`.
 
-#### PExtensibleset
+### Tooling
 
-An exception to the above is due to the fact that `clojure.set` does not
-provide interfaces for extensible sets. So, we provide our own
-intersection, union, difference, subset, and superset.  These operators
-work most efficiently on com.dean.interval-tree collections and provide
-support for backward interoperability with clojure (or possibly other)
-set datatypes.
+```
+$ lein codox                 # Generate API docs in doc/api
+$ lein stats                 # Print project statistics
+```
 
-#### Root Container
+### Benchmarks
 
-The individual collection types (ordered-set, ordered-map, interval-set,
-interval-map} are defined by their individual Class (clojure
-`deftype`) of top level container that holds the root of an
-indexed tree.  This container describes the behavior of the underlying
-tree data structure along several architectural dimensions.
+```
+$ lein bench                  # Criterium, N=100K (~5 min)
+$ lein bench --full           # Criterium, N=10K,100K,500K (~40 min)
+$ lein bench --readme --full  # README tables only (~10 min)
+$ lein bench --sizes 50000    # Custom sizes
+
+$ lein bench-simple           # Quick iteration bench (100 to 100K)
+$ lein bench-simple --full    # Full suite (100 to 1M)
+$ lein bench-range-map        # Range-map vs Guava TreeRangeMap
+$ lein bench-parallel         # Parallel threshold crossover analysis
+$ lein bench-report           # Analyze latest benchmark results
+```
+
+[Criterium](https://github.com/hugoduncan/criterium) results are written to
+`bench-results/<timestamp>.edn`.
 
-##### INodeCollection
 
+---
 
-The fundamental collection of nodes provides an interface to node
-allocation machinery and to the root contained node.  A variant
-based on persistent (on-disk) storage, for example, has been built
-with customizations at this layer.
+## Inspiration
 
-##### IBalancedCollection
+The implementation of this weight-balanced binary tree data
+structure library was inspired by the following:
 
-For functional balanced trees, provides an interface to the `stitch`
-function that returns a new, properly balanced tree containing one newly
-allocated node adjoined.  The provided algorithm is
-[weight balanced](https://en.wikipedia.org/wiki/Weight-balanced_tree)
-however others may be used. We've experimented with red-black trees,
-in particular, as variants at this layer.
+-  Adams (1992)
+   'Implementing Sets Efficiently in a Functional Language'
+   Technical Report CSTR 92-10, University of Southampton.
+   <http://groups.csail.mit.edu/mac/users/adams/BB/92-10.ps>
 
-##### IOrderedCollection
+-  Hirai and Yamamoto (2011)
+   'Balancing Weight-Balanced Trees'
+   Journal of Functional Programming / 21 (3):
+   Pages 287-307
+   <https://yoichihirai.com/bst.pdf>
 
-Ordered collections define a comparator and predicates to determine the
-underlying algorithmic compatibility of other collections. Interval
-Collections are a special type of OrderedCollection.
+-  Oleg Kiselyov
+   'Towards the best collection API, A design of the overall optimal
+   collection traversal interface'
+   <https://okmij.org/ftp/papers/LL3-collections-enumerators.txt>
 
-#### Tree
+-  Nievergelt and Reingold (1972)
+   'Binary Search Trees of Bounded Balance'
+   STOC '72 Proceedings
+   4th Annual ACM symposium on Theory of Computing
+   Pages 137-142
+   <https://dl.acm.org/doi/abs/10.1145/800152.804906>
 
-The heart of the library is our [persistent tree](https://github.com/dco-dev/interval-tree/blob/master/src/com/dean/interval_tree/tree/tree.clj).
+-  Driscoll, Sarnak, Sleator, and Tarjan (1989)
+   'Making Data Structures Persistent'
+   Journal of Computer and System Sciences Volume 38 Issue 1, February 1989
+   18th Annual ACM Symposium on Theory of Computing
+   Pages 86-124
+   <https://www.sciencedirect.com/science/article/pii/0022000089900342>
 
-The code is well documented and explains in more detail the efficiencies
-of the internal collection operators.
+-  MIT Scheme weight balanced tree as reimplemented by Yoichi Hirai
+   and Kazuhiko Yamamoto using the revised non-variant algorithm recommended
+   integer balance parameters from (Hirai/Yamamoto 2011).
+   <https://www.cambridge.org/core/journals/journal-of-functional-programming/article/balancing-weightbalanced-trees/7281C4DE7E56B74F2D13F06E31DCBC5B>
 
-This species of binary tree supports representations of sets, maps,
-and vectors.  In addition to indexed key and range query, it
-supports the `nth` operation to return nth node from the beginning of
-the ordered tree, and `node-rank` to return the rank (sequential
-position) of a given key within the ordered tree, both in logarithmic
-time.
+-  Wikipedia
+   'Interval Tree'
+   <https://en.wikipedia.org/wiki/Interval_tree>
 
-The axes of exstensibility of the tree implemntation
-(`*compare*`,`*n-join*`, `*t-join*`) correspond to the interfaces
-described above.
+-  Wikipedia
+   'Segment Tree'
+   <https://en.wikipedia.org/wiki/Segment_tree>
 
-### Inspiration
+-  Google Guava
+   'RangeMap'
+   <https://guava.dev/releases/snapshot/api/docs/com/google/common/collect/RangeMap.html>
 
- This implementation of a weight-balanced binary interval-tree data
- structure was inspired by the following:
+-  Wikipedia
+   'Weight Balanced Tree'
+   <https://en.wikipedia.org/wiki/Weight-balanced_tree>
 
- -  Adams (1992)
-     'Implementing Sets Efficiently in a Functional Language'
-     Technical Report CSTR 92-10, University of Southampton.
-     <http://groups.csail.mit.edu/mac/users/adams/BB/92-10.ps>
+-  Andrew Baine (2007)
+   'Purely Functional Data Structures in Common Lisp'
+   Google Summer of Code 2007, mentored by Rahul Jain
+   <https://funds.common-lisp.dev/funds.pdf>
+   <https://developers.google.com/open-source/gsoc/2007/>
 
- -  Hirai and Yamamoto (2011)
-     'Balancing Weight-Balanced Trees'
-     Journal of Functional Programming / 21 (3):
-     Pages 287-307
-     <https://yoichihirai.com/bst.pdf>
+- Scott L. Burson
+   'Functional Set-Theoretic Collections for Common Lisp'
+   <https://fset.common-lisp.dev/>
 
- -  Oleg Kiselyov
-     'Towards the best collection API, A design of the overall optimal
-     collection traversal interface'
-     <http://pobox.com/~oleg/ftp/papers/LL3-collections-enumerators.txt>
+-  Adams (1993)
+   'Efficient sets—a balancing act'
+   Journal of Functional Programming 3(4): 553-562
+   <https://www.cambridge.org/core/journals/journal-of-functional-programming/article/functional-pearls-efficient-setsa-balancing-act/0CAA1C189B4F7C15CE9B8C02D0D4B54E>
 
- -  Nievergelt and Reingold (1972)
-     'Binary Search Trees of Bounded Balance'
-     STOC '72 Proceedings
-     4th Annual ACM symposium on Theory of Computing
-     Pages 137-142
+-  Blelloch, Ferizovic, and Sun (2016)
+   'Just Join for Parallel Ordered Sets'
+   ACM SPAA 2016
+   <https://dl.acm.org/doi/10.1145/2935764.2935768>
 
- -  Driscoll, Sarnak, Sleator, and Tarjan (1989)
-     'Making Data Structures Persistent'
-     Journal of Computer and System Sciences Volume 38 Issue 1, February 1989
-     18th Annual ACM Symposium on Theory of Computing
-     Pages 86-124
-
- -  MIT Scheme weight balanced tree as reimplemented by Yoichi Hirai
-     and Kazuhiko Yamamoto using the revised non-variant algorithm recommended
-     integer balance parameters from (Hirai/Yamomoto 2011).
+-  Boehm, Atkinson, and Plass (1995)
+   'Ropes: an Alternative to Strings'
+   Software: Practice and Experience 25(12)
+   <https://www.cs.rit.edu/usr/local/pub/jeh/courses/QUARTERS/FP/Labs/CesswordsII/boehm-ropes.pdf>
 
- -  Wikipedia
-     'Interval Tree'
-     <https://en.wikipedia.org/wiki/Interval_tree>
+-  Haskell containers library (Data.Set, Data.Map)
+   <https://hackage.haskell.org/package/containers>
 
- -  Wikipedia
-     'Weight Balanced Tree'
-     <https://en.wikipedia.org/wiki/Weight-balanced_tree>
+-  SLIB Weight-Balanced Trees (Aubrey Jaffer)
+   <https://people.csail.mit.edu/jaffer/slib/Weight_002dBalanced-Trees.html>
 
- -  Andrew Baine, Rahul Jaine (2007)
-     'Purely Functional Data Structures in Common Lisp'
-     Google Summer of Code 2007
-     <https://common-lisp.net/project/funds/funds.pdf>
-     <https://developers.google.com/open-source/gsoc/2007/>
+-  PAM: Parallel Augmented Maps
+   <https://cmuparlay.github.io/PAMWeb/>
 
- - Scott L. Burson
-     'Functional Set-Theoretic Collections for Common Lisp'
-     <https://common-lisp.net/project/fset/>
+---
 
-### License
+## License
 
 The use and distribution terms for this software are covered by the [Eclipse Public License 1.0](http://opensource.org/licenses/eclipse-1.0.php), which can be found in the file LICENSE.txt at the root of this distribution. By using this software in any fashion, you are agreeing to be bound by the terms of this license. You must not remove this notice, or any other, from this software.
+
+---
+
+*For extended examples featuring Zorp, Kevin the sentient flip-flop, and Big Toe Tony's 47 feet, see [Zorp's Sneaker Emporium](doc/zorp-example.md).*
diff --git a/bb.edn b/bb.edn
new file mode 100644
index 0000000..a51c02d
--- /dev/null
+++ b/bb.edn
@@ -0,0 +1,10 @@
+{:paths ["etc/lib"]
+ :deps {com.github.danlentz/clj-figlet {:mvn/version "0.1.4"}
+        com.github.danlentz/clj-format {:mvn/version "0.1.1"}}
+ :tasks
+ {stats {:doc "Project stats report"
+         :task (load-file "etc/stats.bb")}
+  bench-report {:doc "Benchmark report from bench-results EDN"
+                :task (load-file "etc/bench_report.bb")}
+  paper {:doc "Build the concept paper PDF"
+         :task (load-file "etc/paper.bb")}}}
diff --git a/deps.edn b/deps.edn
new file mode 100644
index 0000000..f75baa0
--- /dev/null
+++ b/deps.edn
@@ -0,0 +1,63 @@
+{:paths ["src" "resources"]
+
+ :deps {org.clojure/clojure {:mvn/version "1.12.4"}}
+
+ :aliases
+ {:dev
+  {:extra-paths ["test"]
+   :extra-deps {org.clojure/data.avl        {:mvn/version "0.2.0"}
+                org.clojure/test.check       {:mvn/version "1.1.1"}
+                org.clojure/math.combinatorics {:mvn/version "0.3.2"}
+                criterium/criterium          {:mvn/version "0.4.6"}
+                com.clojure-goes-fast/clj-memory-meter {:mvn/version "0.3.0"}
+                com.google.guava/guava       {:mvn/version "33.0.0-jre"}}
+   :jvm-opts ["-Djdk.attach.allowAttachSelf"
+              "-XX:+EnableDynamicAgentLoading"]}
+
+  :test
+  {:extra-paths ["test"]
+   :extra-deps {org.clojure/data.avl        {:mvn/version "0.2.0"}
+                org.clojure/test.check       {:mvn/version "1.1.1"}
+                org.clojure/math.combinatorics {:mvn/version "0.3.2"}
+                com.clojure-goes-fast/clj-memory-meter {:mvn/version "0.3.0"}
+                com.google.guava/guava       {:mvn/version "33.0.0-jre"}
+                io.github.cognitect-labs/test-runner
+                {:git/tag "v0.5.1" :git/sha "dfb30dd"}}
+   :jvm-opts ["-Djdk.attach.allowAttachSelf"
+              "-XX:+EnableDynamicAgentLoading"]
+   :main-opts ["-m" "cognitect.test-runner"]}
+
+  :bench
+  {:extra-paths ["test"]
+   :extra-deps {org.clojure/data.avl        {:mvn/version "0.2.0"}
+                org.clojure/test.check       {:mvn/version "1.1.1"}
+                criterium/criterium          {:mvn/version "0.4.6"}
+                com.clojure-goes-fast/clj-memory-meter {:mvn/version "0.3.0"}
+                com.google.guava/guava       {:mvn/version "33.0.0-jre"}}
+   :jvm-opts ["-Djdk.attach.allowAttachSelf"
+              "-XX:+EnableDynamicAgentLoading"
+              "-Xmx8g"]
+   :main-opts ["-m" "ordered-collections.bench-runner"]}
+
+  :bench-simple
+  {:extra-paths ["test"]
+   :extra-deps {org.clojure/data.avl        {:mvn/version "0.2.0"}
+                criterium/criterium          {:mvn/version "0.4.6"}
+                com.google.guava/guava       {:mvn/version "33.0.0-jre"}}
+   :jvm-opts ["-Djdk.attach.allowAttachSelf"
+              "-XX:+EnableDynamicAgentLoading"
+              "-Xmx8g"]
+   :main-opts ["-m" "ordered-collections.simple-bench"]}
+
+  :bench-range-map
+  {:extra-paths ["test"]
+   :extra-deps {com.google.guava/guava {:mvn/version "33.0.0-jre"}}
+   :jvm-opts ["-Xmx8g"]
+   :main-opts ["-m" "ordered-collections.range-map-bench"]}
+
+  :bench-parallel
+  {:extra-paths ["test"]
+   :extra-deps {org.clojure/data.avl   {:mvn/version "0.2.0"}
+                criterium/criterium    {:mvn/version "0.4.6"}}
+   :jvm-opts ["-Xmx8g"]
+   :main-opts ["-m" "ordered-collections.parallel-threshold-bench"]}}}
diff --git a/doc/algorithms.md b/doc/algorithms.md
new file mode 100644
index 0000000..1b148a5
--- /dev/null
+++ b/doc/algorithms.md
@@ -0,0 +1,796 @@
+# Algorithms
+
+## Weight-Balanced Trees
+
+Each node stores a key, value, left and right children, and **subtree weight** (= 1 + size(left) + size(right)). Specialized node types exist for performance: `LongKeyNode` (unboxed `long` key), `DoubleKeyNode` (unboxed `double` key), and `IntervalNode` (additional max-endpoint field for interval augmentation).
+
+These are not separate tree implementations. The library uses one shared tree
+algebra, parameterized by two hooks: `order/*compare*` for ordering semantics
+and `*t-join*` for node reconstruction. Collection constructors bind those at
+the boundary, so the same split/join/search code serves generic nodes,
+primitive-specialized nodes, and augmented variants.
+
+```
+        ┌─────────────────┐
+        │  key: 50        │
+        │  val: "fifty"   │
+        │  weight: 7      │
+        └────────┬────────┘
+                 │
+      ┌──────────┴──────────┐
+      ▼                     ▼
+ ┌─────────┐          ┌─────────┐
+ │ key: 25 │          │ key: 75 │
+ │ wt: 3   │          │ wt: 3   │
+ └────┬────┘          └────┬────┘
+      │                    │
+   ┌──┴──┐              ┌──┴──┐
+   ▼     ▼              ▼     ▼
+ [10]   [30]          [60]   [90]
+ wt:1   wt:1          wt:1   wt:1
+```
+
+Leaves are a sentinel value (weight 0). The weight field serves double duty: it *is* the balance invariant and it enables O(log n) positional access.
+
+## Balance Invariant
+
+Hirai-Yamamoto parameters (δ=3, γ=2):
+
+```
+weight(left)  + 1 ≤ δ × (weight(right) + 1)
+weight(right) + 1 ≤ δ × (weight(left)  + 1)
+```
+
+No subtree can be more than 3× its sibling's weight. When violated, `stitch-wb` applies a single or double rotation:
+
+- **Single rotation** when the heavy child's *outer* subtree dominates (checked via γ)
+- **Double rotation** when the heavy child's *inner* subtree dominates
+
+```
+Single right:                Double right:
+       [C]       [A]              [C]           [B]
+      /   \     /   \            /   \         /   \
+    [A]    z  x    [C]         [A]    z      [A]   [C]
+   /   \          /   \       /   \         /  \   /  \
+  x    [B]      [B]    z    w    [B]       w   x  y   z
+                                /   \
+                               x     y
+```
+
+Hirai & Yamamoto (2011) proved using Coq that (δ=3, γ=2) is the unique integer parameter pair guaranteeing O(log n) height and correct rebalancing for all insert/delete sequences. Height bound: ≤ log₃/₂ n ≈ 1.71 log₂ n.
+
+![Rotations and Stitch](assets/rotation-stitch.svg)
+
+## Split and Join
+
+Everything reduces to these two primitives.
+
+**Split** divides a tree at a key into (left, found, right):
+
+```
+split(tree, 50):
+
+         [40]
+        /    \
+     [20]    [60]
+     /  \    /  \
+   [10][30][50][80]
+
+            ↓
+
+ LEFT (<50)       FOUND     RIGHT (>50)
+    [40]            50          [60]
+    /  \                          \
+ [20]  [30]                       [80]
+  /
+[10]
+```
+
+**Join** (`node-concat3`) combines two trees with a pivot key, rebalancing as needed. When the trees are similarly sized, the pivot becomes the root directly. When one side is much heavier, join walks down the heavy side until it finds a subtree of comparable weight, inserts the pivot there, and rebalances upward.
+
+```
+join(left, 50, right):
+
+ LEFT           RIGHT             [50]
+  [25]           [75]            /    \
+  /  \           /  \    →    [25]    [75]
+[10] [30]     [60] [90]      /  \    /  \
+                            [10][30][60][90]
+```
+
+**Join without pivot** (`node-concat2`) extracts the greatest element from the left tree and uses it as the pivot for `node-concat3`. Used by intersection and difference when the split key is absent.
+
+Both split and join are O(log n). The key property of weight-balanced trees: weight composes trivially — `weight(join(L, k, R)) = weight(L) + 1 + weight(R)` — so no auxiliary recomputation (height, color) is needed after joining. This gives WBTs lower constant factors for split/join than AVL or red-black trees.
+
+Because `join` is also the representation hook, the same recursive algorithms
+rebuild the correct node type automatically. Different collection variants
+inherit the same operation structure while choosing different storage or
+augmentation behavior at node construction time.
+
+## Enumerators: The Fundamental Traversal Interface
+
+Below split/join, the tree's basic traversal primitive is the **enumerator**.
+An enumerator is a compact explicit traversal state: a chain of frames
+representing the current node plus the remaining path to the next node in
+sorted order.
+
+The forward enumerator descends the left spine:
+
+```
+node-enumerator(root)
+  = [current-node | continuation]
+```
+
+Advancing the enumerator does two things:
+- if the current node has a right subtree, descend that subtree's left spine
+- otherwise, resume from the saved continuation
+
+The reverse enumerator is symmetric: descend the right spine, then resume
+outward through saved continuations.
+
+Why this matters:
+- it gives in-order traversal without recursion or lazy-seq allocation in the hot path
+- it is the common substrate for `node-reduce`, `node-reduce-right`, sequence construction, and tree-to-tree linear merges
+- it keeps traversal mechanics separate from collection presentation (`seq`, `rseq`, key seqs, entry seqs)
+
+This is close in spirit to Oleg Kiselyov's "Towards the best collection API:
+A design of the overall optimal collection traversal interface", which argues
+for enumerator-style traversal as the fundamental collection-walking primitive.
+The tree code applies that idea at the node level and then builds the public
+seq/reduce interfaces on top of it.
+
+![Enumerator: Left-Spine Decomposition](assets/enumerator-spine.svg)
+
+Conceptually, the layering is:
+
+```
+enumerator         ; explicit tree-walk state
+  ↓
+node-reduce        ; eager traversal API
+node-seq / direct seq types
+  ↓
+collection seq/reduce interfaces
+```
+
+This is why the tree code treats enumerators as fundamental rather than as a
+small helper for `seq`. They are the shared low-level traversal interface from
+which both eager reduction and Clojure-facing sequence behavior are derived.
+
+## The Reduction Stack
+
+The enumerator feeds into a layered reduction architecture. Unary reducers
+(nodes, keys, entries) share a single factory (`make-unary-reducer`) that
+combines an enumerator direction with a projection function. The kv reducer
+is hand-written separately because its 3-arity `(f acc k v)` shape doesn't
+fit the unary projection model — forcing it through a projection would require
+packing k and v into a MapEntry just to unpack them. Direct seq types
+(`KeySeq`, `EntrySeq`) walk the enumerator without lazy-seq allocation.
+Parallel fold splits the tree into chunks (via positional split) and reduces
+each chunk independently.
+
+![The Reduction Stack](assets/reduction-stack.svg)
+
+## The Join-Based Paradigm
+
+All tree operations reduce to split and join (Adams 1992, Blelloch et al. 2016):
+
+| Operation | Implementation |
+|-----------|----------------|
+| insert(k, v) | split at k, join with new node |
+| delete(k) | split at k, join left and right |
+| union(A, B) | split A at root(B), recurse on halves, join |
+| intersection(A, B) | split A at root(B), recurse, join if found, concat if not |
+| difference(A, B) | split A at root(B), recurse, concat halves |
+
+Balance logic lives only in join. All operations inherit O(log n) balancing automatically.
+
+## Set Operations
+
+Union, intersection, and difference use Adams' divide-and-conquer:
+
+```
+union(T₁, T₂):
+  if T₁ empty: return T₂
+  if T₂ empty: return T₁
+  (k, v) = root(T₂)
+  (L₁, _, R₁) = split(T₁, k)
+  return join(union(L₁, left(T₂)), k, v, union(R₁, right(T₂)))
+
+intersection(T₁, T₂):
+  if T₁ empty or T₂ empty: return ∅
+  (k, v) = root(T₂)
+  (L₁, present, R₁) = split(T₁, k)
+  L = intersection(L₁, left(T₂))
+  R = intersection(R₁, right(T₂))
+  if present: return join(L, k, v, R)
+  else:       return concat(L, R)
+
+difference(T₁, T₂):
+  if T₁ empty: return ∅
+  if T₂ empty: return T₁
+  (k, _) = root(T₂)
+  (L₁, _, R₁) = split(T₁, k)
+  return concat(difference(L₁, left(T₂)), difference(R₁, right(T₂)))
+```
+
+**Work complexity:** O(m log(n/m + 1)) where m ≤ n. This is information-theoretically optimal — it matches the comparison-based lower bound. When m ≪ n (e.g., merging a small set into a large one), this approaches O(m log n). When m ≈ n, it's O(n). The naive element-by-element insertion approach is always O(m log n), which is worse when m is large.
+
+### Parallelism
+
+The two recursive calls in each operation are independent. The implementation forks the left recursion as a `ForkJoinTask` and computes the right recursion inline, then joins:
+
+```
+fork-join:
+  left-task  = fork(union(L₁, left(T₂)))   ← submitted to ForkJoinPool
+  right-result = union(R₁, right(T₂))       ← computed inline
+  left-result  = left-task.join()            ← wait for fork
+  return join(left-result, k, v, right-result)
+```
+
+The current implementation uses operation-specific root thresholds:
+- union: `131,072`
+- intersection: `65,536`
+- difference: `131,072`
+- ordered-map merge: `65,536`
+
+Below those root thresholds, the operations stay sequential. Once in the
+parallel path, recursive splits re-fork at `65,536`, subject to the branch-shape
+guard described below. Tiny subtrees still use the direct sequential cutoff of
+`64`.
+
+Span is O(log² n), giving near-linear speedup on many cores (Blelloch et al. 2016).
+
+## Fork-Join Parallelism
+
+Six operations use Java's `ForkJoinPool` for automatic parallelism: union, intersection, difference, merge-with, and two forms of parallel fold. Set operations use the three-layer fork-join pattern directly; fold delegates to `clojure.core.reducers/fold`.
+
+### The pattern
+
+Every parallel operation has three layers:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Entry point                                                │
+│  Is the caller already in a ForkJoinPool worker thread?     │
+│    yes → call par-fn directly                               │
+│    no  → submit par-fn to the common pool via .invoke       │
+├─────────────────────────────────────────────────────────────┤
+│  par-fn (parallel recursion)                                │
+│  Is the subtree large enough to justify forking?            │
+│    yes → fork left subtree, compute right inline, join      │
+│    no  → call seq-fn                                        │
+├─────────────────────────────────────────────────────────────┤
+│  seq-fn (sequential recursion)                              │
+│  Same algorithm, no fork overhead                           │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Why the pool entry point is needed
+
+`ForkJoinTask.fork()` can only be called from within a `ForkJoinPool` worker thread. When user code calls `union` from a regular thread (e.g. the main thread or a core.async thread), the operation must first be submitted to the pool. Once inside the pool, recursive calls are already on worker threads and can fork directly:
+
+```
+(if (ForkJoinTask/inForkJoinPool)
+  (par-fn root)                          ;; already inside pool
+  (.invoke fork-join-pool                ;; enter pool
+    (ForkJoinTask/adapt (fn [] (par-fn root)))))
+```
+
+### Task representation
+
+The hot recursive path no longer goes through `Callable` plus
+`ForkJoinTask/adapt`, and it no longer relies on repeated dynamic-var rebinding.
+Instead, the sequential and parallel kernels use explicit-argument helpers
+(`cmp`, `create`) and fork a small internal `RecursiveTask` wrapper.
+
+That matters because the set-algebra recursion is fine-grained: if task
+creation, comparator rebinding, or closure allocation are too expensive, the
+practical crossover climbs far above where the algorithm should pay off.
+
+### Threshold tuning
+
+Parallelism uses four guards to keep fork overhead from dominating:
+
+| Threshold | Value | Purpose |
+|-----------|-------|---------|
+| `union` root threshold | 131,072 | Enter parallel union only above this combined subtree size |
+| `intersection` root threshold | 65,536 | Enter parallel intersection only above this combined subtree size |
+| `difference` root threshold | 131,072 | Enter parallel difference only above this combined subtree size |
+| `merge` root threshold | 65,536 | Enter parallel ordered-map merge only above this combined subtree size |
+| recursive threshold | 65,536 | Once already in the parallel path, re-fork only above this combined subtree size |
+| `+parallel-min-branch+` | 65,536 | Only fork when both recursive branches are substantive enough |
+| `+sequential-cutoff+` | 64 | Subtree size below which set operations use direct linear merge |
+| `+min-fold-chunk-size+` | 4,096 | Minimum chunk size for parallel fold (floor on user-supplied value) |
+
+The root thresholds are operation-specific because one conservative value left
+too many practical wins on the table. Union and difference reconstruct more
+output than intersection; merge behaves differently again; comparator cost and
+tree shape also matter. The fold chunk floor prevents excessive O(log n) tree
+splits when `r/fold`'s default chunk size (256) would create too many chunks.
+
+`parallel_threshold_bench.clj` is useful for local tuning, but it does not
+produce one stable crossover point across machines. In the April 2, 2026
+reruns, the production-path benchmark favored per-operation entry thresholds
+plus a lower recursive threshold and a branch-shape guard. That matches the
+actual workload differences between union, intersection, difference, and
+ordered-map merge more closely than a single universal threshold.
+
+### Operations using this pattern
+
+**Set operations** (union, intersection, difference, merge-with): The tree's divide-and-conquer structure maps directly to fork-join. Split T₁ at T₂'s root, fork the left halves, compute the right halves inline, join results. Work O(m log(n/m + 1)), span O(log² n).
+
+**Parallel fold** (`node-fold`): Split the tree into roughly equal subtrees using `node-split` at evenly-spaced positions, then fold them in parallel via `r/fold`. Splitting is done eagerly in the caller's thread (where dynamic bindings are available); each chunk's sequential reduce uses `node-reduce` which needs no bindings. Work O(n), span O(n/p + k log n) where k is the number of chunks.
+
+## Positional Access
+
+Weight at each node enables O(log n) index operations without any additional data structure.
+
+### nth (index → element)
+
+```
+nth(tree, i):
+  left-size = weight(left)
+  if i < left-size:  recurse into left
+  if i == left-size: return this node
+  else:              recurse into right with i' = i - left-size - 1
+```
+
+### rank (element → index)
+
+Accumulate left subtree sizes while descending:
+
+```
+rank(tree, key):
+  acc = 0
+  if key < node.key: recurse left, keep acc
+  if key = node.key: return acc + weight(left)
+  if key > node.key: acc += weight(left) + 1, recurse right
+```
+
+### Derived operations
+
+- **slice(start, end)**: split-at start, split-at (end - start) on the right half
+- **median**: nth at ⌊n/2⌋
+- **percentile(p)**: nth at ⌊n × p / 100⌋
+
+All O(log n). Available on `ordered-set`, `ordered-map`, `fuzzy-set`, `fuzzy-map`.
+
+## Nearest (Floor / Ceiling)
+
+`ordered-set` and `ordered-map` implement directional nearest-neighbor via tree descent:
+
+| Test | Meaning |
+|------|---------|
+| `:<=` | floor — greatest element ≤ k |
+| `:<` | predecessor — greatest element < k |
+| `:>=` | ceiling — least element ≥ k |
+| `:>` | successor — least element > k |
+
+Standard BST descent with candidate tracking. O(log n).
+
+## Parallel Fold
+
+Collections implement `clojure.core.reducers/CollFold` via `node-fold`. The tree is split into roughly equal chunks using `node-split`; those chunks are then folded in parallel by `clojure.core.reducers/fold`.
+
+Minimum chunk size: **`+min-fold-chunk-size+` = 4,096**. User-supplied chunk sizes below that floor are rounded up to avoid excessive tree splitting overhead.
+
+Span is approximately O(n/p + k log n), where `p` is processor count and `k` is the number of chunks.
+
+## Interval Tree Augmentation
+
+`IntervalNode` adds a field `z`: the maximum right endpoint in the subtree. This is maintained during rotations — each node's `z` is the max of its own interval's endpoint and its children's `z` values.
+
+```
+      ┌─────────────────────┐
+      │  interval: [3,7]    │
+      │  max-end: 15        │  ← max of all endpoints in subtree
+      └─────────┬───────────┘
+                │
+     ┌──────────┴──────────┐
+     ▼                     ▼
+┌─────────┐          ┌─────────┐
+│ [1,5]   │          │ [8,15]  │
+│ max: 5  │          │ max: 15 │
+└────┬────┘          └────┬────┘
+     │                    │
+  ┌──┴──┐              ┌──┴──┐
+  ▼     ▼              ▼     ▼
+[0,2] [4,6]         [6,10] [12,15]
+max:2 max:6         max:10 max:15
+```
+
+### Query algorithm
+
+The implementation supports both point queries and interval-vs-interval overlap queries. Given a query interval `i`:
+
+```
+search(node, i):
+  if leaf: return
+
+  # Search right if query's endpoint ≥ node's start point
+  if b(i) >= a(node.key):
+    search(right, i)
+
+  # Check current node for intersection
+  if intersects?(i, node.key):
+    collect(node)
+
+  # Search left only if query's start ≤ max endpoint in left subtree
+  if a(i) <= left.z:
+    search(left, i)
+```
+
+`intersects?` checks for any common point between two intervals (overlap, containment in either direction). The `z` field enables pruning: if `left.z < a(query)`, no interval in the left subtree can overlap the query.
+
+Complexity: O(log n + k) where k = number of matching intervals.
+
+Point queries are a special case: a point `p` is treated as the interval `[p, p]`.
+
+## Range Map
+
+`range-map` enforces non-overlapping ranges. Each point maps to exactly one value. Ranges are half-open: `[lo, hi)`.
+
+### Insert (assoc)
+
+Inserting `[25, 75) → :new` into a tree containing `[0, 100) → :a`:
+
+```
+Step 1: Find all ranges overlapping [25, 75)
+  → [[0, 100) → :a]
+
+Step 2: Remove overlapping ranges from tree
+
+Step 3: Re-insert trimmed portions outside [25, 75)
+  → [0, 25) → :a,  [75, 100) → :a
+
+Step 4: Insert new range
+  → [0, 25) → :a,  [25, 75) → :new,  [75, 100) → :a
+```
+
+### Coalescing insert (assoc-coalescing)
+
+When adjacent ranges have the same value, merge them:
+
+```
+Before: [0, 50) → :a    [50, 100) → :a   (two ranges)
+Insert [100, 150) → :a with coalescing:
+After:  [0, 50) → :a    [50, 150) → :a   (adjacent merged)
+```
+
+Complexity: O(k log n) where k = number of overlapping/adjacent ranges.
+
+## Segment Tree
+
+Each `AggregateNode` stores a pre-computed aggregate (`agg`) of its entire subtree under a user-specified associative operation. Created via a custom node constructor that computes `agg = op(left.agg, op(value, right.agg))` at every node.
+
+```
+                ┌─────────────┐
+                │ key: 3      │
+                │ val: 40     │
+                │ agg: 150 ◄──────── sum of entire tree
+                └──────┬──────┘
+           ┌───────────┴───────────┐
+    ┌──────┴──────┐         ┌──────┴──────┐
+    │ key: 1      │         │ key: 4      │
+    │ val: 20     │         │ val: 50     │
+    │ agg: 30     │         │ agg: 80     │
+    └──────┬──────┘         └──────┬──────┘
+           │                       │
+    ┌──────┴──────┐         ┌──────┴──────┐
+    │ key: 0      │         │ key: 5      │
+    │ val: 10     │         │ val: 30     │
+    │ agg: 10     │         │ agg: 30     │
+    └─────────────┘         └─────────────┘
+```
+
+### Range query
+
+Two implementations: `query-range` (basic) and `query-range-fast` (uses subtree bounds to short-circuit).
+
+```
+query-range-fast(node, lo, hi):
+  if leaf: return identity
+
+  # Find subtree's actual key range
+  l-lo = min key in left subtree (or node.key if left is leaf)
+  r-hi = max key in right subtree (or node.key if right is leaf)
+
+  # Entire subtree outside range
+  if r-hi < lo or l-lo > hi: return identity
+
+  # Entire subtree inside range → use pre-computed aggregate!
+  if lo ≤ l-lo and r-hi ≤ hi: return node.agg
+
+  # Partial overlap → recurse
+  L = query-range-fast(left, lo, hi)
+  V = node.val if lo ≤ node.key ≤ hi, else identity
+  R = query-range-fast(right, lo, hi)
+  return op(L, op(V, R))
+```
+
+The key optimization: when a subtree is entirely within the query range, return its `agg` directly instead of recursing. This gives O(log n) for both queries and updates.
+
+## Fuzzy Lookup
+
+Fuzzy collections find the closest element by distance. The algorithm uses split:
+
+```
+find-nearest(tree, query):
+  (left, exact, right) = split(tree, query)
+
+  if exact: return exact
+
+  floor   = greatest(left)    ← O(log n)
+  ceiling = least(right)      ← O(log n)
+
+  return argmin(|query - floor|, |query - ceiling|)
+```
+
+When equidistant, a configurable tiebreaker (`:< ` or `:>`) determines preference. The `distance-fn` is also configurable (defaults to numeric absolute difference).
+
+**Invariant:** The nearest element by distance is always a sort-order neighbor (floor or ceiling), so split gives us the only two candidates. O(log n).
+
+## Handling Duplicates
+
+`ordered-multiset` and `priority-queue` allow duplicate keys by appending an internal sequence counter.
+
+**Multiset** stores `[value, seqnum]` pairs. Comparison: first by value, then by seqnum. This gives stable insertion order for equal values and FIFO behavior on removal.
+
+**Priority queue** stores `[priority, seqnum, value]` triples. Sorted by priority first, then seqnum. `peek` returns the minimum-priority element; among equal priorities, the earliest inserted.
+
+## Complexity Summary
+
+| Operation | Time | Notes |
+|-----------|------|-------|
+| Lookup | O(log n) | All collections |
+| Insert / Delete | O(log n) | Persistent (path copying) |
+| nth / rank | O(log n) | Via subtree weights |
+| median / percentile | O(log n) | Via nth |
+| nearest (floor/ceiling) | O(log n) | Ordered sets and maps |
+| Split (by key or index) | O(log n) | |
+| Join | O(log n) | Universal primitive |
+| Union / Intersection / Difference | O(m log(n/m+1)) | Work-optimal, fork-join parallel |
+| Parallel fold | O(n/p + log²n) | p = processors |
+| Interval query | O(log n + k) | k = result count |
+| Range-map assoc | O(k log n) | k = overlapping ranges |
+| Segment-tree query | O(log n) | Pre-computed aggregates |
+| Fuzzy lookup | O(log n) | Split + floor/ceiling |
+| Rope nth | O(log n) | Descent by element counts |
+| Rope concat | O(log n) | Structural join |
+| Rope split | O(log n) | Split-join with concat3 |
+| Rope splice / insert / remove | O(log n) | Split + concat |
+| Rope reduce | O(n) | Chunk-aware traversal |
+| Rope parallel fold | O(n/p + log²n) | Fork-join over split halves |
+
+## Ropes: Implicit-Index Chunk Trees
+
+A rope is a persistent sequence built on the same weight-balanced tree
+infrastructure, but with a fundamentally different indexing model. Where
+ordered sets and maps use a comparator to position elements by key, a rope
+uses **positional indexing** — the element's position in the sequence is
+determined entirely by subtree element counts.
+
+### Node Representation
+
+Each rope node reuses `SimpleNode` with repurposed fields:
+
+```
+        ┌────────────────────────┐
+        │  k: chunk [a b c ...]  │   ← vector of elements (the "chunk")
+        │  v: 1042               │   ← total element count of subtree
+        │  x: 9                  │   ← node count (for WBT balance)
+        │  l: ●  r: ●            │
+        └────────────────────────┘
+```
+
+Two distinct size metrics coexist:
+
+- `tree/node-size` (field `x`) — **node count**, used by WBT rotations
+- `rope-size` (field `v`) — **element count**, used for indexed access
+
+This separation is essential. The tree stays balanced by node count (so all the
+existing rotation machinery works unchanged), while indexed operations descend
+by element count.
+
+### Chunk Size Invariant (CSI)
+
+Chunks are bounded by a formal invariant analogous to B-tree minimum fill:
+
+```
+target = 256    min = 256
+
+Every chunk has size in [min, target] except:
+  - If the rope has ≤ 1 chunk, it may be any size in [1, target]
+  - Otherwise, only the rightmost chunk (the "runt") may be [1, target]
+```
+
+CSI is enforced locally at each mutation site:
+
+| Operation | Enforcement |
+|---|---|
+| `rope-concat` | Position-aware boundary check: l's rightmost becomes internal (must be ≥ min); r's leftmost only needs fixing if r has ≥ 2 chunks. `merge-boundary` pulls one neighbor when combined boundary < min. |
+| `rope-split` | `ensure-split-parts` repairs the right fringe of the left half and the left fringe of the right half. |
+| `rope-sub` | `ensure-left-fringe` + `ensure-right-fringe` after recursive extraction. |
+| `rope-conj-right` | Fills rightmost chunk up to target; overflows to new node. |
+| `coll->root` | `partition-all target` always produces valid chunks. |
+
+`rechunk-balanced` is the core partitioning helper: it packs greedily at target
+size, but when the last full chunk would leave a remainder below min, it splits
+the final two pieces evenly so both halves are ≥ min.
+
+### Indexed Access
+
+`rope-nth` descends by subtree element counts:
+
+```
+rope-nth(node, i):
+  ls = element-count(left)
+  cs = chunk-size(node)
+  if i < ls:            recurse into left
+  if i < ls + cs:       return chunk[i - ls]
+  else:                 recurse into right with i' = i - ls - cs
+```
+
+Cost: O(log n) — one comparison per tree level, then a constant-time vector
+lookup within the chunk.
+
+### Split
+
+`rope-split-at` follows the standard split-join pattern from Blelloch et al.,
+adapted for positional indexing. The key optimization: it uses `rope-join`
+(a concat3 — balanced join with a known pivot chunk) during unwind rather than
+`raw-rope-concat` (concat2, which must extract a pivot).
+
+```
+rope-split(node, i):
+  ls = element-count(left)
+  cs = chunk-size(node)
+
+  if i < ls:
+    (ll, lr) = rope-split(left, i)
+    return (ll, rope-join(chunk, lr, right))    ← concat3, O(|height diff|)
+
+  if i within chunk:
+    split the chunk vector via subvec
+    return (concat(left, left-piece), concat(right-piece, right))
+
+  if i > ls + cs:
+    (rl, rr) = rope-split(right, i - ls - cs)
+    return (rope-join(chunk, left, rl), rr)
+```
+
+`rope-join` is O(|height(l) - height(r)|) per call, and the height differences
+telescope across levels, giving **O(log n) total** for the full split. The
+earlier implementation used concat2 at each level, which was O(log²n).
+
+### Concatenation
+
+`rope-concat` is the rope's fundamental structural operation. For the common
+case (both boundary chunks ≥ min), it delegates directly to `raw-rope-concat`
+— the standard WBT join, O(log n).
+
+When boundary chunks need repair (the left tree's rightmost was a runt that
+now becomes internal), `merge-boundary` removes the two boundary chunks,
+combines them, rechunks, and rebuilds. If the combined content is still below
+min, it pulls one additional neighbor chunk — at most one level of cascading.
+
+### Subrope (Range Extraction)
+
+`rope-sub` does direct recursive range extraction rather than split-twice:
+
+```
+slice(node, start, end):
+  if range fully covers node: return node    ← full subtree sharing
+  left-part  = slice(left,  start, min(end, ls))
+  mid-part   = subvec chunk at boundaries
+  right-part = slice(right, max(0, start-rs), end-rs)
+  return concat(concat(left-part, mid-part), right-part)
+```
+
+This reuses whole subtrees when the requested window fully contains them,
+taking chunk subvecs only at the two cut boundaries. Fringe normalization
+is applied once at the end.
+
+### Transient Tail Buffer
+
+`TransientRope` uses a mutable `ArrayList` as a tail buffer. `conj!` appends
+to the tail in O(1); when the tail reaches target chunk size (256 elements),
+it is flushed into the persistent tree via `rope-concat`. This amortizes tree
+operations over 256 element appends, cutting build time roughly in half
+compared to persistent `conj`.
+
+```
+conj!(transient, x):
+  tail.add(x)
+  if tail.size >= target:
+    chunk = vec(tail)
+    tail.clear()
+    root = rope-concat(root, coll->root(chunk))
+
+persistent!(transient):
+  flush remaining tail
+  return Rope(root)
+```
+
+### Why Not a Comparator?
+
+The rope deliberately avoids the library's `order/*compare*` / `tree/*t-join*`
+dynamic variable hooks. Position is the ordering — there is no meaningful key
+to compare. This means the rope cannot reuse `node-split`, `node-concat3`,
+or the comparator-driven add/remove paths. Instead, it has its own
+position-aware equivalents (`rope-split-at`, `rope-join`, `rope-nth`, etc.)
+that thread through the tree by element count rather than key comparison.
+
+The shared infrastructure it *does* reuse: `node-stitch` (rotation logic),
+`node-weight` (balance metric), `SimpleNode` (storage), and the enumerator /
+reducer machinery for traversal.
+
+### Performance vs PersistentVector
+
+```
+Rope WINS (advantage grows with N):
+
+┌────────────────────┬───────┬────────┬────────┬──────────────────────┐
+│      Workload      │ N=10K │ N=100K │ N=500K │      Asymptotic      │
+├────────────────────┼───────┼────────┼────────┼──────────────────────┤
+│ 200 random edits   │   43x │   498x │  1968x │ O(k·log n) vs O(k·n) │
+│ Single splice      │    6x │   116x │   584x │ O(log n) vs O(n)     │
+│ Concat many pieces │  3.4x │   5.4x │   9.5x │ O(k) vs O(n)         │
+│ Chunk iteration    │   58x │    83x │   117x │ natural structure     │
+│ Reduce (sum)       │  0.4x │   1.7x │   1.3x │ 256-elem chunk wins  │
+└────────────────────┴───────┴────────┴────────┴──────────────────────┘
+
+Rope loses (bounded, inherent O(log n) vs O(1)):
+
+┌────────────────────┬───────┬────────┬────────┐
+│      Workload      │ N=10K │ N=100K │ N=500K │
+├────────────────────┼───────┼────────┼────────┤
+│ Split              │   19x │     7x │    21x │
+│ Slice              │   65x │    51x │    24x │
+│ Random nth (1000)  │  1.6x │   1.9x │   2.5x │
+└────────────────────┴───────┴────────┴────────┘
+```
+
+Reduce beats vectors at N ≥ 100K because the rope's 256-element chunk size
+gives better cache locality per reduction step than PersistentVector's 32-wide
+trie nodes. The direct recursive tree walk (no enumerator frames) and native
+vector `.reduce` delegation keep per-element overhead minimal.
+
+Every remaining loss is structural — there are no non-inherent performance gaps:
+
+```
+┌─────────────────────┬──────────┬───────────────────────────────────────────────────┐
+│        Loss         │  Ratio   │                   Why inherent                    │
+├─────────────────────┼──────────┼───────────────────────────────────────────────────┤
+│ Split/slice         │ ~15-60x  │ O(log n) tree walk vs O(1) subvec wrapper         │
+│ Random nth          │ 1.3-2.6x │ O(log n) tree descent vs O(1) trie lookup         │
+│ Reduce at 10K       │ 0.6x     │ Fixed tree-walk overhead for 39 chunks            │
+│ Build via transient │ 2.2-2.6x │ Periodic O(log n) tree flush vs O(1) array append │
+│ Build via conj      │ 12-18x   │ O(log n) per append vs O(1) amortized             │
+└─────────────────────┴──────────┴───────────────────────────────────────────────────┘
+```
+
+Split/slice/nth are the price of tree-backed indexing — `subvec` wraps the
+existing vector in constant time, while the rope must walk its tree. The
+absolute times are microseconds (5-12µs for split, ~250µs for 1000 random
+nths). Construction is best done via `(oc/rope coll)` which is a single O(n)
+chunking pass, not element-by-element `conj`.
+
+The editing wins are unbounded: each mid-sequence edit on a vector copies O(n)
+elements, while the rope does O(log n) tree work. At 500K elements, 200 random
+edits take 3ms on the rope vs 5.4 seconds on the vector.
+
+### References
+
+- Boehm, Atkinson & Plass (1995): "Ropes: an Alternative to Strings" — the canonical rope paper; lazy concatenation, Fibonacci rebalancing, stack-based iteration
+- Blelloch, Ferizovic & Sun (2016): "Just Join for Parallel Ordered Sets" — the split-join paradigm that the rope's `rope-split-at` / `rope-join` follows
+
+---
+
+## References
+
+- Adams (1992): "Implementing Sets Efficiently in a Functional Language" — split/join paradigm, divide-and-conquer set operations
+- Adams (1993): "Efficient sets—a balancing act" — elegant functional pearls treatment
+- Hirai & Yamamoto (2011): "Balancing Weight-Balanced Trees" — Coq-verified (δ=3, γ=2) parameters
+- Blelloch, Ferizovic & Sun (2016): "Just Join for Parallel Ordered Sets" — work-optimality proof, parallel algorithms
+- Sun, Ferizovic & Blelloch (2018): "PAM: Parallel Augmented Maps" — augmented tree framework (interval/segment trees)
diff --git a/doc/api/com.dean.interval-tree.tree.html b/doc/api/com.dean.interval-tree.tree.html
deleted file mode 100644
index 6045018..0000000
--- a/doc/api/com.dean.interval-tree.tree.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4 current"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-difference"><div class="inner"><span>difference</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-intersection"><div class="inner"><span>intersection</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-interval-map"><div class="inner"><span>interval-map</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-interval-set"><div class="inner"><span>interval-set</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-ordered-map"><div class="inner"><span>ordered-map</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-ordered-map-by"><div class="inner"><span>ordered-map-by</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-ordered-set"><div class="inner"><span>ordered-set</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-ordered-set-by"><div class="inner"><span>ordered-set-by</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-subset"><div class="inner"><span>subset</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-superset"><div class="inner"><span>superset</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.html#var-union"><div class="inner"><span>union</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree</h1><div class="doc"><pre class="plaintext"></pre></div><div class="public anchor" id="var-difference"><h3>difference</h3><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-intersection"><h3>intersection</h3><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-interval-map"><h3>interval-map</h3><div class="usage"><code>(interval-map)</code><code>(interval-map coll)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-interval-set"><h3>interval-set</h3><div class="usage"><code>(interval-set)</code><code>(interval-set coll)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-ordered-map"><h3>ordered-map</h3><div class="usage"><code>(ordered-map)</code><code>(ordered-map coll)</code><code>(ordered-map compare-fn coll)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-ordered-map-by"><h3>ordered-map-by</h3><div class="usage"><code>(ordered-map-by pred coll)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-ordered-set"><h3>ordered-set</h3><div class="usage"><code>(ordered-set)</code><code>(ordered-set coll)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-ordered-set-by"><h3>ordered-set-by</h3><div class="usage"><code>(ordered-set-by pred coll)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-subset"><h3>subset</h3><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-superset"><h3>superset</h3><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-union"><h3>union</h3><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/com.dean.interval-tree.tree.interval-map.html b/doc/api/com.dean.interval-tree.tree.interval-map.html
deleted file mode 100644
index 6b97b2a..0000000
--- a/doc/api/com.dean.interval-tree.tree.interval-map.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree.interval-map documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch current"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="com.dean.interval-tree.tree.interval-map.html#var-with-interval-map"><div class="inner"><span>with-interval-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree.interval-map</h1><div class="doc"><pre class="plaintext"></pre></div><div class="public anchor" id="var-with-interval-map"><h3>with-interval-map</h3><h4 class="type">macro</h4><div class="usage"><code>(with-interval-map x &amp; body)</code></div><div class="doc"><pre class="plaintext"></pre></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/com.dean.interval-tree.tree.interval-set.html b/doc/api/com.dean.interval-tree.tree.interval-set.html
deleted file mode 100644
index c346d93..0000000
--- a/doc/api/com.dean.interval-tree.tree.interval-set.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree.interval-set documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch current"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="com.dean.interval-tree.tree.interval-set.html#var-with-interval-set"><div class="inner"><span>with-interval-set</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree.interval-set</h1><div class="doc"><pre class="plaintext"></pre></div><div class="public anchor" id="var-with-interval-set"><h3>with-interval-set</h3><h4 class="type">macro</h4><div class="usage"><code>(with-interval-set x &amp; body)</code></div><div class="doc"><pre class="plaintext"></pre></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/com.dean.interval-tree.tree.interval.html b/doc/api/com.dean.interval-tree.tree.interval.html
deleted file mode 100644
index a8a721a..0000000
--- a/doc/api/com.dean.interval-tree.tree.interval.html
+++ /dev/null
@@ -1,11 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree.interval documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch current"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="com.dean.interval-tree.tree.interval.html#var-includes.3F"><div class="inner"><span>includes?</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.interval.html#var-intersects.3F"><div class="inner"><span>intersects?</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.interval.html#var-ordered-pair"><div class="inner"><span>ordered-pair</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.interval.html#var-ordered-pair.3F"><div class="inner"><span>ordered-pair?</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.interval.html#var-overlaps.3F"><div class="inner"><span>overlaps?</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.interval.html#var-PInterval"><div class="inner"><span>PInterval</span></div></a></li><li class="depth-2 branch"><a href="com.dean.interval-tree.tree.interval.html#var-a"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>a</span></div></a></li><li class="depth-2"><a href="com.dean.interval-tree.tree.interval.html#var-b"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>b</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree.interval</h1><div class="doc"><pre class="plaintext"></pre></div><div class="public anchor" id="var-includes.3F"><h3>includes?</h3><div class="usage"><code>(includes? i0 i1)</code></div><div class="doc"><pre class="plaintext">Inclusive intervals?    [==========]
-[====]</pre></div></div><div class="public anchor" id="var-intersects.3F"><h3>intersects?</h3><div class="usage"><code>(intersects? i0 i1)</code></div><div class="doc"><pre class="plaintext">returns true if there is any common point between intervals i0 and i1
-</pre></div></div><div class="public anchor" id="var-ordered-pair"><h3>ordered-pair</h3><div class="usage"><code>(ordered-pair x y)</code><code>(ordered-pair x)</code></div><div class="doc"><pre class="plaintext">Ensure a normalized interval pair.
-</pre></div></div><div class="public anchor" id="var-ordered-pair.3F"><h3>ordered-pair?</h3><div class="usage"><code>(ordered-pair? x)</code></div><div class="doc"><pre class="plaintext">valid interval pair?
-</pre></div></div><div class="public anchor" id="var-overlaps.3F"><h3>overlaps?</h3><div class="usage"><code>(overlaps? i0 i1)</code></div><div class="doc"><pre class="plaintext">Overlapping intervals?   [=========]
-[=========]</pre></div></div><div class="public anchor" id="var-PInterval"><h3>PInterval</h3><h4 class="type">protocol</h4><div class="usage"></div><div class="doc"><pre class="plaintext">an interval is represented as an ordered pair of endpoints
-</pre></div><div class="members"><h4>members</h4><div class="inner"><div class="public anchor" id="var-a"><h3>a</h3><div class="usage"><code>(a _)</code></div><div class="doc"><pre class="plaintext">interval start coordinate
-</pre></div></div><div class="public anchor" id="var-b"><h3>b</h3><div class="usage"><code>(b _)</code></div><div class="doc"><pre class="plaintext">interval end coordinate
-</pre></div></div></div></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/com.dean.interval-tree.tree.node.html b/doc/api/com.dean.interval-tree.tree.node.html
deleted file mode 100644
index f368800..0000000
--- a/doc/api/com.dean.interval-tree.tree.node.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree.node documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch current"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="com.dean.interval-tree.tree.node.html#var--k"><div class="inner"><span>-k</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.node.html#var--kv"><div class="inner"><span>-kv</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.node.html#var--l"><div class="inner"><span>-l</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.node.html#var--r"><div class="inner"><span>-r</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.node.html#var--v"><div class="inner"><span>-v</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.node.html#var--x"><div class="inner"><span>-x</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.node.html#var--z"><div class="inner"><span>-z</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.node.html#var-leaf"><div class="inner"><span>leaf</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.node.html#var-leaf.3F"><div class="inner"><span>leaf?</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree.node</h1><div class="doc"><pre class="plaintext"></pre></div><div class="public anchor" id="var--k"><h3>-k</h3><div class="usage"><code>(-k n)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var--kv"><h3>-kv</h3><div class="usage"><code>(-kv n)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var--l"><h3>-l</h3><div class="usage"><code>(-l n)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var--r"><h3>-r</h3><div class="usage"><code>(-r n)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var--v"><h3>-v</h3><div class="usage"><code>(-v n)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var--x"><h3>-x</h3><div class="usage"><code>(-x n)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var--z"><h3>-z</h3><div class="usage"><code>(-z n)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-leaf"><h3>leaf</h3><div class="usage"><code>(leaf)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-leaf.3F"><h3>leaf?</h3><div class="usage"><code>(leaf? x)</code></div><div class="doc"><pre class="plaintext"></pre></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/com.dean.interval-tree.tree.order.html b/doc/api/com.dean.interval-tree.tree.order.html
deleted file mode 100644
index c0d50a6..0000000
--- a/doc/api/com.dean.interval-tree.tree.order.html
+++ /dev/null
@@ -1,4 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree.order documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch current"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-*compare*"><div class="inner"><span>*compare*</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-.3C.3D"><div class="inner"><span>&lt;=</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-.3E.3D"><div class="inner"><span>&gt;=</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-compare"><div class="inner"><span>compare</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-compare-by"><div class="inner"><span>compare-by</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-compare.3C"><div class="inner"><span>compare&lt;</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-compare.3C.3D"><div class="inner"><span>compare&lt;=</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-compare.3D"><div class="inner"><span>compare=</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-compare.3E"><div class="inner"><span>compare&gt;</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-compare.3E.3D"><div class="inner"><span>compare&gt;=</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-normal-compare"><div class="inner"><span>normal-compare</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.order.html#var-normalize"><div class="inner"><span>normalize</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree.order</h1><div class="doc"><pre class="plaintext"></pre></div><div class="public anchor" id="var-*compare*"><h3>*compare*</h3><h4 class="dynamic">dynamic</h4><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-.3C.3D"><h3>&lt;=</h3><div class="usage"><code>(&lt;= x)</code><code>(&lt;= x y)</code><code>(&lt;= x y &amp; more)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-.3E.3D"><h3>&gt;=</h3><div class="usage"><code>(&gt;= x)</code><code>(&gt;= x y)</code><code>(&gt;= x y &amp; more)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-compare"><h3>compare</h3><div class="usage"><code>(compare x y)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-compare-by"><h3>compare-by</h3><div class="usage"><code>(compare-by pred)</code></div><div class="doc"><pre class="plaintext">Given a predicate that defines a total order over some domain,
-return a three-way comparator built from it.</pre></div></div><div class="public anchor" id="var-compare.3C"><h3>compare&lt;</h3><div class="usage"><code>(compare&lt; x y)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-compare.3C.3D"><h3>compare&lt;=</h3><div class="usage"><code>(compare&lt;= x y)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-compare.3D"><h3>compare=</h3><div class="usage"><code>(compare= x y)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-compare.3E"><h3>compare&gt;</h3><div class="usage"><code>(compare&gt; x y)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-compare.3E.3D"><h3>compare&gt;=</h3><div class="usage"><code>(compare&gt;= x y)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-max"><h3>max</h3><div class="usage"><code>(max x &amp; args)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-normal-compare"><h3>normal-compare</h3><div class="usage"><code>(normal-compare x y)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-normalize"><h3>normalize</h3><div class="usage"><code>(normalize x)</code></div><div class="doc"><pre class="plaintext"></pre></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/com.dean.interval-tree.tree.ordered-map.html b/doc/api/com.dean.interval-tree.tree.ordered-map.html
deleted file mode 100644
index f28fd72..0000000
--- a/doc/api/com.dean.interval-tree.tree.ordered-map.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree.ordered-map documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch current"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="com.dean.interval-tree.tree.ordered-map.html#var-with-ordered-map"><div class="inner"><span>with-ordered-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree.ordered-map</h1><div class="doc"><pre class="plaintext"></pre></div><div class="public anchor" id="var-with-ordered-map"><h3>with-ordered-map</h3><h4 class="type">macro</h4><div class="usage"><code>(with-ordered-map x &amp; body)</code></div><div class="doc"><pre class="plaintext"></pre></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/com.dean.interval-tree.tree.ordered-set.html b/doc/api/com.dean.interval-tree.tree.ordered-set.html
deleted file mode 100644
index 9df1a2f..0000000
--- a/doc/api/com.dean.interval-tree.tree.ordered-set.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree.ordered-set documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch current"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="com.dean.interval-tree.tree.ordered-set.html#var-with-ordered-set"><div class="inner"><span>with-ordered-set</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree.ordered-set</h1><div class="doc"><pre class="plaintext"></pre></div><div class="public anchor" id="var-with-ordered-set"><h3>with-ordered-set</h3><h4 class="type">macro</h4><div class="usage"><code>(with-ordered-set x &amp; body)</code></div><div class="doc"><pre class="plaintext"></pre></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/com.dean.interval-tree.tree.protocol.html b/doc/api/com.dean.interval-tree.tree.protocol.html
deleted file mode 100644
index c4088e5..0000000
--- a/doc/api/com.dean.interval-tree.tree.protocol.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree.protocol documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch current"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="com.dean.interval-tree.tree.protocol.html#var-PExtensibleSet"><div class="inner"><span>PExtensibleSet</span></div></a></li><li class="depth-2 branch"><a href="com.dean.interval-tree.tree.protocol.html#var-difference"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>difference</span></div></a></li><li class="depth-2 branch"><a href="com.dean.interval-tree.tree.protocol.html#var-intersection"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>intersection</span></div></a></li><li class="depth-2 branch"><a href="com.dean.interval-tree.tree.protocol.html#var-subset"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>subset</span></div></a></li><li class="depth-2 branch"><a href="com.dean.interval-tree.tree.protocol.html#var-superset"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>superset</span></div></a></li><li class="depth-2"><a href="com.dean.interval-tree.tree.protocol.html#var-union"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>union</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree.protocol</h1><div class="doc"><pre class="plaintext"></pre></div><div class="public anchor" id="var-PExtensibleSet"><h3>PExtensibleSet</h3><h4 class="type">protocol</h4><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div><div class="members"><h4>members</h4><div class="inner"><div class="public anchor" id="var-difference"><h3>difference</h3><div class="usage"><code>(difference this that)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-intersection"><h3>intersection</h3><div class="usage"><code>(intersection this that)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-subset"><h3>subset</h3><div class="usage"><code>(subset this that)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-superset"><h3>superset</h3><div class="usage"><code>(superset this that)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-union"><h3>union</h3><div class="usage"><code>(union this that)</code></div><div class="doc"><pre class="plaintext"></pre></div></div></div></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/com.dean.interval-tree.tree.root.html b/doc/api/com.dean.interval-tree.tree.root.html
deleted file mode 100644
index 17a35b8..0000000
--- a/doc/api/com.dean.interval-tree.tree.root.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree.root documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch current"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree.root</h1><div class="doc"><pre class="plaintext"></pre></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/com.dean.interval-tree.tree.tree.html b/doc/api/com.dean.interval-tree.tree.tree.html
deleted file mode 100644
index cb601b1..0000000
--- a/doc/api/com.dean.interval-tree.tree.tree.html
+++ /dev/null
@@ -1,154 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean.interval-tree.tree.tree documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5 current"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-*n-join*"><div class="inner"><span>*n-join*</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-*t-join*"><div class="inner"><span>*t-join*</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-.2Bdelta.2B"><div class="inner"><span>+delta+</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-.2Bgamma.2B"><div class="inner"><span>+gamma+</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-kvlr"><div class="inner"><span>kvlr</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-lr"><div class="inner"><span>lr</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-maybe-z"><div class="inner"><span>maybe-z</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-add"><div class="inner"><span>node-add</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-chunked-fold"><div class="inner"><span>node-chunked-fold</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-compare"><div class="inner"><span>node-compare</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-concat2"><div class="inner"><span>node-concat2</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-concat3"><div class="inner"><span>node-concat3</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-create"><div class="inner"><span>node-create</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-create-weight-balanced"><div class="inner"><span>node-create-weight-balanced</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-create-weight-balanced-interval"><div class="inner"><span>node-create-weight-balanced-interval</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-enum-first"><div class="inner"><span>node-enum-first</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-enum-prior"><div class="inner"><span>node-enum-prior</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-enum-rest"><div class="inner"><span>node-enum-rest</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-enumerator"><div class="inner"><span>node-enumerator</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-enumerator-reverse"><div class="inner"><span>node-enumerator-reverse</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-filter"><div class="inner"><span>node-filter</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-find"><div class="inner"><span>node-find</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-find-best-interval"><div class="inner"><span>node-find-best-interval</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-find-intervals"><div class="inner"><span>node-find-intervals</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-find-nearest"><div class="inner"><span>node-find-nearest</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-fold-left"><div class="inner"><span>node-fold-left</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-fold-right"><div class="inner"><span>node-fold-right</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-greatest"><div class="inner"><span>node-greatest</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-healthy.3F"><div class="inner"><span>node-healthy?</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-invert"><div class="inner"><span>node-invert</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-iter"><div class="inner"><span>node-iter</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-iter-reverse"><div class="inner"><span>node-iter-reverse</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-least"><div class="inner"><span>node-least</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-map-compare"><div class="inner"><span>node-map-compare</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-map-merge"><div class="inner"><span>node-map-merge</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-nth"><div class="inner"><span>node-nth</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-rank"><div class="inner"><span>node-rank</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-remove"><div class="inner"><span>node-remove</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-remove-greatest"><div class="inner"><span>node-remove-greatest</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-remove-least"><div class="inner"><span>node-remove-least</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-seq"><div class="inner"><span>node-seq</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-seq-reverse"><div class="inner"><span>node-seq-reverse</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-set-compare"><div class="inner"><span>node-set-compare</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-set-difference"><div class="inner"><span>node-set-difference</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-set-intersection"><div class="inner"><span>node-set-intersection</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-set-union"><div class="inner"><span>node-set-union</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-singleton"><div class="inner"><span>node-singleton</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-size"><div class="inner"><span>node-size</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-split"><div class="inner"><span>node-split</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-split-greater"><div class="inner"><span>node-split-greater</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-split-lesser"><div class="inner"><span>node-split-lesser</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-split-nth"><div class="inner"><span>node-split-nth</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-stitch"><div class="inner"><span>node-stitch</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-stitch-weight-balanced"><div class="inner"><span>node-stitch-weight-balanced</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-subseq"><div class="inner"><span>node-subseq</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-subset.3F"><div class="inner"><span>node-subset?</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-vec"><div class="inner"><span>node-vec</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-node-weight"><div class="inner"><span>node-weight</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-rotate-double-left"><div class="inner"><span>rotate-double-left</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-rotate-double-right"><div class="inner"><span>rotate-double-right</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-rotate-single-left"><div class="inner"><span>rotate-single-left</span></div></a></li><li class="depth-1"><a href="com.dean.interval-tree.tree.tree.html#var-rotate-single-right"><div class="inner"><span>rotate-single-right</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">com.dean.interval-tree.tree.tree</h1><div class="doc"><pre class="plaintext"></pre></div><div class="public anchor" id="var-*n-join*"><h3>*n-join*</h3><h4 class="dynamic">dynamic</h4><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-*t-join*"><h3>*t-join*</h3><h4 class="dynamic">dynamic</h4><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-.2Bdelta.2B"><h3>+delta+</h3><div class="usage"></div><div class="doc"><pre class="plaintext">The primary balancing rotation coefficient that is used for the
-determination whether two subtrees of a node are in balance or
-require adjustment by means of a rotation operation.  The specific
-rotation to be performed is determined by `+gamma+`.</pre></div></div><div class="public anchor" id="var-.2Bgamma.2B"><h3>+gamma+</h3><div class="usage"></div><div class="doc"><pre class="plaintext">The secondary balancing rotation coefficient that is used for the
-determination of whether a single or double rotation operation should
-occur, once it has been decided based on `+delta+` that a rotation is
-indeed required.</pre></div></div><div class="public anchor" id="var-kvlr"><h3>kvlr</h3><h4 class="type">macro</h4><div class="usage"><code>(kvlr [ksym vsym lsym rsym] n &amp; body)</code></div><div class="doc"><pre class="plaintext">destructure node n: key value left right. This is the principal destructuring macro
-for operating on regions of trees</pre></div></div><div class="public anchor" id="var-lr"><h3>lr</h3><h4 class="type">macro</h4><div class="usage"><code>(lr [lsym rsym] n &amp; body)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-maybe-z"><h3>maybe-z</h3><div class="usage"><code>(maybe-z n)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-node-add"><h3>node-add</h3><div class="usage"><code>(node-add n k)</code><code>(node-add n k v)</code></div><div class="doc"><pre class="plaintext">Insert a new key/value into the tree rooted at n.
-</pre></div></div><div class="public anchor" id="var-node-chunked-fold"><h3>node-chunked-fold</h3><div class="usage"><code>(node-chunked-fold i n combinef reducef)</code></div><div class="doc"><pre class="plaintext">Parallel chunked fold mechansim to suport clojure.core.reducers/CollFold
-</pre></div></div><div class="public anchor" id="var-node-compare"><h3>node-compare</h3><div class="usage"><code>(node-compare accessor n1 n2)</code></div><div class="doc"><pre class="plaintext">return 3-way comparison of the trees n1 and n2 using an accessor
-to compare specific node consitituent values: :k, :v, :kv, or any
-user-specifed function.  Default, when not specified, to the
-entire node structure. return-value semantics:
- -1  -&gt; n1 is LESS-THAN    n2
-  0  -&gt; n1 is EQUAL-TO     n2
- +1  -&gt; n1 is GREATER-THAN n2</pre></div></div><div class="public anchor" id="var-node-concat2"><h3>node-concat2</h3><div class="usage"><code>(node-concat2 l r)</code></div><div class="doc"><pre class="plaintext">Join two trees, the left rooted at l, and the right at r,
-performing a single balancing operation on the resulting tree, if
-needed. Assumes all keys in l are smaller than all keys in r, and
-the relative balance of l and r is such that no more than one rotation
-operation will be required to balance the resulting tree.</pre></div></div><div class="public anchor" id="var-node-concat3"><h3>node-concat3</h3><div class="usage"><code>(node-concat3 k v l r)</code></div><div class="doc"><pre class="plaintext">Join two trees, the left rooted at l, and the right at r,
-with a new key/value, performing rotation operations on the resulting
-trees and subtrees. Assumes all keys in l are smaller than all keys in
-r, and the relative balance of l and r is such that no more than one
-rotation operation will be required to balance the resulting tree.</pre></div></div><div class="public anchor" id="var-node-create"><h3>node-create</h3><div class="usage"><code>(node-create k v l r)</code></div><div class="doc"><pre class="plaintext">Join left and right subtrees at root k/v.
-Assumes all keys in l &lt; k &lt; all keys in r.</pre></div></div><div class="public anchor" id="var-node-create-weight-balanced"><h3>node-create-weight-balanced</h3><div class="usage"><code>(node-create-weight-balanced k v l r)</code></div><div class="doc"><pre class="plaintext">Join left and right weight-balanced subtrees at root k/v.
-Assumes all keys in l &lt; k &lt; all keys in r.</pre></div></div><div class="public anchor" id="var-node-create-weight-balanced-interval"><h3>node-create-weight-balanced-interval</h3><div class="usage"><code>(node-create-weight-balanced-interval i v l r)</code></div><div class="doc"><pre class="plaintext">Join left and right weight-balanced interval subtrees at root k/v.
-Assumes all keys in l &lt; k &lt; all keys in r.</pre></div></div><div class="public anchor" id="var-node-enum-first"><h3>node-enum-first</h3><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-node-enum-prior"><h3>node-enum-prior</h3><div class="usage"><code>(node-enum-prior enum)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-node-enum-rest"><h3>node-enum-rest</h3><div class="usage"><code>(node-enum-rest enum)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-node-enumerator"><h3>node-enumerator</h3><div class="usage"><code>(node-enumerator n)</code><code>(node-enumerator n enum)</code></div><div class="doc"><pre class="plaintext">Efficient mechanism to accomplish partial enumeration of
-tree-structure into a seq representation without incurring the
-overhead of operating over the entire tree.  Used internally for
-implementation of higher-level collection api routines</pre></div></div><div class="public anchor" id="var-node-enumerator-reverse"><h3>node-enumerator-reverse</h3><div class="usage"><code>(node-enumerator-reverse n)</code><code>(node-enumerator-reverse n enum)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-node-filter"><h3>node-filter</h3><div class="usage"><code>(node-filter p n)</code></div><div class="doc"><pre class="plaintext">return a tree with all nodes of n satisfying predicate p.
-</pre></div></div><div class="public anchor" id="var-node-find"><h3>node-find</h3><div class="usage"><code>(node-find n k)</code></div><div class="doc"><pre class="plaintext">find a node in n whose key = k
-</pre></div></div><div class="public anchor" id="var-node-find-best-interval"><h3>node-find-best-interval</h3><div class="usage"><code>(node-find-best-interval n i pred)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-node-find-intervals"><h3>node-find-intervals</h3><div class="usage"><code>(node-find-intervals n i)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-node-find-nearest"><h3>node-find-nearest</h3><div class="usage"><code>(node-find-nearest n k &amp; [gt-or-lt])</code></div><div class="doc"><pre class="plaintext">Find the nearest k according to relation expressed by :&lt; or :&gt;
-</pre></div></div><div class="public anchor" id="var-node-fold-left"><h3>node-fold-left</h3><div class="usage"><code>(node-fold-left f n)</code><code>(node-fold-left f base n)</code></div><div class="doc"><pre class="plaintext">Fold-left (reduce) the collection from least to greatest.
-</pre></div></div><div class="public anchor" id="var-node-fold-right"><h3>node-fold-right</h3><div class="usage"><code>(node-fold-right f n)</code><code>(node-fold-right f base n)</code></div><div class="doc"><pre class="plaintext">Fold-right (reduce) the collection from greatest to least.
-</pre></div></div><div class="public anchor" id="var-node-greatest"><h3>node-greatest</h3><div class="usage"><code>(node-greatest n)</code></div><div class="doc"><pre class="plaintext">Return the node containing the minimum key of the tree rooted at n
-</pre></div></div><div class="public anchor" id="var-node-healthy.3F"><h3>node-healthy?</h3><div class="usage"><code>(node-healthy? n)</code></div><div class="doc"><pre class="plaintext">verify node `n` and all descendants satisfy the node-invariants
-of a weight-balanced binary tree.</pre></div></div><div class="public anchor" id="var-node-invert"><h3>node-invert</h3><div class="usage"><code>(node-invert n)</code></div><div class="doc"><pre class="plaintext">return a tree in which the keys and values of n are reversed.
-</pre></div></div><div class="public anchor" id="var-node-iter"><h3>node-iter</h3><div class="usage"><code>(node-iter n f)</code></div><div class="doc"><pre class="plaintext">For the side-effect, apply f to each node of the tree rooted at n.
-</pre></div></div><div class="public anchor" id="var-node-iter-reverse"><h3>node-iter-reverse</h3><div class="usage"><code>(node-iter-reverse n f)</code></div><div class="doc"><pre class="plaintext">For the side-effect, apply f to each node of the tree rooted at n.
-</pre></div></div><div class="public anchor" id="var-node-least"><h3>node-least</h3><div class="usage"><code>(node-least n)</code></div><div class="doc"><pre class="plaintext">Return the node containing the minimum key of the tree rooted at n
-</pre></div></div><div class="public anchor" id="var-node-map-compare"><h3>node-map-compare</h3><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-node-map-merge"><h3>node-map-merge</h3><div class="usage"><code>(node-map-merge n1 n2 merge-fn)</code></div><div class="doc"><pre class="plaintext">Merge two maps in worst case linear time.
-</pre></div></div><div class="public anchor" id="var-node-nth"><h3>node-nth</h3><div class="usage"><code>(node-nth n index)</code></div><div class="doc"><pre class="plaintext">Return nth node from the beginning of the ordered tree rooted at n.
-(Logarithmic Time)</pre></div></div><div class="public anchor" id="var-node-rank"><h3>node-rank</h3><div class="usage"><code>(node-rank n k)</code></div><div class="doc"><pre class="plaintext">Return the rank (sequential position) of a given KEY within the
-ordered tree rooted at n. (Logarithmic Time)</pre></div></div><div class="public anchor" id="var-node-remove"><h3>node-remove</h3><div class="usage"><code>(node-remove n k)</code></div><div class="doc"><pre class="plaintext">remove the node whose key is equal to k, if present.
-</pre></div></div><div class="public anchor" id="var-node-remove-greatest"><h3>node-remove-greatest</h3><div class="usage"><code>(node-remove-greatest n)</code></div><div class="doc"><pre class="plaintext">Return a tree the same as the one rooted at n, with the node
-containing the maximum key removed. See node-greatest.</pre></div></div><div class="public anchor" id="var-node-remove-least"><h3>node-remove-least</h3><div class="usage"><code>(node-remove-least n)</code></div><div class="doc"><pre class="plaintext">Return a tree the same as the one rooted at n, with the node
-containing the minimum key removed. See node-least.</pre></div></div><div class="public anchor" id="var-node-seq"><h3>node-seq</h3><div class="usage"><code>(node-seq n)</code></div><div class="doc"><pre class="plaintext">Return a (lazy) seq of nodes in tree rooted at n in the order they occur.
-(Logarithmic Time)</pre></div></div><div class="public anchor" id="var-node-seq-reverse"><h3>node-seq-reverse</h3><div class="usage"><code>(node-seq-reverse n)</code></div><div class="doc"><pre class="plaintext">Return a (lazy) seq of nodes in tree rooted at n in reverse order.
-</pre></div></div><div class="public anchor" id="var-node-set-compare"><h3>node-set-compare</h3><div class="usage"></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-node-set-difference"><h3>node-set-difference</h3><div class="usage"><code>(node-set-difference n1 n2)</code></div><div class="doc"><pre class="plaintext"></pre></div></div><div class="public anchor" id="var-node-set-intersection"><h3>node-set-intersection</h3><div class="usage"><code>(node-set-intersection n1 n2)</code></div><div class="doc"><pre class="plaintext">set intersection
-</pre></div></div><div class="public anchor" id="var-node-set-union"><h3>node-set-union</h3><div class="usage"><code>(node-set-union n1 n2)</code></div><div class="doc"><pre class="plaintext">set union
-</pre></div></div><div class="public anchor" id="var-node-singleton"><h3>node-singleton</h3><div class="usage"><code>(node-singleton k v)</code></div><div class="doc"><pre class="plaintext">Create and return a newly allocated, balanced tree
-containing a single association, that of key K with value V.</pre></div></div><div class="public anchor" id="var-node-size"><h3>node-size</h3><div class="usage"><code>(node-size n)</code></div><div class="doc"><pre class="plaintext">returns the balance metric of the tree rooted at n.
-</pre></div></div><div class="public anchor" id="var-node-split"><h3>node-split</h3><div class="usage"><code>(node-split n k)</code></div><div class="doc"><pre class="plaintext">returns a triple (l present r) where: l is the set of elements of
-n that are &lt; k, r is the set of elements of n that are &gt; k, present
-is false if n contains no element equal to k, or (k v) if n contains
-an element with key equal to k.</pre></div></div><div class="public anchor" id="var-node-split-greater"><h3>node-split-greater</h3><div class="usage"><code>(node-split-greater n k)</code></div><div class="doc"><pre class="plaintext">return a tree of all nodes whose key is greater than k (Logarithmic time).
-</pre></div></div><div class="public anchor" id="var-node-split-lesser"><h3>node-split-lesser</h3><div class="usage"><code>(node-split-lesser n k)</code></div><div class="doc"><pre class="plaintext">return a tree of all nodes whose key is less than k (Logarithmic time).
-</pre></div></div><div class="public anchor" id="var-node-split-nth"><h3>node-split-nth</h3><div class="usage"><code>(node-split-nth n i)</code></div><div class="doc"><pre class="plaintext">return a tree of all nodes whose position is &gt;= i. (Logarithmic Time)
-</pre></div></div><div class="public anchor" id="var-node-stitch"><h3>node-stitch</h3><div class="usage"><code>(node-stitch k v l r)</code></div><div class="doc"><pre class="plaintext">The `stitch` operation is the sole balancing constructor and
-interface to the specific balancing rotation algorithm of the tree.
-other balancing algorithms (AVL Tree, Red-Black Tree) can be
-implemented here without effect to other aspects of the tree.
-Sometimes referred to as `n-join` operation</pre></div></div><div class="public anchor" id="var-node-stitch-weight-balanced"><h3>node-stitch-weight-balanced</h3><div class="usage"><code>(node-stitch-weight-balanced k v l r)</code></div><div class="doc"><pre class="plaintext">Weight-Balancing Algorithm:
-
-Join left and right subtrees at root k/v, performing a single or
-double rotation to balance the resulting tree, if needed.  Assumes
-all keys in l &lt; k &lt; all keys in r, and the relative weight balance
-of the left and right subtrees is such that no more than one
-single/double rotation will result in each subtree being less than
-+delta+ times the weight of the other.  This is the heart of tree
-construction.</pre></div></div><div class="public anchor" id="var-node-subseq"><h3>node-subseq</h3><div class="usage"><code>(node-subseq n from)</code><code>(node-subseq n from to)</code></div><div class="doc"><pre class="plaintext">Return a (lazy) seq of nodes for the slice of the tree beginning
-at position `from` ending at `to`.</pre></div></div><div class="public anchor" id="var-node-subset.3F"><h3>node-subset?</h3><div class="usage"><code>(node-subset? super sub)</code></div><div class="doc"><pre class="plaintext">return true if `sub` is a subset of `super`
-</pre></div></div><div class="public anchor" id="var-node-vec"><h3>node-vec</h3><div class="usage"><code>(node-vec n &amp; {:keys [accessor reverse?]})</code></div><div class="doc"><pre class="plaintext">Eagerly return a vector of all nodes in tree rooted at n in
-the specified order, optionally using an accessor to extract
-specific node consitituent values: :k, :v, :kv, or any
-user-specifed function.  Default, when not specified, to the
-entire node structure.</pre></div></div><div class="public anchor" id="var-node-weight"><h3>node-weight</h3><div class="usage"><code>(node-weight n)</code></div><div class="doc"><pre class="plaintext">returns node weight as appropriate for rotation calculations using
-the 'revised non-variant algorithm' for weight balanced binary tree.</pre></div></div><div class="public anchor" id="var-rotate-double-left"><h3>rotate-double-left</h3><div class="usage"><code>(rotate-double-left ak av x c)</code></div><div class="doc"><pre class="plaintext">Perform a double left rotation, moving Y1, the left subtree of the
-left subtree of the right subtree of A, into the left subtree (shown
-below).  This must occur in order to restore proper balance when the
-weight of the left subtree of node A is less then the weight of the
-right subtree of node A multiplied by rotation coefficient +delta+
-and the weight of the left subtree of node B is greater than or equal
-to the weight of the right subtree of node B multiplied by rotation
-coefficient +gamma+.
-
-              ,---,                                    ,---,
-              | A |                                    | B |
-           ___:---:___                             ____:---:____
-      ,---:           :---,                   ,---:             :---,
-      | X |           | C |                   | A |             | C |
-      '---'           :---:         =&gt;        :---:             :---:
-                 ,---:     :---,         ,---:     :---,   ,---:     :---,
-                 | B |     | Z |         | X |     | y1|   | y2|     | Z |
-                 :---:     '---'         '---'     '---'   '---'     '---'
-            ,---:     :---,
-            | y1|     | y2|
-            '---'     '---'</pre></div></div><div class="public anchor" id="var-rotate-double-right"><h3>rotate-double-right</h3><div class="usage"><code>(rotate-double-right ck cv a z)</code></div><div class="doc"><pre class="plaintext">Perform a double right rotation, moving Y2, the right subtree of
-the right subtree of the left subtree of C, into the right
-subtree (shown below).  This must occur in order to restore proper
-balance when the weight of the right subtree of node C is less then
-the weight of the left subtree of node C multiplied by rotation
-coefficient +delta+ and the weight of the right subtree of node B
-is greater than or equal to the weight of the left subtree of node B
-multiplied by rotation coefficient +gamma+.
-
-              ,---,                                    ,---,
-              | C |                                    | B |
-           ___:---:___                             ____:---:____
-      ,---:           :---,                   ,---:             :---,
-      | A |           | Z |                   | A |             | C |
-      :---:           '---'        =&gt;         :---:             :---:
- ,---:     :---,                         ,---:     :---,   ,---:     :---,
- | X |     | B |                         | X |     | y1|   | y2|     | Z |
- '---'     :---:                         '---'     '---'   '---'     '---'
-      ,---:     :---,
-      | y1|     | y2|
-      '---'     '---'</pre></div></div><div class="public anchor" id="var-rotate-single-left"><h3>rotate-single-left</h3><div class="usage"><code>(rotate-single-left ak av x b)</code></div><div class="doc"><pre class="plaintext">Perform a single left rotation, moving Y, the left subtree of the
-right subtree of A, into the left subtree (shown below).  This must
-occur in order to restore proper balance when the weight of the left
-subtree of node A is less then the weight of the right subtree of
-node A multiplied by rotation coefficient +delta+ and the weight of
-the left subtree of node B is less than the weight of the right subtree
-of node B multiplied by rotation coefficient +gamma+
-
-              ,---,                                  ,---,
-              | A |                                  | B |
-              :---:                                  :---:
-             :     :                                :     :
-        ,---:       :---,                      ,---:       :---,
-        | X |       | B |           =&gt;         | A |       | Z |
-        '---'       :---:                      :---:       '---'
-               ,---:     :---,            ,---:     :---,
-               | Y |     | Z |            | X |     | Y |
-               '---'     '---'            '---'     '---'</pre></div></div><div class="public anchor" id="var-rotate-single-right"><h3>rotate-single-right</h3><div class="usage"><code>(rotate-single-right bk bv a z)</code></div><div class="doc"><pre class="plaintext">Perform a single right rotation, moving Y, the right subtree of the
-left subtree of B, into the right subtree (shown below).  This must
-occur in order to restore proper balance when the weight of the right
-subtree of node B is less then the weight of the left subtree of
-node B multiplied by rotation coefficient +delta+ and the weight of the
-right subtree of node A is less than the weight of the left subtree
-of node A multiplied by rotation coefficient +gamma+.
-
-              ,---,                                  ,---,
-              | B |                                  | A |
-              :---:                                  :---:
-             :     :                                :     :
-        ,---:       :---,                      ,---:       :---,
-        | A |       | Z |          =&gt;          | X |       | B |
-        :---:       '---'                      '---'       :---:
-   ,---:     :---,                                    ,---:     :---,
-   | X |     | Y |                                    | Y |     | Z |
-   '---'     '---'                                    '---'     '---'</pre></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/css/default.css b/doc/api/css/default.css
deleted file mode 100644
index 33f78fe..0000000
--- a/doc/api/css/default.css
+++ /dev/null
@@ -1,551 +0,0 @@
-body {
-    font-family: Helvetica, Arial, sans-serif;
-    font-size: 15px;
-}
-
-pre, code {
-    font-family: Monaco, DejaVu Sans Mono, Consolas, monospace;
-    font-size: 9pt;
-    margin: 15px 0;
-}
-
-h1 {
-    font-weight: normal;
-    font-size: 29px;
-    margin: 10px 0 2px 0;
-    padding: 0;
-}
-
-h2 {
-    font-weight: normal;
-    font-size: 25px;
-}
-
-h5.license {
-    margin: 9px 0 22px 0;
-    color: #555;
-    font-weight: normal;
-    font-size: 12px;
-    font-style: italic;
-}
-
-.document h1, .namespace-index h1 {
-    font-size: 32px;
-    margin-top: 12px;
-}
-
-#header, #content, .sidebar {
-    position: fixed;
-}
-
-#header {
-    top: 0;
-    left: 0;
-    right: 0;
-    height: 22px;
-    color: #f5f5f5;
-    padding: 5px 7px;
-}
-
-#content {
-    top: 32px;
-    right: 0;
-    bottom: 0;
-    overflow: auto;
-    background: #fff;
-    color: #333;
-    padding: 0 18px;
-}
-
-.sidebar {
-    position: fixed;
-    top: 32px;
-    bottom: 0;
-    overflow: auto;
-}
-
-.sidebar.primary {
-    background: #e2e2e2;
-    border-right: solid 1px #cccccc;
-    left: 0;
-    width: 250px;
-}
-
-.sidebar.secondary {
-    background: #f2f2f2;
-    border-right: solid 1px #d7d7d7;
-    left: 251px;
-    width: 200px;
-}
-
-#content.namespace-index, #content.document {
-    left: 251px;
-}
-
-#content.namespace-docs {
-    left: 452px;
-}
-
-#content.document {
-    padding-bottom: 10%;
-}
-
-#header {
-    background: #3f3f3f;
-    box-shadow: 0 0 8px rgba(0, 0, 0, 0.4);
-    z-index: 100;
-}
-
-#header h1 {
-    margin: 0;
-    padding: 0;
-    font-size: 18px;
-    font-weight: lighter;
-    text-shadow: -1px -1px 0px #333;
-}
-
-#header h1 .project-version {
-    font-weight: normal;
-}
-
-.project-version {
-    padding-left: 0.15em;
-}
-
-#header a, .sidebar a {
-    display: block;
-    text-decoration: none;
-}
-
-#header a {
-    color: #f5f5f5;
-}
-
-.sidebar a {
-    color: #333;
-}
-
-#header h2 {
-    float: right;
-    font-size: 9pt;
-    font-weight: normal;
-    margin: 4px 3px;
-    padding: 0;
-    color: #bbb;
-}
-
-#header h2 a {
-    display: inline;
-}
-
-.sidebar h3 {
-    margin: 0;
-    padding: 10px 13px 0 13px;
-    font-size: 19px;
-    font-weight: lighter;
-}
-
-.sidebar h3 a {
-    color: #444;
-}
-
-.sidebar h3.no-link {
-    color: #636363;
-}
-
-.sidebar ul {
-    padding: 7px 0 6px 0;
-    margin: 0;
-}
-
-.sidebar ul.index-link {
-    padding-bottom: 4px;
-}
-
-.sidebar li {
-    display: block;
-    vertical-align: middle;
-}
-
-.sidebar li a, .sidebar li .no-link {
-    border-left: 3px solid transparent;
-    padding: 0 10px;
-    white-space: nowrap;
-}
-
-.sidebar li .no-link {
-    display: block;
-    color: #777;
-    font-style: italic;
-}
-
-.sidebar li .inner {
-    display: inline-block;
-    padding-top: 7px;
-    height: 24px;
-}
-
-.sidebar li a, .sidebar li .tree {
-    height: 31px;
-}
-
-.depth-1 .inner { padding-left: 2px; }
-.depth-2 .inner { padding-left: 6px; }
-.depth-3 .inner { padding-left: 20px; }
-.depth-4 .inner { padding-left: 34px; }
-.depth-5 .inner { padding-left: 48px; }
-.depth-6 .inner { padding-left: 62px; }
-
-.sidebar li .tree {
-    display: block;
-    float: left;
-    position: relative;
-    top: -10px;
-    margin: 0 4px 0 0;
-    padding: 0;
-}
-
-.sidebar li.depth-1 .tree {
-    display: none;
-}
-
-.sidebar li .tree .top, .sidebar li .tree .bottom {
-    display: block;
-    margin: 0;
-    padding: 0;
-    width: 7px;
-}
-
-.sidebar li .tree .top {
-    border-left: 1px solid #aaa;
-    border-bottom: 1px solid #aaa;
-    height: 19px;
-}
-
-.sidebar li .tree .bottom {
-    height: 22px;
-}
-
-.sidebar li.branch .tree .bottom {
-    border-left: 1px solid #aaa;
-}
-
-.sidebar.primary li.current a {
-    border-left: 3px solid #a33;
-    color: #a33;
-}
-
-.sidebar.secondary li.current a {
-    border-left: 3px solid #33a;
-    color: #33a;
-}
-
-.namespace-index h2 {
-    margin: 30px 0 0 0;
-}
-
-.namespace-index h3 {
-    font-size: 16px;
-    font-weight: bold;
-    margin-bottom: 0;
-}
-
-.namespace-index .topics {
-    padding-left: 30px;
-    margin: 11px 0 0 0;
-}
-
-.namespace-index .topics li {
-    padding: 5px 0;
-}
-
-.namespace-docs h3 {
-    font-size: 18px;
-    font-weight: bold;
-}
-
-.public h3 {
-    margin: 0;
-    float: left;
-}
-
-.usage {
-    clear: both;
-}
-
-.public {
-    margin: 0;
-    border-top: 1px solid #e0e0e0;
-    padding-top: 14px;
-    padding-bottom: 6px;
-}
-
-.public:last-child {
-    margin-bottom: 20%;
-}
-
-.members .public:last-child {
-    margin-bottom: 0;
-}
-
-.members {
-    margin: 15px 0;
-}
-
-.members h4 {
-    color: #555;
-    font-weight: normal;
-    font-variant: small-caps;
-    margin: 0 0 5px 0;
-}
-
-.members .inner {
-    padding-top: 5px;
-    padding-left: 12px;
-    margin-top: 2px;
-    margin-left: 7px;
-    border-left: 1px solid #bbb;
-}
-
-#content .members .inner h3 {
-    font-size: 12pt;
-}
-
-.members .public {
-    border-top: none;
-    margin-top: 0;
-    padding-top: 6px;
-    padding-bottom: 0;
-}
-
-.members .public:first-child {
-    padding-top: 0;
-}
-
-h4.type,
-h4.dynamic,
-h4.added,
-h4.deprecated {
-    float: left;
-    margin: 3px 10px 15px 0;
-    font-size: 15px;
-    font-weight: bold;
-    font-variant: small-caps;
-}
-
-.public h4.type,
-.public h4.dynamic,
-.public h4.added,
-.public h4.deprecated {
-    font-size: 13px;
-    font-weight: bold;
-    margin: 3px 0 0 10px;
-}
-
-.members h4.type,
-.members h4.added,
-.members h4.deprecated {
-    margin-top: 1px;
-}
-
-h4.type {
-    color: #717171;
-}
-
-h4.dynamic {
-    color: #9933aa;
-}
-
-h4.added {
-    color: #508820;
-}
-
-h4.deprecated {
-    color: #880000;
-}
-
-.namespace {
-    margin-bottom: 30px;
-}
-
-.namespace:last-child {
-    margin-bottom: 10%;
-}
-
-.index {
-    padding: 0;
-    font-size: 80%;
-    margin: 15px 0;
-    line-height: 16px;
-}
-
-.index * {
-    display: inline;
-}
-
-.index p {
-    padding-right: 3px;
-}
-
-.index li {
-    padding-right: 5px;
-}
-
-.index ul {
-    padding-left: 0;
-}
-
-.type-sig {
-    clear: both;
-    color: #088;
-}
-
-.type-sig pre {
-    padding-top: 10px;
-    margin: 0;
-}
-
-.usage code {
-    display: block;
-    color: #008;
-    margin: 2px 0;
-}
-
-.usage code:first-child {
-    padding-top: 10px;
-}
-
-p {
-    margin: 15px 0;
-}
-
-.public p:first-child, .public pre.plaintext {
-    margin-top: 12px;
-}
-
-.doc {
-    margin: 0 0 26px 0;
-    clear: both;
-}
-
-.public .doc {
-    margin: 0;
-}
-
-.namespace-index .doc {
-    margin-bottom: 20px;
-}
-
-.namespace-index .namespace .doc {
-    margin-bottom: 10px;
-}
-
-.markdown p, .markdown li, .markdown dt, .markdown dd, .markdown td {
-    line-height: 22px;
-}
-
-.markdown li {
-    padding: 2px 0;
-}
-
-.markdown h2 {
-    font-weight: normal;
-    font-size: 25px;
-    margin: 30px 0 10px 0;
-}
-
-.markdown h3 {
-    font-weight: normal;
-    font-size: 20px;
-    margin: 30px 0 0 0;
-}
-
-.markdown h4 {
-    font-size: 15px;
-    margin: 22px 0 -4px 0;
-}
-
-.doc, .public, .namespace .index {
-    max-width: 680px;
-    overflow-x: visible;
-}
-
-.markdown pre > code {
-    display: block;
-    padding: 10px;
-}
-
-.markdown pre > code, .src-link a {
-    border: 1px solid #e4e4e4;
-    border-radius: 2px;
-}
-
-.markdown code:not(.hljs), .src-link a {
-    background: #f6f6f6;
-}
-
-pre.deps {
-    display: inline-block;
-    margin: 0 10px;
-    border: 1px solid #e4e4e4;
-    border-radius: 2px;
-    padding: 10px;
-    background-color: #f6f6f6;
-}
-
-.markdown hr {
-    border-style: solid;
-    border-top: none;
-    color: #ccc;
-}
-
-.doc ul, .doc ol {
-    padding-left: 30px;
-}
-
-.doc table {
-    border-collapse: collapse;
-    margin: 0 10px;
-}
-
-.doc table td, .doc table th {
-    border: 1px solid #dddddd;
-    padding: 4px 6px;
-}
-
-.doc table th {
-    background: #f2f2f2;
-}
-
-.doc dl {
-    margin: 0 10px 20px 10px;
-}
-
-.doc dl dt {
-    font-weight: bold;
-    margin: 0;
-    padding: 3px 0;
-    border-bottom: 1px solid #ddd;
-}
-
-.doc dl dd {
-    padding: 5px 0;
-    margin: 0 0 5px 10px;
-}
-
-.doc abbr {
-    border-bottom: 1px dotted #333;
-    font-variant: none;
-    cursor: help;
-}
-
-.src-link {
-    margin-bottom: 15px;
-}
-
-.src-link a {
-    font-size: 70%;
-    padding: 1px 4px;
-    text-decoration: none;
-    color: #5555bb;
-}
diff --git a/doc/api/css/highlight.css b/doc/api/css/highlight.css
deleted file mode 100644
index d0cdaa3..0000000
--- a/doc/api/css/highlight.css
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-github.com style (c) Vasily Polovnyov <vast@whiteants.net>
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  color: #333;
-  background: #f8f8f8;
-}
-
-.hljs-comment,
-.hljs-quote {
-  color: #998;
-  font-style: italic;
-}
-
-.hljs-keyword,
-.hljs-selector-tag,
-.hljs-subst {
-  color: #333;
-  font-weight: bold;
-}
-
-.hljs-number,
-.hljs-literal,
-.hljs-variable,
-.hljs-template-variable,
-.hljs-tag .hljs-attr {
-  color: #008080;
-}
-
-.hljs-string,
-.hljs-doctag {
-  color: #d14;
-}
-
-.hljs-title,
-.hljs-section,
-.hljs-selector-id {
-  color: #900;
-  font-weight: bold;
-}
-
-.hljs-subst {
-  font-weight: normal;
-}
-
-.hljs-type,
-.hljs-class .hljs-title {
-  color: #458;
-  font-weight: bold;
-}
-
-.hljs-tag,
-.hljs-name,
-.hljs-attribute {
-  color: #000080;
-  font-weight: normal;
-}
-
-.hljs-regexp,
-.hljs-link {
-  color: #009926;
-}
-
-.hljs-symbol,
-.hljs-bullet {
-  color: #990073;
-}
-
-.hljs-built_in,
-.hljs-builtin-name {
-  color: #0086b3;
-}
-
-.hljs-meta {
-  color: #999;
-  font-weight: bold;
-}
-
-.hljs-deletion {
-  background: #fdd;
-}
-
-.hljs-addition {
-  background: #dfd;
-}
-
-.hljs-emphasis {
-  font-style: italic;
-}
-
-.hljs-strong {
-  font-weight: bold;
-}
diff --git a/doc/api/index.html b/doc/api/index.html
deleted file mode 100644
index c2cae52..0000000
--- a/doc/api/index.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>com.dean/interval-tree 0.1.0</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>com</span></div></div></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>dean</span></div></div></li><li class="depth-3"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-tree</span></div></div></li><li class="depth-4"><a href="com.dean.interval-tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.interval-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>interval-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.node.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>node</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.order.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>order</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-map.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-map</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.ordered-set.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ordered-set</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.protocol.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>protocol</span></div></a></li><li class="depth-5 branch"><a href="com.dean.interval-tree.tree.root.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>root</span></div></a></li><li class="depth-5"><a href="com.dean.interval-tree.tree.tree.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>tree</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">com.dean/interval-tree</span> <span class="project-version">0.1.0</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>Modular, Extensible, Foldable Weight-Balanced Tree.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[com.dean/interval-tree "0.1.0"]</pre><h2>Namespaces</h2><div class="namespace"><h3><a href="com.dean.interval-tree.tree.html">com.dean.interval-tree.tree</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="com.dean.interval-tree.tree.html#var-difference">difference</a> </li><li> <a href="com.dean.interval-tree.tree.html#var-intersection">intersection</a> </li><li> <a href="com.dean.interval-tree.tree.html#var-interval-map">interval-map</a> </li><li> <a href="com.dean.interval-tree.tree.html#var-interval-set">interval-set</a> </li><li> <a href="com.dean.interval-tree.tree.html#var-ordered-map">ordered-map</a> </li><li> <a href="com.dean.interval-tree.tree.html#var-ordered-map-by">ordered-map-by</a> </li><li> <a href="com.dean.interval-tree.tree.html#var-ordered-set">ordered-set</a> </li><li> <a href="com.dean.interval-tree.tree.html#var-ordered-set-by">ordered-set-by</a> </li><li> <a href="com.dean.interval-tree.tree.html#var-subset">subset</a> </li><li> <a href="com.dean.interval-tree.tree.html#var-superset">superset</a> </li><li> <a href="com.dean.interval-tree.tree.html#var-union">union</a> </li></ul></div></div><div class="namespace"><h3><a href="com.dean.interval-tree.tree.interval.html">com.dean.interval-tree.tree.interval</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="com.dean.interval-tree.tree.interval.html#var-includes.3F">includes?</a> </li><li> <a href="com.dean.interval-tree.tree.interval.html#var-intersects.3F">intersects?</a> </li><li> <a href="com.dean.interval-tree.tree.interval.html#var-ordered-pair">ordered-pair</a> </li><li> <a href="com.dean.interval-tree.tree.interval.html#var-ordered-pair.3F">ordered-pair?</a> </li><li> <a href="com.dean.interval-tree.tree.interval.html#var-overlaps.3F">overlaps?</a> </li><li> <a href="com.dean.interval-tree.tree.interval.html#var-PInterval">PInterval</a> </li></ul></div></div><div class="namespace"><h3><a href="com.dean.interval-tree.tree.interval-map.html">com.dean.interval-tree.tree.interval-map</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="com.dean.interval-tree.tree.interval-map.html#var-with-interval-map">with-interval-map</a> </li></ul></div></div><div class="namespace"><h3><a href="com.dean.interval-tree.tree.interval-set.html">com.dean.interval-tree.tree.interval-set</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="com.dean.interval-tree.tree.interval-set.html#var-with-interval-set">with-interval-set</a> </li></ul></div></div><div class="namespace"><h3><a href="com.dean.interval-tree.tree.node.html">com.dean.interval-tree.tree.node</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="com.dean.interval-tree.tree.node.html#var--k">-k</a> </li><li> <a href="com.dean.interval-tree.tree.node.html#var--kv">-kv</a> </li><li> <a href="com.dean.interval-tree.tree.node.html#var--l">-l</a> </li><li> <a href="com.dean.interval-tree.tree.node.html#var--r">-r</a> </li><li> <a href="com.dean.interval-tree.tree.node.html#var--v">-v</a> </li><li> <a href="com.dean.interval-tree.tree.node.html#var--x">-x</a> </li><li> <a href="com.dean.interval-tree.tree.node.html#var--z">-z</a> </li><li> <a href="com.dean.interval-tree.tree.node.html#var-leaf">leaf</a> </li><li> <a href="com.dean.interval-tree.tree.node.html#var-leaf.3F">leaf?</a> </li></ul></div></div><div class="namespace"><h3><a href="com.dean.interval-tree.tree.order.html">com.dean.interval-tree.tree.order</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="com.dean.interval-tree.tree.order.html#var-*compare*">*compare*</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-.3C.3D">&lt;=</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-.3E.3D">&gt;=</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-compare">compare</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-compare-by">compare-by</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-compare.3C">compare&lt;</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-compare.3C.3D">compare&lt;=</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-compare.3D">compare=</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-compare.3E">compare&gt;</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-compare.3E.3D">compare&gt;=</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-max">max</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-normal-compare">normal-compare</a> </li><li> <a href="com.dean.interval-tree.tree.order.html#var-normalize">normalize</a> </li></ul></div></div><div class="namespace"><h3><a href="com.dean.interval-tree.tree.ordered-map.html">com.dean.interval-tree.tree.ordered-map</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="com.dean.interval-tree.tree.ordered-map.html#var-with-ordered-map">with-ordered-map</a> </li></ul></div></div><div class="namespace"><h3><a href="com.dean.interval-tree.tree.ordered-set.html">com.dean.interval-tree.tree.ordered-set</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="com.dean.interval-tree.tree.ordered-set.html#var-with-ordered-set">with-ordered-set</a> </li></ul></div></div><div class="namespace"><h3><a href="com.dean.interval-tree.tree.protocol.html">com.dean.interval-tree.tree.protocol</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="com.dean.interval-tree.tree.protocol.html#var-PExtensibleSet">PExtensibleSet</a> </li></ul></div></div><div class="namespace"><h3><a href="com.dean.interval-tree.tree.root.html">com.dean.interval-tree.tree.root</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul></ul></div></div><div class="namespace"><h3><a href="com.dean.interval-tree.tree.tree.html">com.dean.interval-tree.tree.tree</a></h3><div class="doc"><pre class="plaintext"></pre></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="com.dean.interval-tree.tree.tree.html#var-*n-join*">*n-join*</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-*t-join*">*t-join*</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-.2Bdelta.2B">+delta+</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-.2Bgamma.2B">+gamma+</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-kvlr">kvlr</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-lr">lr</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-maybe-z">maybe-z</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-add">node-add</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-chunked-fold">node-chunked-fold</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-compare">node-compare</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-concat2">node-concat2</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-concat3">node-concat3</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-create">node-create</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-create-weight-balanced">node-create-weight-balanced</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-create-weight-balanced-interval">node-create-weight-balanced-interval</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-enum-first">node-enum-first</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-enum-prior">node-enum-prior</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-enum-rest">node-enum-rest</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-enumerator">node-enumerator</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-enumerator-reverse">node-enumerator-reverse</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-filter">node-filter</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-find">node-find</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-find-best-interval">node-find-best-interval</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-find-intervals">node-find-intervals</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-find-nearest">node-find-nearest</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-fold-left">node-fold-left</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-fold-right">node-fold-right</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-greatest">node-greatest</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-healthy.3F">node-healthy?</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-invert">node-invert</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-iter">node-iter</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-iter-reverse">node-iter-reverse</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-least">node-least</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-map-compare">node-map-compare</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-map-merge">node-map-merge</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-nth">node-nth</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-rank">node-rank</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-remove">node-remove</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-remove-greatest">node-remove-greatest</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-remove-least">node-remove-least</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-seq">node-seq</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-seq-reverse">node-seq-reverse</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-set-compare">node-set-compare</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-set-difference">node-set-difference</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-set-intersection">node-set-intersection</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-set-union">node-set-union</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-singleton">node-singleton</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-size">node-size</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-split">node-split</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-split-greater">node-split-greater</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-split-lesser">node-split-lesser</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-split-nth">node-split-nth</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-stitch">node-stitch</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-stitch-weight-balanced">node-stitch-weight-balanced</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-subseq">node-subseq</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-subset.3F">node-subset?</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-vec">node-vec</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-node-weight">node-weight</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-rotate-double-left">rotate-double-left</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-rotate-double-right">rotate-double-right</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-rotate-single-left">rotate-single-left</a> </li><li> <a href="com.dean.interval-tree.tree.tree.html#var-rotate-single-right">rotate-single-right</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/doc/api/js/highlight.min.js b/doc/api/js/highlight.min.js
deleted file mode 100644
index 6486ffd..0000000
--- a/doc/api/js/highlight.min.js
+++ /dev/null
@@ -1,2 +0,0 @@
-/*! highlight.js v9.6.0 | BSD3 License | git.io/hljslicense */
-!function(e){var n="object"==typeof window&&window||"object"==typeof self&&self;"undefined"!=typeof exports?e(exports):n&&(n.hljs=e({}),"function"==typeof define&&define.amd&&define([],function(){return n.hljs}))}(function(e){function n(e){return e.replace(/[&<>]/gm,function(e){return I[e]})}function t(e){return e.nodeName.toLowerCase()}function r(e,n){var t=e&&e.exec(n);return t&&0===t.index}function a(e){return k.test(e)}function i(e){var n,t,r,i,o=e.className+" ";if(o+=e.parentNode?e.parentNode.className:"",t=B.exec(o))return R(t[1])?t[1]:"no-highlight";for(o=o.split(/\s+/),n=0,r=o.length;r>n;n++)if(i=o[n],a(i)||R(i))return i}function o(e,n){var t,r={};for(t in e)r[t]=e[t];if(n)for(t in n)r[t]=n[t];return r}function u(e){var n=[];return function r(e,a){for(var i=e.firstChild;i;i=i.nextSibling)3===i.nodeType?a+=i.nodeValue.length:1===i.nodeType&&(n.push({event:"start",offset:a,node:i}),a=r(i,a),t(i).match(/br|hr|img|input/)||n.push({event:"stop",offset:a,node:i}));return a}(e,0),n}function c(e,r,a){function i(){return e.length&&r.length?e[0].offset!==r[0].offset?e[0].offset<r[0].offset?e:r:"start"===r[0].event?e:r:e.length?e:r}function o(e){function r(e){return" "+e.nodeName+'="'+n(e.value)+'"'}l+="<"+t(e)+w.map.call(e.attributes,r).join("")+">"}function u(e){l+="</"+t(e)+">"}function c(e){("start"===e.event?o:u)(e.node)}for(var s=0,l="",f=[];e.length||r.length;){var g=i();if(l+=n(a.substr(s,g[0].offset-s)),s=g[0].offset,g===e){f.reverse().forEach(u);do c(g.splice(0,1)[0]),g=i();while(g===e&&g.length&&g[0].offset===s);f.reverse().forEach(o)}else"start"===g[0].event?f.push(g[0].node):f.pop(),c(g.splice(0,1)[0])}return l+n(a.substr(s))}function s(e){function n(e){return e&&e.source||e}function t(t,r){return new RegExp(n(t),"m"+(e.cI?"i":"")+(r?"g":""))}function r(a,i){if(!a.compiled){if(a.compiled=!0,a.k=a.k||a.bK,a.k){var u={},c=function(n,t){e.cI&&(t=t.toLowerCase()),t.split(" ").forEach(function(e){var t=e.split("|");u[t[0]]=[n,t[1]?Number(t[1]):1]})};"string"==typeof a.k?c("keyword",a.k):E(a.k).forEach(function(e){c(e,a.k[e])}),a.k=u}a.lR=t(a.l||/\w+/,!0),i&&(a.bK&&(a.b="\\b("+a.bK.split(" ").join("|")+")\\b"),a.b||(a.b=/\B|\b/),a.bR=t(a.b),a.e||a.eW||(a.e=/\B|\b/),a.e&&(a.eR=t(a.e)),a.tE=n(a.e)||"",a.eW&&i.tE&&(a.tE+=(a.e?"|":"")+i.tE)),a.i&&(a.iR=t(a.i)),null==a.r&&(a.r=1),a.c||(a.c=[]);var s=[];a.c.forEach(function(e){e.v?e.v.forEach(function(n){s.push(o(e,n))}):s.push("self"===e?a:e)}),a.c=s,a.c.forEach(function(e){r(e,a)}),a.starts&&r(a.starts,i);var l=a.c.map(function(e){return e.bK?"\\.?("+e.b+")\\.?":e.b}).concat([a.tE,a.i]).map(n).filter(Boolean);a.t=l.length?t(l.join("|"),!0):{exec:function(){return null}}}}r(e)}function l(e,t,a,i){function o(e,n){var t,a;for(t=0,a=n.c.length;a>t;t++)if(r(n.c[t].bR,e))return n.c[t]}function u(e,n){if(r(e.eR,n)){for(;e.endsParent&&e.parent;)e=e.parent;return e}return e.eW?u(e.parent,n):void 0}function c(e,n){return!a&&r(n.iR,e)}function g(e,n){var t=N.cI?n[0].toLowerCase():n[0];return e.k.hasOwnProperty(t)&&e.k[t]}function h(e,n,t,r){var a=r?"":y.classPrefix,i='<span class="'+a,o=t?"":C;return i+=e+'">',i+n+o}function p(){var e,t,r,a;if(!E.k)return n(B);for(a="",t=0,E.lR.lastIndex=0,r=E.lR.exec(B);r;)a+=n(B.substr(t,r.index-t)),e=g(E,r),e?(M+=e[1],a+=h(e[0],n(r[0]))):a+=n(r[0]),t=E.lR.lastIndex,r=E.lR.exec(B);return a+n(B.substr(t))}function d(){var e="string"==typeof E.sL;if(e&&!x[E.sL])return n(B);var t=e?l(E.sL,B,!0,L[E.sL]):f(B,E.sL.length?E.sL:void 0);return E.r>0&&(M+=t.r),e&&(L[E.sL]=t.top),h(t.language,t.value,!1,!0)}function b(){k+=null!=E.sL?d():p(),B=""}function v(e){k+=e.cN?h(e.cN,"",!0):"",E=Object.create(e,{parent:{value:E}})}function m(e,n){if(B+=e,null==n)return b(),0;var t=o(n,E);if(t)return t.skip?B+=n:(t.eB&&(B+=n),b(),t.rB||t.eB||(B=n)),v(t,n),t.rB?0:n.length;var r=u(E,n);if(r){var a=E;a.skip?B+=n:(a.rE||a.eE||(B+=n),b(),a.eE&&(B=n));do E.cN&&(k+=C),E.skip||(M+=E.r),E=E.parent;while(E!==r.parent);return r.starts&&v(r.starts,""),a.rE?0:n.length}if(c(n,E))throw new Error('Illegal lexeme "'+n+'" for mode "'+(E.cN||"<unnamed>")+'"');return B+=n,n.length||1}var N=R(e);if(!N)throw new Error('Unknown language: "'+e+'"');s(N);var w,E=i||N,L={},k="";for(w=E;w!==N;w=w.parent)w.cN&&(k=h(w.cN,"",!0)+k);var B="",M=0;try{for(var I,j,O=0;;){if(E.t.lastIndex=O,I=E.t.exec(t),!I)break;j=m(t.substr(O,I.index-O),I[0]),O=I.index+j}for(m(t.substr(O)),w=E;w.parent;w=w.parent)w.cN&&(k+=C);return{r:M,value:k,language:e,top:E}}catch(T){if(T.message&&-1!==T.message.indexOf("Illegal"))return{r:0,value:n(t)};throw T}}function f(e,t){t=t||y.languages||E(x);var r={r:0,value:n(e)},a=r;return t.filter(R).forEach(function(n){var t=l(n,e,!1);t.language=n,t.r>a.r&&(a=t),t.r>r.r&&(a=r,r=t)}),a.language&&(r.second_best=a),r}function g(e){return y.tabReplace||y.useBR?e.replace(M,function(e,n){return y.useBR&&"\n"===e?"<br>":y.tabReplace?n.replace(/\t/g,y.tabReplace):void 0}):e}function h(e,n,t){var r=n?L[n]:t,a=[e.trim()];return e.match(/\bhljs\b/)||a.push("hljs"),-1===e.indexOf(r)&&a.push(r),a.join(" ").trim()}function p(e){var n,t,r,o,s,p=i(e);a(p)||(y.useBR?(n=document.createElementNS("http://www.w3.org/1999/xhtml","div"),n.innerHTML=e.innerHTML.replace(/\n/g,"").replace(/<br[ \/]*>/g,"\n")):n=e,s=n.textContent,r=p?l(p,s,!0):f(s),t=u(n),t.length&&(o=document.createElementNS("http://www.w3.org/1999/xhtml","div"),o.innerHTML=r.value,r.value=c(t,u(o),s)),r.value=g(r.value),e.innerHTML=r.value,e.className=h(e.className,p,r.language),e.result={language:r.language,re:r.r},r.second_best&&(e.second_best={language:r.second_best.language,re:r.second_best.r}))}function d(e){y=o(y,e)}function b(){if(!b.called){b.called=!0;var e=document.querySelectorAll("pre code");w.forEach.call(e,p)}}function v(){addEventListener("DOMContentLoaded",b,!1),addEventListener("load",b,!1)}function m(n,t){var r=x[n]=t(e);r.aliases&&r.aliases.forEach(function(e){L[e]=n})}function N(){return E(x)}function R(e){return e=(e||"").toLowerCase(),x[e]||x[L[e]]}var w=[],E=Object.keys,x={},L={},k=/^(no-?highlight|plain|text)$/i,B=/\blang(?:uage)?-([\w-]+)\b/i,M=/((^(<[^>]+>|\t|)+|(?:\n)))/gm,C="</span>",y={classPrefix:"hljs-",tabReplace:null,useBR:!1,languages:void 0},I={"&":"&amp;","<":"&lt;",">":"&gt;"};return e.highlight=l,e.highlightAuto=f,e.fixMarkup=g,e.highlightBlock=p,e.configure=d,e.initHighlighting=b,e.initHighlightingOnLoad=v,e.registerLanguage=m,e.listLanguages=N,e.getLanguage=R,e.inherit=o,e.IR="[a-zA-Z]\\w*",e.UIR="[a-zA-Z_]\\w*",e.NR="\\b\\d+(\\.\\d+)?",e.CNR="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",e.BNR="\\b(0b[01]+)",e.RSR="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",e.BE={b:"\\\\[\\s\\S]",r:0},e.ASM={cN:"string",b:"'",e:"'",i:"\\n",c:[e.BE]},e.QSM={cN:"string",b:'"',e:'"',i:"\\n",c:[e.BE]},e.PWM={b:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|like)\b/},e.C=function(n,t,r){var a=e.inherit({cN:"comment",b:n,e:t,c:[]},r||{});return a.c.push(e.PWM),a.c.push({cN:"doctag",b:"(?:TODO|FIXME|NOTE|BUG|XXX):",r:0}),a},e.CLCM=e.C("//","$"),e.CBCM=e.C("/\\*","\\*/"),e.HCM=e.C("#","$"),e.NM={cN:"number",b:e.NR,r:0},e.CNM={cN:"number",b:e.CNR,r:0},e.BNM={cN:"number",b:e.BNR,r:0},e.CSSNM={cN:"number",b:e.NR+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",r:0},e.RM={cN:"regexp",b:/\//,e:/\/[gimuy]*/,i:/\n/,c:[e.BE,{b:/\[/,e:/\]/,r:0,c:[e.BE]}]},e.TM={cN:"title",b:e.IR,r:0},e.UTM={cN:"title",b:e.UIR,r:0},e.METHOD_GUARD={b:"\\.\\s*"+e.UIR,r:0},e});hljs.registerLanguage("clojure",function(e){var t={"builtin-name":"def defonce cond apply if-not if-let if not not= = < > <= >= == + / * - rem quot neg? pos? delay? symbol? keyword? true? false? integer? empty? coll? list? set? ifn? fn? associative? sequential? sorted? counted? reversible? number? decimal? class? distinct? isa? float? rational? reduced? ratio? odd? even? char? seq? vector? string? map? nil? contains? zero? instance? not-every? not-any? libspec? -> ->> .. . inc compare do dotimes mapcat take remove take-while drop letfn drop-last take-last drop-while while intern condp case reduced cycle split-at split-with repeat replicate iterate range merge zipmap declare line-seq sort comparator sort-by dorun doall nthnext nthrest partition eval doseq await await-for let agent atom send send-off release-pending-sends add-watch mapv filterv remove-watch agent-error restart-agent set-error-handler error-handler set-error-mode! error-mode shutdown-agents quote var fn loop recur throw try monitor-enter monitor-exit defmacro defn defn- macroexpand macroexpand-1 for dosync and or when when-not when-let comp juxt partial sequence memoize constantly complement identity assert peek pop doto proxy defstruct first rest cons defprotocol cast coll deftype defrecord last butlast sigs reify second ffirst fnext nfirst nnext defmulti defmethod meta with-meta ns in-ns create-ns import refer keys select-keys vals key val rseq name namespace promise into transient persistent! conj! assoc! dissoc! pop! disj! use class type num float double short byte boolean bigint biginteger bigdec print-method print-dup throw-if printf format load compile get-in update-in pr pr-on newline flush read slurp read-line subvec with-open memfn time re-find re-groups rand-int rand mod locking assert-valid-fdecl alias resolve ref deref refset swap! reset! set-validator! compare-and-set! alter-meta! reset-meta! commute get-validator alter ref-set ref-history-count ref-min-history ref-max-history ensure sync io! new next conj set! to-array future future-call into-array aset gen-class reduce map filter find empty hash-map hash-set sorted-map sorted-map-by sorted-set sorted-set-by vec vector seq flatten reverse assoc dissoc list disj get union difference intersection extend extend-type extend-protocol int nth delay count concat chunk chunk-buffer chunk-append chunk-first chunk-rest max min dec unchecked-inc-int unchecked-inc unchecked-dec-inc unchecked-dec unchecked-negate unchecked-add-int unchecked-add unchecked-subtract-int unchecked-subtract chunk-next chunk-cons chunked-seq? prn vary-meta lazy-seq spread list* str find-keyword keyword symbol gensym force rationalize"},r="a-zA-Z_\\-!.?+*=<>&#'",n="["+r+"]["+r+"0-9/;:]*",a="[-+]?\\d+(\\.\\d+)?",o={b:n,r:0},s={cN:"number",b:a,r:0},i=e.inherit(e.QSM,{i:null}),c=e.C(";","$",{r:0}),d={cN:"literal",b:/\b(true|false|nil)\b/},l={b:"[\\[\\{]",e:"[\\]\\}]"},m={cN:"comment",b:"\\^"+n},p=e.C("\\^\\{","\\}"),u={cN:"symbol",b:"[:]{1,2}"+n},f={b:"\\(",e:"\\)"},h={eW:!0,r:0},y={k:t,l:n,cN:"name",b:n,starts:h},b=[f,i,m,p,c,u,l,s,d,o];return f.c=[e.C("comment",""),y,h],h.c=b,l.c=b,{aliases:["clj"],i:/\S/,c:[f,i,m,p,c,u,l,s,d]}});hljs.registerLanguage("clojure-repl",function(e){return{c:[{cN:"meta",b:/^([\w.-]+|\s*#_)=>/,starts:{e:/$/,sL:"clojure"}}]}});
\ No newline at end of file
diff --git a/doc/api/js/jquery.min.js b/doc/api/js/jquery.min.js
deleted file mode 100644
index 73f33fb..0000000
--- a/doc/api/js/jquery.min.js
+++ /dev/null
@@ -1,4 +0,0 @@
-/*! jQuery v1.11.0 | (c) 2005, 2014 jQuery Foundation, Inc. | jquery.org/license */
-!function(a,b){"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){var c=[],d=c.slice,e=c.concat,f=c.push,g=c.indexOf,h={},i=h.toString,j=h.hasOwnProperty,k="".trim,l={},m="1.11.0",n=function(a,b){return new n.fn.init(a,b)},o=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,p=/^-ms-/,q=/-([\da-z])/gi,r=function(a,b){return b.toUpperCase()};n.fn=n.prototype={jquery:m,constructor:n,selector:"",length:0,toArray:function(){return d.call(this)},get:function(a){return null!=a?0>a?this[a+this.length]:this[a]:d.call(this)},pushStack:function(a){var b=n.merge(this.constructor(),a);return b.prevObject=this,b.context=this.context,b},each:function(a,b){return n.each(this,a,b)},map:function(a){return this.pushStack(n.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(0>a?b:0);return this.pushStack(c>=0&&b>c?[this[c]]:[])},end:function(){return this.prevObject||this.constructor(null)},push:f,sort:c.sort,splice:c.splice},n.extend=n.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||n.isFunction(g)||(g={}),h===i&&(g=this,h--);i>h;h++)if(null!=(e=arguments[h]))for(d in e)a=g[d],c=e[d],g!==c&&(j&&c&&(n.isPlainObject(c)||(b=n.isArray(c)))?(b?(b=!1,f=a&&n.isArray(a)?a:[]):f=a&&n.isPlainObject(a)?a:{},g[d]=n.extend(j,f,c)):void 0!==c&&(g[d]=c));return g},n.extend({expando:"jQuery"+(m+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===n.type(a)},isArray:Array.isArray||function(a){return"array"===n.type(a)},isWindow:function(a){return null!=a&&a==a.window},isNumeric:function(a){return a-parseFloat(a)>=0},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},isPlainObject:function(a){var b;if(!a||"object"!==n.type(a)||a.nodeType||n.isWindow(a))return!1;try{if(a.constructor&&!j.call(a,"constructor")&&!j.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}if(l.ownLast)for(b in a)return j.call(a,b);for(b in a);return void 0===b||j.call(a,b)},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?h[i.call(a)]||"object":typeof a},globalEval:function(b){b&&n.trim(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(p,"ms-").replace(q,r)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,b,c){var d,e=0,f=a.length,g=s(a);if(c){if(g){for(;f>e;e++)if(d=b.apply(a[e],c),d===!1)break}else for(e in a)if(d=b.apply(a[e],c),d===!1)break}else if(g){for(;f>e;e++)if(d=b.call(a[e],e,a[e]),d===!1)break}else for(e in a)if(d=b.call(a[e],e,a[e]),d===!1)break;return a},trim:k&&!k.call("\ufeff\xa0")?function(a){return null==a?"":k.call(a)}:function(a){return null==a?"":(a+"").replace(o,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(s(Object(a))?n.merge(c,"string"==typeof a?[a]:a):f.call(c,a)),c},inArray:function(a,b,c){var d;if(b){if(g)return g.call(b,a,c);for(d=b.length,c=c?0>c?Math.max(0,d+c):c:0;d>c;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,b){var c=+b.length,d=0,e=a.length;while(c>d)a[e++]=b[d++];if(c!==c)while(void 0!==b[d])a[e++]=b[d++];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;g>f;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,f=0,g=a.length,h=s(a),i=[];if(h)for(;g>f;f++)d=b(a[f],f,c),null!=d&&i.push(d);else for(f in a)d=b(a[f],f,c),null!=d&&i.push(d);return e.apply([],i)},guid:1,proxy:function(a,b){var c,e,f;return"string"==typeof b&&(f=a[b],b=a,a=f),n.isFunction(a)?(c=d.call(arguments,2),e=function(){return a.apply(b||this,c.concat(d.call(arguments)))},e.guid=a.guid=a.guid||n.guid++,e):void 0},now:function(){return+new Date},support:l}),n.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(a,b){h["[object "+b+"]"]=b.toLowerCase()});function s(a){var b=a.length,c=n.type(a);return"function"===c||n.isWindow(a)?!1:1===a.nodeType&&b?!0:"array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a}var t=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s="sizzle"+-new Date,t=a.document,u=0,v=0,w=eb(),x=eb(),y=eb(),z=function(a,b){return a===b&&(j=!0),0},A="undefined",B=1<<31,C={}.hasOwnProperty,D=[],E=D.pop,F=D.push,G=D.push,H=D.slice,I=D.indexOf||function(a){for(var b=0,c=this.length;c>b;b++)if(this[b]===a)return b;return-1},J="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",K="[\\x20\\t\\r\\n\\f]",L="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",M=L.replace("w","w#"),N="\\["+K+"*("+L+")"+K+"*(?:([*^$|!~]?=)"+K+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+M+")|)|)"+K+"*\\]",O=":("+L+")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|"+N.replace(3,8)+")*)|.*)\\)|)",P=new RegExp("^"+K+"+|((?:^|[^\\\\])(?:\\\\.)*)"+K+"+$","g"),Q=new RegExp("^"+K+"*,"+K+"*"),R=new RegExp("^"+K+"*([>+~]|"+K+")"+K+"*"),S=new RegExp("="+K+"*([^\\]'\"]*?)"+K+"*\\]","g"),T=new RegExp(O),U=new RegExp("^"+M+"$"),V={ID:new RegExp("^#("+L+")"),CLASS:new RegExp("^\\.("+L+")"),TAG:new RegExp("^("+L.replace("w","w*")+")"),ATTR:new RegExp("^"+N),PSEUDO:new RegExp("^"+O),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+K+"*(even|odd|(([+-]|)(\\d*)n|)"+K+"*(?:([+-]|)"+K+"*(\\d+)|))"+K+"*\\)|)","i"),bool:new RegExp("^(?:"+J+")$","i"),needsContext:new RegExp("^"+K+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+K+"*((?:-\\d)?\\d*)"+K+"*\\)|)(?=[^-]|$)","i")},W=/^(?:input|select|textarea|button)$/i,X=/^h\d$/i,Y=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,$=/[+~]/,_=/'|\\/g,ab=new RegExp("\\\\([\\da-f]{1,6}"+K+"?|("+K+")|.)","ig"),bb=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:0>d?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)};try{G.apply(D=H.call(t.childNodes),t.childNodes),D[t.childNodes.length].nodeType}catch(cb){G={apply:D.length?function(a,b){F.apply(a,H.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function db(a,b,d,e){var f,g,h,i,j,m,p,q,u,v;if((b?b.ownerDocument||b:t)!==l&&k(b),b=b||l,d=d||[],!a||"string"!=typeof a)return d;if(1!==(i=b.nodeType)&&9!==i)return[];if(n&&!e){if(f=Z.exec(a))if(h=f[1]){if(9===i){if(g=b.getElementById(h),!g||!g.parentNode)return d;if(g.id===h)return d.push(g),d}else if(b.ownerDocument&&(g=b.ownerDocument.getElementById(h))&&r(b,g)&&g.id===h)return d.push(g),d}else{if(f[2])return G.apply(d,b.getElementsByTagName(a)),d;if((h=f[3])&&c.getElementsByClassName&&b.getElementsByClassName)return G.apply(d,b.getElementsByClassName(h)),d}if(c.qsa&&(!o||!o.test(a))){if(q=p=s,u=b,v=9===i&&a,1===i&&"object"!==b.nodeName.toLowerCase()){m=ob(a),(p=b.getAttribute("id"))?q=p.replace(_,"\\$&"):b.setAttribute("id",q),q="[id='"+q+"'] ",j=m.length;while(j--)m[j]=q+pb(m[j]);u=$.test(a)&&mb(b.parentNode)||b,v=m.join(",")}if(v)try{return G.apply(d,u.querySelectorAll(v)),d}catch(w){}finally{p||b.removeAttribute("id")}}}return xb(a.replace(P,"$1"),b,d,e)}function eb(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function fb(a){return a[s]=!0,a}function gb(a){var b=l.createElement("div");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function hb(a,b){var c=a.split("|"),e=a.length;while(e--)d.attrHandle[c[e]]=b}function ib(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&(~b.sourceIndex||B)-(~a.sourceIndex||B);if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function jb(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function kb(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function lb(a){return fb(function(b){return b=+b,fb(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function mb(a){return a&&typeof a.getElementsByTagName!==A&&a}c=db.support={},f=db.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?"HTML"!==b.nodeName:!1},k=db.setDocument=function(a){var b,e=a?a.ownerDocument||a:t,g=e.defaultView;return e!==l&&9===e.nodeType&&e.documentElement?(l=e,m=e.documentElement,n=!f(e),g&&g!==g.top&&(g.addEventListener?g.addEventListener("unload",function(){k()},!1):g.attachEvent&&g.attachEvent("onunload",function(){k()})),c.attributes=gb(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=gb(function(a){return a.appendChild(e.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=Y.test(e.getElementsByClassName)&&gb(function(a){return a.innerHTML="<div class='a'></div><div class='a i'></div>",a.firstChild.className="i",2===a.getElementsByClassName("i").length}),c.getById=gb(function(a){return m.appendChild(a).id=s,!e.getElementsByName||!e.getElementsByName(s).length}),c.getById?(d.find.ID=function(a,b){if(typeof b.getElementById!==A&&n){var c=b.getElementById(a);return c&&c.parentNode?[c]:[]}},d.filter.ID=function(a){var b=a.replace(ab,bb);return function(a){return a.getAttribute("id")===b}}):(delete d.find.ID,d.filter.ID=function(a){var b=a.replace(ab,bb);return function(a){var c=typeof a.getAttributeNode!==A&&a.getAttributeNode("id");return c&&c.value===b}}),d.find.TAG=c.getElementsByTagName?function(a,b){return typeof b.getElementsByTagName!==A?b.getElementsByTagName(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){return typeof b.getElementsByClassName!==A&&n?b.getElementsByClassName(a):void 0},p=[],o=[],(c.qsa=Y.test(e.querySelectorAll))&&(gb(function(a){a.innerHTML="<select t=''><option selected=''></option></select>",a.querySelectorAll("[t^='']").length&&o.push("[*^$]="+K+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||o.push("\\["+K+"*(?:value|"+J+")"),a.querySelectorAll(":checked").length||o.push(":checked")}),gb(function(a){var b=e.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&o.push("name"+K+"*[*^$|!~]?="),a.querySelectorAll(":enabled").length||o.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),o.push(",.*:")})),(c.matchesSelector=Y.test(q=m.webkitMatchesSelector||m.mozMatchesSelector||m.oMatchesSelector||m.msMatchesSelector))&&gb(function(a){c.disconnectedMatch=q.call(a,"div"),q.call(a,"[s!='']:x"),p.push("!=",O)}),o=o.length&&new RegExp(o.join("|")),p=p.length&&new RegExp(p.join("|")),b=Y.test(m.compareDocumentPosition),r=b||Y.test(m.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},z=b?function(a,b){if(a===b)return j=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===e||a.ownerDocument===t&&r(t,a)?-1:b===e||b.ownerDocument===t&&r(t,b)?1:i?I.call(i,a)-I.call(i,b):0:4&d?-1:1)}:function(a,b){if(a===b)return j=!0,0;var c,d=0,f=a.parentNode,g=b.parentNode,h=[a],k=[b];if(!f||!g)return a===e?-1:b===e?1:f?-1:g?1:i?I.call(i,a)-I.call(i,b):0;if(f===g)return ib(a,b);c=a;while(c=c.parentNode)h.unshift(c);c=b;while(c=c.parentNode)k.unshift(c);while(h[d]===k[d])d++;return d?ib(h[d],k[d]):h[d]===t?-1:k[d]===t?1:0},e):l},db.matches=function(a,b){return db(a,null,null,b)},db.matchesSelector=function(a,b){if((a.ownerDocument||a)!==l&&k(a),b=b.replace(S,"='$1']"),!(!c.matchesSelector||!n||p&&p.test(b)||o&&o.test(b)))try{var d=q.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return db(b,l,null,[a]).length>0},db.contains=function(a,b){return(a.ownerDocument||a)!==l&&k(a),r(a,b)},db.attr=function(a,b){(a.ownerDocument||a)!==l&&k(a);var e=d.attrHandle[b.toLowerCase()],f=e&&C.call(d.attrHandle,b.toLowerCase())?e(a,b,!n):void 0;return void 0!==f?f:c.attributes||!n?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},db.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},db.uniqueSort=function(a){var b,d=[],e=0,f=0;if(j=!c.detectDuplicates,i=!c.sortStable&&a.slice(0),a.sort(z),j){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return i=null,a},e=db.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=db.selectors={cacheLength:50,createPseudo:fb,match:V,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(ab,bb),a[3]=(a[4]||a[5]||"").replace(ab,bb),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||db.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&db.error(a[0]),a},PSEUDO:function(a){var b,c=!a[5]&&a[2];return V.CHILD.test(a[0])?null:(a[3]&&void 0!==a[4]?a[2]=a[4]:c&&T.test(c)&&(b=ob(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(ab,bb).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=w[a+" "];return b||(b=new RegExp("(^|"+K+")"+a+"("+K+"|$)"))&&w(a,function(a){return b.test("string"==typeof a.className&&a.className||typeof a.getAttribute!==A&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=db.attr(d,a);return null==e?"!="===b:b?(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e+" ").indexOf(c)>-1:"|="===b?e===c||e.slice(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),t=!i&&!h;if(q){if(f){while(p){l=b;while(l=l[p])if(h?l.nodeName.toLowerCase()===r:1===l.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&t){k=q[s]||(q[s]={}),j=k[a]||[],n=j[0]===u&&j[1],m=j[0]===u&&j[2],l=n&&q.childNodes[n];while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if(1===l.nodeType&&++m&&l===b){k[a]=[u,n,m];break}}else if(t&&(j=(b[s]||(b[s]={}))[a])&&j[0]===u)m=j[1];else while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if((h?l.nodeName.toLowerCase()===r:1===l.nodeType)&&++m&&(t&&((l[s]||(l[s]={}))[a]=[u,m]),l===b))break;return m-=e,m===d||m%d===0&&m/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||db.error("unsupported pseudo: "+a);return e[s]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?fb(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=I.call(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:fb(function(a){var b=[],c=[],d=g(a.replace(P,"$1"));return d[s]?fb(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),!c.pop()}}),has:fb(function(a){return function(b){return db(a,b).length>0}}),contains:fb(function(a){return function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:fb(function(a){return U.test(a||"")||db.error("unsupported lang: "+a),a=a.replace(ab,bb).toLowerCase(),function(b){var c;do if(c=n?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===m},focus:function(a){return a===l.activeElement&&(!l.hasFocus||l.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return X.test(a.nodeName)},input:function(a){return W.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:lb(function(){return[0]}),last:lb(function(a,b){return[b-1]}),eq:lb(function(a,b,c){return[0>c?c+b:c]}),even:lb(function(a,b){for(var c=0;b>c;c+=2)a.push(c);return a}),odd:lb(function(a,b){for(var c=1;b>c;c+=2)a.push(c);return a}),lt:lb(function(a,b,c){for(var d=0>c?c+b:c;--d>=0;)a.push(d);return a}),gt:lb(function(a,b,c){for(var d=0>c?c+b:c;++d<b;)a.push(d);return a})}},d.pseudos.nth=d.pseudos.eq;for(b in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})d.pseudos[b]=jb(b);for(b in{submit:!0,reset:!0})d.pseudos[b]=kb(b);function nb(){}nb.prototype=d.filters=d.pseudos,d.setFilters=new nb;function ob(a,b){var c,e,f,g,h,i,j,k=x[a+" "];if(k)return b?0:k.slice(0);h=a,i=[],j=d.preFilter;while(h){(!c||(e=Q.exec(h)))&&(e&&(h=h.slice(e[0].length)||h),i.push(f=[])),c=!1,(e=R.exec(h))&&(c=e.shift(),f.push({value:c,type:e[0].replace(P," ")}),h=h.slice(c.length));for(g in d.filter)!(e=V[g].exec(h))||j[g]&&!(e=j[g](e))||(c=e.shift(),f.push({value:c,type:g,matches:e}),h=h.slice(c.length));if(!c)break}return b?h.length:h?db.error(a):x(a,i).slice(0)}function pb(a){for(var b=0,c=a.length,d="";c>b;b++)d+=a[b].value;return d}function qb(a,b,c){var d=b.dir,e=c&&"parentNode"===d,f=v++;return b.first?function(b,c,f){while(b=b[d])if(1===b.nodeType||e)return a(b,c,f)}:function(b,c,g){var h,i,j=[u,f];if(g){while(b=b[d])if((1===b.nodeType||e)&&a(b,c,g))return!0}else while(b=b[d])if(1===b.nodeType||e){if(i=b[s]||(b[s]={}),(h=i[d])&&h[0]===u&&h[1]===f)return j[2]=h[2];if(i[d]=j,j[2]=a(b,c,g))return!0}}}function rb(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function sb(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;i>h;h++)(f=a[h])&&(!c||c(f,d,e))&&(g.push(f),j&&b.push(h));return g}function tb(a,b,c,d,e,f){return d&&!d[s]&&(d=tb(d)),e&&!e[s]&&(e=tb(e,f)),fb(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||wb(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:sb(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=sb(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?I.call(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=sb(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):G.apply(g,r)})}function ub(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],i=g||d.relative[" "],j=g?1:0,k=qb(function(a){return a===b},i,!0),l=qb(function(a){return I.call(b,a)>-1},i,!0),m=[function(a,c,d){return!g&&(d||c!==h)||((b=c).nodeType?k(a,c,d):l(a,c,d))}];f>j;j++)if(c=d.relative[a[j].type])m=[qb(rb(m),c)];else{if(c=d.filter[a[j].type].apply(null,a[j].matches),c[s]){for(e=++j;f>e;e++)if(d.relative[a[e].type])break;return tb(j>1&&rb(m),j>1&&pb(a.slice(0,j-1).concat({value:" "===a[j-2].type?"*":""})).replace(P,"$1"),c,e>j&&ub(a.slice(j,e)),f>e&&ub(a=a.slice(e)),f>e&&pb(a))}m.push(c)}return rb(m)}function vb(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,i,j,k){var m,n,o,p=0,q="0",r=f&&[],s=[],t=h,v=f||e&&d.find.TAG("*",k),w=u+=null==t?1:Math.random()||.1,x=v.length;for(k&&(h=g!==l&&g);q!==x&&null!=(m=v[q]);q++){if(e&&m){n=0;while(o=a[n++])if(o(m,g,i)){j.push(m);break}k&&(u=w)}c&&((m=!o&&m)&&p--,f&&r.push(m))}if(p+=q,c&&q!==p){n=0;while(o=b[n++])o(r,s,g,i);if(f){if(p>0)while(q--)r[q]||s[q]||(s[q]=E.call(j));s=sb(s)}G.apply(j,s),k&&!f&&s.length>0&&p+b.length>1&&db.uniqueSort(j)}return k&&(u=w,h=t),r};return c?fb(f):f}g=db.compile=function(a,b){var c,d=[],e=[],f=y[a+" "];if(!f){b||(b=ob(a)),c=b.length;while(c--)f=ub(b[c]),f[s]?d.push(f):e.push(f);f=y(a,vb(e,d))}return f};function wb(a,b,c){for(var d=0,e=b.length;e>d;d++)db(a,b[d],c);return c}function xb(a,b,e,f){var h,i,j,k,l,m=ob(a);if(!f&&1===m.length){if(i=m[0]=m[0].slice(0),i.length>2&&"ID"===(j=i[0]).type&&c.getById&&9===b.nodeType&&n&&d.relative[i[1].type]){if(b=(d.find.ID(j.matches[0].replace(ab,bb),b)||[])[0],!b)return e;a=a.slice(i.shift().value.length)}h=V.needsContext.test(a)?0:i.length;while(h--){if(j=i[h],d.relative[k=j.type])break;if((l=d.find[k])&&(f=l(j.matches[0].replace(ab,bb),$.test(i[0].type)&&mb(b.parentNode)||b))){if(i.splice(h,1),a=f.length&&pb(i),!a)return G.apply(e,f),e;break}}}return g(a,m)(f,b,!n,e,$.test(a)&&mb(b.parentNode)||b),e}return c.sortStable=s.split("").sort(z).join("")===s,c.detectDuplicates=!!j,k(),c.sortDetached=gb(function(a){return 1&a.compareDocumentPosition(l.createElement("div"))}),gb(function(a){return a.innerHTML="<a href='#'></a>","#"===a.firstChild.getAttribute("href")})||hb("type|href|height|width",function(a,b,c){return c?void 0:a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&gb(function(a){return a.innerHTML="<input/>",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||hb("value",function(a,b,c){return c||"input"!==a.nodeName.toLowerCase()?void 0:a.defaultValue}),gb(function(a){return null==a.getAttribute("disabled")})||hb(J,function(a,b,c){var d;return c?void 0:a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),db}(a);n.find=t,n.expr=t.selectors,n.expr[":"]=n.expr.pseudos,n.unique=t.uniqueSort,n.text=t.getText,n.isXMLDoc=t.isXML,n.contains=t.contains;var u=n.expr.match.needsContext,v=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,w=/^.[^:#\[\.,]*$/;function x(a,b,c){if(n.isFunction(b))return n.grep(a,function(a,d){return!!b.call(a,d,a)!==c});if(b.nodeType)return n.grep(a,function(a){return a===b!==c});if("string"==typeof b){if(w.test(b))return n.filter(b,a,c);b=n.filter(b,a)}return n.grep(a,function(a){return n.inArray(a,b)>=0!==c})}n.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?n.find.matchesSelector(d,a)?[d]:[]:n.find.matches(a,n.grep(b,function(a){return 1===a.nodeType}))},n.fn.extend({find:function(a){var b,c=[],d=this,e=d.length;if("string"!=typeof a)return this.pushStack(n(a).filter(function(){for(b=0;e>b;b++)if(n.contains(d[b],this))return!0}));for(b=0;e>b;b++)n.find(a,d[b],c);return c=this.pushStack(e>1?n.unique(c):c),c.selector=this.selector?this.selector+" "+a:a,c},filter:function(a){return this.pushStack(x(this,a||[],!1))},not:function(a){return this.pushStack(x(this,a||[],!0))},is:function(a){return!!x(this,"string"==typeof a&&u.test(a)?n(a):a||[],!1).length}});var y,z=a.document,A=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,B=n.fn.init=function(a,b){var c,d;if(!a)return this;if("string"==typeof a){if(c="<"===a.charAt(0)&&">"===a.charAt(a.length-1)&&a.length>=3?[null,a,null]:A.exec(a),!c||!c[1]&&b)return!b||b.jquery?(b||y).find(a):this.constructor(b).find(a);if(c[1]){if(b=b instanceof n?b[0]:b,n.merge(this,n.parseHTML(c[1],b&&b.nodeType?b.ownerDocument||b:z,!0)),v.test(c[1])&&n.isPlainObject(b))for(c in b)n.isFunction(this[c])?this[c](b[c]):this.attr(c,b[c]);return this}if(d=z.getElementById(c[2]),d&&d.parentNode){if(d.id!==c[2])return y.find(a);this.length=1,this[0]=d}return this.context=z,this.selector=a,this}return a.nodeType?(this.context=this[0]=a,this.length=1,this):n.isFunction(a)?"undefined"!=typeof y.ready?y.ready(a):a(n):(void 0!==a.selector&&(this.selector=a.selector,this.context=a.context),n.makeArray(a,this))};B.prototype=n.fn,y=n(z);var C=/^(?:parents|prev(?:Until|All))/,D={children:!0,contents:!0,next:!0,prev:!0};n.extend({dir:function(a,b,c){var d=[],e=a[b];while(e&&9!==e.nodeType&&(void 0===c||1!==e.nodeType||!n(e).is(c)))1===e.nodeType&&d.push(e),e=e[b];return d},sibling:function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c}}),n.fn.extend({has:function(a){var b,c=n(a,this),d=c.length;return this.filter(function(){for(b=0;d>b;b++)if(n.contains(this,c[b]))return!0})},closest:function(a,b){for(var c,d=0,e=this.length,f=[],g=u.test(a)||"string"!=typeof a?n(a,b||this.context):0;e>d;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&n.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?n.unique(f):f)},index:function(a){return a?"string"==typeof a?n.inArray(this[0],n(a)):n.inArray(a.jquery?a[0]:a,this):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(n.unique(n.merge(this.get(),n(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function E(a,b){do a=a[b];while(a&&1!==a.nodeType);return a}n.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return n.dir(a,"parentNode")},parentsUntil:function(a,b,c){return n.dir(a,"parentNode",c)},next:function(a){return E(a,"nextSibling")},prev:function(a){return E(a,"previousSibling")},nextAll:function(a){return n.dir(a,"nextSibling")},prevAll:function(a){return n.dir(a,"previousSibling")},nextUntil:function(a,b,c){return n.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return n.dir(a,"previousSibling",c)},siblings:function(a){return n.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return n.sibling(a.firstChild)},contents:function(a){return n.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:n.merge([],a.childNodes)}},function(a,b){n.fn[a]=function(c,d){var e=n.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=n.filter(d,e)),this.length>1&&(D[a]||(e=n.unique(e)),C.test(a)&&(e=e.reverse())),this.pushStack(e)}});var F=/\S+/g,G={};function H(a){var b=G[a]={};return n.each(a.match(F)||[],function(a,c){b[c]=!0}),b}n.Callbacks=function(a){a="string"==typeof a?G[a]||H(a):n.extend({},a);var b,c,d,e,f,g,h=[],i=!a.once&&[],j=function(l){for(c=a.memory&&l,d=!0,f=g||0,g=0,e=h.length,b=!0;h&&e>f;f++)if(h[f].apply(l[0],l[1])===!1&&a.stopOnFalse){c=!1;break}b=!1,h&&(i?i.length&&j(i.shift()):c?h=[]:k.disable())},k={add:function(){if(h){var d=h.length;!function f(b){n.each(b,function(b,c){var d=n.type(c);"function"===d?a.unique&&k.has(c)||h.push(c):c&&c.length&&"string"!==d&&f(c)})}(arguments),b?e=h.length:c&&(g=d,j(c))}return this},remove:function(){return h&&n.each(arguments,function(a,c){var d;while((d=n.inArray(c,h,d))>-1)h.splice(d,1),b&&(e>=d&&e--,f>=d&&f--)}),this},has:function(a){return a?n.inArray(a,h)>-1:!(!h||!h.length)},empty:function(){return h=[],e=0,this},disable:function(){return h=i=c=void 0,this},disabled:function(){return!h},lock:function(){return i=void 0,c||k.disable(),this},locked:function(){return!i},fireWith:function(a,c){return!h||d&&!i||(c=c||[],c=[a,c.slice?c.slice():c],b?i.push(c):j(c)),this},fire:function(){return k.fireWith(this,arguments),this},fired:function(){return!!d}};return k},n.extend({Deferred:function(a){var b=[["resolve","done",n.Callbacks("once memory"),"resolved"],["reject","fail",n.Callbacks("once memory"),"rejected"],["notify","progress",n.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return n.Deferred(function(c){n.each(b,function(b,f){var g=n.isFunction(a[b])&&a[b];e[f[1]](function(){var a=g&&g.apply(this,arguments);a&&n.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f[0]+"With"](this===d?c.promise():this,g?[a]:arguments)})}),a=null}).promise()},promise:function(a){return null!=a?n.extend(a,d):d}},e={};return d.pipe=d.then,n.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[1^a][2].disable,b[2][2].lock),e[f[0]]=function(){return e[f[0]+"With"](this===e?d:this,arguments),this},e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=d.call(arguments),e=c.length,f=1!==e||a&&n.isFunction(a.promise)?e:0,g=1===f?a:n.Deferred(),h=function(a,b,c){return function(e){b[a]=this,c[a]=arguments.length>1?d.call(arguments):e,c===i?g.notifyWith(b,c):--f||g.resolveWith(b,c)}},i,j,k;if(e>1)for(i=new Array(e),j=new Array(e),k=new Array(e);e>b;b++)c[b]&&n.isFunction(c[b].promise)?c[b].promise().done(h(b,k,c)).fail(g.reject).progress(h(b,j,i)):--f;return f||g.resolveWith(k,c),g.promise()}});var I;n.fn.ready=function(a){return n.ready.promise().done(a),this},n.extend({isReady:!1,readyWait:1,holdReady:function(a){a?n.readyWait++:n.ready(!0)},ready:function(a){if(a===!0?!--n.readyWait:!n.isReady){if(!z.body)return setTimeout(n.ready);n.isReady=!0,a!==!0&&--n.readyWait>0||(I.resolveWith(z,[n]),n.fn.trigger&&n(z).trigger("ready").off("ready"))}}});function J(){z.addEventListener?(z.removeEventListener("DOMContentLoaded",K,!1),a.removeEventListener("load",K,!1)):(z.detachEvent("onreadystatechange",K),a.detachEvent("onload",K))}function K(){(z.addEventListener||"load"===event.type||"complete"===z.readyState)&&(J(),n.ready())}n.ready.promise=function(b){if(!I)if(I=n.Deferred(),"complete"===z.readyState)setTimeout(n.ready);else if(z.addEventListener)z.addEventListener("DOMContentLoaded",K,!1),a.addEventListener("load",K,!1);else{z.attachEvent("onreadystatechange",K),a.attachEvent("onload",K);var c=!1;try{c=null==a.frameElement&&z.documentElement}catch(d){}c&&c.doScroll&&!function e(){if(!n.isReady){try{c.doScroll("left")}catch(a){return setTimeout(e,50)}J(),n.ready()}}()}return I.promise(b)};var L="undefined",M;for(M in n(l))break;l.ownLast="0"!==M,l.inlineBlockNeedsLayout=!1,n(function(){var a,b,c=z.getElementsByTagName("body")[0];c&&(a=z.createElement("div"),a.style.cssText="border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px",b=z.createElement("div"),c.appendChild(a).appendChild(b),typeof b.style.zoom!==L&&(b.style.cssText="border:0;margin:0;width:1px;padding:1px;display:inline;zoom:1",(l.inlineBlockNeedsLayout=3===b.offsetWidth)&&(c.style.zoom=1)),c.removeChild(a),a=b=null)}),function(){var a=z.createElement("div");if(null==l.deleteExpando){l.deleteExpando=!0;try{delete a.test}catch(b){l.deleteExpando=!1}}a=null}(),n.acceptData=function(a){var b=n.noData[(a.nodeName+" ").toLowerCase()],c=+a.nodeType||1;return 1!==c&&9!==c?!1:!b||b!==!0&&a.getAttribute("classid")===b};var N=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,O=/([A-Z])/g;function P(a,b,c){if(void 0===c&&1===a.nodeType){var d="data-"+b.replace(O,"-$1").toLowerCase();if(c=a.getAttribute(d),"string"==typeof c){try{c="true"===c?!0:"false"===c?!1:"null"===c?null:+c+""===c?+c:N.test(c)?n.parseJSON(c):c}catch(e){}n.data(a,b,c)}else c=void 0}return c}function Q(a){var b;for(b in a)if(("data"!==b||!n.isEmptyObject(a[b]))&&"toJSON"!==b)return!1;return!0}function R(a,b,d,e){if(n.acceptData(a)){var f,g,h=n.expando,i=a.nodeType,j=i?n.cache:a,k=i?a[h]:a[h]&&h;if(k&&j[k]&&(e||j[k].data)||void 0!==d||"string"!=typeof b)return k||(k=i?a[h]=c.pop()||n.guid++:h),j[k]||(j[k]=i?{}:{toJSON:n.noop}),("object"==typeof b||"function"==typeof b)&&(e?j[k]=n.extend(j[k],b):j[k].data=n.extend(j[k].data,b)),g=j[k],e||(g.data||(g.data={}),g=g.data),void 0!==d&&(g[n.camelCase(b)]=d),"string"==typeof b?(f=g[b],null==f&&(f=g[n.camelCase(b)])):f=g,f
-}}function S(a,b,c){if(n.acceptData(a)){var d,e,f=a.nodeType,g=f?n.cache:a,h=f?a[n.expando]:n.expando;if(g[h]){if(b&&(d=c?g[h]:g[h].data)){n.isArray(b)?b=b.concat(n.map(b,n.camelCase)):b in d?b=[b]:(b=n.camelCase(b),b=b in d?[b]:b.split(" ")),e=b.length;while(e--)delete d[b[e]];if(c?!Q(d):!n.isEmptyObject(d))return}(c||(delete g[h].data,Q(g[h])))&&(f?n.cleanData([a],!0):l.deleteExpando||g!=g.window?delete g[h]:g[h]=null)}}}n.extend({cache:{},noData:{"applet ":!0,"embed ":!0,"object ":"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"},hasData:function(a){return a=a.nodeType?n.cache[a[n.expando]]:a[n.expando],!!a&&!Q(a)},data:function(a,b,c){return R(a,b,c)},removeData:function(a,b){return S(a,b)},_data:function(a,b,c){return R(a,b,c,!0)},_removeData:function(a,b){return S(a,b,!0)}}),n.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=n.data(f),1===f.nodeType&&!n._data(f,"parsedAttrs"))){c=g.length;while(c--)d=g[c].name,0===d.indexOf("data-")&&(d=n.camelCase(d.slice(5)),P(f,d,e[d]));n._data(f,"parsedAttrs",!0)}return e}return"object"==typeof a?this.each(function(){n.data(this,a)}):arguments.length>1?this.each(function(){n.data(this,a,b)}):f?P(f,a,n.data(f,a)):void 0},removeData:function(a){return this.each(function(){n.removeData(this,a)})}}),n.extend({queue:function(a,b,c){var d;return a?(b=(b||"fx")+"queue",d=n._data(a,b),c&&(!d||n.isArray(c)?d=n._data(a,b,n.makeArray(c)):d.push(c)),d||[]):void 0},dequeue:function(a,b){b=b||"fx";var c=n.queue(a,b),d=c.length,e=c.shift(),f=n._queueHooks(a,b),g=function(){n.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return n._data(a,c)||n._data(a,c,{empty:n.Callbacks("once memory").add(function(){n._removeData(a,b+"queue"),n._removeData(a,c)})})}}),n.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length<c?n.queue(this[0],a):void 0===b?this:this.each(function(){var c=n.queue(this,a,b);n._queueHooks(this,a),"fx"===a&&"inprogress"!==c[0]&&n.dequeue(this,a)})},dequeue:function(a){return this.each(function(){n.dequeue(this,a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,b){var c,d=1,e=n.Deferred(),f=this,g=this.length,h=function(){--d||e.resolveWith(f,[f])};"string"!=typeof a&&(b=a,a=void 0),a=a||"fx";while(g--)c=n._data(f[g],a+"queueHooks"),c&&c.empty&&(d++,c.empty.add(h));return h(),e.promise(b)}});var T=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,U=["Top","Right","Bottom","Left"],V=function(a,b){return a=b||a,"none"===n.css(a,"display")||!n.contains(a.ownerDocument,a)},W=n.access=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===n.type(c)){e=!0;for(h in c)n.access(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,n.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(n(a),c)})),b))for(;i>h;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},X=/^(?:checkbox|radio)$/i;!function(){var a=z.createDocumentFragment(),b=z.createElement("div"),c=z.createElement("input");if(b.setAttribute("className","t"),b.innerHTML="  <link/><table></table><a href='/a'>a</a>",l.leadingWhitespace=3===b.firstChild.nodeType,l.tbody=!b.getElementsByTagName("tbody").length,l.htmlSerialize=!!b.getElementsByTagName("link").length,l.html5Clone="<:nav></:nav>"!==z.createElement("nav").cloneNode(!0).outerHTML,c.type="checkbox",c.checked=!0,a.appendChild(c),l.appendChecked=c.checked,b.innerHTML="<textarea>x</textarea>",l.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue,a.appendChild(b),b.innerHTML="<input type='radio' checked='checked' name='t'/>",l.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,l.noCloneEvent=!0,b.attachEvent&&(b.attachEvent("onclick",function(){l.noCloneEvent=!1}),b.cloneNode(!0).click()),null==l.deleteExpando){l.deleteExpando=!0;try{delete b.test}catch(d){l.deleteExpando=!1}}a=b=c=null}(),function(){var b,c,d=z.createElement("div");for(b in{submit:!0,change:!0,focusin:!0})c="on"+b,(l[b+"Bubbles"]=c in a)||(d.setAttribute(c,"t"),l[b+"Bubbles"]=d.attributes[c].expando===!1);d=null}();var Y=/^(?:input|select|textarea)$/i,Z=/^key/,$=/^(?:mouse|contextmenu)|click/,_=/^(?:focusinfocus|focusoutblur)$/,ab=/^([^.]*)(?:\.(.+)|)$/;function bb(){return!0}function cb(){return!1}function db(){try{return z.activeElement}catch(a){}}n.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=n._data(a);if(r){c.handler&&(i=c,c=i.handler,e=i.selector),c.guid||(c.guid=n.guid++),(g=r.events)||(g=r.events={}),(k=r.handle)||(k=r.handle=function(a){return typeof n===L||a&&n.event.triggered===a.type?void 0:n.event.dispatch.apply(k.elem,arguments)},k.elem=a),b=(b||"").match(F)||[""],h=b.length;while(h--)f=ab.exec(b[h])||[],o=q=f[1],p=(f[2]||"").split(".").sort(),o&&(j=n.event.special[o]||{},o=(e?j.delegateType:j.bindType)||o,j=n.event.special[o]||{},l=n.extend({type:o,origType:q,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&n.expr.match.needsContext.test(e),namespace:p.join(".")},i),(m=g[o])||(m=g[o]=[],m.delegateCount=0,j.setup&&j.setup.call(a,d,p,k)!==!1||(a.addEventListener?a.addEventListener(o,k,!1):a.attachEvent&&a.attachEvent("on"+o,k))),j.add&&(j.add.call(a,l),l.handler.guid||(l.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,l):m.push(l),n.event.global[o]=!0);a=null}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=n.hasData(a)&&n._data(a);if(r&&(k=r.events)){b=(b||"").match(F)||[""],j=b.length;while(j--)if(h=ab.exec(b[j])||[],o=q=h[1],p=(h[2]||"").split(".").sort(),o){l=n.event.special[o]||{},o=(d?l.delegateType:l.bindType)||o,m=k[o]||[],h=h[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),i=f=m.length;while(f--)g=m[f],!e&&q!==g.origType||c&&c.guid!==g.guid||h&&!h.test(g.namespace)||d&&d!==g.selector&&("**"!==d||!g.selector)||(m.splice(f,1),g.selector&&m.delegateCount--,l.remove&&l.remove.call(a,g));i&&!m.length&&(l.teardown&&l.teardown.call(a,p,r.handle)!==!1||n.removeEvent(a,o,r.handle),delete k[o])}else for(o in k)n.event.remove(a,o+b[j],c,d,!0);n.isEmptyObject(k)&&(delete r.handle,n._removeData(a,"events"))}},trigger:function(b,c,d,e){var f,g,h,i,k,l,m,o=[d||z],p=j.call(b,"type")?b.type:b,q=j.call(b,"namespace")?b.namespace.split("."):[];if(h=l=d=d||z,3!==d.nodeType&&8!==d.nodeType&&!_.test(p+n.event.triggered)&&(p.indexOf(".")>=0&&(q=p.split("."),p=q.shift(),q.sort()),g=p.indexOf(":")<0&&"on"+p,b=b[n.expando]?b:new n.Event(p,"object"==typeof b&&b),b.isTrigger=e?2:3,b.namespace=q.join("."),b.namespace_re=b.namespace?new RegExp("(^|\\.)"+q.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=d),c=null==c?[b]:n.makeArray(c,[b]),k=n.event.special[p]||{},e||!k.trigger||k.trigger.apply(d,c)!==!1)){if(!e&&!k.noBubble&&!n.isWindow(d)){for(i=k.delegateType||p,_.test(i+p)||(h=h.parentNode);h;h=h.parentNode)o.push(h),l=h;l===(d.ownerDocument||z)&&o.push(l.defaultView||l.parentWindow||a)}m=0;while((h=o[m++])&&!b.isPropagationStopped())b.type=m>1?i:k.bindType||p,f=(n._data(h,"events")||{})[b.type]&&n._data(h,"handle"),f&&f.apply(h,c),f=g&&h[g],f&&f.apply&&n.acceptData(h)&&(b.result=f.apply(h,c),b.result===!1&&b.preventDefault());if(b.type=p,!e&&!b.isDefaultPrevented()&&(!k._default||k._default.apply(o.pop(),c)===!1)&&n.acceptData(d)&&g&&d[p]&&!n.isWindow(d)){l=d[g],l&&(d[g]=null),n.event.triggered=p;try{d[p]()}catch(r){}n.event.triggered=void 0,l&&(d[g]=l)}return b.result}},dispatch:function(a){a=n.event.fix(a);var b,c,e,f,g,h=[],i=d.call(arguments),j=(n._data(this,"events")||{})[a.type]||[],k=n.event.special[a.type]||{};if(i[0]=a,a.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,a)!==!1){h=n.event.handlers.call(this,a,j),b=0;while((f=h[b++])&&!a.isPropagationStopped()){a.currentTarget=f.elem,g=0;while((e=f.handlers[g++])&&!a.isImmediatePropagationStopped())(!a.namespace_re||a.namespace_re.test(e.namespace))&&(a.handleObj=e,a.data=e.data,c=((n.event.special[e.origType]||{}).handle||e.handler).apply(f.elem,i),void 0!==c&&(a.result=c)===!1&&(a.preventDefault(),a.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,a),a.result}},handlers:function(a,b){var c,d,e,f,g=[],h=b.delegateCount,i=a.target;if(h&&i.nodeType&&(!a.button||"click"!==a.type))for(;i!=this;i=i.parentNode||this)if(1===i.nodeType&&(i.disabled!==!0||"click"!==a.type)){for(e=[],f=0;h>f;f++)d=b[f],c=d.selector+" ",void 0===e[c]&&(e[c]=d.needsContext?n(c,this).index(i)>=0:n.find(c,this,null,[i]).length),e[c]&&e.push(d);e.length&&g.push({elem:i,handlers:e})}return h<b.length&&g.push({elem:this,handlers:b.slice(h)}),g},fix:function(a){if(a[n.expando])return a;var b,c,d,e=a.type,f=a,g=this.fixHooks[e];g||(this.fixHooks[e]=g=$.test(e)?this.mouseHooks:Z.test(e)?this.keyHooks:{}),d=g.props?this.props.concat(g.props):this.props,a=new n.Event(f),b=d.length;while(b--)c=d[b],a[c]=f[c];return a.target||(a.target=f.srcElement||z),3===a.target.nodeType&&(a.target=a.target.parentNode),a.metaKey=!!a.metaKey,g.filter?g.filter(a,f):a},props:"altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){return null==a.which&&(a.which=null!=b.charCode?b.charCode:b.keyCode),a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,b){var c,d,e,f=b.button,g=b.fromElement;return null==a.pageX&&null!=b.clientX&&(d=a.target.ownerDocument||z,e=d.documentElement,c=d.body,a.pageX=b.clientX+(e&&e.scrollLeft||c&&c.scrollLeft||0)-(e&&e.clientLeft||c&&c.clientLeft||0),a.pageY=b.clientY+(e&&e.scrollTop||c&&c.scrollTop||0)-(e&&e.clientTop||c&&c.clientTop||0)),!a.relatedTarget&&g&&(a.relatedTarget=g===a.target?b.toElement:g),a.which||void 0===f||(a.which=1&f?1:2&f?3:4&f?2:0),a}},special:{load:{noBubble:!0},focus:{trigger:function(){if(this!==db()&&this.focus)try{return this.focus(),!1}catch(a){}},delegateType:"focusin"},blur:{trigger:function(){return this===db()&&this.blur?(this.blur(),!1):void 0},delegateType:"focusout"},click:{trigger:function(){return n.nodeName(this,"input")&&"checkbox"===this.type&&this.click?(this.click(),!1):void 0},_default:function(a){return n.nodeName(a.target,"a")}},beforeunload:{postDispatch:function(a){void 0!==a.result&&(a.originalEvent.returnValue=a.result)}}},simulate:function(a,b,c,d){var e=n.extend(new n.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?n.event.trigger(e,null,b):n.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},n.removeEvent=z.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){var d="on"+b;a.detachEvent&&(typeof a[d]===L&&(a[d]=null),a.detachEvent(d,c))},n.Event=function(a,b){return this instanceof n.Event?(a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||void 0===a.defaultPrevented&&(a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault())?bb:cb):this.type=a,b&&n.extend(this,b),this.timeStamp=a&&a.timeStamp||n.now(),void(this[n.expando]=!0)):new n.Event(a,b)},n.Event.prototype={isDefaultPrevented:cb,isPropagationStopped:cb,isImmediatePropagationStopped:cb,preventDefault:function(){var a=this.originalEvent;this.isDefaultPrevented=bb,a&&(a.preventDefault?a.preventDefault():a.returnValue=!1)},stopPropagation:function(){var a=this.originalEvent;this.isPropagationStopped=bb,a&&(a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0)},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=bb,this.stopPropagation()}},n.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){n.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj;return(!e||e!==d&&!n.contains(d,e))&&(a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b),c}}}),l.submitBubbles||(n.event.special.submit={setup:function(){return n.nodeName(this,"form")?!1:void n.event.add(this,"click._submit keypress._submit",function(a){var b=a.target,c=n.nodeName(b,"input")||n.nodeName(b,"button")?b.form:void 0;c&&!n._data(c,"submitBubbles")&&(n.event.add(c,"submit._submit",function(a){a._submit_bubble=!0}),n._data(c,"submitBubbles",!0))})},postDispatch:function(a){a._submit_bubble&&(delete a._submit_bubble,this.parentNode&&!a.isTrigger&&n.event.simulate("submit",this.parentNode,a,!0))},teardown:function(){return n.nodeName(this,"form")?!1:void n.event.remove(this,"._submit")}}),l.changeBubbles||(n.event.special.change={setup:function(){return Y.test(this.nodeName)?(("checkbox"===this.type||"radio"===this.type)&&(n.event.add(this,"propertychange._change",function(a){"checked"===a.originalEvent.propertyName&&(this._just_changed=!0)}),n.event.add(this,"click._change",function(a){this._just_changed&&!a.isTrigger&&(this._just_changed=!1),n.event.simulate("change",this,a,!0)})),!1):void n.event.add(this,"beforeactivate._change",function(a){var b=a.target;Y.test(b.nodeName)&&!n._data(b,"changeBubbles")&&(n.event.add(b,"change._change",function(a){!this.parentNode||a.isSimulated||a.isTrigger||n.event.simulate("change",this.parentNode,a,!0)}),n._data(b,"changeBubbles",!0))})},handle:function(a){var b=a.target;return this!==b||a.isSimulated||a.isTrigger||"radio"!==b.type&&"checkbox"!==b.type?a.handleObj.handler.apply(this,arguments):void 0},teardown:function(){return n.event.remove(this,"._change"),!Y.test(this.nodeName)}}),l.focusinBubbles||n.each({focus:"focusin",blur:"focusout"},function(a,b){var c=function(a){n.event.simulate(b,a.target,n.event.fix(a),!0)};n.event.special[b]={setup:function(){var d=this.ownerDocument||this,e=n._data(d,b);e||d.addEventListener(a,c,!0),n._data(d,b,(e||0)+1)},teardown:function(){var d=this.ownerDocument||this,e=n._data(d,b)-1;e?n._data(d,b,e):(d.removeEventListener(a,c,!0),n._removeData(d,b))}}}),n.fn.extend({on:function(a,b,c,d,e){var f,g;if("object"==typeof a){"string"!=typeof b&&(c=c||b,b=void 0);for(f in a)this.on(f,b,c,a[f],e);return this}if(null==c&&null==d?(d=b,c=b=void 0):null==d&&("string"==typeof b?(d=c,c=void 0):(d=c,c=b,b=void 0)),d===!1)d=cb;else if(!d)return this;return 1===e&&(g=d,d=function(a){return n().off(a),g.apply(this,arguments)},d.guid=g.guid||(g.guid=n.guid++)),this.each(function(){n.event.add(this,a,d,c,b)})},one:function(a,b,c,d){return this.on(a,b,c,d,1)},off:function(a,b,c){var d,e;if(a&&a.preventDefault&&a.handleObj)return d=a.handleObj,n(a.delegateTarget).off(d.namespace?d.origType+"."+d.namespace:d.origType,d.selector,d.handler),this;if("object"==typeof a){for(e in a)this.off(e,b,a[e]);return this}return(b===!1||"function"==typeof b)&&(c=b,b=void 0),c===!1&&(c=cb),this.each(function(){n.event.remove(this,a,c,b)})},trigger:function(a,b){return this.each(function(){n.event.trigger(a,b,this)})},triggerHandler:function(a,b){var c=this[0];return c?n.event.trigger(a,b,c,!0):void 0}});function eb(a){var b=fb.split("|"),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}var fb="abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",gb=/ jQuery\d+="(?:null|\d+)"/g,hb=new RegExp("<(?:"+fb+")[\\s/>]","i"),ib=/^\s+/,jb=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,kb=/<([\w:]+)/,lb=/<tbody/i,mb=/<|&#?\w+;/,nb=/<(?:script|style|link)/i,ob=/checked\s*(?:[^=]|=\s*.checked.)/i,pb=/^$|\/(?:java|ecma)script/i,qb=/^true\/(.*)/,rb=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,sb={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],area:[1,"<map>","</map>"],param:[1,"<object>","</object>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:l.htmlSerialize?[0,"",""]:[1,"X<div>","</div>"]},tb=eb(z),ub=tb.appendChild(z.createElement("div"));sb.optgroup=sb.option,sb.tbody=sb.tfoot=sb.colgroup=sb.caption=sb.thead,sb.th=sb.td;function vb(a,b){var c,d,e=0,f=typeof a.getElementsByTagName!==L?a.getElementsByTagName(b||"*"):typeof a.querySelectorAll!==L?a.querySelectorAll(b||"*"):void 0;if(!f)for(f=[],c=a.childNodes||a;null!=(d=c[e]);e++)!b||n.nodeName(d,b)?f.push(d):n.merge(f,vb(d,b));return void 0===b||b&&n.nodeName(a,b)?n.merge([a],f):f}function wb(a){X.test(a.type)&&(a.defaultChecked=a.checked)}function xb(a,b){return n.nodeName(a,"table")&&n.nodeName(11!==b.nodeType?b:b.firstChild,"tr")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function yb(a){return a.type=(null!==n.find.attr(a,"type"))+"/"+a.type,a}function zb(a){var b=qb.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function Ab(a,b){for(var c,d=0;null!=(c=a[d]);d++)n._data(c,"globalEval",!b||n._data(b[d],"globalEval"))}function Bb(a,b){if(1===b.nodeType&&n.hasData(a)){var c,d,e,f=n._data(a),g=n._data(b,f),h=f.events;if(h){delete g.handle,g.events={};for(c in h)for(d=0,e=h[c].length;e>d;d++)n.event.add(b,c,h[c][d])}g.data&&(g.data=n.extend({},g.data))}}function Cb(a,b){var c,d,e;if(1===b.nodeType){if(c=b.nodeName.toLowerCase(),!l.noCloneEvent&&b[n.expando]){e=n._data(b);for(d in e.events)n.removeEvent(b,d,e.handle);b.removeAttribute(n.expando)}"script"===c&&b.text!==a.text?(yb(b).text=a.text,zb(b)):"object"===c?(b.parentNode&&(b.outerHTML=a.outerHTML),l.html5Clone&&a.innerHTML&&!n.trim(b.innerHTML)&&(b.innerHTML=a.innerHTML)):"input"===c&&X.test(a.type)?(b.defaultChecked=b.checked=a.checked,b.value!==a.value&&(b.value=a.value)):"option"===c?b.defaultSelected=b.selected=a.defaultSelected:("input"===c||"textarea"===c)&&(b.defaultValue=a.defaultValue)}}n.extend({clone:function(a,b,c){var d,e,f,g,h,i=n.contains(a.ownerDocument,a);if(l.html5Clone||n.isXMLDoc(a)||!hb.test("<"+a.nodeName+">")?f=a.cloneNode(!0):(ub.innerHTML=a.outerHTML,ub.removeChild(f=ub.firstChild)),!(l.noCloneEvent&&l.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||n.isXMLDoc(a)))for(d=vb(f),h=vb(a),g=0;null!=(e=h[g]);++g)d[g]&&Cb(e,d[g]);if(b)if(c)for(h=h||vb(a),d=d||vb(f),g=0;null!=(e=h[g]);g++)Bb(e,d[g]);else Bb(a,f);return d=vb(f,"script"),d.length>0&&Ab(d,!i&&vb(a,"script")),d=h=e=null,f},buildFragment:function(a,b,c,d){for(var e,f,g,h,i,j,k,m=a.length,o=eb(b),p=[],q=0;m>q;q++)if(f=a[q],f||0===f)if("object"===n.type(f))n.merge(p,f.nodeType?[f]:f);else if(mb.test(f)){h=h||o.appendChild(b.createElement("div")),i=(kb.exec(f)||["",""])[1].toLowerCase(),k=sb[i]||sb._default,h.innerHTML=k[1]+f.replace(jb,"<$1></$2>")+k[2],e=k[0];while(e--)h=h.lastChild;if(!l.leadingWhitespace&&ib.test(f)&&p.push(b.createTextNode(ib.exec(f)[0])),!l.tbody){f="table"!==i||lb.test(f)?"<table>"!==k[1]||lb.test(f)?0:h:h.firstChild,e=f&&f.childNodes.length;while(e--)n.nodeName(j=f.childNodes[e],"tbody")&&!j.childNodes.length&&f.removeChild(j)}n.merge(p,h.childNodes),h.textContent="";while(h.firstChild)h.removeChild(h.firstChild);h=o.lastChild}else p.push(b.createTextNode(f));h&&o.removeChild(h),l.appendChecked||n.grep(vb(p,"input"),wb),q=0;while(f=p[q++])if((!d||-1===n.inArray(f,d))&&(g=n.contains(f.ownerDocument,f),h=vb(o.appendChild(f),"script"),g&&Ab(h),c)){e=0;while(f=h[e++])pb.test(f.type||"")&&c.push(f)}return h=null,o},cleanData:function(a,b){for(var d,e,f,g,h=0,i=n.expando,j=n.cache,k=l.deleteExpando,m=n.event.special;null!=(d=a[h]);h++)if((b||n.acceptData(d))&&(f=d[i],g=f&&j[f])){if(g.events)for(e in g.events)m[e]?n.event.remove(d,e):n.removeEvent(d,e,g.handle);j[f]&&(delete j[f],k?delete d[i]:typeof d.removeAttribute!==L?d.removeAttribute(i):d[i]=null,c.push(f))}}}),n.fn.extend({text:function(a){return W(this,function(a){return void 0===a?n.text(this):this.empty().append((this[0]&&this[0].ownerDocument||z).createTextNode(a))},null,a,arguments.length)},append:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=xb(this,a);b.appendChild(a)}})},prepend:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=xb(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},remove:function(a,b){for(var c,d=a?n.filter(a,this):this,e=0;null!=(c=d[e]);e++)b||1!==c.nodeType||n.cleanData(vb(c)),c.parentNode&&(b&&n.contains(c.ownerDocument,c)&&Ab(vb(c,"script")),c.parentNode.removeChild(c));return this},empty:function(){for(var a,b=0;null!=(a=this[b]);b++){1===a.nodeType&&n.cleanData(vb(a,!1));while(a.firstChild)a.removeChild(a.firstChild);a.options&&n.nodeName(a,"select")&&(a.options.length=0)}return this},clone:function(a,b){return a=null==a?!1:a,b=null==b?a:b,this.map(function(){return n.clone(this,a,b)})},html:function(a){return W(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a)return 1===b.nodeType?b.innerHTML.replace(gb,""):void 0;if(!("string"!=typeof a||nb.test(a)||!l.htmlSerialize&&hb.test(a)||!l.leadingWhitespace&&ib.test(a)||sb[(kb.exec(a)||["",""])[1].toLowerCase()])){a=a.replace(jb,"<$1></$2>");try{for(;d>c;c++)b=this[c]||{},1===b.nodeType&&(n.cleanData(vb(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=arguments[0];return this.domManip(arguments,function(b){a=this.parentNode,n.cleanData(vb(this)),a&&a.replaceChild(b,this)}),a&&(a.length||a.nodeType)?this:this.remove()},detach:function(a){return this.remove(a,!0)},domManip:function(a,b){a=e.apply([],a);var c,d,f,g,h,i,j=0,k=this.length,m=this,o=k-1,p=a[0],q=n.isFunction(p);if(q||k>1&&"string"==typeof p&&!l.checkClone&&ob.test(p))return this.each(function(c){var d=m.eq(c);q&&(a[0]=p.call(this,c,d.html())),d.domManip(a,b)});if(k&&(i=n.buildFragment(a,this[0].ownerDocument,!1,this),c=i.firstChild,1===i.childNodes.length&&(i=c),c)){for(g=n.map(vb(i,"script"),yb),f=g.length;k>j;j++)d=i,j!==o&&(d=n.clone(d,!0,!0),f&&n.merge(g,vb(d,"script"))),b.call(this[j],d,j);if(f)for(h=g[g.length-1].ownerDocument,n.map(g,zb),j=0;f>j;j++)d=g[j],pb.test(d.type||"")&&!n._data(d,"globalEval")&&n.contains(h,d)&&(d.src?n._evalUrl&&n._evalUrl(d.src):n.globalEval((d.text||d.textContent||d.innerHTML||"").replace(rb,"")));i=c=null}return this}}),n.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){n.fn[a]=function(a){for(var c,d=0,e=[],g=n(a),h=g.length-1;h>=d;d++)c=d===h?this:this.clone(!0),n(g[d])[b](c),f.apply(e,c.get());return this.pushStack(e)}});var Db,Eb={};function Fb(b,c){var d=n(c.createElement(b)).appendTo(c.body),e=a.getDefaultComputedStyle?a.getDefaultComputedStyle(d[0]).display:n.css(d[0],"display");return d.detach(),e}function Gb(a){var b=z,c=Eb[a];return c||(c=Fb(a,b),"none"!==c&&c||(Db=(Db||n("<iframe frameborder='0' width='0' height='0'/>")).appendTo(b.documentElement),b=(Db[0].contentWindow||Db[0].contentDocument).document,b.write(),b.close(),c=Fb(a,b),Db.detach()),Eb[a]=c),c}!function(){var a,b,c=z.createElement("div"),d="-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;padding:0;margin:0;border:0";c.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",a=c.getElementsByTagName("a")[0],a.style.cssText="float:left;opacity:.5",l.opacity=/^0.5/.test(a.style.opacity),l.cssFloat=!!a.style.cssFloat,c.style.backgroundClip="content-box",c.cloneNode(!0).style.backgroundClip="",l.clearCloneStyle="content-box"===c.style.backgroundClip,a=c=null,l.shrinkWrapBlocks=function(){var a,c,e,f;if(null==b){if(a=z.getElementsByTagName("body")[0],!a)return;f="border:0;width:0;height:0;position:absolute;top:0;left:-9999px",c=z.createElement("div"),e=z.createElement("div"),a.appendChild(c).appendChild(e),b=!1,typeof e.style.zoom!==L&&(e.style.cssText=d+";width:1px;padding:1px;zoom:1",e.innerHTML="<div></div>",e.firstChild.style.width="5px",b=3!==e.offsetWidth),a.removeChild(c),a=c=e=null}return b}}();var Hb=/^margin/,Ib=new RegExp("^("+T+")(?!px)[a-z%]+$","i"),Jb,Kb,Lb=/^(top|right|bottom|left)$/;a.getComputedStyle?(Jb=function(a){return a.ownerDocument.defaultView.getComputedStyle(a,null)},Kb=function(a,b,c){var d,e,f,g,h=a.style;return c=c||Jb(a),g=c?c.getPropertyValue(b)||c[b]:void 0,c&&(""!==g||n.contains(a.ownerDocument,a)||(g=n.style(a,b)),Ib.test(g)&&Hb.test(b)&&(d=h.width,e=h.minWidth,f=h.maxWidth,h.minWidth=h.maxWidth=h.width=g,g=c.width,h.width=d,h.minWidth=e,h.maxWidth=f)),void 0===g?g:g+""}):z.documentElement.currentStyle&&(Jb=function(a){return a.currentStyle},Kb=function(a,b,c){var d,e,f,g,h=a.style;return c=c||Jb(a),g=c?c[b]:void 0,null==g&&h&&h[b]&&(g=h[b]),Ib.test(g)&&!Lb.test(b)&&(d=h.left,e=a.runtimeStyle,f=e&&e.left,f&&(e.left=a.currentStyle.left),h.left="fontSize"===b?"1em":g,g=h.pixelLeft+"px",h.left=d,f&&(e.left=f)),void 0===g?g:g+""||"auto"});function Mb(a,b){return{get:function(){var c=a();if(null!=c)return c?void delete this.get:(this.get=b).apply(this,arguments)}}}!function(){var b,c,d,e,f,g,h=z.createElement("div"),i="border:0;width:0;height:0;position:absolute;top:0;left:-9999px",j="-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;padding:0;margin:0;border:0";h.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",b=h.getElementsByTagName("a")[0],b.style.cssText="float:left;opacity:.5",l.opacity=/^0.5/.test(b.style.opacity),l.cssFloat=!!b.style.cssFloat,h.style.backgroundClip="content-box",h.cloneNode(!0).style.backgroundClip="",l.clearCloneStyle="content-box"===h.style.backgroundClip,b=h=null,n.extend(l,{reliableHiddenOffsets:function(){if(null!=c)return c;var a,b,d,e=z.createElement("div"),f=z.getElementsByTagName("body")[0];if(f)return e.setAttribute("className","t"),e.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",a=z.createElement("div"),a.style.cssText=i,f.appendChild(a).appendChild(e),e.innerHTML="<table><tr><td></td><td>t</td></tr></table>",b=e.getElementsByTagName("td"),b[0].style.cssText="padding:0;margin:0;border:0;display:none",d=0===b[0].offsetHeight,b[0].style.display="",b[1].style.display="none",c=d&&0===b[0].offsetHeight,f.removeChild(a),e=f=null,c},boxSizing:function(){return null==d&&k(),d},boxSizingReliable:function(){return null==e&&k(),e},pixelPosition:function(){return null==f&&k(),f},reliableMarginRight:function(){var b,c,d,e;if(null==g&&a.getComputedStyle){if(b=z.getElementsByTagName("body")[0],!b)return;c=z.createElement("div"),d=z.createElement("div"),c.style.cssText=i,b.appendChild(c).appendChild(d),e=d.appendChild(z.createElement("div")),e.style.cssText=d.style.cssText=j,e.style.marginRight=e.style.width="0",d.style.width="1px",g=!parseFloat((a.getComputedStyle(e,null)||{}).marginRight),b.removeChild(c)}return g}});function k(){var b,c,h=z.getElementsByTagName("body")[0];h&&(b=z.createElement("div"),c=z.createElement("div"),b.style.cssText=i,h.appendChild(b).appendChild(c),c.style.cssText="-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;position:absolute;display:block;padding:1px;border:1px;width:4px;margin-top:1%;top:1%",n.swap(h,null!=h.style.zoom?{zoom:1}:{},function(){d=4===c.offsetWidth}),e=!0,f=!1,g=!0,a.getComputedStyle&&(f="1%"!==(a.getComputedStyle(c,null)||{}).top,e="4px"===(a.getComputedStyle(c,null)||{width:"4px"}).width),h.removeChild(b),c=h=null)}}(),n.swap=function(a,b,c,d){var e,f,g={};for(f in b)g[f]=a.style[f],a.style[f]=b[f];e=c.apply(a,d||[]);for(f in b)a.style[f]=g[f];return e};var Nb=/alpha\([^)]*\)/i,Ob=/opacity\s*=\s*([^)]*)/,Pb=/^(none|table(?!-c[ea]).+)/,Qb=new RegExp("^("+T+")(.*)$","i"),Rb=new RegExp("^([+-])=("+T+")","i"),Sb={position:"absolute",visibility:"hidden",display:"block"},Tb={letterSpacing:0,fontWeight:400},Ub=["Webkit","O","Moz","ms"];function Vb(a,b){if(b in a)return b;var c=b.charAt(0).toUpperCase()+b.slice(1),d=b,e=Ub.length;while(e--)if(b=Ub[e]+c,b in a)return b;return d}function Wb(a,b){for(var c,d,e,f=[],g=0,h=a.length;h>g;g++)d=a[g],d.style&&(f[g]=n._data(d,"olddisplay"),c=d.style.display,b?(f[g]||"none"!==c||(d.style.display=""),""===d.style.display&&V(d)&&(f[g]=n._data(d,"olddisplay",Gb(d.nodeName)))):f[g]||(e=V(d),(c&&"none"!==c||!e)&&n._data(d,"olddisplay",e?c:n.css(d,"display"))));for(g=0;h>g;g++)d=a[g],d.style&&(b&&"none"!==d.style.display&&""!==d.style.display||(d.style.display=b?f[g]||"":"none"));return a}function Xb(a,b,c){var d=Qb.exec(b);return d?Math.max(0,d[1]-(c||0))+(d[2]||"px"):b}function Yb(a,b,c,d,e){for(var f=c===(d?"border":"content")?4:"width"===b?1:0,g=0;4>f;f+=2)"margin"===c&&(g+=n.css(a,c+U[f],!0,e)),d?("content"===c&&(g-=n.css(a,"padding"+U[f],!0,e)),"margin"!==c&&(g-=n.css(a,"border"+U[f]+"Width",!0,e))):(g+=n.css(a,"padding"+U[f],!0,e),"padding"!==c&&(g+=n.css(a,"border"+U[f]+"Width",!0,e)));return g}function Zb(a,b,c){var d=!0,e="width"===b?a.offsetWidth:a.offsetHeight,f=Jb(a),g=l.boxSizing()&&"border-box"===n.css(a,"boxSizing",!1,f);if(0>=e||null==e){if(e=Kb(a,b,f),(0>e||null==e)&&(e=a.style[b]),Ib.test(e))return e;d=g&&(l.boxSizingReliable()||e===a.style[b]),e=parseFloat(e)||0}return e+Yb(a,b,c||(g?"border":"content"),d,f)+"px"}n.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=Kb(a,"opacity");return""===c?"1":c}}}},cssNumber:{columnCount:!0,fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":l.cssFloat?"cssFloat":"styleFloat"},style:function(a,b,c,d){if(a&&3!==a.nodeType&&8!==a.nodeType&&a.style){var e,f,g,h=n.camelCase(b),i=a.style;if(b=n.cssProps[h]||(n.cssProps[h]=Vb(i,h)),g=n.cssHooks[b]||n.cssHooks[h],void 0===c)return g&&"get"in g&&void 0!==(e=g.get(a,!1,d))?e:i[b];if(f=typeof c,"string"===f&&(e=Rb.exec(c))&&(c=(e[1]+1)*e[2]+parseFloat(n.css(a,b)),f="number"),null!=c&&c===c&&("number"!==f||n.cssNumber[h]||(c+="px"),l.clearCloneStyle||""!==c||0!==b.indexOf("background")||(i[b]="inherit"),!(g&&"set"in g&&void 0===(c=g.set(a,c,d)))))try{i[b]="",i[b]=c}catch(j){}}},css:function(a,b,c,d){var e,f,g,h=n.camelCase(b);return b=n.cssProps[h]||(n.cssProps[h]=Vb(a.style,h)),g=n.cssHooks[b]||n.cssHooks[h],g&&"get"in g&&(f=g.get(a,!0,c)),void 0===f&&(f=Kb(a,b,d)),"normal"===f&&b in Tb&&(f=Tb[b]),""===c||c?(e=parseFloat(f),c===!0||n.isNumeric(e)?e||0:f):f}}),n.each(["height","width"],function(a,b){n.cssHooks[b]={get:function(a,c,d){return c?0===a.offsetWidth&&Pb.test(n.css(a,"display"))?n.swap(a,Sb,function(){return Zb(a,b,d)}):Zb(a,b,d):void 0},set:function(a,c,d){var e=d&&Jb(a);return Xb(a,c,d?Yb(a,b,d,l.boxSizing()&&"border-box"===n.css(a,"boxSizing",!1,e),e):0)}}}),l.opacity||(n.cssHooks.opacity={get:function(a,b){return Ob.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?.01*parseFloat(RegExp.$1)+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=n.isNumeric(b)?"alpha(opacity="+100*b+")":"",f=d&&d.filter||c.filter||"";c.zoom=1,(b>=1||""===b)&&""===n.trim(f.replace(Nb,""))&&c.removeAttribute&&(c.removeAttribute("filter"),""===b||d&&!d.filter)||(c.filter=Nb.test(f)?f.replace(Nb,e):f+" "+e)}}),n.cssHooks.marginRight=Mb(l.reliableMarginRight,function(a,b){return b?n.swap(a,{display:"inline-block"},Kb,[a,"marginRight"]):void 0}),n.each({margin:"",padding:"",border:"Width"},function(a,b){n.cssHooks[a+b]={expand:function(c){for(var d=0,e={},f="string"==typeof c?c.split(" "):[c];4>d;d++)e[a+U[d]+b]=f[d]||f[d-2]||f[0];return e}},Hb.test(a)||(n.cssHooks[a+b].set=Xb)}),n.fn.extend({css:function(a,b){return W(this,function(a,b,c){var d,e,f={},g=0;if(n.isArray(b)){for(d=Jb(a),e=b.length;e>g;g++)f[b[g]]=n.css(a,b[g],!1,d);return f}return void 0!==c?n.style(a,b,c):n.css(a,b)
-},a,b,arguments.length>1)},show:function(){return Wb(this,!0)},hide:function(){return Wb(this)},toggle:function(a){return"boolean"==typeof a?a?this.show():this.hide():this.each(function(){V(this)?n(this).show():n(this).hide()})}});function $b(a,b,c,d,e){return new $b.prototype.init(a,b,c,d,e)}n.Tween=$b,$b.prototype={constructor:$b,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||"swing",this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(n.cssNumber[c]?"":"px")},cur:function(){var a=$b.propHooks[this.prop];return a&&a.get?a.get(this):$b.propHooks._default.get(this)},run:function(a){var b,c=$b.propHooks[this.prop];return this.pos=b=this.options.duration?n.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):$b.propHooks._default.set(this),this}},$b.prototype.init.prototype=$b.prototype,$b.propHooks={_default:{get:function(a){var b;return null==a.elem[a.prop]||a.elem.style&&null!=a.elem.style[a.prop]?(b=n.css(a.elem,a.prop,""),b&&"auto"!==b?b:0):a.elem[a.prop]},set:function(a){n.fx.step[a.prop]?n.fx.step[a.prop](a):a.elem.style&&(null!=a.elem.style[n.cssProps[a.prop]]||n.cssHooks[a.prop])?n.style(a.elem,a.prop,a.now+a.unit):a.elem[a.prop]=a.now}}},$b.propHooks.scrollTop=$b.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},n.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2}},n.fx=$b.prototype.init,n.fx.step={};var _b,ac,bc=/^(?:toggle|show|hide)$/,cc=new RegExp("^(?:([+-])=|)("+T+")([a-z%]*)$","i"),dc=/queueHooks$/,ec=[jc],fc={"*":[function(a,b){var c=this.createTween(a,b),d=c.cur(),e=cc.exec(b),f=e&&e[3]||(n.cssNumber[a]?"":"px"),g=(n.cssNumber[a]||"px"!==f&&+d)&&cc.exec(n.css(c.elem,a)),h=1,i=20;if(g&&g[3]!==f){f=f||g[3],e=e||[],g=+d||1;do h=h||".5",g/=h,n.style(c.elem,a,g+f);while(h!==(h=c.cur()/d)&&1!==h&&--i)}return e&&(g=c.start=+g||+d||0,c.unit=f,c.end=e[1]?g+(e[1]+1)*e[2]:+e[2]),c}]};function gc(){return setTimeout(function(){_b=void 0}),_b=n.now()}function hc(a,b){var c,d={height:a},e=0;for(b=b?1:0;4>e;e+=2-b)c=U[e],d["margin"+c]=d["padding"+c]=a;return b&&(d.opacity=d.width=a),d}function ic(a,b,c){for(var d,e=(fc[b]||[]).concat(fc["*"]),f=0,g=e.length;g>f;f++)if(d=e[f].call(c,b,a))return d}function jc(a,b,c){var d,e,f,g,h,i,j,k,m=this,o={},p=a.style,q=a.nodeType&&V(a),r=n._data(a,"fxshow");c.queue||(h=n._queueHooks(a,"fx"),null==h.unqueued&&(h.unqueued=0,i=h.empty.fire,h.empty.fire=function(){h.unqueued||i()}),h.unqueued++,m.always(function(){m.always(function(){h.unqueued--,n.queue(a,"fx").length||h.empty.fire()})})),1===a.nodeType&&("height"in b||"width"in b)&&(c.overflow=[p.overflow,p.overflowX,p.overflowY],j=n.css(a,"display"),k=Gb(a.nodeName),"none"===j&&(j=k),"inline"===j&&"none"===n.css(a,"float")&&(l.inlineBlockNeedsLayout&&"inline"!==k?p.zoom=1:p.display="inline-block")),c.overflow&&(p.overflow="hidden",l.shrinkWrapBlocks()||m.always(function(){p.overflow=c.overflow[0],p.overflowX=c.overflow[1],p.overflowY=c.overflow[2]}));for(d in b)if(e=b[d],bc.exec(e)){if(delete b[d],f=f||"toggle"===e,e===(q?"hide":"show")){if("show"!==e||!r||void 0===r[d])continue;q=!0}o[d]=r&&r[d]||n.style(a,d)}if(!n.isEmptyObject(o)){r?"hidden"in r&&(q=r.hidden):r=n._data(a,"fxshow",{}),f&&(r.hidden=!q),q?n(a).show():m.done(function(){n(a).hide()}),m.done(function(){var b;n._removeData(a,"fxshow");for(b in o)n.style(a,b,o[b])});for(d in o)g=ic(q?r[d]:0,d,m),d in r||(r[d]=g.start,q&&(g.end=g.start,g.start="width"===d||"height"===d?1:0))}}function kc(a,b){var c,d,e,f,g;for(c in a)if(d=n.camelCase(c),e=b[d],f=a[c],n.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=n.cssHooks[d],g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}function lc(a,b,c){var d,e,f=0,g=ec.length,h=n.Deferred().always(function(){delete i.elem}),i=function(){if(e)return!1;for(var b=_b||gc(),c=Math.max(0,j.startTime+j.duration-b),d=c/j.duration||0,f=1-d,g=0,i=j.tweens.length;i>g;g++)j.tweens[g].run(f);return h.notifyWith(a,[j,f,c]),1>f&&i?c:(h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:n.extend({},b),opts:n.extend(!0,{specialEasing:{}},c),originalProperties:b,originalOptions:c,startTime:_b||gc(),duration:c.duration,tweens:[],createTween:function(b,c){var d=n.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(d),d},stop:function(b){var c=0,d=b?j.tweens.length:0;if(e)return this;for(e=!0;d>c;c++)j.tweens[c].run(1);return b?h.resolveWith(a,[j,b]):h.rejectWith(a,[j,b]),this}}),k=j.props;for(kc(k,j.opts.specialEasing);g>f;f++)if(d=ec[f].call(j,a,k,j.opts))return d;return n.map(k,ic,j),n.isFunction(j.opts.start)&&j.opts.start.call(a,j),n.fx.timer(n.extend(i,{elem:a,anim:j,queue:j.opts.queue})),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always)}n.Animation=n.extend(lc,{tweener:function(a,b){n.isFunction(a)?(b=a,a=["*"]):a=a.split(" ");for(var c,d=0,e=a.length;e>d;d++)c=a[d],fc[c]=fc[c]||[],fc[c].unshift(b)},prefilter:function(a,b){b?ec.unshift(a):ec.push(a)}}),n.speed=function(a,b,c){var d=a&&"object"==typeof a?n.extend({},a):{complete:c||!c&&b||n.isFunction(a)&&a,duration:a,easing:c&&b||b&&!n.isFunction(b)&&b};return d.duration=n.fx.off?0:"number"==typeof d.duration?d.duration:d.duration in n.fx.speeds?n.fx.speeds[d.duration]:n.fx.speeds._default,(null==d.queue||d.queue===!0)&&(d.queue="fx"),d.old=d.complete,d.complete=function(){n.isFunction(d.old)&&d.old.call(this),d.queue&&n.dequeue(this,d.queue)},d},n.fn.extend({fadeTo:function(a,b,c,d){return this.filter(V).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=n.isEmptyObject(a),f=n.speed(b,c,d),g=function(){var b=lc(this,n.extend({},a),f);(e||n._data(this,"finish"))&&b.stop(!0)};return g.finish=g,e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,b,c){var d=function(a){var b=a.stop;delete a.stop,b(c)};return"string"!=typeof a&&(c=b,b=a,a=void 0),b&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,e=null!=a&&a+"queueHooks",f=n.timers,g=n._data(this);if(e)g[e]&&g[e].stop&&d(g[e]);else for(e in g)g[e]&&g[e].stop&&dc.test(e)&&d(g[e]);for(e=f.length;e--;)f[e].elem!==this||null!=a&&f[e].queue!==a||(f[e].anim.stop(c),b=!1,f.splice(e,1));(b||!c)&&n.dequeue(this,a)})},finish:function(a){return a!==!1&&(a=a||"fx"),this.each(function(){var b,c=n._data(this),d=c[a+"queue"],e=c[a+"queueHooks"],f=n.timers,g=d?d.length:0;for(c.finish=!0,n.queue(this,a,[]),e&&e.stop&&e.stop.call(this,!0),b=f.length;b--;)f[b].elem===this&&f[b].queue===a&&(f[b].anim.stop(!0),f.splice(b,1));for(b=0;g>b;b++)d[b]&&d[b].finish&&d[b].finish.call(this);delete c.finish})}}),n.each(["toggle","show","hide"],function(a,b){var c=n.fn[b];n.fn[b]=function(a,d,e){return null==a||"boolean"==typeof a?c.apply(this,arguments):this.animate(hc(b,!0),a,d,e)}}),n.each({slideDown:hc("show"),slideUp:hc("hide"),slideToggle:hc("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){n.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),n.timers=[],n.fx.tick=function(){var a,b=n.timers,c=0;for(_b=n.now();c<b.length;c++)a=b[c],a()||b[c]!==a||b.splice(c--,1);b.length||n.fx.stop(),_b=void 0},n.fx.timer=function(a){n.timers.push(a),a()?n.fx.start():n.timers.pop()},n.fx.interval=13,n.fx.start=function(){ac||(ac=setInterval(n.fx.tick,n.fx.interval))},n.fx.stop=function(){clearInterval(ac),ac=null},n.fx.speeds={slow:600,fast:200,_default:400},n.fn.delay=function(a,b){return a=n.fx?n.fx.speeds[a]||a:a,b=b||"fx",this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},function(){var a,b,c,d,e=z.createElement("div");e.setAttribute("className","t"),e.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",a=e.getElementsByTagName("a")[0],c=z.createElement("select"),d=c.appendChild(z.createElement("option")),b=e.getElementsByTagName("input")[0],a.style.cssText="top:1px",l.getSetAttribute="t"!==e.className,l.style=/top/.test(a.getAttribute("style")),l.hrefNormalized="/a"===a.getAttribute("href"),l.checkOn=!!b.value,l.optSelected=d.selected,l.enctype=!!z.createElement("form").enctype,c.disabled=!0,l.optDisabled=!d.disabled,b=z.createElement("input"),b.setAttribute("value",""),l.input=""===b.getAttribute("value"),b.value="t",b.setAttribute("type","radio"),l.radioValue="t"===b.value,a=b=c=d=e=null}();var mc=/\r/g;n.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=n.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,n(this).val()):a,null==e?e="":"number"==typeof e?e+="":n.isArray(e)&&(e=n.map(e,function(a){return null==a?"":a+""})),b=n.valHooks[this.type]||n.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=n.valHooks[e.type]||n.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(mc,""):null==c?"":c)}}}),n.extend({valHooks:{option:{get:function(a){var b=n.find.attr(a,"value");return null!=b?b:n.text(a)}},select:{get:function(a){for(var b,c,d=a.options,e=a.selectedIndex,f="select-one"===a.type||0>e,g=f?null:[],h=f?e+1:d.length,i=0>e?h:f?e:0;h>i;i++)if(c=d[i],!(!c.selected&&i!==e||(l.optDisabled?c.disabled:null!==c.getAttribute("disabled"))||c.parentNode.disabled&&n.nodeName(c.parentNode,"optgroup"))){if(b=n(c).val(),f)return b;g.push(b)}return g},set:function(a,b){var c,d,e=a.options,f=n.makeArray(b),g=e.length;while(g--)if(d=e[g],n.inArray(n.valHooks.option.get(d),f)>=0)try{d.selected=c=!0}catch(h){d.scrollHeight}else d.selected=!1;return c||(a.selectedIndex=-1),e}}}}),n.each(["radio","checkbox"],function(){n.valHooks[this]={set:function(a,b){return n.isArray(b)?a.checked=n.inArray(n(a).val(),b)>=0:void 0}},l.checkOn||(n.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})});var nc,oc,pc=n.expr.attrHandle,qc=/^(?:checked|selected)$/i,rc=l.getSetAttribute,sc=l.input;n.fn.extend({attr:function(a,b){return W(this,n.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){n.removeAttr(this,a)})}}),n.extend({attr:function(a,b,c){var d,e,f=a.nodeType;if(a&&3!==f&&8!==f&&2!==f)return typeof a.getAttribute===L?n.prop(a,b,c):(1===f&&n.isXMLDoc(a)||(b=b.toLowerCase(),d=n.attrHooks[b]||(n.expr.match.bool.test(b)?oc:nc)),void 0===c?d&&"get"in d&&null!==(e=d.get(a,b))?e:(e=n.find.attr(a,b),null==e?void 0:e):null!==c?d&&"set"in d&&void 0!==(e=d.set(a,c,b))?e:(a.setAttribute(b,c+""),c):void n.removeAttr(a,b))},removeAttr:function(a,b){var c,d,e=0,f=b&&b.match(F);if(f&&1===a.nodeType)while(c=f[e++])d=n.propFix[c]||c,n.expr.match.bool.test(c)?sc&&rc||!qc.test(c)?a[d]=!1:a[n.camelCase("default-"+c)]=a[d]=!1:n.attr(a,c,""),a.removeAttribute(rc?c:d)},attrHooks:{type:{set:function(a,b){if(!l.radioValue&&"radio"===b&&n.nodeName(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}}}}),oc={set:function(a,b,c){return b===!1?n.removeAttr(a,c):sc&&rc||!qc.test(c)?a.setAttribute(!rc&&n.propFix[c]||c,c):a[n.camelCase("default-"+c)]=a[c]=!0,c}},n.each(n.expr.match.bool.source.match(/\w+/g),function(a,b){var c=pc[b]||n.find.attr;pc[b]=sc&&rc||!qc.test(b)?function(a,b,d){var e,f;return d||(f=pc[b],pc[b]=e,e=null!=c(a,b,d)?b.toLowerCase():null,pc[b]=f),e}:function(a,b,c){return c?void 0:a[n.camelCase("default-"+b)]?b.toLowerCase():null}}),sc&&rc||(n.attrHooks.value={set:function(a,b,c){return n.nodeName(a,"input")?void(a.defaultValue=b):nc&&nc.set(a,b,c)}}),rc||(nc={set:function(a,b,c){var d=a.getAttributeNode(c);return d||a.setAttributeNode(d=a.ownerDocument.createAttribute(c)),d.value=b+="","value"===c||b===a.getAttribute(c)?b:void 0}},pc.id=pc.name=pc.coords=function(a,b,c){var d;return c?void 0:(d=a.getAttributeNode(b))&&""!==d.value?d.value:null},n.valHooks.button={get:function(a,b){var c=a.getAttributeNode(b);return c&&c.specified?c.value:void 0},set:nc.set},n.attrHooks.contenteditable={set:function(a,b,c){nc.set(a,""===b?!1:b,c)}},n.each(["width","height"],function(a,b){n.attrHooks[b]={set:function(a,c){return""===c?(a.setAttribute(b,"auto"),c):void 0}}})),l.style||(n.attrHooks.style={get:function(a){return a.style.cssText||void 0},set:function(a,b){return a.style.cssText=b+""}});var tc=/^(?:input|select|textarea|button|object)$/i,uc=/^(?:a|area)$/i;n.fn.extend({prop:function(a,b){return W(this,n.prop,a,b,arguments.length>1)},removeProp:function(a){return a=n.propFix[a]||a,this.each(function(){try{this[a]=void 0,delete this[a]}catch(b){}})}}),n.extend({propFix:{"for":"htmlFor","class":"className"},prop:function(a,b,c){var d,e,f,g=a.nodeType;if(a&&3!==g&&8!==g&&2!==g)return f=1!==g||!n.isXMLDoc(a),f&&(b=n.propFix[b]||b,e=n.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){var b=n.find.attr(a,"tabindex");return b?parseInt(b,10):tc.test(a.nodeName)||uc.test(a.nodeName)&&a.href?0:-1}}}}),l.hrefNormalized||n.each(["href","src"],function(a,b){n.propHooks[b]={get:function(a){return a.getAttribute(b,4)}}}),l.optSelected||(n.propHooks.selected={get:function(a){var b=a.parentNode;return b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex),null}}),n.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){n.propFix[this.toLowerCase()]=this}),l.enctype||(n.propFix.enctype="encoding");var vc=/[\t\r\n\f]/g;n.fn.extend({addClass:function(a){var b,c,d,e,f,g,h=0,i=this.length,j="string"==typeof a&&a;if(n.isFunction(a))return this.each(function(b){n(this).addClass(a.call(this,b,this.className))});if(j)for(b=(a||"").match(F)||[];i>h;h++)if(c=this[h],d=1===c.nodeType&&(c.className?(" "+c.className+" ").replace(vc," "):" ")){f=0;while(e=b[f++])d.indexOf(" "+e+" ")<0&&(d+=e+" ");g=n.trim(d),c.className!==g&&(c.className=g)}return this},removeClass:function(a){var b,c,d,e,f,g,h=0,i=this.length,j=0===arguments.length||"string"==typeof a&&a;if(n.isFunction(a))return this.each(function(b){n(this).removeClass(a.call(this,b,this.className))});if(j)for(b=(a||"").match(F)||[];i>h;h++)if(c=this[h],d=1===c.nodeType&&(c.className?(" "+c.className+" ").replace(vc," "):"")){f=0;while(e=b[f++])while(d.indexOf(" "+e+" ")>=0)d=d.replace(" "+e+" "," ");g=a?n.trim(d):"",c.className!==g&&(c.className=g)}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):this.each(n.isFunction(a)?function(c){n(this).toggleClass(a.call(this,c,this.className,b),b)}:function(){if("string"===c){var b,d=0,e=n(this),f=a.match(F)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else(c===L||"boolean"===c)&&(this.className&&n._data(this,"__className__",this.className),this.className=this.className||a===!1?"":n._data(this,"__className__")||"")})},hasClass:function(a){for(var b=" "+a+" ",c=0,d=this.length;d>c;c++)if(1===this[c].nodeType&&(" "+this[c].className+" ").replace(vc," ").indexOf(b)>=0)return!0;return!1}}),n.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){n.fn[b]=function(a,c){return arguments.length>0?this.on(b,null,a,c):this.trigger(b)}}),n.fn.extend({hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return 1===arguments.length?this.off(a,"**"):this.off(b,a||"**",c)}});var wc=n.now(),xc=/\?/,yc=/(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g;n.parseJSON=function(b){if(a.JSON&&a.JSON.parse)return a.JSON.parse(b+"");var c,d=null,e=n.trim(b+"");return e&&!n.trim(e.replace(yc,function(a,b,e,f){return c&&b&&(d=0),0===d?a:(c=e||b,d+=!f-!e,"")}))?Function("return "+e)():n.error("Invalid JSON: "+b)},n.parseXML=function(b){var c,d;if(!b||"string"!=typeof b)return null;try{a.DOMParser?(d=new DOMParser,c=d.parseFromString(b,"text/xml")):(c=new ActiveXObject("Microsoft.XMLDOM"),c.async="false",c.loadXML(b))}catch(e){c=void 0}return c&&c.documentElement&&!c.getElementsByTagName("parsererror").length||n.error("Invalid XML: "+b),c};var zc,Ac,Bc=/#.*$/,Cc=/([?&])_=[^&]*/,Dc=/^(.*?):[ \t]*([^\r\n]*)\r?$/gm,Ec=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Fc=/^(?:GET|HEAD)$/,Gc=/^\/\//,Hc=/^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,Ic={},Jc={},Kc="*/".concat("*");try{Ac=location.href}catch(Lc){Ac=z.createElement("a"),Ac.href="",Ac=Ac.href}zc=Hc.exec(Ac.toLowerCase())||[];function Mc(a){return function(b,c){"string"!=typeof b&&(c=b,b="*");var d,e=0,f=b.toLowerCase().match(F)||[];if(n.isFunction(c))while(d=f[e++])"+"===d.charAt(0)?(d=d.slice(1)||"*",(a[d]=a[d]||[]).unshift(c)):(a[d]=a[d]||[]).push(c)}}function Nc(a,b,c,d){var e={},f=a===Jc;function g(h){var i;return e[h]=!0,n.each(a[h]||[],function(a,h){var j=h(b,c,d);return"string"!=typeof j||f||e[j]?f?!(i=j):void 0:(b.dataTypes.unshift(j),g(j),!1)}),i}return g(b.dataTypes[0])||!e["*"]&&g("*")}function Oc(a,b){var c,d,e=n.ajaxSettings.flatOptions||{};for(d in b)void 0!==b[d]&&((e[d]?a:c||(c={}))[d]=b[d]);return c&&n.extend(!0,a,c),a}function Pc(a,b,c){var d,e,f,g,h=a.contents,i=a.dataTypes;while("*"===i[0])i.shift(),void 0===e&&(e=a.mimeType||b.getResponseHeader("Content-Type"));if(e)for(g in h)if(h[g]&&h[g].test(e)){i.unshift(g);break}if(i[0]in c)f=i[0];else{for(g in c){if(!i[0]||a.converters[g+" "+i[0]]){f=g;break}d||(d=g)}f=f||d}return f?(f!==i[0]&&i.unshift(f),c[f]):void 0}function Qc(a,b,c,d){var e,f,g,h,i,j={},k=a.dataTypes.slice();if(k[1])for(g in a.converters)j[g.toLowerCase()]=a.converters[g];f=k.shift();while(f)if(a.responseFields[f]&&(c[a.responseFields[f]]=b),!i&&d&&a.dataFilter&&(b=a.dataFilter(b,a.dataType)),i=f,f=k.shift())if("*"===f)f=i;else if("*"!==i&&i!==f){if(g=j[i+" "+f]||j["* "+f],!g)for(e in j)if(h=e.split(" "),h[1]===f&&(g=j[i+" "+h[0]]||j["* "+h[0]])){g===!0?g=j[e]:j[e]!==!0&&(f=h[0],k.unshift(h[1]));break}if(g!==!0)if(g&&a["throws"])b=g(b);else try{b=g(b)}catch(l){return{state:"parsererror",error:g?l:"No conversion from "+i+" to "+f}}}return{state:"success",data:b}}n.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Ac,type:"GET",isLocal:Ec.test(zc[1]),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Kc,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":n.parseJSON,"text xml":n.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(a,b){return b?Oc(Oc(a,n.ajaxSettings),b):Oc(n.ajaxSettings,a)},ajaxPrefilter:Mc(Ic),ajaxTransport:Mc(Jc),ajax:function(a,b){"object"==typeof a&&(b=a,a=void 0),b=b||{};var c,d,e,f,g,h,i,j,k=n.ajaxSetup({},b),l=k.context||k,m=k.context&&(l.nodeType||l.jquery)?n(l):n.event,o=n.Deferred(),p=n.Callbacks("once memory"),q=k.statusCode||{},r={},s={},t=0,u="canceled",v={readyState:0,getResponseHeader:function(a){var b;if(2===t){if(!j){j={};while(b=Dc.exec(f))j[b[1].toLowerCase()]=b[2]}b=j[a.toLowerCase()]}return null==b?null:b},getAllResponseHeaders:function(){return 2===t?f:null},setRequestHeader:function(a,b){var c=a.toLowerCase();return t||(a=s[c]=s[c]||a,r[a]=b),this},overrideMimeType:function(a){return t||(k.mimeType=a),this},statusCode:function(a){var b;if(a)if(2>t)for(b in a)q[b]=[q[b],a[b]];else v.always(a[v.status]);return this},abort:function(a){var b=a||u;return i&&i.abort(b),x(0,b),this}};if(o.promise(v).complete=p.add,v.success=v.done,v.error=v.fail,k.url=((a||k.url||Ac)+"").replace(Bc,"").replace(Gc,zc[1]+"//"),k.type=b.method||b.type||k.method||k.type,k.dataTypes=n.trim(k.dataType||"*").toLowerCase().match(F)||[""],null==k.crossDomain&&(c=Hc.exec(k.url.toLowerCase()),k.crossDomain=!(!c||c[1]===zc[1]&&c[2]===zc[2]&&(c[3]||("http:"===c[1]?"80":"443"))===(zc[3]||("http:"===zc[1]?"80":"443")))),k.data&&k.processData&&"string"!=typeof k.data&&(k.data=n.param(k.data,k.traditional)),Nc(Ic,k,b,v),2===t)return v;h=k.global,h&&0===n.active++&&n.event.trigger("ajaxStart"),k.type=k.type.toUpperCase(),k.hasContent=!Fc.test(k.type),e=k.url,k.hasContent||(k.data&&(e=k.url+=(xc.test(e)?"&":"?")+k.data,delete k.data),k.cache===!1&&(k.url=Cc.test(e)?e.replace(Cc,"$1_="+wc++):e+(xc.test(e)?"&":"?")+"_="+wc++)),k.ifModified&&(n.lastModified[e]&&v.setRequestHeader("If-Modified-Since",n.lastModified[e]),n.etag[e]&&v.setRequestHeader("If-None-Match",n.etag[e])),(k.data&&k.hasContent&&k.contentType!==!1||b.contentType)&&v.setRequestHeader("Content-Type",k.contentType),v.setRequestHeader("Accept",k.dataTypes[0]&&k.accepts[k.dataTypes[0]]?k.accepts[k.dataTypes[0]]+("*"!==k.dataTypes[0]?", "+Kc+"; q=0.01":""):k.accepts["*"]);for(d in k.headers)v.setRequestHeader(d,k.headers[d]);if(k.beforeSend&&(k.beforeSend.call(l,v,k)===!1||2===t))return v.abort();u="abort";for(d in{success:1,error:1,complete:1})v[d](k[d]);if(i=Nc(Jc,k,b,v)){v.readyState=1,h&&m.trigger("ajaxSend",[v,k]),k.async&&k.timeout>0&&(g=setTimeout(function(){v.abort("timeout")},k.timeout));try{t=1,i.send(r,x)}catch(w){if(!(2>t))throw w;x(-1,w)}}else x(-1,"No Transport");function x(a,b,c,d){var j,r,s,u,w,x=b;2!==t&&(t=2,g&&clearTimeout(g),i=void 0,f=d||"",v.readyState=a>0?4:0,j=a>=200&&300>a||304===a,c&&(u=Pc(k,v,c)),u=Qc(k,u,v,j),j?(k.ifModified&&(w=v.getResponseHeader("Last-Modified"),w&&(n.lastModified[e]=w),w=v.getResponseHeader("etag"),w&&(n.etag[e]=w)),204===a||"HEAD"===k.type?x="nocontent":304===a?x="notmodified":(x=u.state,r=u.data,s=u.error,j=!s)):(s=x,(a||!x)&&(x="error",0>a&&(a=0))),v.status=a,v.statusText=(b||x)+"",j?o.resolveWith(l,[r,x,v]):o.rejectWith(l,[v,x,s]),v.statusCode(q),q=void 0,h&&m.trigger(j?"ajaxSuccess":"ajaxError",[v,k,j?r:s]),p.fireWith(l,[v,x]),h&&(m.trigger("ajaxComplete",[v,k]),--n.active||n.event.trigger("ajaxStop")))}return v},getJSON:function(a,b,c){return n.get(a,b,c,"json")},getScript:function(a,b){return n.get(a,void 0,b,"script")}}),n.each(["get","post"],function(a,b){n[b]=function(a,c,d,e){return n.isFunction(c)&&(e=e||d,d=c,c=void 0),n.ajax({url:a,type:b,dataType:e,data:c,success:d})}}),n.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){n.fn[b]=function(a){return this.on(b,a)}}),n._evalUrl=function(a){return n.ajax({url:a,type:"GET",dataType:"script",async:!1,global:!1,"throws":!0})},n.fn.extend({wrapAll:function(a){if(n.isFunction(a))return this.each(function(b){n(this).wrapAll(a.call(this,b))});if(this[0]){var b=n(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&1===a.firstChild.nodeType)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){return this.each(n.isFunction(a)?function(b){n(this).wrapInner(a.call(this,b))}:function(){var b=n(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=n.isFunction(a);return this.each(function(c){n(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){n.nodeName(this,"body")||n(this).replaceWith(this.childNodes)}).end()}}),n.expr.filters.hidden=function(a){return a.offsetWidth<=0&&a.offsetHeight<=0||!l.reliableHiddenOffsets()&&"none"===(a.style&&a.style.display||n.css(a,"display"))},n.expr.filters.visible=function(a){return!n.expr.filters.hidden(a)};var Rc=/%20/g,Sc=/\[\]$/,Tc=/\r?\n/g,Uc=/^(?:submit|button|image|reset|file)$/i,Vc=/^(?:input|select|textarea|keygen)/i;function Wc(a,b,c,d){var e;if(n.isArray(b))n.each(b,function(b,e){c||Sc.test(a)?d(a,e):Wc(a+"["+("object"==typeof e?b:"")+"]",e,c,d)});else if(c||"object"!==n.type(b))d(a,b);else for(e in b)Wc(a+"["+e+"]",b[e],c,d)}n.param=function(a,b){var c,d=[],e=function(a,b){b=n.isFunction(b)?b():null==b?"":b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};if(void 0===b&&(b=n.ajaxSettings&&n.ajaxSettings.traditional),n.isArray(a)||a.jquery&&!n.isPlainObject(a))n.each(a,function(){e(this.name,this.value)});else for(c in a)Wc(c,a[c],b,e);return d.join("&").replace(Rc,"+")},n.fn.extend({serialize:function(){return n.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var a=n.prop(this,"elements");return a?n.makeArray(a):this}).filter(function(){var a=this.type;return this.name&&!n(this).is(":disabled")&&Vc.test(this.nodeName)&&!Uc.test(a)&&(this.checked||!X.test(a))}).map(function(a,b){var c=n(this).val();return null==c?null:n.isArray(c)?n.map(c,function(a){return{name:b.name,value:a.replace(Tc,"\r\n")}}):{name:b.name,value:c.replace(Tc,"\r\n")}}).get()}}),n.ajaxSettings.xhr=void 0!==a.ActiveXObject?function(){return!this.isLocal&&/^(get|post|head|put|delete|options)$/i.test(this.type)&&$c()||_c()}:$c;var Xc=0,Yc={},Zc=n.ajaxSettings.xhr();a.ActiveXObject&&n(a).on("unload",function(){for(var a in Yc)Yc[a](void 0,!0)}),l.cors=!!Zc&&"withCredentials"in Zc,Zc=l.ajax=!!Zc,Zc&&n.ajaxTransport(function(a){if(!a.crossDomain||l.cors){var b;return{send:function(c,d){var e,f=a.xhr(),g=++Xc;if(f.open(a.type,a.url,a.async,a.username,a.password),a.xhrFields)for(e in a.xhrFields)f[e]=a.xhrFields[e];a.mimeType&&f.overrideMimeType&&f.overrideMimeType(a.mimeType),a.crossDomain||c["X-Requested-With"]||(c["X-Requested-With"]="XMLHttpRequest");for(e in c)void 0!==c[e]&&f.setRequestHeader(e,c[e]+"");f.send(a.hasContent&&a.data||null),b=function(c,e){var h,i,j;if(b&&(e||4===f.readyState))if(delete Yc[g],b=void 0,f.onreadystatechange=n.noop,e)4!==f.readyState&&f.abort();else{j={},h=f.status,"string"==typeof f.responseText&&(j.text=f.responseText);try{i=f.statusText}catch(k){i=""}h||!a.isLocal||a.crossDomain?1223===h&&(h=204):h=j.text?200:404}j&&d(h,i,j,f.getAllResponseHeaders())},a.async?4===f.readyState?setTimeout(b):f.onreadystatechange=Yc[g]=b:b()},abort:function(){b&&b(void 0,!0)}}}});function $c(){try{return new a.XMLHttpRequest}catch(b){}}function _c(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}n.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/(?:java|ecma)script/},converters:{"text script":function(a){return n.globalEval(a),a}}}),n.ajaxPrefilter("script",function(a){void 0===a.cache&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),n.ajaxTransport("script",function(a){if(a.crossDomain){var b,c=z.head||n("head")[0]||z.documentElement;return{send:function(d,e){b=z.createElement("script"),b.async=!0,a.scriptCharset&&(b.charset=a.scriptCharset),b.src=a.url,b.onload=b.onreadystatechange=function(a,c){(c||!b.readyState||/loaded|complete/.test(b.readyState))&&(b.onload=b.onreadystatechange=null,b.parentNode&&b.parentNode.removeChild(b),b=null,c||e(200,"success"))},c.insertBefore(b,c.firstChild)},abort:function(){b&&b.onload(void 0,!0)}}}});var ad=[],bd=/(=)\?(?=&|$)|\?\?/;n.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=ad.pop()||n.expando+"_"+wc++;return this[a]=!0,a}}),n.ajaxPrefilter("json jsonp",function(b,c,d){var e,f,g,h=b.jsonp!==!1&&(bd.test(b.url)?"url":"string"==typeof b.data&&!(b.contentType||"").indexOf("application/x-www-form-urlencoded")&&bd.test(b.data)&&"data");return h||"jsonp"===b.dataTypes[0]?(e=b.jsonpCallback=n.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,h?b[h]=b[h].replace(bd,"$1"+e):b.jsonp!==!1&&(b.url+=(xc.test(b.url)?"&":"?")+b.jsonp+"="+e),b.converters["script json"]=function(){return g||n.error(e+" was not called"),g[0]},b.dataTypes[0]="json",f=a[e],a[e]=function(){g=arguments},d.always(function(){a[e]=f,b[e]&&(b.jsonpCallback=c.jsonpCallback,ad.push(e)),g&&n.isFunction(f)&&f(g[0]),g=f=void 0}),"script"):void 0}),n.parseHTML=function(a,b,c){if(!a||"string"!=typeof a)return null;"boolean"==typeof b&&(c=b,b=!1),b=b||z;var d=v.exec(a),e=!c&&[];return d?[b.createElement(d[1])]:(d=n.buildFragment([a],b,e),e&&e.length&&n(e).remove(),n.merge([],d.childNodes))};var cd=n.fn.load;n.fn.load=function(a,b,c){if("string"!=typeof a&&cd)return cd.apply(this,arguments);var d,e,f,g=this,h=a.indexOf(" ");return h>=0&&(d=a.slice(h,a.length),a=a.slice(0,h)),n.isFunction(b)?(c=b,b=void 0):b&&"object"==typeof b&&(f="POST"),g.length>0&&n.ajax({url:a,type:f,dataType:"html",data:b}).done(function(a){e=arguments,g.html(d?n("<div>").append(n.parseHTML(a)).find(d):a)}).complete(c&&function(a,b){g.each(c,e||[a.responseText,b,a])}),this},n.expr.filters.animated=function(a){return n.grep(n.timers,function(b){return a===b.elem}).length};var dd=a.document.documentElement;function ed(a){return n.isWindow(a)?a:9===a.nodeType?a.defaultView||a.parentWindow:!1}n.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=n.css(a,"position"),l=n(a),m={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=n.css(a,"top"),i=n.css(a,"left"),j=("absolute"===k||"fixed"===k)&&n.inArray("auto",[f,i])>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),n.isFunction(b)&&(b=b.call(a,c,h)),null!=b.top&&(m.top=b.top-h.top+g),null!=b.left&&(m.left=b.left-h.left+e),"using"in b?b.using.call(a,m):l.css(m)}},n.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){n.offset.setOffset(this,a,b)});var b,c,d={top:0,left:0},e=this[0],f=e&&e.ownerDocument;if(f)return b=f.documentElement,n.contains(b,e)?(typeof e.getBoundingClientRect!==L&&(d=e.getBoundingClientRect()),c=ed(f),{top:d.top+(c.pageYOffset||b.scrollTop)-(b.clientTop||0),left:d.left+(c.pageXOffset||b.scrollLeft)-(b.clientLeft||0)}):d},position:function(){if(this[0]){var a,b,c={top:0,left:0},d=this[0];return"fixed"===n.css(d,"position")?b=d.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),n.nodeName(a[0],"html")||(c=a.offset()),c.top+=n.css(a[0],"borderTopWidth",!0),c.left+=n.css(a[0],"borderLeftWidth",!0)),{top:b.top-c.top-n.css(d,"marginTop",!0),left:b.left-c.left-n.css(d,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||dd;while(a&&!n.nodeName(a,"html")&&"static"===n.css(a,"position"))a=a.offsetParent;return a||dd})}}),n.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c=/Y/.test(b);n.fn[a]=function(d){return W(this,function(a,d,e){var f=ed(a);return void 0===e?f?b in f?f[b]:f.document.documentElement[d]:a[d]:void(f?f.scrollTo(c?n(f).scrollLeft():e,c?e:n(f).scrollTop()):a[d]=e)},a,d,arguments.length,null)}}),n.each(["top","left"],function(a,b){n.cssHooks[b]=Mb(l.pixelPosition,function(a,c){return c?(c=Kb(a,b),Ib.test(c)?n(a).position()[b]+"px":c):void 0})}),n.each({Height:"height",Width:"width"},function(a,b){n.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){n.fn[d]=function(d,e){var f=arguments.length&&(c||"boolean"!=typeof d),g=c||(d===!0||e===!0?"margin":"border");return W(this,function(b,c,d){var e;return n.isWindow(b)?b.document.documentElement["client"+a]:9===b.nodeType?(e=b.documentElement,Math.max(b.body["scroll"+a],e["scroll"+a],b.body["offset"+a],e["offset"+a],e["client"+a])):void 0===d?n.css(b,c,g):n.style(b,c,d,g)},b,f?d:void 0,f,null)}})}),n.fn.size=function(){return this.length},n.fn.andSelf=n.fn.addBack,"function"==typeof define&&define.amd&&define("jquery",[],function(){return n});var fd=a.jQuery,gd=a.$;return n.noConflict=function(b){return a.$===n&&(a.$=gd),b&&a.jQuery===n&&(a.jQuery=fd),n},typeof b===L&&(a.jQuery=a.$=n),n});
diff --git a/doc/api/js/page_effects.js b/doc/api/js/page_effects.js
deleted file mode 100644
index fdacbf8..0000000
--- a/doc/api/js/page_effects.js
+++ /dev/null
@@ -1,112 +0,0 @@
-function visibleInParent(element) {
-    var position = $(element).position().top
-    return position > -50 && position < ($(element).offsetParent().height() - 50)
-}
-
-function hasFragment(link, fragment) {
-    return $(link).attr("href").indexOf("#" + fragment) != -1
-}
-
-function findLinkByFragment(elements, fragment) {
-    return $(elements).filter(function(i, e) { return hasFragment(e, fragment)}).first()
-}
-
-function scrollToCurrentVarLink(elements) {
-    var elements = $(elements);
-    var parent   = elements.offsetParent();
-
-    if (elements.length == 0) return;
-
-    var top    = elements.first().position().top;
-    var bottom = elements.last().position().top + elements.last().height();
-
-    if (top >= 0 && bottom <= parent.height()) return;
-
-    if (top < 0) {
-        parent.scrollTop(parent.scrollTop() + top);
-    }
-    else if (bottom > parent.height()) {
-        parent.scrollTop(parent.scrollTop() + bottom - parent.height());
-    }
-}
-
-function setCurrentVarLink() {
-    $('.secondary a').parent().removeClass('current')
-    $('.anchor').
-        filter(function(index) { return visibleInParent(this) }).
-        each(function(index, element) {
-            findLinkByFragment(".secondary a", element.id).
-                parent().
-                addClass('current')
-        });
-    scrollToCurrentVarLink('.secondary .current');
-}
-
-var hasStorage = (function() { try { return localStorage.getItem } catch(e) {} }())
-
-function scrollPositionId(element) {
-    var directory = window.location.href.replace(/[^\/]+\.html$/, '')
-    return 'scroll::' + $(element).attr('id') + '::' + directory
-}
-
-function storeScrollPosition(element) {
-    if (!hasStorage) return;
-    localStorage.setItem(scrollPositionId(element) + "::x", $(element).scrollLeft())
-    localStorage.setItem(scrollPositionId(element) + "::y", $(element).scrollTop())
-}
-
-function recallScrollPosition(element) {
-    if (!hasStorage) return;
-    $(element).scrollLeft(localStorage.getItem(scrollPositionId(element) + "::x"))
-    $(element).scrollTop(localStorage.getItem(scrollPositionId(element) + "::y"))
-}
-
-function persistScrollPosition(element) {
-    recallScrollPosition(element)
-    $(element).scroll(function() { storeScrollPosition(element) })
-}
-
-function sidebarContentWidth(element) {
-    var widths = $(element).find('.inner').map(function() { return $(this).innerWidth() })
-    return Math.max.apply(Math, widths)
-}
-
-function calculateSize(width, snap, margin, minimum) {
-    if (width == 0) {
-        return 0
-    }
-    else {
-        return Math.max(minimum, (Math.ceil(width / snap) * snap) + (margin * 2))
-    }
-}
-
-function resizeSidebars() {
-    var primaryWidth   = sidebarContentWidth('.primary')
-    var secondaryWidth = 0
-
-    if ($('.secondary').length != 0) {
-        secondaryWidth = sidebarContentWidth('.secondary')
-    }
-
-    // snap to grid
-    primaryWidth   = calculateSize(primaryWidth, 32, 13, 160)
-    secondaryWidth = calculateSize(secondaryWidth, 32, 13, 160)
-
-    $('.primary').css('width', primaryWidth)
-    $('.secondary').css('width', secondaryWidth).css('left', primaryWidth + 1)
-
-    if (secondaryWidth > 0) {
-        $('#content').css('left', primaryWidth + secondaryWidth + 2)
-    }
-    else {
-        $('#content').css('left', primaryWidth + 1)
-    }
-}
-
-$(window).ready(resizeSidebars)
-$(window).ready(setCurrentVarLink)
-$(window).ready(function() { persistScrollPosition('.primary')})
-$(window).ready(function() {
-    $('#content').scroll(setCurrentVarLink)
-    $(window).resize(setCurrentVarLink)
-})
diff --git a/doc/assets/enumerator-spine.svg b/doc/assets/enumerator-spine.svg
new file mode 100644
index 0000000..7deaa6b
--- /dev/null
+++ b/doc/assets/enumerator-spine.svg
@@ -0,0 +1,154 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 560" font-family="'SF Mono', 'Menlo', monospace" font-size="12">
+  <defs>
+    <marker id="a" markerWidth="8" markerHeight="6" refX="8" refY="3" orient="auto"><path d="M0,0 L8,3 L0,6" fill="#555"/></marker>
+    <marker id="ag" markerWidth="8" markerHeight="6" refX="8" refY="3" orient="auto"><path d="M0,0 L8,3 L0,6" fill="#27ae60"/></marker>
+    <marker id="ab" markerWidth="8" markerHeight="6" refX="8" refY="3" orient="auto"><path d="M0,0 L8,3 L0,6" fill="#2980b9"/></marker>
+  </defs>
+
+  <text x="400" y="24" text-anchor="middle" font-size="15" font-weight="bold" fill="#222" font-family="Georgia">Enumerator: Left-Spine Decomposition</text>
+  <text x="400" y="42" text-anchor="middle" font-size="11" fill="#888" font-family="Georgia">The fundamental traversal primitive — everything else is built on this</text>
+
+  <!-- The tree -->
+  <g transform="translate(100,60)">
+    <text x="120" y="0" text-anchor="middle" font-size="11" fill="#888" font-family="Georgia">Binary Tree</text>
+
+    <!-- Node 4 (root) -->
+    <rect x="95" y="15" width="50" height="28" rx="6" fill="#2c3e50"/>
+    <text x="120" y="34" text-anchor="middle" fill="white" font-weight="bold">4</text>
+
+    <!-- Node 2 -->
+    <rect x="35" y="75" width="50" height="28" rx="6" fill="#2c3e50"/>
+    <text x="60" y="94" text-anchor="middle" fill="white" font-weight="bold">2</text>
+
+    <!-- Node 6 -->
+    <rect x="155" y="75" width="50" height="28" rx="6" fill="#95a5a6"/>
+    <text x="180" y="94" text-anchor="middle" fill="white">6</text>
+
+    <!-- Node 1 -->
+    <rect x="5" y="135" width="50" height="28" rx="6" fill="#2c3e50"/>
+    <text x="30" y="154" text-anchor="middle" fill="white" font-weight="bold">1</text>
+
+    <!-- Node 3 -->
+    <rect x="65" y="135" width="50" height="28" rx="6" fill="#95a5a6"/>
+    <text x="90" y="154" text-anchor="middle" fill="white">3</text>
+
+    <!-- Node 5 -->
+    <rect x="125" y="135" width="50" height="28" rx="6" fill="#95a5a6"/>
+    <text x="150" y="154" text-anchor="middle" fill="white">5</text>
+
+    <!-- Node 7 -->
+    <rect x="185" y="135" width="50" height="28" rx="6" fill="#95a5a6"/>
+    <text x="210" y="154" text-anchor="middle" fill="white">7</text>
+
+    <!-- Edges -->
+    <line x1="110" y1="43" x2="70" y2="75" stroke="#555" stroke-width="1.5"/>
+    <line x1="130" y1="43" x2="170" y2="75" stroke="#555" stroke-width="1.5"/>
+    <line x1="50" y1="103" x2="35" y2="135" stroke="#555" stroke-width="1.5"/>
+    <line x1="70" y1="103" x2="85" y2="135" stroke="#555" stroke-width="1.5"/>
+    <line x1="170" y1="103" x2="155" y2="135" stroke="#555" stroke-width="1.5"/>
+    <line x1="190" y1="103" x2="205" y2="135" stroke="#555" stroke-width="1.5"/>
+
+    <!-- Left spine highlight -->
+    <path d="M120,30 L60,89 L30,149" stroke="#e74c3c" stroke-width="3" fill="none" stroke-dasharray="6,3"/>
+    <text x="-15" y="100" fill="#e74c3c" font-size="10" font-family="Georgia" font-style="italic">left spine</text>
+  </g>
+
+  <!-- Arrow from tree to enum chain -->
+  <line x1="330" y1="140" x2="380" y2="140" stroke="#27ae60" stroke-width="2" marker-end="url(#ag)"/>
+  <text x="355" y="132" text-anchor="middle" font-size="9" fill="#27ae60" font-family="Georgia">enumerate</text>
+
+  <!-- EnumFrame chain -->
+  <g transform="translate(400,70)">
+    <text x="170" y="0" text-anchor="middle" font-size="11" fill="#888" font-family="Georgia">EnumFrame Chain (the enumerator state)</text>
+
+    <!-- Frame 1 (current) -->
+    <rect x="0" y="20" width="100" height="60" rx="6" fill="#27ae60" stroke="#1e8c4c" stroke-width="2"/>
+    <text x="50" y="38" text-anchor="middle" fill="white" font-weight="bold" font-size="13">node: 1</text>
+    <text x="50" y="53" text-anchor="middle" fill="#d5f5e3" font-size="10">subtree: nil</text>
+    <text x="50" y="68" text-anchor="middle" fill="#d5f5e3" font-size="10">next: →</text>
+    <text x="50" y="95" text-anchor="middle" fill="#27ae60" font-size="10" font-weight="bold" font-family="Georgia">▲ current</text>
+
+    <!-- Arrow -->
+    <line x1="100" y1="50" x2="125" y2="50" stroke="#27ae60" stroke-width="2" marker-end="url(#ag)"/>
+
+    <!-- Frame 2 -->
+    <rect x="127" y="20" width="100" height="60" rx="6" fill="#2ecc71" opacity="0.8"/>
+    <text x="177" y="38" text-anchor="middle" fill="white" font-weight="bold" font-size="13">node: 2</text>
+    <text x="177" y="53" text-anchor="middle" fill="#d5f5e3" font-size="10">subtree: ⟨3⟩</text>
+    <text x="177" y="68" text-anchor="middle" fill="#d5f5e3" font-size="10">next: →</text>
+
+    <!-- Arrow -->
+    <line x1="227" y1="50" x2="252" y2="50" stroke="#27ae60" stroke-width="2" marker-end="url(#ag)"/>
+
+    <!-- Frame 4 -->
+    <rect x="254" y="20" width="100" height="60" rx="6" fill="#2ecc71" opacity="0.6"/>
+    <text x="304" y="38" text-anchor="middle" fill="white" font-weight="bold" font-size="13">node: 4</text>
+    <text x="304" y="53" text-anchor="middle" fill="#d5f5e3" font-size="10">subtree: ⟨6⟩</text>
+    <text x="304" y="68" text-anchor="middle" fill="#d5f5e3" font-size="10">next: nil</text>
+  </g>
+
+  <!-- Advance illustration -->
+  <g transform="translate(40,250)">
+    <text x="380" y="0" text-anchor="middle" font-size="13" font-weight="bold" fill="#222" font-family="Georgia">Advance: visit 1, then visit 2, then enumerate subtree ⟨3⟩</text>
+
+    <!-- Step 1 -->
+    <text x="80" y="30" text-anchor="middle" font-size="10" fill="#e74c3c" font-weight="bold">After visiting 1:</text>
+    <rect x="10" y="40" width="140" height="45" rx="5" fill="#f9f9f9" stroke="#ccc"/>
+    <text x="80" y="58" text-anchor="middle" font-size="10">subtree = nil → skip</text>
+    <text x="80" y="73" text-anchor="middle" font-size="10">advance to next frame →</text>
+
+    <!-- Step 2 -->
+    <text x="310" y="30" text-anchor="middle" font-size="10" fill="#e74c3c" font-weight="bold">After visiting 2:</text>
+    <rect x="200" y="40" width="220" height="45" rx="5" fill="#f9f9f9" stroke="#ccc"/>
+    <text x="310" y="58" text-anchor="middle" font-size="10">subtree = ⟨3⟩ → enumerate left spine</text>
+    <text x="310" y="73" text-anchor="middle" font-size="10">produces: [3 | nil | Frame(4,⟨6⟩)]</text>
+
+    <!-- Step 3 -->
+    <text x="580" y="30" text-anchor="middle" font-size="10" fill="#e74c3c" font-weight="bold">After visiting 3:</text>
+    <rect x="470" y="40" width="220" height="45" rx="5" fill="#f9f9f9" stroke="#ccc"/>
+    <text x="580" y="58" text-anchor="middle" font-size="10">subtree = nil → skip</text>
+    <text x="580" y="73" text-anchor="middle" font-size="10">advance to Frame(4,⟨6⟩) →  ...</text>
+
+    <!-- Result sequence -->
+    <text x="380" y="115" text-anchor="middle" font-size="11" fill="#555" font-family="Georgia">Produced sequence: 1, 2, 3, 4, 5, 6, 7</text>
+  </g>
+
+  <!-- What's built on enumerators -->
+  <g transform="translate(40,400)">
+    <rect x="0" y="0" width="720" height="140" rx="8" fill="#f0f7ff" stroke="#2980b9" stroke-width="1.5"/>
+    <text x="360" y="22" text-anchor="middle" font-size="13" font-weight="bold" fill="#2980b9" font-family="Georgia">Everything Built on Enumerators</text>
+
+    <!-- Reduction -->
+    <rect x="20" y="38" width="145" height="85" rx="5" fill="white" stroke="#2980b9"/>
+    <text x="92" y="55" text-anchor="middle" font-size="10" font-weight="bold" fill="#2c3e50">Reduction</text>
+    <text x="92" y="70" text-anchor="middle" font-size="9" fill="#555">node-reduce</text>
+    <text x="92" y="82" text-anchor="middle" font-size="9" fill="#555">node-reduce-keys</text>
+    <text x="92" y="94" text-anchor="middle" font-size="9" fill="#555">node-reduce-entries</text>
+    <text x="92" y="106" text-anchor="middle" font-size="9" fill="#555">node-reduce-kv</text>
+    <text x="92" y="118" text-anchor="middle" font-size="9" fill="#555">+ reverse variants</text>
+
+    <!-- Seq Types -->
+    <rect x="185" y="38" width="145" height="85" rx="5" fill="white" stroke="#2980b9"/>
+    <text x="257" y="55" text-anchor="middle" font-size="10" font-weight="bold" fill="#2c3e50">Seq Types</text>
+    <text x="257" y="70" text-anchor="middle" font-size="9" fill="#555">KeySeq / KeySeqReverse</text>
+    <text x="257" y="82" text-anchor="middle" font-size="9" fill="#555">EntrySeq / EntrySeqReverse</text>
+    <text x="257" y="94" text-anchor="middle" font-size="9" fill="#555">RopeSeq / RopeSeqReverse</text>
+    <text x="257" y="106" text-anchor="middle" font-size="9" fill="#555">node-seq / node-seq-reverse</text>
+
+    <!-- Fold -->
+    <rect x="350" y="38" width="145" height="85" rx="5" fill="white" stroke="#2980b9"/>
+    <text x="422" y="55" text-anchor="middle" font-size="10" font-weight="bold" fill="#2c3e50">Parallel Fold</text>
+    <text x="422" y="70" text-anchor="middle" font-size="9" fill="#555">node-chunks (split tree)</text>
+    <text x="422" y="82" text-anchor="middle" font-size="9" fill="#555">node-fold (fork-join)</text>
+    <text x="422" y="94" text-anchor="middle" font-size="9" fill="#555">r/fold on each chunk</text>
+    <text x="422" y="106" text-anchor="middle" font-size="9" fill="#555">via node-reduce per chunk</text>
+
+    <!-- Comparison -->
+    <rect x="515" y="38" width="185" height="85" rx="5" fill="white" stroke="#2980b9"/>
+    <text x="607" y="55" text-anchor="middle" font-size="10" font-weight="bold" fill="#2c3e50">Comparison &amp; Equality</text>
+    <text x="607" y="70" text-anchor="middle" font-size="9" fill="#555">node-compare (paired walk)</text>
+    <text x="607" y="82" text-anchor="middle" font-size="9" fill="#555">node-set-compare</text>
+    <text x="607" y="94" text-anchor="middle" font-size="9" fill="#555">node-map-compare</text>
+    <text x="607" y="106" text-anchor="middle" font-size="9" fill="#555">hasheq (ordered hash)</text>
+  </g>
+</svg>
diff --git a/doc/assets/reduction-stack.svg b/doc/assets/reduction-stack.svg
new file mode 100644
index 0000000..7e48b65
--- /dev/null
+++ b/doc/assets/reduction-stack.svg
@@ -0,0 +1,151 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 760 680" font-family="Georgia, serif" font-size="11">
+  <defs>
+    <marker id="ad" markerWidth="8" markerHeight="6" refX="8" refY="3" orient="auto"><path d="M0,0 L8,3 L0,6" fill="#555"/></marker>
+  </defs>
+
+  <text x="380" y="22" text-anchor="middle" font-size="15" font-weight="bold" fill="#222">How (reduce + 0 ordered-set) Actually Works</text>
+
+  <!-- The call -->
+  <rect x="200" y="42" width="360" height="28" rx="5" fill="#eafaf1" stroke="#27ae60" stroke-width="2"/>
+  <text x="380" y="61" text-anchor="middle" font-size="12" font-weight="bold" fill="#1e8c4c" font-family="monospace">(reduce + 0 (ordered-set [50 30 20 40 10]))</text>
+
+  <!-- Step 1: IReduceInit -->
+  <line x1="380" y1="70" x2="380" y2="90" stroke="#555" stroke-width="1.5" marker-end="url(#ad)"/>
+  <rect x="140" y="93" width="480" height="40" rx="5" fill="#f8f9fa" stroke="#bdc3c7"/>
+  <text x="380" y="110" text-anchor="middle" font-size="10" fill="#2c3e50">Clojure calls <tspan font-family="monospace">.reduce(IReduceInit)</tspan> on OrderedSet → delegates to <tspan font-family="monospace" font-weight="bold">node-reduce-keys</tspan></text>
+  <text x="380" y="125" text-anchor="middle" font-size="9" fill="#888">projection: -k (extract key from node) · direction: forward</text>
+
+  <!-- Step 2: make-unary-reducer -->
+  <line x1="380" y1="133" x2="380" y2="150" stroke="#555" stroke-width="1.5" marker-end="url(#ad)"/>
+  <rect x="100" y="153" width="560" height="55" rx="5" fill="#e74c3c" opacity="0.1" stroke="#e74c3c"/>
+  <text x="380" y="170" text-anchor="middle" font-size="10" font-weight="bold" fill="#c0392b">make-unary-reducer kernel (enum-reduce-init macro)</text>
+  <text x="380" y="186" text-anchor="middle" font-size="10" fill="#555" font-family="monospace">loop [e (node-enumerator root), acc 0]</text>
+  <text x="380" y="200" text-anchor="middle" font-size="9" fill="#888">at each step: acc = (+ acc (-k (node-enum-first e))), then e = (node-enum-rest e)</text>
+
+  <!-- Step 3: The actual execution trace -->
+  <line x1="380" y1="208" x2="380" y2="225" stroke="#555" stroke-width="1.5" marker-end="url(#ad)"/>
+
+  <!-- Tree on the left -->
+  <g transform="translate(40,235)">
+    <text x="75" y="0" text-anchor="middle" font-size="10" fill="#888" font-weight="bold">The tree</text>
+    <rect x="55" y="10" width="40" height="22" rx="4" fill="#2c3e50"/>
+    <text x="75" y="26" text-anchor="middle" fill="white" font-size="10">30</text>
+    <rect x="25" y="45" width="35" height="22" rx="4" fill="#2c3e50"/>
+    <text x="42" y="61" text-anchor="middle" fill="white" font-size="10">10</text>
+    <rect x="90" y="45" width="35" height="22" rx="4" fill="#2c3e50"/>
+    <text x="107" y="61" text-anchor="middle" fill="white" font-size="10">40</text>
+    <rect x="45" y="80" width="30" height="20" rx="3" fill="#95a5a6"/>
+    <text x="60" y="95" text-anchor="middle" fill="white" font-size="9">20</text>
+    <rect x="105" y="80" width="30" height="20" rx="3" fill="#95a5a6"/>
+    <text x="120" y="95" text-anchor="middle" fill="white" font-size="9">50</text>
+    <line x1="65" y1="32" x2="50" y2="45" stroke="#555" stroke-width="1"/>
+    <line x1="85" y1="32" x2="100" y2="45" stroke="#555" stroke-width="1"/>
+    <line x1="50" y1="67" x2="55" y2="80" stroke="#555" stroke-width="1"/>
+    <line x1="115" y1="67" x2="115" y2="80" stroke="#555" stroke-width="1"/>
+  </g>
+
+  <!-- Execution trace on the right -->
+  <g transform="translate(200,235)">
+    <text x="260" y="0" text-anchor="middle" font-size="10" fill="#888" font-weight="bold">Enumerator walk → accumulator</text>
+
+    <!-- Header -->
+    <rect x="50" y="10" width="55" height="18" rx="3" fill="#2c3e50"/>
+    <text x="77" y="23" text-anchor="middle" fill="white" font-size="9" font-weight="bold">step</text>
+    <rect x="110" y="10" width="175" height="18" rx="3" fill="#2c3e50"/>
+    <text x="197" y="23" text-anchor="middle" fill="white" font-size="9" font-weight="bold">EnumFrame chain</text>
+    <rect x="290" y="10" width="60" height="18" rx="3" fill="#2c3e50"/>
+    <text x="320" y="23" text-anchor="middle" fill="white" font-size="9" font-weight="bold">key</text>
+    <rect x="355" y="10" width="80" height="18" rx="3" fill="#2c3e50"/>
+    <text x="395" y="23" text-anchor="middle" fill="white" font-size="9" font-weight="bold">acc = (+ acc k)</text>
+    <rect x="440" y="10" width="60" height="18" rx="3" fill="#2c3e50"/>
+    <text x="470" y="23" text-anchor="middle" fill="white" font-size="9" font-weight="bold">result</text>
+
+    <!-- Row 0: initial -->
+    <text x="77" y="46" text-anchor="middle" font-size="9" fill="#555">init</text>
+    <text x="197" y="46" text-anchor="middle" font-size="9" fill="#555" font-family="monospace">[10|⟨20⟩] → [30|⟨40⟩] → nil</text>
+    <text x="320" y="46" text-anchor="middle" font-size="9" fill="#888">—</text>
+    <text x="395" y="46" text-anchor="middle" font-size="9" fill="#888">—</text>
+    <text x="470" y="46" text-anchor="middle" font-size="10" font-weight="bold" fill="#2c3e50">0</text>
+
+    <!-- Row 1 -->
+    <text x="77" y="66" text-anchor="middle" font-size="9" fill="#555">1</text>
+    <text x="197" y="66" text-anchor="middle" font-size="9" fill="#27ae60" font-family="monospace">[10|⟨20⟩] → [30|⟨40⟩]</text>
+    <text x="320" y="66" text-anchor="middle" font-size="10" font-weight="bold" fill="#e74c3c">10</text>
+    <text x="395" y="66" text-anchor="middle" font-size="9" fill="#555" font-family="monospace">(+ 0 10)</text>
+    <text x="470" y="66" text-anchor="middle" font-size="10" font-weight="bold" fill="#2c3e50">10</text>
+
+    <!-- Row 2 -->
+    <text x="77" y="86" text-anchor="middle" font-size="9" fill="#555">2</text>
+    <text x="197" y="86" text-anchor="middle" font-size="9" fill="#27ae60" font-family="monospace">[20|nil] → [30|⟨40⟩]</text>
+    <text x="320" y="86" text-anchor="middle" font-size="10" font-weight="bold" fill="#e74c3c">20</text>
+    <text x="395" y="86" text-anchor="middle" font-size="9" fill="#555" font-family="monospace">(+ 10 20)</text>
+    <text x="470" y="86" text-anchor="middle" font-size="10" font-weight="bold" fill="#2c3e50">30</text>
+
+    <!-- Row 3 -->
+    <text x="77" y="106" text-anchor="middle" font-size="9" fill="#555">3</text>
+    <text x="197" y="106" text-anchor="middle" font-size="9" fill="#27ae60" font-family="monospace">[30|⟨40⟩] → nil</text>
+    <text x="320" y="106" text-anchor="middle" font-size="10" font-weight="bold" fill="#e74c3c">30</text>
+    <text x="395" y="106" text-anchor="middle" font-size="9" fill="#555" font-family="monospace">(+ 30 30)</text>
+    <text x="470" y="106" text-anchor="middle" font-size="10" font-weight="bold" fill="#2c3e50">60</text>
+
+    <!-- Row 4 -->
+    <text x="77" y="126" text-anchor="middle" font-size="9" fill="#555">4</text>
+    <text x="197" y="126" text-anchor="middle" font-size="9" fill="#27ae60" font-family="monospace">[40|⟨50⟩] → nil</text>
+    <text x="320" y="126" text-anchor="middle" font-size="10" font-weight="bold" fill="#e74c3c">40</text>
+    <text x="395" y="126" text-anchor="middle" font-size="9" fill="#555" font-family="monospace">(+ 60 40)</text>
+    <text x="470" y="126" text-anchor="middle" font-size="10" font-weight="bold" fill="#2c3e50">100</text>
+
+    <!-- Row 5 -->
+    <text x="77" y="146" text-anchor="middle" font-size="9" fill="#555">5</text>
+    <text x="197" y="146" text-anchor="middle" font-size="9" fill="#27ae60" font-family="monospace">[50|nil] → nil</text>
+    <text x="320" y="146" text-anchor="middle" font-size="10" font-weight="bold" fill="#e74c3c">50</text>
+    <text x="395" y="146" text-anchor="middle" font-size="9" fill="#555" font-family="monospace">(+ 100 50)</text>
+    <text x="470" y="146" text-anchor="middle" font-size="10" font-weight="bold" fill="#27ae60">150</text>
+
+    <!-- Row 6: done -->
+    <text x="77" y="166" text-anchor="middle" font-size="9" fill="#555">done</text>
+    <text x="197" y="166" text-anchor="middle" font-size="9" fill="#888" font-family="monospace">nil</text>
+    <text x="470" y="166" text-anchor="middle" font-size="12" font-weight="bold" fill="#27ae60">→ 150</text>
+  </g>
+
+  <!-- Annotations -->
+  <g transform="translate(40,435)">
+    <rect x="0" y="0" width="680" height="100" rx="8" fill="#f0f7ff" stroke="#2980b9"/>
+    <text x="340" y="20" text-anchor="middle" font-size="11" font-weight="bold" fill="#2471a3">What makes this efficient</text>
+
+    <text x="20" y="42" font-size="10" fill="#555">• No lazy-seq allocation — the enumerator is a chain of 3-field deftype objects, not cons cells</text>
+    <text x="20" y="58" font-size="10" fill="#555">• No intermediate collections — the accumulator is updated in-place through the loop</text>
+    <text x="20" y="74" font-size="10" fill="#555">• <tspan font-family="monospace">reduced?</tspan> checked at every step — early termination is free</text>
+    <text x="20" y="90" font-size="10" fill="#555">• Same mechanism serves all projections: keys (-k), entries (MapEntry), nodes (identity), reverse</text>
+  </g>
+
+  <!-- The three alternative paths -->
+  <g transform="translate(40,550)">
+    <rect x="0" y="0" width="680" height="110" rx="8" fill="#f8f9fa" stroke="#bdc3c7"/>
+    <text x="340" y="18" text-anchor="middle" font-size="11" font-weight="bold" fill="#2c3e50">Same enumerator, different consumers</text>
+
+    <rect x="15" y="30" width="155" height="65" rx="5" fill="white" stroke="#3498db"/>
+    <text x="92" y="48" text-anchor="middle" font-size="10" font-weight="bold" fill="#2471a3">reduce</text>
+    <text x="92" y="63" text-anchor="middle" font-size="8" fill="#555">enum-reduce-init macro</text>
+    <text x="92" y="76" text-anchor="middle" font-size="8" fill="#555">projection: -k, identity,</text>
+    <text x="92" y="88" text-anchor="middle" font-size="8" fill="#555">or MapEntry</text>
+
+    <rect x="185" y="30" width="155" height="65" rx="5" fill="white" stroke="#8e44ad"/>
+    <text x="262" y="48" text-anchor="middle" font-size="10" font-weight="bold" fill="#6c3483">seq / rseq</text>
+    <text x="262" y="63" text-anchor="middle" font-size="8" fill="#555">KeySeq / EntrySeq deftypes</text>
+    <text x="262" y="76" text-anchor="middle" font-size="8" fill="#555">ISeq.first → project(enum-first)</text>
+    <text x="262" y="88" text-anchor="middle" font-size="8" fill="#555">ISeq.next → enum-rest</text>
+
+    <rect x="355" y="30" width="155" height="65" rx="5" fill="white" stroke="#27ae60"/>
+    <text x="432" y="48" text-anchor="middle" font-size="10" font-weight="bold" fill="#1e8c4c">fold</text>
+    <text x="432" y="63" text-anchor="middle" font-size="8" fill="#555">split tree → chunks</text>
+    <text x="432" y="76" text-anchor="middle" font-size="8" fill="#555">fork-join each chunk</text>
+    <text x="432" y="88" text-anchor="middle" font-size="8" fill="#555">via node-reduce per chunk</text>
+
+    <rect x="525" y="30" width="140" height="65" rx="5" fill="white" stroke="#e67e22"/>
+    <text x="595" y="48" text-anchor="middle" font-size="10" font-weight="bold" fill="#d35400">reduce-kv</text>
+    <text x="595" y="63" text-anchor="middle" font-size="8" fill="#555">direct recursive walk</text>
+    <text x="595" y="76" text-anchor="middle" font-size="8" fill="#555">(f acc k v) — no packing</text>
+    <text x="595" y="88" text-anchor="middle" font-size="8" fill="#555">separate for 3-arity perf</text>
+  </g>
+</svg>
diff --git a/doc/assets/rope-csi-boundary.svg b/doc/assets/rope-csi-boundary.svg
new file mode 100644
index 0000000..a4cfc53
--- /dev/null
+++ b/doc/assets/rope-csi-boundary.svg
@@ -0,0 +1,71 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="960" height="430" viewBox="0 0 960 430" role="img" aria-labelledby="title desc">
+  <title id="title">Chunk size invariant and boundary repair</title>
+  <desc id="desc">A rope concat boundary where an undersized internal chunk is repaired by merging and rechunking the boundary area.</desc>
+  <defs>
+    <style>
+      .bg { fill: #fbfcfe; }
+      .title { font: 700 28px Georgia, serif; fill: #102a43; }
+      .label { font: 600 18px Georgia, serif; fill: #243b53; }
+      .text { font: 15px Georgia, serif; fill: #486581; }
+      .small { font: 13px Georgia, serif; fill: #627d98; }
+      .ok { fill: #e3f9e5; stroke: #2f855a; stroke-width: 2; }
+      .runt { fill: #ffe3c2; stroke: #b36a00; stroke-width: 2; }
+      .bad { fill: #fde8e8; stroke: #c53030; stroke-width: 2; }
+      .fixed { fill: #d9f0ff; stroke: #1f6feb; stroke-width: 2; }
+      .arrow { stroke: #52606d; stroke-width: 3; marker-end: url(#arrow); }
+      .brace { fill: none; stroke: #7b8794; stroke-width: 2; }
+    </style>
+    <marker id="arrow" markerWidth="10" markerHeight="10" refX="8" refY="5" orient="auto">
+      <path d="M0,0 L10,5 L0,10 z" fill="#52606d"/>
+    </marker>
+  </defs>
+
+  <rect class="bg" x="0" y="0" width="960" height="430"/>
+  <text class="title" x="40" y="46">Chunk Size Invariant: only the rightmost chunk may be undersized</text>
+
+  <text class="label" x="40" y="92">Before concat</text>
+  <g transform="translate(40 112)">
+    <rect class="ok" rx="10" ry="10" width="150" height="54"/>
+    <rect class="runt" rx="10" ry="10" x="164" width="90" height="54"/>
+    <rect class="runt" rx="10" ry="10" x="388" width="80" height="54"/>
+    <rect class="ok" rx="10" ry="10" x="482" width="150" height="54"/>
+    <text class="text" x="75" y="33" text-anchor="middle">left chunk</text>
+    <text class="text" x="209" y="33" text-anchor="middle">left runt</text>
+    <text class="text" x="428" y="33" text-anchor="middle">right edge</text>
+    <text class="text" x="557" y="33" text-anchor="middle">right chunk</text>
+    <text class="small" x="209" y="74" text-anchor="middle">valid only because it is rightmost</text>
+    <text class="small" x="428" y="74" text-anchor="middle">becomes internal after concat</text>
+  </g>
+
+  <line class="arrow" x1="300" y1="180" x2="300" y2="226"/>
+  <text class="label" x="40" y="256">Naive concat would break CSI</text>
+
+  <g transform="translate(40 274)">
+    <rect class="ok" rx="10" ry="10" width="150" height="54"/>
+    <rect class="bad" rx="10" ry="10" x="164" width="90" height="54"/>
+    <rect class="bad" rx="10" ry="10" x="268" width="80" height="54"/>
+    <rect class="ok" rx="10" ry="10" x="362" width="150" height="54"/>
+    <text class="text" x="75" y="33" text-anchor="middle">left chunk</text>
+    <text class="text" x="209" y="33" text-anchor="middle">too small</text>
+    <text class="text" x="308" y="33" text-anchor="middle">too small</text>
+    <text class="text" x="437" y="33" text-anchor="middle">right chunk</text>
+  </g>
+
+  <path class="brace" d="M 214 336 C 214 356, 214 356, 234 356 S 254 376, 274 376 S 294 356, 314 356 S 334 356, 334 336"/>
+  <text class="small" x="274" y="398" text-anchor="middle">merge boundary region, then rechunk</text>
+
+  <line class="arrow" x1="624" y1="140" x2="792" y2="140"/>
+  <line class="arrow" x1="624" y1="300" x2="792" y2="300"/>
+
+  <text class="label" x="700" y="92">After boundary repair</text>
+  <g transform="translate(680 112)">
+    <rect class="fixed" rx="10" ry="10" width="120" height="54"/>
+    <rect class="fixed" rx="10" ry="10" x="134" width="120" height="54"/>
+    <text class="text" x="60" y="33" text-anchor="middle">rechunked</text>
+    <text class="text" x="194" y="33" text-anchor="middle">rechunked</text>
+    <text class="small" x="127" y="78" text-anchor="middle">both chunks back in the valid range</text>
+  </g>
+
+  <text class="small" x="680" y="234">This is why rope concat is not just raw tree append.</text>
+  <text class="small" x="680" y="256">The boundary must be repaired when a former runt moves inward.</text>
+</svg>
diff --git a/doc/assets/rope-splice-sharing.svg b/doc/assets/rope-splice-sharing.svg
new file mode 100644
index 0000000..19e5d43
--- /dev/null
+++ b/doc/assets/rope-splice-sharing.svg
@@ -0,0 +1,56 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="960" height="420" viewBox="0 0 960 420" role="img" aria-labelledby="title desc">
+  <title id="title">Rope splice with structural sharing</title>
+  <desc id="desc">Splicing replaces the middle range while reusing left and right structure.</desc>
+  <defs>
+    <style>
+      .bg { fill: #fcfbf7; }
+      .title { font: 700 28px Georgia, serif; fill: #1f2933; }
+      .label { font: 600 18px Georgia, serif; fill: #243b53; }
+      .text { font: 15px Georgia, serif; fill: #486581; }
+      .shared { fill: #d9f0ff; stroke: #1f6feb; stroke-width: 2; }
+      .removed { fill: #fde8e8; stroke: #c53030; stroke-width: 2; }
+      .inserted { fill: #e3f9e5; stroke: #2f855a; stroke-width: 2; }
+      .outline { fill: none; stroke: #7b8794; stroke-width: 2; stroke-dasharray: 7 5; }
+      .arrow { stroke: #52606d; stroke-width: 3; marker-end: url(#arrow); }
+    </style>
+    <marker id="arrow" markerWidth="10" markerHeight="10" refX="8" refY="5" orient="auto">
+      <path d="M0,0 L10,5 L0,10 z" fill="#52606d"/>
+    </marker>
+  </defs>
+
+  <rect class="bg" x="0" y="0" width="960" height="420"/>
+  <text class="title" x="40" y="48">Splice replaces one middle range and shares the rest</text>
+
+  <text class="label" x="40" y="95">Before</text>
+  <g transform="translate(40 112)">
+    <rect class="shared" rx="10" ry="10" width="190" height="56"/>
+    <rect class="removed" rx="10" ry="10" x="205" width="190" height="56"/>
+    <rect class="shared" rx="10" ry="10" x="410" width="190" height="56"/>
+    <text class="text" x="95" y="34" text-anchor="middle">shared left</text>
+    <text class="text" x="300" y="34" text-anchor="middle">remove [start,end)</text>
+    <text class="text" x="505" y="34" text-anchor="middle">shared right</text>
+  </g>
+
+  <line class="arrow" x1="320" y1="184" x2="320" y2="232"/>
+
+  <text class="label" x="640" y="95">Inserted content</text>
+  <g transform="translate(640 112)">
+    <rect class="inserted" rx="10" ry="10" width="220" height="56"/>
+    <text class="text" x="110" y="34" text-anchor="middle">new middle chunk(s)</text>
+  </g>
+
+  <text class="label" x="40" y="286">After</text>
+  <g transform="translate(40 302)">
+    <rect class="shared" rx="10" ry="10" width="190" height="56"/>
+    <rect class="inserted" rx="10" ry="10" x="205" width="220" height="56"/>
+    <rect class="shared" rx="10" ry="10" x="440" width="190" height="56"/>
+    <text class="text" x="95" y="34" text-anchor="middle">same left subtree</text>
+    <text class="text" x="315" y="34" text-anchor="middle">replacement</text>
+    <text class="text" x="535" y="34" text-anchor="middle">same right subtree</text>
+  </g>
+
+  <rect class="outline" x="34" y="106" width="572" height="68" rx="14" ry="14"/>
+  <rect class="outline" x="34" y="296" width="602" height="68" rx="14" ry="14"/>
+  <text class="text" x="718" y="320">Only the path near the edit is rebuilt.</text>
+  <text class="text" x="718" y="344">Large unchanged subtrees are shared.</text>
+</svg>
diff --git a/doc/assets/rope-split-concat.svg b/doc/assets/rope-split-concat.svg
new file mode 100644
index 0000000..fcc0bbb
--- /dev/null
+++ b/doc/assets/rope-split-concat.svg
@@ -0,0 +1,60 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="960" height="380" viewBox="0 0 960 380" role="img" aria-labelledby="title desc">
+  <title id="title">Rope split and concat</title>
+  <desc id="desc">A rope split at one point into two shared halves, then concatenated in reversed order.</desc>
+  <defs>
+    <style>
+      .bg { fill: #fbfcfe; }
+      .title { font: 700 28px Georgia, serif; fill: #102a43; }
+      .label { font: 600 18px Georgia, serif; fill: #243b53; }
+      .text { font: 15px Georgia, serif; fill: #486581; }
+      .chunk-a { fill: #d9f0ff; stroke: #1f6feb; stroke-width: 2; }
+      .chunk-b { fill: #ffe3c2; stroke: #b36a00; stroke-width: 2; }
+      .chunk-c { fill: #e3f9e5; stroke: #2f855a; stroke-width: 2; }
+      .arrow { stroke: #52606d; stroke-width: 3; marker-end: url(#arrow); }
+      .cut { stroke: #d64545; stroke-width: 4; stroke-dasharray: 8 6; }
+    </style>
+    <marker id="arrow" markerWidth="10" markerHeight="10" refX="8" refY="5" orient="auto">
+      <path d="M0,0 L10,5 L0,10 z" fill="#52606d"/>
+    </marker>
+  </defs>
+
+  <rect class="bg" x="0" y="0" width="960" height="380"/>
+  <text class="title" x="40" y="48">Split once, share both halves, concat structurally</text>
+
+  <text class="label" x="40" y="92">Original rope</text>
+  <g transform="translate(40 112)">
+    <rect class="chunk-a" rx="10" ry="10" width="160" height="52"/>
+    <rect class="chunk-a" rx="10" ry="10" x="170" width="160" height="52"/>
+    <rect class="chunk-b" rx="10" ry="10" x="340" width="160" height="52"/>
+    <rect class="chunk-b" rx="10" ry="10" x="510" width="160" height="52"/>
+    <rect class="chunk-c" rx="10" ry="10" x="680" width="160" height="52"/>
+    <text class="text" x="80" y="32" text-anchor="middle">[0 ... 19999]</text>
+    <text class="text" x="250" y="32" text-anchor="middle">[20000 ... 39999]</text>
+    <text class="text" x="420" y="32" text-anchor="middle">[40000 ... 59999]</text>
+    <text class="text" x="590" y="32" text-anchor="middle">[60000 ... 79999]</text>
+    <text class="text" x="760" y="32" text-anchor="middle">[80000 ... 99999]</text>
+    <line class="cut" x1="330" y1="-12" x2="330" y2="64"/>
+    <text class="label" x="330" y="-18" text-anchor="middle">split at 40000</text>
+  </g>
+
+  <line class="arrow" x1="330" y1="190" x2="220" y2="246"/>
+  <line class="arrow" x1="330" y1="190" x2="560" y2="246"/>
+
+  <text class="label" x="70" y="286">head</text>
+  <g transform="translate(40 300)">
+    <rect class="chunk-a" rx="10" ry="10" width="160" height="52"/>
+    <rect class="chunk-a" rx="10" ry="10" x="170" width="160" height="52"/>
+    <text class="text" x="80" y="32" text-anchor="middle">[0 ... 19999]</text>
+    <text class="text" x="250" y="32" text-anchor="middle">[20000 ... 39999]</text>
+  </g>
+
+  <text class="label" x="520" y="286">tail</text>
+  <g transform="translate(490 300)">
+    <rect class="chunk-b" rx="10" ry="10" width="160" height="52"/>
+    <rect class="chunk-b" rx="10" ry="10" x="170" width="160" height="52"/>
+    <rect class="chunk-c" rx="10" ry="10" x="340" width="160" height="52"/>
+    <text class="text" x="80" y="32" text-anchor="middle">[40000 ... 59999]</text>
+    <text class="text" x="250" y="32" text-anchor="middle">[60000 ... 79999]</text>
+    <text class="text" x="420" y="32" text-anchor="middle">[80000 ... 99999]</text>
+  </g>
+</svg>
diff --git a/doc/assets/rope-structure.svg b/doc/assets/rope-structure.svg
new file mode 100644
index 0000000..9c08ebe
--- /dev/null
+++ b/doc/assets/rope-structure.svg
@@ -0,0 +1,74 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="960" height="420" viewBox="0 0 960 420" role="img" aria-labelledby="title desc">
+  <title id="title">Chunked rope tree structure</title>
+  <desc id="desc">A balanced rope tree whose nodes store chunk vectors and subtree element counts.</desc>
+  <defs>
+    <style>
+      .bg { fill: #fcfbf7; }
+      .title { font: 700 28px Georgia, serif; fill: #1f2933; }
+      .label { font: 600 17px Georgia, serif; fill: #243b53; }
+      .text { font: 15px Georgia, serif; fill: #334e68; }
+      .small { font: 13px Georgia, serif; fill: #486581; }
+      .node { fill: #fff7e8; stroke: #7c5e10; stroke-width: 2; }
+      .chunk { fill: #e8f1f2; stroke: #20636d; stroke-width: 2; }
+      .accent { fill: #f0b429; }
+      .line { stroke: #52606d; stroke-width: 2.5; }
+    </style>
+  </defs>
+
+  <rect class="bg" x="0" y="0" width="960" height="420"/>
+
+  <text class="title" x="40" y="48">Rope = balanced tree of chunks</text>
+  <text class="text" x="40" y="78">Each node carries a chunk plus subtree element count. Navigation is by position, not key comparison.</text>
+
+  <line class="line" x1="480" y1="130" x2="300" y2="205"/>
+  <line class="line" x1="480" y1="130" x2="660" y2="205"/>
+  <line class="line" x1="300" y1="255" x2="190" y2="322"/>
+  <line class="line" x1="300" y1="255" x2="410" y2="322"/>
+  <line class="line" x1="660" y1="255" x2="550" y2="322"/>
+  <line class="line" x1="660" y1="255" x2="770" y2="322"/>
+
+  <g transform="translate(390 92)">
+    <rect class="node" rx="14" ry="14" width="180" height="74"/>
+    <text class="label" x="90" y="28" text-anchor="middle">root node</text>
+    <text class="text" x="90" y="50" text-anchor="middle">chunk = [4 5]</text>
+    <text class="small" x="90" y="66" text-anchor="middle">subtree-size = 12</text>
+  </g>
+
+  <g transform="translate(210 217)">
+    <rect class="node" rx="14" ry="14" width="180" height="74"/>
+    <text class="label" x="90" y="28" text-anchor="middle">left subtree</text>
+    <text class="text" x="90" y="50" text-anchor="middle">chunk = [2 3]</text>
+    <text class="small" x="90" y="66" text-anchor="middle">subtree-size = 6</text>
+  </g>
+
+  <g transform="translate(570 217)">
+    <rect class="node" rx="14" ry="14" width="180" height="74"/>
+    <text class="label" x="90" y="28" text-anchor="middle">right subtree</text>
+    <text class="text" x="90" y="50" text-anchor="middle">chunk = [8 9]</text>
+    <text class="small" x="90" y="66" text-anchor="middle">subtree-size = 4</text>
+  </g>
+
+  <g transform="translate(110 330)">
+    <rect class="chunk" rx="12" ry="12" width="160" height="48"/>
+    <text class="text" x="80" y="30" text-anchor="middle">[0 1]</text>
+  </g>
+
+  <g transform="translate(330 330)">
+    <rect class="chunk" rx="12" ry="12" width="160" height="48"/>
+    <text class="text" x="80" y="30" text-anchor="middle">[6 7]</text>
+  </g>
+
+  <g transform="translate(470 330)">
+    <rect class="chunk" rx="12" ry="12" width="160" height="48"/>
+    <text class="text" x="80" y="30" text-anchor="middle">[10 11]</text>
+  </g>
+
+  <g transform="translate(690 330)">
+    <rect class="chunk" rx="12" ry="12" width="160" height="48"/>
+    <text class="text" x="80" y="30" text-anchor="middle">[12 13]</text>
+  </g>
+
+  <circle class="accent" cx="914" cy="122" r="9"/>
+  <text class="small" x="894" y="154" text-anchor="end">index 0 walks left</text>
+  <text class="small" x="894" y="174" text-anchor="end">later positions walk right</text>
+</svg>
diff --git a/doc/assets/rotation-stitch.svg b/doc/assets/rotation-stitch.svg
new file mode 100644
index 0000000..dccd7af
--- /dev/null
+++ b/doc/assets/rotation-stitch.svg
@@ -0,0 +1,118 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 310" font-family="Georgia, serif" font-size="11">
+
+  <text x="400" y="22" text-anchor="middle" font-size="15" font-weight="bold" fill="#222">Rotations &amp; Stitch: The Balancing Constructor</text>
+  <text x="400" y="40" text-anchor="middle" font-size="10" fill="#888">node-stitch(k, v, l, r, create) — the ONLY place balance decisions happen</text>
+
+  <!-- Balance check -->
+  <g transform="translate(30,55)">
+    <rect x="0" y="0" width="740" height="40" rx="6" fill="#f8f9fa" stroke="#2c3e50"/>
+    <text x="370" y="16" text-anchor="middle" font-size="11" font-weight="bold" fill="#2c3e50">Weight check: delta=3, gamma=2</text>
+    <text x="370" y="32" text-anchor="middle" font-size="10" fill="#555" font-family="monospace">if rw > 3*lw → rotate left  |  if lw > 3*rw → rotate right  |  else → create(k,v,l,r)</text>
+  </g>
+
+  <!-- Single rotation -->
+  <g transform="translate(30,115)">
+    <rect x="0" y="0" width="360" height="175" rx="8" fill="#eaf2f8" stroke="#2980b9" stroke-width="1.5"/>
+    <text x="180" y="22" text-anchor="middle" font-size="13" font-weight="bold" fill="#2471a3">Single Right Rotation</text>
+    <text x="180" y="38" text-anchor="middle" font-size="9" fill="#888">outer subtree dominates</text>
+
+    <!-- Before -->
+    <text x="90" y="60" text-anchor="middle" font-size="10" fill="#555" font-weight="bold">Before</text>
+
+    <rect x="70" y="70" width="44" height="26" rx="5" fill="#e74c3c"/>
+    <text x="92" y="88" text-anchor="middle" fill="white" font-size="11" font-weight="bold">C</text>
+
+    <rect x="30" y="110" width="44" height="26" rx="5" fill="#2c3e50"/>
+    <text x="52" y="128" text-anchor="middle" fill="white" font-size="11" font-weight="bold">A</text>
+
+    <circle cx="126" cy="122" r="10" fill="#bdc3c7"/>
+    <circle cx="18" cy="152" r="8" fill="#bdc3c7"/>
+    <circle cx="66" cy="152" r="8" fill="#95a5a6"/>
+
+    <line x1="80" y1="96" x2="60" y2="110" stroke="#555" stroke-width="1.2"/>
+    <line x1="104" y1="96" x2="122" y2="112" stroke="#555" stroke-width="1.2"/>
+    <line x1="42" y1="136" x2="22" y2="144" stroke="#555" stroke-width="1.2"/>
+    <line x1="62" y1="136" x2="62" y2="144" stroke="#555" stroke-width="1.2"/>
+
+    <!-- Arrow -->
+    <text x="180" y="125" text-anchor="middle" font-size="26" fill="#2980b9">→</text>
+
+    <!-- After -->
+    <text x="285" y="60" text-anchor="middle" font-size="10" fill="#555" font-weight="bold">After</text>
+
+    <rect x="263" y="70" width="44" height="26" rx="5" fill="#2c3e50"/>
+    <text x="285" y="88" text-anchor="middle" fill="white" font-size="11" font-weight="bold">A</text>
+
+    <circle cx="242" cy="118" r="8" fill="#bdc3c7"/>
+
+    <rect x="296" y="106" width="44" height="26" rx="5" fill="#27ae60"/>
+    <text x="318" y="124" text-anchor="middle" fill="white" font-size="11" font-weight="bold">C</text>
+
+    <circle cx="300" cy="148" r="8" fill="#95a5a6"/>
+    <circle cx="340" cy="148" r="8" fill="#bdc3c7"/>
+
+    <line x1="275" y1="96" x2="246" y2="110" stroke="#555" stroke-width="1.2"/>
+    <line x1="295" y1="96" x2="310" y2="106" stroke="#555" stroke-width="1.2"/>
+    <line x1="308" y1="132" x2="304" y2="140" stroke="#555" stroke-width="1.2"/>
+    <line x1="328" y1="132" x2="336" y2="140" stroke="#555" stroke-width="1.2"/>
+  </g>
+
+  <!-- Double rotation -->
+  <g transform="translate(410,115)">
+    <rect x="0" y="0" width="370" height="180" rx="8" fill="#fef9e7" stroke="#e67e22" stroke-width="1.5"/>
+    <text x="185" y="22" text-anchor="middle" font-size="13" font-weight="bold" fill="#d35400">Double Right Rotation</text>
+    <text x="185" y="38" text-anchor="middle" font-size="9" fill="#888">inner subtree dominates</text>
+
+    <!-- Before -->
+    <text x="80" y="58" text-anchor="middle" font-size="10" fill="#555" font-weight="bold">Before</text>
+
+    <rect x="60" y="66" width="42" height="24" rx="5" fill="#e74c3c"/>
+    <text x="81" y="83" text-anchor="middle" fill="white" font-size="11" font-weight="bold">C</text>
+
+    <rect x="24" y="102" width="42" height="24" rx="5" fill="#2c3e50"/>
+    <text x="45" y="119" text-anchor="middle" fill="white" font-size="11" font-weight="bold">A</text>
+
+    <circle cx="118" cy="114" r="7" fill="#bdc3c7"/>
+    <circle cx="16" cy="140" r="6" fill="#bdc3c7"/>
+
+    <rect x="42" y="134" width="36" height="20" rx="4" fill="#e67e22"/>
+    <text x="60" y="148" text-anchor="middle" fill="white" font-size="10" font-weight="bold">B</text>
+
+    <circle cx="44" cy="166" r="5" fill="#95a5a6"/>
+    <circle cx="70" cy="166" r="5" fill="#95a5a6"/>
+
+    <line x1="71" y1="90" x2="53" y2="102" stroke="#555" stroke-width="1.2"/>
+    <line x1="91" y1="90" x2="114" y2="107" stroke="#555" stroke-width="1.2"/>
+    <line x1="35" y1="126" x2="20" y2="134" stroke="#555" stroke-width="1.2"/>
+    <line x1="55" y1="126" x2="55" y2="134" stroke="#555" stroke-width="1.2"/>
+    <line x1="50" y1="154" x2="48" y2="161" stroke="#555" stroke-width="1.2"/>
+    <line x1="70" y1="154" x2="66" y2="161" stroke="#555" stroke-width="1.2"/>
+
+    <!-- Arrow -->
+    <text x="185" y="122" text-anchor="middle" font-size="26" fill="#e67e22">→</text>
+
+    <!-- After -->
+    <text x="300" y="58" text-anchor="middle" font-size="10" fill="#555" font-weight="bold">After</text>
+
+    <rect x="281" y="66" width="38" height="24" rx="5" fill="#e67e22"/>
+    <text x="300" y="83" text-anchor="middle" fill="white" font-size="11" font-weight="bold">B</text>
+
+    <rect x="242" y="102" width="38" height="24" rx="5" fill="#2c3e50"/>
+    <text x="261" y="119" text-anchor="middle" fill="white" font-size="11" font-weight="bold">A</text>
+
+    <rect x="322" y="102" width="38" height="24" rx="5" fill="#27ae60"/>
+    <text x="341" y="119" text-anchor="middle" fill="white" font-size="11" font-weight="bold">C</text>
+
+    <circle cx="236" cy="140" r="6" fill="#bdc3c7"/>
+    <circle cx="270" cy="140" r="5" fill="#95a5a6"/>
+    <circle cx="324" cy="140" r="5" fill="#95a5a6"/>
+    <circle cx="354" cy="140" r="6" fill="#bdc3c7"/>
+
+    <line x1="292" y1="90" x2="270" y2="102" stroke="#555" stroke-width="1.2"/>
+    <line x1="308" y1="90" x2="332" y2="102" stroke="#555" stroke-width="1.2"/>
+    <line x1="252" y1="126" x2="240" y2="134" stroke="#555" stroke-width="1.2"/>
+    <line x1="270" y1="126" x2="266" y2="135" stroke="#555" stroke-width="1.2"/>
+    <line x1="332" y1="126" x2="328" y2="135" stroke="#555" stroke-width="1.2"/>
+    <line x1="350" y1="126" x2="350" y2="134" stroke="#555" stroke-width="1.2"/>
+  </g>
+</svg>
diff --git a/doc/benchmarks.md b/doc/benchmarks.md
new file mode 100644
index 0000000..d6c67ca
--- /dev/null
+++ b/doc/benchmarks.md
@@ -0,0 +1,438 @@
+# Benchmarks
+
+This is the canonical performance document for the project: benchmark
+methodology, current numbers, and the implementation details that most directly
+explain those numbers.
+
+## Running
+
+```
+$ lein bench                  # Criterium, N=100K (~5 min)
+$ lein bench --full           # Criterium, N=10K,100K,500K (~30 min)
+$ lein bench --readme --full  # README tables only (~10 min)
+$ lein bench --sizes 50000    # Custom sizes
+
+$ lein bench-simple           # Quick iteration bench (100 to 100K)
+$ lein bench-simple --full    # Full suite (100 to 1M)
+$ lein bench-range-map        # Range-map vs Guava TreeRangeMap
+$ lein bench-parallel         # Parallel threshold crossover analysis
+$ lein bench-rope-tuning      # Rope chunk-size sweep
+```
+
+Results are written to `bench-results/<timestamp>.edn` with system info, sizes, and per-operation Criterium statistics.
+
+## Environment
+
+| | |
+|--|--|
+| JVM | OpenJDK 25.0.2, 64-bit Server VM |
+| Clojure | 1.12.4 |
+| OS / Arch | Mac OS X 26.3.1 / aarch64 |
+| Available processors | 12 |
+| Heap | 8192 MB |
+| Method | Criterium quick-benchmark (6 samples, JIT warmup, outlier detection) |
+
+Relative ratios are more meaningful than absolute times.
+
+## Set Operations
+
+Two sets of size N with 50% overlap. Adams' divide-and-conquer with optional
+fork-join parallelism. Set algebra uses operation-specific root thresholds:
+
+- union `131,072`
+- intersection `65,536`
+- difference `131,072`
+- ordered-map merge `65,536`
+
+Recursive re-forking currently uses `65,536` for all four operations, plus a
+`65,536` minimum-branch guard and a `64` sequential cutoff for tiny subtrees.
+
+This is the library's dominant advantage. The split/join structure gives
+work-optimal set algebra, and fork-join parallelism helps extend that advantage
+to larger multicore workloads.
+
+### vs sorted-set (speedup)
+
+| Operation | N=10K | N=100K | N=500K |
+|-----------|------:|-------:|-------:|
+| Union | **15.4x** | **26.4x** | **56.6x** |
+| Intersection | **9.0x** | **17.0x** | **36.2x** |
+| Difference | **9.6x** | **22.1x** | **50.2x** |
+
+### vs data.avl (speedup)
+
+| Operation | N=10K | N=100K | N=500K |
+|-----------|------:|-------:|-------:|
+| Union | **10.9x** | **20.5x** | **42.1x** |
+| Intersection | **7.2x** | **13.0x** | **28.1x** |
+| Difference | **7.2x** | **12.7x** | **32.0x** |
+
+Interpretation:
+- against `sorted-set`, the gap is mainly algorithmic: generic `clojure.set`
+  paths over built-in sorted collections do not exploit a native split/join
+  algebra
+- against `data.avl`, both libraries benefit from ordered trees, but this
+  library's split/join constant factors are lower and the set operations also
+  parallelize
+
+### vs clojure.set on hash-set (exploratory, unfair baseline)
+
+This is not an ordered-collection comparison, so it should be read as an
+exploratory stress test rather than as the main benchmark story. Even so, the
+current split/join implementation still wins decisively.
+
+| Operation | N=10K | N=100K | N=500K |
+|-----------|------:|-------:|-------:|
+| Union | **4.2x** | **7.2x** | **16.3x** |
+| Intersection | **3.8x** | **6.1x** | **12.9x** |
+| Difference | **4.4x** | **7.6x** | **18.6x** |
+
+### Raw times (ms)
+
+| Operation | N | sorted-set | data.avl | ordered-set |
+|-----------|---|----------:|----------:|----------:|
+| Union | 10K | 3.63 | 2.56 | **0.24** |
+| | 100K | 42.71 | 33.27 | **1.62** |
+| | 500K | 246.60 | 183.40 | **4.36** |
+| Intersection | 10K | 2.32 | 1.85 | **0.26** |
+| | 100K | 30.36 | 23.25 | **1.79** |
+| | 500K | 170.02 | 131.96 | **4.70** |
+| Difference | 10K | 2.02 | 1.51 | **0.21** |
+| | 100K | 30.70 | 17.71 | **1.39** |
+| | 500K | 156.97 | 100.24 | **3.13** |
+
+### Raw times vs clojure.set on hash-set (ms)
+
+| Operation | N | clojure.set/hash-set | ordered-set |
+|-----------|---|---------------------:|------------:|
+| Union | 10K | 1.00 | **0.24** |
+| | 100K | 11.65 | **1.62** |
+| | 500K | 70.93 | **4.36** |
+| Intersection | 10K | 0.98 | **0.26** |
+| | 100K | 10.85 | **1.79** |
+| | 500K | 60.70 | **4.70** |
+| Difference | 10K | 0.91 | **0.21** |
+| | 100K | 10.51 | **1.39** |
+| | 500K | 58.12 | **3.13** |
+
+## Fold (r/fold)
+
+Parallel fold via `r/fold`. The tree is split into equal subtrees and folded in parallel. sorted-set and data.avl fall back to sequential reduce.
+
+Implementation note: `CollFold` is not just delegated blindly to `r/fold`.
+`node-fold` splits the tree eagerly in the caller thread and then folds chunk
+indices in parallel. That
+keeps split overhead under control and avoids depending on dynamic bindings
+inside worker tasks.
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| sorted-set | 0.33ms | 3.02ms | 16.37ms |
+| data.avl | 0.76ms | 4.34ms | 35.04ms |
+| **ordered-set** | **0.13ms** | **0.73ms** | **3.97ms** |
+| vs sorted-set | **2.5x** | **4.1x** | **4.1x** |
+| vs data.avl | **5.8x** | **5.9x** | **8.8x** |
+
+## Construction
+
+Batch from collection (parallel fold + union).
+
+This is why constructor-based bulk loading is the right path to benchmark and
+the right path to use. Sequential `conj` is a different workload and is covered
+separately below.
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| sorted-set | 4.65ms | 75.02ms | 542.18ms |
+| data.avl | 2.33ms | 35.16ms | 291.11ms |
+| **ordered-set** | **1.55ms** | **26.34ms** | **172.21ms** |
+| vs sorted-set | **3.0x** | **2.8x** | **3.1x** |
+| vs data.avl | **1.5x** | **1.3x** | **1.7x** |
+
+## Split
+
+100 splits at random keys. Weight-balanced trees have lower constant factors — no height recomputation.
+
+This is one of the cleanest demonstrations of the representation choice. Weight
+composes trivially after join; AVL trees must recompute heights bottom-up.
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| data.avl | 0.45ms | 0.68ms | 0.96ms |
+| **ordered-set** | **0.07ms** | **0.09ms** | **0.12ms** |
+| vs data.avl | **6.8x** | **7.2x** | **7.8x** |
+
+## Lookup
+
+10K random lookups. These are all in the same practical performance tier; small
+differences are not especially meaningful compared with the much larger wins in
+set algebra, split/join-derived operations, construction, and fold.
+
+Treat these as near-parity numbers, not as a headline differentiator.
+
+### Set (ms)
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| sorted-set | 1.47 | 2.14 | 2.89 |
+| data.avl | 1.51 | 2.13 | 2.85 |
+| ordered-set | 1.42 | 2.58 | 2.94 |
+
+### Map (ms)
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| sorted-map | 1.55 | 2.21 | 3.12 |
+| data.avl | 1.45 | 2.11 | 2.85 |
+| ordered-map | 1.21 | 1.87 | 2.71 |
+
+## Set Equality
+
+Randomized integer sets, measured in isolation with `lein bench-simple`.
+
+This is not one of the library's headline capabilities, but it is a useful
+sanity check for ordered-set's direct tree comparison path. The most meaningful
+cases are:
+
+- equal sets of the same size
+- same-size sets differing in one element
+
+The cardinality-mismatch case is effectively a count check and is not very
+interesting.
+
+### Equal sets
+
+| | N=1K | N=10K | N=100K |
+|--|-----:|------:|-------:|
+| hash-set | 0.03ms | 0.28ms | 3.66ms |
+| sorted-set | 0.10ms | 1.19ms | 14.80ms |
+| data.avl | 0.13ms | 1.40ms | 15.10ms |
+| ordered-set | 0.01ms | 0.10ms | 1.59ms |
+| vs hash-set | **3.4x** | **2.8x** | **2.3x** |
+| vs sorted-set | **11.3x** | **12.0x** | **9.3x** |
+| vs data.avl | **14.0x** | **14.1x** | **9.5x** |
+
+Interpretation:
+
+- by `1K`, ordered-set is already competitive to clearly faster on equal-set comparison
+- by `10K`, ordered-set's direct ordered comparison path is clearly better
+- by `100K`, ordered-set is still several times faster than hash-set and about
+  an order of magnitude faster than sorted-set and data.avl
+
+### Same size, one different element
+
+| | N=1K | N=10K | N=100K |
+|--|-----:|------:|-------:|
+| hash-set | 0.01ms | 0.10ms | 0.33ms |
+| sorted-set | 0.10ms | 1.20ms | 14.93ms |
+| data.avl | 0.11ms | 1.36ms | 15.07ms |
+| ordered-set | 0.01ms | 0.10ms | 1.09ms |
+
+Interpretation:
+
+- hash-set still wins the unequal cases at larger sizes
+- ordered-set still substantially beats sorted-set and data.avl
+- ordered-set is still in the same practical tier at `10K`, then well ahead of
+  the ordered competitors by `100K`
+
+This is a good example of where direct ordered traversal helps beyond set
+algebra itself: once sets are large enough, the library can compare two
+compatible ordered sets very efficiently without falling back to generic
+membership-oriented equality work.
+
+## Last Element
+
+1000 calls. O(log n) via `java.util.SortedSet.last()` vs O(n) seq traversal.
+
+This is endpoint access, not a claim about `clojure.core/last`.
+
+| | N=10K | N=100K |
+|--|------:|-------:|
+| sorted-set | 424ms | 5,085ms |
+| data.avl | 538ms | 5,376ms |
+| **ordered-set** | **0.12ms** | **0.13ms** |
+
+~40,000x faster at N=100K. Gap grows linearly with N.
+
+## Iteration (reduce)
+
+Both ordered-collections and data.avl implement direct tree reduction paths,
+which is why both are much faster than seq-driven reduction over `sorted-set`.
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| sorted-set | 0.31ms | 3.43ms | 17.81ms |
+| data.avl | 0.06ms | 0.95ms | 5.31ms |
+| ordered-set | 0.07ms | 0.98ms | 4.84ms |
+
+4–5x faster than sorted-set at larger sizes. On par with data.avl.
+
+## Insert (sequential conj, not batch)
+
+This section is deliberately separate from construction. It measures repeated
+single-element mutation, not bulk loading.
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| sorted-set | 6.37ms | 71.62ms | 1,220ms |
+| data.avl | 5.25ms | 49.26ms | 983ms |
+| ordered-set | 4.61ms | 44.81ms | 906ms |
+
+## Delete
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| sorted-set | 3.30ms | 36.43ms | 621.05ms |
+| data.avl | 1.91ms | 26.13ms | 482.01ms |
+| ordered-set | 1.82ms | 22.90ms | 461.38ms |
+
+## Positional Access
+
+Both O(log n). sorted-set has no nth/rank.
+
+These are enabled by subtree sizes. For this library, size is part of the core
+tree invariant rather than an add-on feature.
+
+### nth (10K accesses by index)
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| data.avl | 0.85ms | 1.73ms | 2.83ms |
+| ordered-set | 1.40ms | 2.00ms | 2.80ms |
+
+data.avl is usually faster, but the gap narrows substantially at 500K.
+
+### rank-of (10K lookups)
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| data.avl | 2.39ms | 3.49ms | 6.03ms |
+| ordered-set | 1.15ms | 2.62ms | 4.99ms |
+
+ordered-set is ~1.2-2.1x faster in these measurements.
+
+## Interval Collections
+
+### Construction (ms)
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| interval-set | 9.3 | 191.9 | 1,367.3 |
+| interval-map | 10.4 | 233.0 | 1,667.2 |
+
+### Lookup (1K overlap queries, ms)
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| interval-map | 61.4 | 80.3 | 94.9 |
+
+Sub-linear growth — O(log n + k) means query time depends more on result count than collection size.
+
+## Map Construction
+
+| | N=10K | N=100K | N=500K |
+|--|------:|-------:|-------:|
+| sorted-map | 3.14ms | 55.25ms | 436.80ms |
+| data.avl | 2.37ms | 37.41ms | 335.96ms |
+| ordered-map | **1.45ms** | **28.81ms** | **191.14ms** |
+
+2.3x faster than sorted-map and 1.8x faster than data.avl at N=500K in these measurements.
+
+## Rope vs PersistentVector
+
+The rope is a persistent sequence optimized for structural editing. Where
+PersistentVector is O(n) for mid-sequence splice/insert/remove, the rope is
+O(log n). The advantage is unbounded and grows linearly with collection size.
+
+### Structural Editing
+
+| Workload | N=10K | N=100K | N=500K |
+|---|---:|---:|---:|
+| 200 random edits — rope | 2.6ms | 2.2ms | 2.9ms |
+| 200 random edits — vector | 97ms | 1.04s | 5.4s |
+| **Speedup** | **38x** | **473x** | **1862x** |
+
+| Workload | N=10K | N=100K | N=500K |
+|---|---:|---:|---:|
+| Single splice — rope | 128µs | 54µs | 49µs |
+| Single splice — vector | 842µs | 6.0ms | 27ms |
+| **Speedup** | **7x** | **111x** | **551x** |
+
+At 500K elements, 200 random splice operations take ~3ms on the rope vs ~5.4
+seconds on the vector. The rope's time is nearly constant across sizes because
+each operation is O(log n).
+
+### Concatenation
+
+| Workload | N=10K | N=100K | N=500K |
+|---|---:|---:|---:|
+| Concat many pieces — rope | 36µs | 123µs | 364µs |
+| Concat many pieces — vector | 102µs | 800µs | 3.4ms |
+| **Speedup** | **3x** | **7x** | **9x** |
+
+Bulk concatenation collects chunks in O(total chunks) and builds the tree
+directly, avoiding pairwise tree operations.
+
+### Reduce
+
+| Workload | N=10K | N=100K | N=500K |
+|---|---:|---:|---:|
+| Reduce sum — rope | 145µs | 601µs | 2.8ms |
+| Reduce sum — vector | 93µs | 617µs | 3.6ms |
+| **Ratio** | 0.6x | ~1x | **1.3x** |
+
+The rope beats vectors on reduce at N >= 100K because 256-element chunks give
+better cache locality per reduction step than PersistentVector's 32-wide trie
+nodes. The rope uses a direct in-order tree walk (no enumerator frames) and
+delegates to the vector's native `.reduce` for chunk-internal iteration.
+
+### Parallel Fold
+
+| Workload | N=10K | N=100K | N=500K |
+|---|---:|---:|---:|
+| Fold sum — rope | 0.22ms | 0.31ms | 0.85ms |
+| Fold sum — vector | 1.23ms | 0.47ms | 1.13ms |
+| **Speedup** | **5.6x** | **1.5x** | **1.3x** |
+
+The rope's `r/fold` uses tree-based fork-join decomposition — split at the
+midpoint, fork left, compute right inline, join. This maps directly onto the
+`ForkJoinPool` work-stealing model without a separate chunking pass. At small N
+the speedup is largest because the rope's tree structure provides immediate
+parallelism while the vector's fold has higher setup overhead.
+
+### Rope vs String (text workload)
+
+For text-editing workloads, the rope also beats `java.lang.String` at scale:
+
+| Workload (N=100K chars) | Rope | String | Speedup |
+|---|---:|---:|---:|
+| Splice 32 chars at midpoint | 3.6µs | 13.4µs | **3.8x** |
+| Split at midpoint | 425ns | 2.6µs | **6.1x** |
+
+String splice and split copy the entire string (O(n)); the rope does O(log n)
+tree work.
+
+### Where the Rope Loses
+
+| Workload | Ratio | Why |
+|---|---|---|
+| Split / slice | ~20x slower | O(log n) vs O(1) `subvec` wrapper |
+| Random nth | 0.4-0.7x | O(log n) vs O(1) trie lookup |
+| Build via transient | 2-3x slower | Periodic O(log n) tree flush vs O(1) array append |
+
+These losses are inherent to the tree-backed design, not to the
+implementation. The absolute times are microseconds.
+
+## Specialized Node Types
+
+Primitive-specialized node types reduce boxing and comparison overhead for
+common homogeneous-key cases:
+
+```clojure
+(long-ordered-set data)     ;; unboxed long keys
+(double-ordered-set data)   ;; unboxed double keys
+(string-ordered-set data)   ;; String.compareTo
+```
+
+These are constant-factor optimizations on top of the same tree algebra, not a
+separate implementation strategy.
diff --git a/doc/collections-api.md b/doc/collections-api.md
new file mode 100644
index 0000000..ef1fefc
--- /dev/null
+++ b/doc/collections-api.md
@@ -0,0 +1,603 @@
+# Collections API Reference
+
+This document is a practical reference for the library's collection types.
+Use it to answer three questions quickly:
+
+- Which constructor should I use?
+- Which collection-specific operations does this type support?
+- Which standard Clojure operations work as expected on it?
+
+All library-specific constructors and extension functions are in
+`ordered-collections.core`.
+
+```clojure
+(require '[ordered-collections.core :as oc])
+```
+
+Standard Clojure operations such as `assoc`, `get`, `contains?`, `seq`,
+`reduce`, `first`, `last`, `nth`, and `rseq` work directly on the collection
+instances themselves where supported.
+
+## Conventions
+
+- `O(log n)` means logarithmic in collection size.
+- `O(log n + k)` means logarithmic search plus `k` returned elements.
+- `r/fold` refers to `clojure.core.reducers/fold`.
+- For ordered maps, seq/reduce/nth results are entries (`[k v]`).
+- For ordered sets, seq/reduce/nth results are elements.
+- `split-key` returns `[left hit right]`.
+  For sets, `hit` is the element itself.
+  For maps, `hit` is `[k v]`.
+
+---
+
+## Comparators
+
+These are public helpers for constructing ordered collections with specialized
+or custom ordering.
+
+| Function | Signature | Notes |
+|---|---|---|
+| `long-compare` | — | Specialized `Comparator` for `Long` keys. |
+| `double-compare` | — | Specialized `Comparator` for `Double` keys. |
+| `string-compare` | — | Specialized `Comparator` for `String` keys. |
+| `general-compare` | — | Total order over all values, including non-`Comparable` types (Namespace, Var, etc.). Use with `ordered-set-with` / `ordered-map-with`. ~20% slower lookups on `Comparable` types vs default. |
+| `compare-by` | `[pred]` | Convert a total-order predicate such as `<` or `>` into a `Comparator`. |
+
+---
+
+## Ordered Set
+
+Persistent sorted set with positional access, nearest/range operations,
+parallel set algebra, and parallel fold.
+
+### Constructors
+
+- `ordered-set`
+  - `(ordered-set)`
+  - `(ordered-set coll)`
+- `ordered-set-by`
+  - `(ordered-set-by pred coll)`
+- `ordered-set-with`
+  - `(ordered-set-with comparator)`
+  - `(ordered-set-with comparator coll)`
+- `long-ordered-set`
+  - `(long-ordered-set)`
+  - `(long-ordered-set coll)`
+- `double-ordered-set`
+  - `(double-ordered-set)`
+  - `(double-ordered-set coll)`
+- `string-ordered-set`
+  - `(string-ordered-set)`
+  - `(string-ordered-set coll)`
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `union` | `[s1 s2]` | Divide-and-conquer set union; parallel for large compatible sets. |
+| `intersection` | `[s1 s2]` | Divide-and-conquer set intersection; parallel for large compatible sets. |
+| `difference` | `[s1 s2]` | Divide-and-conquer set difference; parallel for large compatible sets. |
+| `subset?` | `[s1 s2]` | Subset test. |
+| `superset?` | `[s1 s2]` | Superset test. |
+| `disjoint?` | `[s1 s2]` | Disjointness test. |
+| `rank` | `[coll x]` | 0-based rank of `x`, or `nil` if absent. |
+| `slice` | `[coll start end]` | Elements in index range `[start,end)`. |
+| `median` | `[coll]` | Lower median for even-sized collections. |
+| `percentile` | `[coll pct]` | Element at percentile `0..100`. |
+| `nearest` | `[coll test k]` | Nearest element satisfying `:<`, `:<=`, `:>=`, `:>`. |
+| `subrange` | `[coll test k]` `[coll t1 k1 t2 k2]` | Structure-sharing subcollection. |
+| `split-key` | `[k coll]` | Returns `[left hit right]`. |
+| `split-at` | `[i coll]` | Returns `[left right]`. |
+
+### Standard collection operations
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `conj` | `[coll x]` | Add element. |
+| `disj` | `[coll x]` | Remove element. |
+| `contains?` | `[coll x]` | Exact membership test. |
+| `nth` | `[coll i]` `[coll i not-found]` | Positional access. |
+| `first` / `last` | `[coll]` | Min/max element. |
+| `seq` / `rseq` | `[coll]` | Sorted / reverse-sorted traversal. |
+| `reduce` | `[f coll]` `[f init coll]` | Direct tree traversal. |
+| `r/fold` | `[n combinef reducef coll]` | Parallel chunked fold. |
+| `count` | `[coll]` | O(1). |
+
+---
+
+## Ordered Map
+
+Persistent sorted map with positional access, nearest/range operations,
+parallel merge, and parallel fold.
+
+### Constructors
+
+- `ordered-map`
+  - `(ordered-map)`
+  - `(ordered-map coll)`
+- `ordered-map-by`
+  - `(ordered-map-by pred coll)`
+- `ordered-map-with`
+  - `(ordered-map-with comparator)`
+  - `(ordered-map-with comparator coll)`
+- `long-ordered-map`
+  - `(long-ordered-map)`
+  - `(long-ordered-map coll)`
+- `double-ordered-map`
+  - `(double-ordered-map)`
+  - `(double-ordered-map coll)`
+- `string-ordered-map`
+  - `(string-ordered-map)`
+  - `(string-ordered-map coll)`
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `assoc-new` | `[m k v]` | Associate only if `k` is absent. |
+| `ordered-merge-with` | `[f & maps]` | Merge ordered maps; parallel for large compatible maps. |
+| `rank` | `[coll k]` | 0-based rank of key `k`, or `nil`. |
+| `slice` | `[coll start end]` | Entries in index range `[start,end)`. |
+| `median` | `[coll]` | Median entry. |
+| `percentile` | `[coll pct]` | Entry at percentile `0..100`. |
+| `nearest` | `[coll test k]` | Nearest entry satisfying `:<`, `:<=`, `:>=`, `:>`. |
+| `subrange` | `[coll test k]` `[coll t1 k1 t2 k2]` | Structure-sharing submap. |
+| `split-key` | `[k coll]` | Returns `[left-map hit right-map]`. |
+| `split-at` | `[i coll]` | Returns `[left right]`. |
+
+### Standard collection operations
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `assoc` | `[m k v]` | Add/update entry. |
+| `dissoc` | `[m k]` | Remove key. |
+| `get` | `[m k]` `[m k not-found]` | Exact key lookup. |
+| `contains?` | `[m k]` | Exact key membership. |
+| `nth` | `[m i]` `[m i not-found]` | Entry at index. |
+| `first` / `last` | `[m]` | Min/max key entry. |
+| `seq` / `rseq` | `[m]` | Sorted / reverse-sorted entries. |
+| `reduce` | `[f m]` `[f init m]` | Reduction over entries. |
+| `reduce-kv` | `[f init m]` | `(f acc k v)`. |
+| `r/fold` | `[n combinef reducef coll]` | Parallel chunked fold. |
+| `count` | `[m]` | O(1). |
+
+---
+
+## Interval Set
+
+Set of intervals with overlap queries via interval-tree augmentation.
+
+### Constructors
+
+- `interval-set`
+  - `(interval-set)`
+  - `(interval-set coll)`
+
+Bare scalar values become point intervals `[x x]`.
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `overlapping` | `[iset point]` `[iset interval]` | All stored intervals overlapping the query. |
+| `span` | `[iset]` | Bounding interval `[min max]`, or `nil`. |
+| `union` | `[s1 s2]` | Interval-set union. |
+| `intersection` | `[s1 s2]` | Interval-set intersection. |
+| `difference` | `[s1 s2]` | Interval-set difference. |
+| `subset?` | `[s1 s2]` | Subset test. |
+| `superset?` | `[s1 s2]` | Superset test. |
+| `disjoint?` | `[s1 s2]` | Disjointness test. |
+
+### Standard collection operations
+
+Important: interval collections intentionally use overlap semantics for lookup-style operations.
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `conj` | `[coll interval]` | Add interval. |
+| `disj` | `[coll interval]` | Remove exact stored interval. |
+| `contains?` | `[coll query]` | True if any stored interval overlaps the point/interval query. |
+| `get` / IFn | `[coll query]` `[coll query not-found]` | Returns overlapping intervals, not an exact membership value. |
+| `nth` | `[coll i]` `[coll i not-found]` | Interval at index. |
+| `first` / `last` | `[coll]` | First/last interval by interval ordering. |
+| `seq` / `rseq` | `[coll]` | Sorted / reverse-sorted intervals. |
+| `reduce` | `[f coll]` `[f init coll]` | Reduction over intervals. |
+| `r/fold` | `[n combinef reducef coll]` | Parallel chunked fold. |
+| `count` | `[coll]` | O(1). |
+
+Also callable as a function:
+
+- `(iset point)`
+- `(iset [lo hi])`
+
+Both return overlapping intervals.
+
+---
+
+## Interval Map
+
+Map from intervals to values with overlap queries via interval-tree augmentation.
+
+### Constructors
+
+- `interval-map`
+  - `(interval-map)`
+  - `(interval-map coll)`
+
+Input shape is `[[interval value] ...]`.
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `overlapping` | `[imap point]` `[imap interval]` | All stored `[interval value]` entries overlapping the query. |
+| `span` | `[imap]` | Bounding interval `[min max]`, or `nil`. |
+
+### Standard collection operations
+
+Important: interval-map intentionally overloads map-style lookup with overlap-query semantics.
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `assoc` | `[m interval v]` | Add/update interval-value entry. |
+| `dissoc` | `[m interval]` | Remove exact stored interval. |
+| `get` / IFn | `[m query]` `[m query not-found]` | Returns the seq of overlapping values, not a single exact-key value. |
+| `contains?` | `[m query]` | True if any stored interval overlaps the query. |
+| `find` / `entryAt` | `[m query]` | Returns the first overlapping stored entry. |
+| `nth` | `[m i]` `[m i not-found]` | Entry at index. |
+| `first` / `last` | `[m]` | First/last stored entry by interval ordering. |
+| `seq` / `rseq` | `[m]` | Sorted / reverse-sorted entries. |
+| `reduce` | `[f m]` `[f init m]` | Reduction over entries. |
+| `reduce-kv` | `[f init m]` | `(f acc interval value)`. |
+| `r/fold` | `[n combinef reducef coll]` | Parallel chunked fold. |
+| `count` | `[m]` | O(1). |
+
+Also callable as a function:
+
+- `(imap point)`
+- `(imap [lo hi])`
+
+Both return overlapping values.
+
+---
+
+## Range Map
+
+Persistent map from non-overlapping half-open ranges `[lo, hi)` to values.
+Inserting a range carves out or replaces overlapping portions of existing ranges.
+
+### Constructors
+
+- `range-map`
+  - `(range-map)`
+  - `(range-map coll)`
+
+Input may be a map or seq of `[[range value] ...]` pairs.
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `ranges` | `[rm]` | Seq of `[[lo hi] value]` entries. |
+| `gaps` | `[rm]` | Unmapped half-open gaps. |
+| `get-entry` | `[rm point]` | `[[lo hi] value]` containing `point`, or `nil`. |
+| `assoc-coalescing` | `[rm [lo hi] v]` | Insert and merge adjacent equal-valued ranges. |
+| `range-remove` | `[rm [lo hi]]` | Remove all mappings intersecting the range. |
+| `span` | `[rm]` | Bounding range `[min max]`, or `nil`. |
+
+### Standard collection operations
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `assoc` | `[rm [lo hi] v]` | Insert without coalescing. |
+| `get` / IFn | `[rm point]` `[rm point not-found]` | Value containing `point`. |
+| `contains?` | `[rm point]` | Point membership. |
+| `seq` | `[rm]` | Sorted `[[lo hi] value]` entries. |
+| `reduce` | `[f rm]` `[f init rm]` | Reduction over entries. |
+| `reduce-kv` | `[f init rm]` | `(f acc range value)`. |
+| `count` | `[rm]` | O(1). |
+
+Also callable as a function:
+
+- `(rm point)`
+
+returns the value for the containing range, or `nil`.
+
+---
+
+## Segment Tree
+
+Persistent ordered map with cached subtree aggregates for fast range queries.
+
+### Constructors
+
+- `segment-tree`
+  - `(segment-tree op identity coll)`
+- `segment-tree-with`
+  - `(segment-tree-with comparator op identity)`
+  - `(segment-tree-with comparator op identity coll)`
+- `segment-tree-by`
+  - `(segment-tree-by pred op identity coll)`
+- `sum-tree`
+  - `(sum-tree coll)`
+- `min-tree`
+  - `(min-tree coll)`
+- `max-tree`
+  - `(max-tree coll)`
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `query` | `[st lo hi]` | Aggregate over inclusive key range `[lo,hi]`. |
+| `aggregate` | `[st]` | Whole-tree aggregate. |
+| `update-val` | `[st k v]` | Replace value at key. |
+| `update-fn` | `[st k f]` | Update value at key via `f`. |
+| `rank` | `[st k]` | Rank of key `k`, or `nil`. |
+| `slice` | `[st start end]` | Entries in index range `[start,end)`. |
+| `median` | `[st]` | Median entry. |
+| `percentile` | `[st pct]` | Entry at percentile `0..100`. |
+| `nearest` | `[st test k]` | Nearest entry satisfying `:<`, `:<=`, `:>=`, `:>`. |
+| `subrange` | `[st test k]` `[st t1 k1 t2 k2]` | Structure-sharing submap. |
+| `split-key` | `[k st]` | Returns `[left hit right]`. |
+| `split-at` | `[i st]` | Returns `[left right]`. |
+
+### Standard collection operations
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `assoc` | `[st k v]` | Add/update key and recompute aggregates. |
+| `get` / IFn | `[st k]` `[st k not-found]` | Exact key lookup. |
+| `contains?` | `[st k]` | Exact key membership. |
+| `seq` / `rseq` | `[st]` | Sorted / reverse-sorted entries. |
+| `reduce` | `[f st]` `[f init st]` | Reduction over entries. |
+| `reduce-kv` | `[f init st]` | `(f acc k v)`. |
+| `count` | `[st]` | O(1). |
+
+Also callable as a function:
+
+- `(st k)`
+
+returns the value at key `k`.
+
+---
+
+## Priority Queue
+
+Persistent priority queue ordered by priority and stable insertion order within
+equal priorities.
+
+Queue order is defined by the configured comparator:
+
+- `peek-min` / `pop-min` operate on the first element in queue order
+- `peek-max` / `pop-max` operate on the last element in queue order
+
+### Constructors
+
+- `priority-queue`
+  - `(priority-queue)`
+  - `(priority-queue pairs)`
+- `priority-queue-by`
+  - `(priority-queue-by pred pairs)`
+- `priority-queue-with`
+  - `(priority-queue-with comparator)`
+  - `(priority-queue-with comparator pairs)`
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `push` | `[pq priority value]` | Insert one element. |
+| `push-all` | `[pq pairs]` | Insert many `[priority value]` pairs. |
+| `peek-min` | `[pq]` | First `[priority value]` in queue order, or `nil`. |
+| `peek-min-val` | `[pq]` | First value only. |
+| `pop-min` | `[pq]` | Remove first element. |
+| `peek-max` | `[pq]` | Last `[priority value]` in queue order, or `nil`. |
+| `peek-max-val` | `[pq]` | Last value only. |
+| `pop-max` | `[pq]` | Remove last element. |
+
+### Standard collection operations
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `peek` | `[pq]` | Same as `peek-min`. |
+| `pop` | `[pq]` | Same as `pop-min`. |
+| `seq` / `rseq` | `[pq]` | Queue-order / reverse queue-order entries. |
+| `reduce` | `[f pq]` `[f init pq]` | Reduction over `[priority value]` entries. |
+| `r/fold` | `[n combinef reducef pq]` | Parallel chunked fold. |
+| `count` | `[pq]` | O(1). |
+
+---
+
+## Ordered Multiset
+
+Persistent sorted bag that allows duplicate elements.
+
+### Constructors
+
+- `ordered-multiset`
+  - `(ordered-multiset)`
+  - `(ordered-multiset coll)`
+- `ordered-multiset-by`
+  - `(ordered-multiset-by pred coll)`
+- `ordered-multiset-with`
+  - `(ordered-multiset-with comparator)`
+  - `(ordered-multiset-with comparator coll)`
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `multiplicity` | `[ms x]` | Count of `x`. |
+| `disj-one` | `[ms x]` | Remove one occurrence. |
+| `disj-all` | `[ms x]` | Remove all occurrences. |
+| `distinct-elements` | `[ms]` | Distinct sorted elements. |
+| `element-frequencies` | `[ms]` | `{element -> count}` map. |
+
+### Standard collection operations
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `conj` | `[ms x]` | Add one occurrence. |
+| `disj` | `[ms x]` | Same as `disj-one`. |
+| `nth` | `[ms i]` `[ms i not-found]` | Positional access with duplicates counted. |
+| `seq` / `rseq` | `[ms]` | Sorted / reverse-sorted elements, duplicates repeated. |
+| `reduce` | `[f ms]` `[f init ms]` | Reduction over elements. |
+| `r/fold` | `[n combinef reducef ms]` | Parallel chunked fold. |
+| `count` | `[ms]` | Total element count, including duplicates. |
+
+---
+
+## Fuzzy Set
+
+Ordered set with nearest-neighbor lookup by distance.
+
+### Constructors
+
+- `fuzzy-set`
+  - `(fuzzy-set coll & {:keys [tiebreak distance]})`
+- `fuzzy-set-by`
+  - `(fuzzy-set-by comparator coll & {:keys [tiebreak distance]})`
+
+Options:
+
+- `:tiebreak` — `:<` or `:>`
+- `:distance` — distance function
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `fuzzy-nearest` | `[fs query]` | Returns `[element distance]`. |
+| `fuzzy-exact-contains?` | `[fs x]` | Exact membership only. |
+| `nearest` | `[fs test k]` | Nearest element satisfying `:<`, `:<=`, `:>=`, `:>`. |
+| `subrange` | `[fs test k]` `[fs t1 k1 t2 k2]` | Structure-sharing subcollection. |
+| `split-key` | `[k fs]` | Returns `[left hit right]`. |
+| `split-at` | `[i fs]` | Returns `[left right]`. |
+| `rank` | `[fs x]` | Rank of exact key, or `nil`. |
+| `slice` | `[fs start end]` | Elements in index range `[start,end)`. |
+| `median` | `[fs]` | Median element. |
+| `percentile` | `[fs pct]` | Element at percentile `0..100`. |
+
+### Standard collection operations
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `conj` | `[fs x]` | Add element. |
+| `disj` | `[fs x]` | Remove element. |
+| `contains?` | `[fs x]` | Exact membership. |
+| `nth` | `[fs i]` `[fs i not-found]` | Positional access. |
+| `seq` / `rseq` | `[fs]` | Sorted / reverse-sorted elements. |
+| `reduce` | `[f fs]` `[f init fs]` | Reduction over elements. |
+| `r/fold` | `[n combinef reducef fs]` | Parallel chunked fold. |
+| `count` | `[fs]` | O(1). |
+
+Also callable as a function:
+
+- `(fs query)`
+
+returns the nearest element.
+
+---
+
+## Fuzzy Map
+
+Ordered map with nearest-neighbor lookup by key distance.
+
+### Constructors
+
+- `fuzzy-map`
+  - `(fuzzy-map coll & {:keys [tiebreak distance]})`
+- `fuzzy-map-by`
+  - `(fuzzy-map-by comparator coll & {:keys [tiebreak distance]})`
+
+Options are the same as `fuzzy-set`.
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `fuzzy-nearest` | `[fm query]` | Returns `[key value distance]`. |
+| `fuzzy-exact-contains?` | `[fm k]` | Exact key membership only. |
+| `fuzzy-exact-get` | `[fm k]` `[fm k not-found]` | Exact key lookup only. |
+| `rank` | `[fm k]` | Rank of exact key, or `nil`. |
+| `slice` | `[fm start end]` | Entries in index range `[start,end)`. |
+| `median` | `[fm]` | Median entry. |
+| `percentile` | `[fm pct]` | Entry at percentile `0..100`. |
+
+### Standard collection operations
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `assoc` | `[fm k v]` | Add/update key-value pair. |
+| `dissoc` | `[fm k]` | Remove exact key. |
+| `get` / IFn | `[fm k]` `[fm k not-found]` | Fuzzy lookup: value for nearest key. |
+| `contains?` | `[fm k]` | Exact key membership. |
+| `nth` | `[fm i]` `[fm i not-found]` | Positional access. |
+| `seq` / `rseq` | `[fm]` | Sorted / reverse-sorted entries. |
+| `reduce` | `[f fm]` `[f init fm]` | Reduction over entries. |
+| `reduce-kv` | `[f init fm]` | `(f acc k v)`. |
+| `r/fold` | `[n combinef reducef fm]` | Parallel chunked fold. |
+| `count` | `[fm]` | O(1). |
+
+Also callable as a function:
+
+- `(fm query)`
+
+returns the value for the nearest key.
+
+---
+
+## Rope
+
+Persistent chunked sequence optimized for structural editing: O(log n) concat,
+split, splice, insert, and remove. Backed by a weight-balanced tree of chunk
+vectors. Implements `IPersistentVector` (`(vector? rope)` is true),
+`java.util.List`, `java.util.RandomAccess`, `Comparable`, and `r/fold`.
+
+### Constructors
+
+- `rope`
+  - `(rope)`
+  - `(rope coll)`
+
+### Collection-specific operations
+
+| Function | Signature(s) | Notes |
+|---|---|---|
+| `rope-concat` | `[x]` `[a b]` `[a b & more]` | One arg: coerce to rope. Two: O(log n) join. Three+: O(total chunks) bulk. |
+| `rope-split` | `[rope i]` | Split at index, returns `[left right]`. O(log n). |
+| `rope-sub` | `[rope start end]` | Subrange rope. O(log n). |
+| `rope-insert` | `[rope i coll]` | Insert elements at index. O(log n). |
+| `rope-remove` | `[rope start end]` | Remove range `[start, end)`. O(log n). |
+| `rope-splice` | `[rope start end coll]` | Replace range with new content. O(log n). |
+| `rope-chunks` | `[rope]` | Seq of internal chunk vectors. |
+| `rope-chunks-reverse` | `[rope]` | Reverse seq of internal chunk vectors. |
+| `rope-chunk-count` | `[rope]` | Number of chunks. |
+| `rope-str` | `[rope]` | Rope of chars/strings to String via StringBuilder. |
+
+### Standard collection operations
+
+| Operation | Signature(s) | Notes |
+|---|---|---|
+| `conj` | `[rope x]` | Append to end. |
+| `assoc` | `[rope i x]` | Replace element at index (or append if `i = count`). |
+| `nth` | `[rope i]` `[rope i not-found]` | Positional access. O(log n). |
+| `get` | `[rope i]` `[rope i not-found]` | Same as `nth`. |
+| `peek` | `[rope]` | Last element. |
+| `pop` | `[rope]` | Remove last element. |
+| `seq` / `rseq` | `[rope]` | Forward / reverse traversal. |
+| `reduce` | `[f rope]` `[f init rope]` | Chunk-aware reduction with `reduced` support. |
+| `r/fold` | `[n combinef reducef rope]` | Parallel fork-join fold. |
+| `compare` | `[rope1 rope2]` | Lexicographic comparison. |
+| `count` | `[rope]` | O(1). |
+
+Also supports `java.util.List` methods: `.get`, `.indexOf`, `.lastIndexOf`,
+`.contains`, `.containsAll`, `.subList`, `.size`, `.toArray`.
+
+`rope-sub` returns a `Rope` that shares structure with the original rope,
+supporting all rope operations including `assoc`, `conj`, `peek`, and `pop`.
+
+Since `Rope` implements `IPersistentVector`, `(vec rope)` returns the rope
+itself. Use `(into [] rope)` to materialize a `PersistentVector`.
diff --git a/doc/competitive-analysis.md b/doc/competitive-analysis.md
new file mode 100644
index 0000000..bfed48f
--- /dev/null
+++ b/doc/competitive-analysis.md
@@ -0,0 +1,158 @@
+# Competitive Analysis: ordered-collections
+
+Comparison with `clojure.core/sorted-set`, `clojure.core/sorted-map`, and `clojure.data.avl`.
+
+## Summary
+
+| Aspect | ordered-collections | clojure.core | clojure.data.avl |
+|--------|---------------------|--------------|------------------|
+| **Tree type** | Weight-balanced | Red-black | AVL |
+| **Set operations** | O(m log(n/m+1)), parallel | O(n) via clojure.set | O(m log(n/m+1)) |
+| **O(log n) nth/rank** | Yes | No | Yes |
+| **Fast endpoint access** | Yes | Seq `last` is O(n) | Seq `last` is O(n) |
+| **Parallel fold** | Yes (fork-join) | No | No |
+| **Interval trees** | Yes | No | No |
+| **Segment trees** | Yes | No | No |
+| **Range maps** | Yes | No | No |
+| **Fuzzy lookup** | Yes | No | No |
+| **Memory/element** | ~64 bytes | ~61 bytes | ~64 bytes |
+
+## Algorithmic Differences
+
+### Set Operations
+
+All three libraries support union, intersection, and difference.
+
+**clojure.core** uses `clojure.set/union` etc., which iterate element-by-element. O(n log n) regardless of overlap.
+
+In the current benchmark suite, ordered-collections also beats the unfair
+`clojure.set` + hash-set baseline on these workloads, but that comparison is
+best treated as exploratory rather than as the main competitive claim.
+
+**data.avl** and **ordered-collections** both use Adams' divide-and-conquer algorithm: split one tree at the other's root, recurse on halves, join. O(m log(n/m + 1)) where m ≤ n — information-theoretically optimal. When one set is much smaller, this is dramatically better than linear.
+
+**ordered-collections** additionally parallelizes the two independent recursive
+calls via `ForkJoinPool`, with granularity tuned from the benchmark suite.
+In practice, this yields very large wins over `sorted-set` and clear wins over
+`data.avl` on set algebra, especially as collections grow. See
+[Benchmarks](benchmarks.md) for current measurements.
+
+### Split and Join
+
+| | clojure.core | data.avl | ordered-collections |
+|--|:---:|:---:|:---:|
+| `split-key` | — | O(log n) | O(log n) |
+| `split-at` | — | O(log n) | O(log n) |
+| `join` | — | O(log n) | O(log n) |
+
+Both data.avl and ordered-collections expose split/join, but ordered-collections
+has materially lower constant factors in the current benchmark suite because
+weight composes trivially: `weight(join(L, k, R)) = weight(L) + 1 + weight(R)`.
+AVL trees must recompute heights bottom-up after joining. Red-black trees must
+reconcile color invariants. This difference compounds in set operations, which
+call split/join at every level of recursion.
+
+### Positional Access
+
+Both ordered-collections and data.avl track subtree sizes, enabling:
+- `(nth coll i)` — O(log n) vs O(n) for core sorted collections
+- `(rank-of coll x)` — 0-based index of element
+- `(split-at i coll)` — split at position
+
+ordered-collections additionally provides `slice`, `median`, and `percentile` — all O(log n), all derived from `nth`.
+
+### First / Last
+
+| Operation | clojure.core | data.avl | ordered-collections |
+|-----------|:---:|:---:|:---:|
+| `(first coll)` | O(1) | O(1) | O(1) |
+| `java.util.SortedSet.last()` | — | — | **O(log n)** |
+| seq-based `last` | **O(n)** | **O(n)** | **O(n)** |
+
+`last` on a 1M-element sorted-set scans the entire collection. ordered-collections
+also supports fast endpoint access through `java.util.SortedSet.last()`, which
+traverses only the right spine of the tree.
+
+### Parallel Fold
+
+ordered-collections implements `clojure.core.reducers/CollFold` by splitting
+the tree into larger chunks and delegating those chunks to `r/fold`. Chunking
+follows the `r/fold` granularity provided by the caller rather than imposing a
+separate library-level floor.
+
+sorted-set and data.avl fall back to sequential reduce.
+
+## Feature Comparison with data.avl
+
+| Feature | ordered-collections | data.avl |
+|---------|:---:|:---:|
+| `split-key` / `split-at` | ✓ | ✓ |
+| `subrange` | ✓ | ✓ |
+| `nearest` (floor/ceiling) | ✓ | ✓ |
+| `nth` / `rank-of` | ✓ | ✓ |
+| `slice` / `median` / `percentile` | ✓ | — |
+| Parallel set operations | ✓ | — |
+| Parallel `r/fold` | ✓ | — |
+| Interval trees | ✓ | — |
+| Segment trees | ✓ | — |
+| Fuzzy sets/maps | ✓ | — |
+| Range maps | ✓ | — |
+| Priority queues | ✓ | — |
+| Multisets | ✓ | — |
+| EDN serialization | ✓ | ✓ |
+| ClojureScript | — | ✓ |
+| Transient support | — | ✓ |
+
+### What data.avl has that we don't
+
+**ClojureScript support.** ordered-collections is JVM-only (`java.util.SortedSet`, `ForkJoinPool`, etc.).
+
+**Transient support.** data.avl supports `transient`/`persistent!` for batch mutation. ordered-collections uses persistent construction throughout, mitigated by parallel batch construction which is competitive in practice.
+
+## Memory
+
+From `memory_test.clj` at N=100,000 (measured with clj-memory-meter):
+
+| Collection | Bytes/Element | vs core |
+|------------|:---:|:---:|
+| sorted-set | 60.6 | 1.00x |
+| data.avl sorted-set | 64.0 | 1.06x |
+| **ordered-set** | 64.0 | 1.06x |
+
+| Collection | Bytes/Entry | vs core |
+|------------|:---:|:---:|
+| sorted-map | 84.6 | 1.00x |
+| data.avl sorted-map | 88.0 | 1.04x |
+| **ordered-map** | 88.0 | 1.04x |
+
+The extra ~4 bytes/node is the weight field. Both data.avl and ordered-collections pay this cost for subtree size tracking.
+
+## Specialized Collections
+
+Not available elsewhere in the Clojure ecosystem:
+
+**Interval trees** — augmented with max-endpoint per subtree. O(log n + k) overlap queries for both point and interval queries:
+```clojure
+(def events (oc/interval-set [[0 10] [5 15] [20 30]]))
+(events [8 12])  ;=> ([0 10] [5 15])
+(events 5)       ;=> ([0 10] [5 15])
+```
+
+**Segment trees** — pre-computed subtree aggregates. O(log n) range queries and updates with any associative operation:
+```clojure
+(def st (oc/sum-tree {0 10, 1 20, 2 30, 3 40}))
+(oc/query st 1 3)  ;=> 90
+```
+
+**Range maps** — non-overlapping `[lo, hi)` ranges. Inserting a range automatically carves out overlaps:
+```clojure
+(def rm (oc/range-map {[0 10] :a [20 30] :b}))
+(rm 5)   ;=> :a
+(rm 15)  ;=> nil
+```
+
+**Fuzzy sets/maps** — nearest-neighbor by distance with configurable tiebreaking:
+```clojure
+(def fs (oc/fuzzy-set [1.0 2.0 3.0 10.0]))
+(fs 2.1)  ;=> 2.0
+```
diff --git a/doc/concept/concept.md b/doc/concept/concept.md
new file mode 100644
index 0000000..535f748
--- /dev/null
+++ b/doc/concept/concept.md
@@ -0,0 +1,566 @@
+# One Tree, Many Forests: Representational Polymorphism in a Parallel Split/Join Tree Algebra
+
+*A Weight-Balanced Kernel for Persistent Sets, Maps, Intervals, Segments, Ropes, and Beyond*
+
+**Dan Lentz**
+
+---
+
+## Abstract
+
+We describe *ordered-collections*, a Clojure library in which a single
+weight-balanced tree algebra kernel serves as the substrate for eleven
+persistent collection types. The kernel is parameterized by a small set of
+open extension points -- a comparator for ordering, a node constructor for
+representation, and a set of root-level interfaces for collection identity --
+through which collection types configure the shared infrastructure without
+modifying it. We call this design pattern *representational polymorphism*:
+dynamic binding variables are captured once at collection boundaries and
+threaded as explicit arguments through hot recursive paths, achieving the
+flexibility of dynamic dispatch with the performance of static
+parameterization. This same pattern enables automatic fork-join parallelism
+on set algebra, because the captured context propagates correctly into forked
+threads where dynamic bindings would not. We present the abstraction
+architecture and test its generality against three increasingly demanding
+challenges: parallel set algebra (same node types, different threads),
+augmented trees (different node types, same comparator), and a chunked
+persistent rope (no comparator at all). Benchmark evidence confirms the
+approach yields strong performance (28-57x on parallel set algebra, up to
+1968x on rope structural editing) without sacrificing generality.
+
+We use the term *representational polymorphism* to mean polymorphism over
+concrete collection representation within a shared kernel. This usage is
+unrelated to GHC's representation polymorphism over runtime value
+representation.
+
+---
+
+## 1. Introduction
+
+Persistent data structures are foundational to functional programming. A
+typical functional language runtime provides a handful of built-in persistent
+collections -- vectors, hash maps, sorted maps -- each implemented as a
+standalone data structure with its own balancing scheme, traversal machinery,
+and persistence mechanism. When a programmer needs an interval tree, a
+segment tree, a rope, or a priority queue, they must find or build a separate
+implementation from scratch.
+
+This fragmentation has compounding costs. Each implementation independently
+solves the same subproblems: balancing, persistence through path copying,
+traversal, reduction, parallel decomposition. Optimizations applied to one
+structure -- parallel fold, primitive key specialization, enumerator-based
+reduction -- must be independently rediscovered and applied to each. The
+result is an ecosystem of isolated implementations that share nothing.
+
+We present an alternative architecture. A single tree algebra kernel,
+approximately 2000 lines of Clojure, provides the shared substrate for
+eleven persistent collection types. The kernel implements all structural
+operations -- rotations, split, join, set algebra, positional access,
+traversal, parallel decomposition -- parameterized by a small, well-chosen
+set of extension points. Collection types are thin layers that configure
+these extension points and wrap the kernel's operations in type-appropriate
+semantics.
+
+The central insight is that weight-balanced trees with the split/join
+paradigm (Adams 1992; Blelloch, Ferizovic & Sun 2016) have an unusually
+clean factoring of concerns. Balance logic lives only in `join`. The
+recursive decomposition of every operation is independent of key ordering
+and node representation. This creates a natural extensibility boundary that
+we exploit through a pattern we call *representational polymorphism*.
+
+### Contributions
+
+1. **Representational polymorphism** as a design pattern for parameterizing
+   persistent tree kernels in dynamically-typed languages.
+
+2. **A layered abstraction architecture** with five distinct extension
+   points that together support eleven collection types from one kernel.
+
+3. **Three tests of generality**: parallel set algebra (testing thread
+   safety), augmented trees (testing node extensibility), and a chunked
+   persistent rope (testing the architecture's limits with a non-comparator
+   collection type that has no prior Clojure implementation).
+
+4. **Benchmark evidence** that this generality does not cost performance.
+
+---
+
+## 2. Foundation
+
+### 2.1 Why Weight-Balanced Trees
+
+The choice of balancing scheme is not incidental -- it is the architectural
+foundation that makes everything else possible.
+
+Weight-balanced trees (Nievergelt & Reingold 1972) store a subtree size at
+each node and maintain balance by bounding the ratio of sibling weights.
+Using the parameters delta=3, gamma=2 -- the unique valid integer pair,
+proven correct by Hirai & Yamamoto (2011) via Coq -- the height bound is
+log\_{3/2} n ~ 1.71 log\_2 n.
+
+Weight-balanced trees have three properties that distinguish them from AVL
+and red-black trees for our purposes:
+
+**Weight composes trivially after join.** After joining two subtrees with a
+pivot, the new weight is `weight(left) + 1 + weight(right)`. No auxiliary
+data (height, color, rank) needs recomputation. This gives WBTs the lowest
+constant factor for split/join of any practical balanced tree family.
+
+**The weight field IS the balance invariant AND the positional index.** The
+same `x` field that maintains tree balance also supports O(log n) nth, rank,
+slice, median, and percentile. No secondary data structure is needed for
+positional access.
+
+**The weight field composes with augmented data.** Interval tree
+max-endpoints, segment tree aggregates, and rope element counts all compose
+in the same framework as the weight itself -- computed during node
+construction and propagated automatically through rotations.
+
+### 2.2 The Split/Join Paradigm
+
+Adams (1992) showed that all tree operations reduce to two primitives:
+
+- **Split(tree, key)** → (left, found, right) in O(log n)
+- **Join(left, key, right)** → balanced tree in O(|height diff|)
+
+Insert is split + join. Delete is split + join. Union, intersection,
+difference are recursive split + join. Subrange extraction, positional
+split, fold -- all split + join.
+
+The critical property: **balance logic lives only in join.** Every operation
+inherits correct balancing automatically. This is the factoring that creates
+the kernel's extensibility boundary: the recursive structure of every
+operation is independent of how nodes are constructed. The kernel provides
+the structure; the extension points provide the representation.
+
+Blelloch, Ferizovic & Sun (2016) formalized this paradigm, proved it
+work-optimal (O(m log(n/m+1)) for set operations), and showed the span is
+O(log^2 n) -- enabling near-linear parallel speedup.
+
+---
+
+## 3. The Architecture
+
+The architecture has five layers, each providing a distinct extension point.
+Together they form a stack that transforms a generic tree algebra into a
+family of specialized persistent collections.
+
+![Architecture Layers](figures/architecture-layers.svg)
+
+### 3.1 Layer 1: Node Interfaces
+
+At the lowest level, three Java interfaces define what a tree node IS:
+
+```
+INode          — k(), v(), l(), r(), kv()     core fields
+IBalancedNode  — x()                          balance metric (weight)
+IAugmentedNode — z()                          auxiliary per-subtree data
+```
+
+Every node type implements `INode` and `IBalancedNode`. Augmented types
+additionally implement `IAugmentedNode`. The kernel accesses all node fields
+through these interfaces, never through concrete types. Field accessors use
+`definline` for zero-overhead inlining.
+
+This abstraction allows five concrete node types to share one tree algebra:
+
+```
+SimpleNode    [k v l r ^long x]          general purpose
+LongKeyNode   [^long k v l r ^long x]    unboxed long keys
+DoubleKeyNode [^double k v l r ^long x]  unboxed double keys
+IntervalNode  [k v l r ^long x z]        max-endpoint augmentation
+AggregateNode [k v l r ^long x agg]      cached subtree aggregate
+```
+
+### 3.2 Layer 2: The Two Dynamic Hooks
+
+Two Clojure dynamic variables parameterize the kernel:
+
+```clojure
+(def ^:dynamic *compare* default-comparator)   ;; java.util.Comparator
+(def ^:dynamic *t-join*  node-create-simple)    ;; [k v l r] → node
+```
+
+**`*compare*`** determines key ordering. Six serializable comparator types
+are provided, each a singleton with type-based equality enabling
+identity-check fast paths in hot lookup code.
+
+**`*t-join*`** determines node construction. It is a function
+`[key value left right] → new-node` that creates the appropriate node type
+and computes any augmented data.
+
+These two hooks suffice because the split/join paradigm cleanly separates
+the *recursive structure* of every operation from the *semantics* of
+ordering and node construction.
+
+### 3.3 Layer 3: Root-Level Interfaces
+
+Three Java interfaces define the contract between a collection type and the
+kernel:
+
+```
+INodeCollection     — getRoot(), getAllocator()
+IOrderedCollection  — getCmp(), isCompatible(), isSimilar()
+IBalancedCollection — getStitch()
+```
+
+`isCompatible()` enables fast compatibility checks for binary operations:
+two collections with the same comparator and constructor can have their
+trees combined directly without translation.
+
+### 3.4 Layer 4: Representational Polymorphism
+
+![Representational Polymorphism](figures/representational-polymorphism.svg)
+
+This is the central design pattern. The dynamic hooks (Layer 2) provide
+flexibility; representational polymorphism provides performance.
+
+The pattern: **capture once at the boundary, thread explicitly through the
+recursion.**
+
+```clojure
+;; Public entry point — reads dynamic vars:
+(defn node-set-union [n1 n2]
+  (node-set-union* n1 n2 *compare* *t-join*))
+
+;; Private hot path — explicit args, no dynamic var lookups:
+(defn- node-set-union* [n1 n2 ^Comparator cmp create]
+  (cond
+    (leaf? n1) n2
+    (leaf? n2) n1
+    :else
+    (let [[l1 _ r1] (node-split* n1 (root-key n2) cmp create)]
+      (node-concat3 (root-key n2) (root-val n2)
+        (node-set-union* l1 (left n2) cmp create)
+        (node-set-union* r1 (right n2) cmp create)
+        cmp create))))
+```
+
+Every hot recursive path follows this convention: a public arity that reads
+from dynamic vars, and a private `*`-suffixed arity that takes `cmp` and
+`create` as explicit arguments. The cost of dynamic binding is paid once per
+top-level operation; the inner recursion uses only local argument passing.
+
+This eliminates ~5-10ns per dynamic var access per node. But performance is
+only half the story. The pattern also solves a critical **correctness
+problem** for parallel execution, as we show in Section 4.1.
+
+### 3.5 Layer 5: Domain Protocols
+
+Ten Clojure protocols define the user-facing operations that collection
+types may support:
+
+```
+PExtensibleSet    — union, intersection, difference, subset?, superset?
+PRanked           — rank-of, slice, median, percentile
+PNearest          — nearest (floor/ceiling), subrange
+PSplittable       — split-key, split-at
+PRangeAggregate   — aggregate-range, aggregate, update-val, update-fn
+PIntervalCollection — overlapping
+PMultiset         — multiplicity, disj-one, disj-all
+PPriorityQueue    — push, peek-min, pop-min, peek-max, pop-max
+PFuzzy            — fuzzy-nearest, fuzzy-exact-contains?
+PRangeMap         — ranges, gaps, assoc-coalescing, range-remove
+```
+
+The protocols compose orthogonally with the kernel parameterization: any
+combination of comparator, node constructor, and protocol set defines a
+valid collection type.
+
+### 3.6 The Collection Family
+
+![Collection Family](figures/collection-family.svg)
+
+The architecture supports eleven collection types, each a thin wrapper
+that configures the extension points:
+
+| Collection | Comparator | Node Constructor | Augmentation | Key Semantics |
+|---|---|---|---|---|
+| ordered-set | default | SimpleNode | — | element = key |
+| ordered-map | default | SimpleNode | — | key → value |
+| long-ordered-set | Long/compare | LongKeyNode | — | unboxed long |
+| double-ordered-set | Double/compare | DoubleKeyNode | — | unboxed double |
+| string-ordered-set | String.compareTo | SimpleNode | — | string fast path |
+| interval-set | interval cmp | IntervalNode | max endpoint | [lo,hi] overlap |
+| interval-map | interval cmp | IntervalNode | max endpoint | [lo,hi] → value |
+| segment-tree | default | AggregateNode | cached op | range aggregate |
+| range-map | range cmp | SimpleNode | — | non-overlapping [lo,hi) |
+| fuzzy-set | default | SimpleNode | — | nearest-neighbor |
+| priority-queue | priority cmp | SimpleNode | — | [priority, value] |
+| multiset | element cmp | SimpleNode | — | [element, cardinality] |
+| rope | *none* | SimpleNode | — | chunk vector, positional |
+
+Adding a new collection type requires no kernel changes. When any part of
+the kernel is optimized, every collection type benefits automatically. This
+is the compound dividend of shared infrastructure.
+
+---
+
+## 4. Three Tests of Generality
+
+We test the architecture against three increasingly demanding challenges.
+Each pushes a different aspect of the design to its limits.
+
+### 4.1 Test 1: Parallel Set Algebra
+
+**Challenge:** Can the architecture support automatic fork-join parallelism
+across collection types without changes to the kernel?
+
+The split/join formulation of set operations has a natural parallel
+structure: the two recursive calls on the left and right halves of a split
+are independent and can be computed concurrently.
+
+But Clojure's dynamic variable bindings are thread-local. When a
+ForkJoinPool worker thread forks a subtask, the child task sees the *root
+bindings* (the defaults), not the collection-specific bindings. If the
+parallel kernel read `*compare*` from dynamic vars, forked tasks would use
+the wrong comparator. The result would be silent data corruption.
+
+This is not a hypothetical concern. The library's interval tree construction
+originally used parallel fold, which lost the `*t-join*` binding in forked
+threads, producing `SimpleNode`s instead of `IntervalNode`s and silently
+dropping max-endpoint augmentation.
+
+**How the architecture solves it:** Because representational polymorphism
+captures `cmp` and `create` as explicit arguments before entering the pool,
+all forked tasks receive the correct context through ordinary argument
+passing. No dynamic variable propagation is needed.
+
+```clojure
+(defn- node-set-union-parallel*
+  [n1 n2 ^Comparator cmp create recursive-threshold]
+  ;; cmp and create are explicit — correct in any thread
+  (let [[l1 _ r1] (node-split* n1 (root-key n2) cmp create)]
+    (fork-join
+      [left  (union-parallel* l1 (left n2) cmp create threshold)
+       right (union-parallel* r1 (right n2) cmp create threshold)]
+      (node-concat3 (root-key n2) (root-val n2)
+                    left right cmp create))))
+```
+
+The pattern designed for performance also solves the correctness problem of
+parallel execution. This is not a coincidence: both problems stem from the
+same need to decouple the kernel's recursive structure from the execution
+environment.
+
+The library uses empirically tuned, operation-specific thresholds (65K-131K
+for root entry, 65K for recursive re-fork, with a branch-shape guard that
+avoids forking lopsided splits). These were determined by a dedicated
+threshold sweep tool included in the library.
+
+### 4.2 Test 2: Augmented Trees
+
+**Challenge:** Can the architecture support per-subtree cached data --
+interval max-endpoints, segment aggregates -- without kernel modifications?
+
+The `*t-join*` hook makes this straightforward. The pattern for any
+associative per-subtree property:
+
+1. Define a node type with an extra field (implementing `IAugmentedNode`)
+2. Define a constructor that computes the field from k, v, l, r
+3. Bind `*t-join*` to that constructor
+
+Every rotation, split, and join calls the constructor. The augmented data
+propagates automatically. The kernel's rotation code contains no
+augmentation-specific logic -- it simply calls `create`, and the right thing
+happens.
+
+**Interval trees** augment each node with the maximum endpoint in its
+subtree, enabling O(log n + k) overlap queries.
+
+**Segment trees** augment each node with the cached aggregate of an
+associative operation, enabling O(log n) range queries.
+
+The augmentation pattern is openly extensible. Any collection type that
+needs per-subtree cached data can follow the same recipe. The kernel does
+the rest.
+
+### 4.3 Test 3: The Rope
+
+**Challenge:** Can the architecture support a collection with *no
+comparator*, *no keys*, and *fundamentally different semantics* from every
+other type in the family?
+
+The rope is the most demanding test. An interval map and an ordered set are
+both comparator-ordered key-value trees -- they differ only in augmentation.
+A rope is something altogether different: an implicit-index chunked sequence
+where position is derived entirely from subtree element counts.
+
+| Property | Interval Map | Rope |
+|---|---|---|
+| Ordering | comparator on intervals | implicit positional |
+| Key type | [lo, hi] interval pairs | none |
+| Node value | user value | subtree element count |
+| Node key | interval | chunk vector |
+| Primary query | overlap search | indexed access |
+| Primary mutation | assoc/dissoc by key | splice/insert at index |
+
+To our knowledge, no persistent rope implementation exists in the Clojure
+ecosystem.
+
+![Rope Kernel Sharing](figures/rope-kernel-sharing.svg)
+
+**What the rope reuses unchanged:** `node-stitch` (rotations), `node-weight`
+(balance), `SimpleNode` (storage, with repurposed fields), `node-greatest`/
+`node-least` (fringe access), `node-remove-least` (pivot extraction),
+`node-key-seq` (enumerator traversal), `node-reduce-keys` (chunk reduction),
+`node-healthy?` (balance verification) — eight kernel facilities.
+
+**What the rope replaces:** `node-split` → `rope-split-at` (index-based),
+`node-concat3` → `rope-join` (positional join), `node-add` →
+`rope-conj-right` (chunk append), `node-find` → `rope-nth` (element-count
+descent), `node-assoc` → `rope-assoc` (index-based update) — five
+position-aware equivalents, structurally isomorphic to what they replace.
+
+**The dual-metric design:** Each rope node stores both a subtree *node
+count* (for WBT balance) and a subtree *element count* (for indexed
+access). The tree balances by node count — so all rotation machinery works
+unchanged — while indexed operations descend by element count.
+
+**The Chunk Size Invariant:** A formal invariant analogous to B-tree minimum
+fill ensures that node-count balance implies good index performance. Every
+chunk has size in [min, target] (default [128, 256]); only the rightmost
+may be smaller.
+
+**The thin-layer claim:** The rope's algorithmic code is approximately 400
+lines, built on the 2000-line kernel. Compare this to building a rope from
+scratch — Boehm et al. (1995) requires its own balancing scheme, persistence
+mechanism, and traversal infrastructure. The WBT kernel provides all of
+these, and the rope inherits improvements to any of them automatically.
+
+---
+
+## 5. Evaluation
+
+### 5.1 Parallel Set Algebra
+
+The divide-and-conquer set algebra achieves dramatic speedups, growing with
+collection size as parallelism kicks in:
+
+| Operation | N=10K | N=100K | N=500K |
+|---|---:|---:|---:|
+| Union vs sorted-set | **15x** | **26x** | **57x** |
+| Intersection vs sorted-set | **9x** | **17x** | **36x** |
+| Difference vs sorted-set | **10x** | **22x** | **50x** |
+
+The advantage compounds from: (a) work-optimal O(m log(n/m+1)) complexity
+vs O(n) for naive approaches; (b) automatic fork-join parallelism above
+configurable thresholds; (c) lower join constants from trivial weight
+composition.
+
+### 5.2 Rope Structural Editing
+
+The rope delivers the architecture's most extreme performance ratios:
+
+| Workload | N=10K | N=100K | N=500K |
+|---|---:|---:|---:|
+| 200 random edits | **43x** | **498x** | **1968x** |
+| Single splice | **6x** | **116x** | **584x** |
+| Concat many pieces | **3x** | **5x** | **10x** |
+| Reduce (sum) | 0.4x | **1.7x** | **1.3x** |
+
+The structural editing advantage is unbounded: each vector splice copies
+O(n) elements while each rope splice does O(log n) tree work. The
+advantage grows linearly with N.
+
+Reduce beats vectors at scale because the rope's 256-element chunks give
+better cache locality per reduction step than PersistentVector's 32-wide
+trie nodes.
+
+### 5.3 Single-Element Operations
+
+Lookup, insert, and delete are near-parity (1.0-1.1x) with alternatives.
+These are single-element operations that do not exploit the split/join
+advantage. We report this honestly: the library's strength is structural
+and bulk operations, not point queries.
+
+---
+
+## 6. Limitations
+
+**Single-element operations** show no dramatic advantage. For pure
+lookup-heavy workloads, hash-based structures remain faster.
+
+**JVM-specific.** The dynamic var pattern relies on Clojure's thread-local
+binding mechanism. A ClojureScript port would require explicit context
+objects.
+
+**Threshold tuning is empirical.** The parallel thresholds represent
+practical defaults, not provable optima.
+
+**No formal verification.** The library is tested empirically: 579 tests,
+467K+ assertions, 27 property-based tests with vector reference oracles.
+
+---
+
+## 7. Related Work
+
+**Adams (1992, 1993).** The split/join paradigm for weight-balanced trees.
+The foundational insight on which this library builds.
+
+**Blelloch, Ferizovic & Sun (2016, 2022).** Formalized join-based
+algorithms, proved work-optimality, demonstrated parallel span of
+O(log^2 n). Their PAM library (Sun et al. 2018) is the closest related
+system: a C++ library implementing parallel augmented maps using templates
+for static polymorphism. We demonstrate the paradigm in a dynamic functional
+language, with the additional challenge of thread-local bindings that do not
+propagate to forked tasks.
+
+**Hirai & Yamamoto (2011).** Proved (delta=3, gamma=2) is the unique valid
+integer parameter pair. Found bugs in MIT Scheme and Haskell's Data.Map.
+
+**Haskell containers.** Weight-balanced trees in a pure functional language.
+No augmentation, no parallelism, no collection diversity beyond sets and
+maps.
+
+**Clojure data.avl (Marczyk).** AVL trees with split/join. No parallelism,
+no augmented types, higher join constants due to height recomputation.
+
+**Boehm, Atkinson & Plass (1995).** The canonical rope paper. Our rope
+uses continuous WBT balance (not Fibonacci rebalancing), generalizes to
+arbitrary elements, and inherits parallel fold from the shared kernel.
+
+**Kiselyov (2003).** Enumerator-based traversal as the fundamental
+collection API. Our enumerator design derives from this work.
+
+---
+
+## 8. Conclusion
+
+We have presented an architecture in which a single weight-balanced tree
+algebra, parameterized by five extension points, serves as the shared
+substrate for eleven persistent collection types. The *representational
+polymorphism* pattern -- capturing dynamic bindings at collection boundaries
+and threading them as explicit arguments through recursive hot paths --
+achieves the flexibility of dynamic dispatch with the performance of static
+parameterization, and simultaneously enables correct parallel execution in a
+language with thread-local dynamic bindings.
+
+We tested this architecture against three escalating challenges. Parallel
+set algebra showed that representational polymorphism enables correct
+fork-join execution (28-57x speedup). Augmented trees showed that the
+`*t-join*` hook supports per-subtree cached data with no kernel
+modifications. The rope -- a collection with no comparator, no keys, and
+fundamentally different semantics -- showed that ~400 lines of
+position-aware code suffice to build a novel collection type on the shared
+kernel, delivering up to 1968x over PersistentVector on structural editing.
+
+The broader lesson: persistent collection libraries need not be collections
+of isolated implementations. A carefully designed kernel with a small,
+well-chosen extensibility interface can support remarkable diversity without
+sacrificing performance. The effort invested in optimizing the kernel pays
+compound dividends across every collection type it supports.
+
+---
+
+## References
+
+- Adams, S. (1992). "Implementing Sets Efficiently in a Functional Language." CSTR 92-10, University of Southampton.
+- Adams, S. (1993). "Efficient sets -- a balancing act." *J. Functional Programming* 3(4).
+- Blelloch, G.E., Ferizovic, D., and Sun, Y. (2016). "Just Join for Parallel Ordered Sets." *ACM SPAA '16*.
+- Blelloch, G.E., Ferizovic, D., and Sun, Y. (2022). "Joinable Parallel Balanced Binary Trees." *ACM TOPC* 9(2).
+- Boehm, H.-J., Atkinson, R., and Plass, M. (1995). "Ropes: an Alternative to Strings." *Software: Practice and Experience* 25(12).
+- Hirai, Y. and Yamamoto, K. (2011). "Balancing Weight-Balanced Trees." *J. Functional Programming* 21(3).
+- Kiselyov, O. (2003). "Towards the best collection API."
+- Nievergelt, J. and Reingold, E.M. (1972). "Binary Search Trees of Bounded Balance." *SIAM J. Computing* 2(1).
+- Sun, Y., Ferizovic, D., and Blelloch, G.E. (2018). "PAM: Parallel Augmented Maps." *PPoPP '18*.
diff --git a/doc/concept/concept.pdf b/doc/concept/concept.pdf
new file mode 100644
index 0000000..1ffb55e
Binary files /dev/null and b/doc/concept/concept.pdf differ
diff --git a/doc/concept/figures/architecture-layers.svg b/doc/concept/figures/architecture-layers.svg
new file mode 100644
index 0000000..000977a
--- /dev/null
+++ b/doc/concept/figures/architecture-layers.svg
@@ -0,0 +1,88 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 720 520" font-family="Georgia, serif">
+  <defs>
+    <linearGradient id="kernel" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0%" stop-color="#2c3e50"/>
+      <stop offset="100%" stop-color="#1a252f"/>
+    </linearGradient>
+    <linearGradient id="hook" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0%" stop-color="#e74c3c"/>
+      <stop offset="100%" stop-color="#c0392b"/>
+    </linearGradient>
+    <linearGradient id="root" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0%" stop-color="#2980b9"/>
+      <stop offset="100%" stop-color="#1f6da0"/>
+    </linearGradient>
+    <linearGradient id="proto" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0%" stop-color="#27ae60"/>
+      <stop offset="100%" stop-color="#1e8c4c"/>
+    </linearGradient>
+    <linearGradient id="coll" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0%" stop-color="#8e44ad"/>
+      <stop offset="100%" stop-color="#6c3483"/>
+    </linearGradient>
+  </defs>
+
+  <!-- Title -->
+  <text x="360" y="30" text-anchor="middle" font-size="16" font-weight="bold" fill="#222">Abstraction Architecture</text>
+
+  <!-- Layer 5: Collection Types (top) -->
+  <rect x="40" y="50" width="640" height="60" rx="8" fill="url(#coll)" opacity="0.9"/>
+  <text x="360" y="75" text-anchor="middle" font-size="13" fill="white" font-weight="bold">Layer 5: Collection Types</text>
+  <text x="360" y="97" text-anchor="middle" font-size="10" fill="#ddd">ordered-set · ordered-map · interval-set · interval-map · segment-tree · range-map · rope · fuzzy-set · priority-queue · multiset</text>
+
+  <!-- Layer 4: Domain Protocols -->
+  <rect x="40" y="125" width="640" height="55" rx="8" fill="url(#proto)" opacity="0.9"/>
+  <text x="360" y="148" text-anchor="middle" font-size="13" fill="white" font-weight="bold">Layer 4: Domain Protocols</text>
+  <text x="360" y="167" text-anchor="middle" font-size="10" fill="#ddd">PExtensibleSet · PRanked · PNearest · PSplittable · PRangeAggregate · PIntervalCollection · PFuzzy · PMultiset · PPriorityQueue</text>
+
+  <!-- Layer 3: Root Interfaces -->
+  <rect x="40" y="195" width="640" height="55" rx="8" fill="url(#root)" opacity="0.9"/>
+  <text x="360" y="218" text-anchor="middle" font-size="13" fill="white" font-weight="bold">Layer 3: Root Interfaces</text>
+  <text x="360" y="237" text-anchor="middle" font-size="10" fill="#ddd">INodeCollection (getRoot, getAllocator) · IOrderedCollection (getCmp, isCompatible) · IBalancedCollection (getStitch)</text>
+
+  <!-- Layer 2: Dynamic Hooks + Representational Polymorphism -->
+  <rect x="40" y="265" width="310" height="70" rx="8" fill="url(#hook)" opacity="0.9"/>
+  <text x="195" y="290" text-anchor="middle" font-size="13" fill="white" font-weight="bold">Layer 2a: Dynamic Hooks</text>
+  <text x="195" y="308" text-anchor="middle" font-size="10" fill="#ddd">*compare* — java.util.Comparator</text>
+  <text x="195" y="322" text-anchor="middle" font-size="10" fill="#ddd">*t-join* — [k v l r] → node</text>
+
+  <rect x="370" y="265" width="310" height="70" rx="8" fill="url(#hook)" opacity="0.85"/>
+  <text x="525" y="290" text-anchor="middle" font-size="13" fill="white" font-weight="bold">Layer 2b: Capture Pattern</text>
+  <text x="525" y="308" text-anchor="middle" font-size="10" fill="#ddd">capture once at boundary</text>
+  <text x="525" y="322" text-anchor="middle" font-size="10" fill="#ddd">thread (cmp, create) explicitly</text>
+
+  <!-- Arrow between hook boxes -->
+  <line x1="350" y1="300" x2="370" y2="300" stroke="#fff" stroke-width="2" marker-end="url(#arrowWhite)"/>
+
+  <!-- Layer 1: Node Types -->
+  <rect x="40" y="350" width="640" height="55" rx="8" fill="#555" opacity="0.9"/>
+  <text x="360" y="373" text-anchor="middle" font-size="13" fill="white" font-weight="bold">Layer 1: Node Interfaces &amp; Types</text>
+  <text x="360" y="392" text-anchor="middle" font-size="10" fill="#ddd">INode (k,v,l,r) · IBalancedNode (x) · IAugmentedNode (z) → SimpleNode · LongKeyNode · DoubleKeyNode · IntervalNode · AggregateNode</text>
+
+  <!-- Layer 0: Kernel -->
+  <rect x="40" y="420" width="640" height="85" rx="8" fill="url(#kernel)" opacity="0.95"/>
+  <text x="360" y="443" text-anchor="middle" font-size="14" fill="white" font-weight="bold">Tree Algebra Kernel — tree.clj (~2000 lines)</text>
+  <text x="360" y="463" text-anchor="middle" font-size="10" fill="#aaa">stitch · split · join · concat · union · intersection · difference · merge · nth · rank · fold · enumerator · reduce</text>
+  <text x="360" y="479" text-anchor="middle" font-size="10" fill="#e74c3c">parallel fork-join: union · intersection · difference · merge — O(log²n) span</text>
+  <text x="360" y="495" text-anchor="middle" font-size="10" fill="#aaa">All parameterized by (cmp, create) — no knowledge of node types or collection semantics</text>
+
+  <!-- Side labels -->
+  <text x="18" y="465" text-anchor="middle" font-size="9" fill="#888" transform="rotate(-90, 18, 465)">SHARED</text>
+  <text x="18" y="82" text-anchor="middle" font-size="9" fill="#888" transform="rotate(-90, 18, 82)">PER-TYPE</text>
+
+  <!-- Arrows showing flow -->
+  <defs>
+    <marker id="arrowGray" markerWidth="8" markerHeight="6" refX="8" refY="3" orient="auto">
+      <path d="M0,0 L8,3 L0,6" fill="#999"/>
+    </marker>
+  </defs>
+  <line x1="360" y1="110" x2="360" y2="125" stroke="#999" stroke-width="1.5" marker-end="url(#arrowGray)"/>
+  <line x1="360" y1="180" x2="360" y2="195" stroke="#999" stroke-width="1.5" marker-end="url(#arrowGray)"/>
+  <line x1="360" y1="250" x2="360" y2="265" stroke="#999" stroke-width="1.5" marker-end="url(#arrowGray)"/>
+  <line x1="360" y1="335" x2="360" y2="350" stroke="#999" stroke-width="1.5" marker-end="url(#arrowGray)"/>
+  <line x1="360" y1="405" x2="360" y2="420" stroke="#999" stroke-width="1.5" marker-end="url(#arrowGray)"/>
+
+  <!-- Legend: "configure" vs "use" -->
+  <text x="700" y="310" text-anchor="end" font-size="9" fill="#e74c3c" font-style="italic">extension points</text>
+  <text x="700" y="465" text-anchor="end" font-size="9" fill="#2c3e50" font-style="italic">shared infrastructure</text>
+</svg>
diff --git a/doc/concept/figures/collection-family.svg b/doc/concept/figures/collection-family.svg
new file mode 100644
index 0000000..7fce9d8
--- /dev/null
+++ b/doc/concept/figures/collection-family.svg
@@ -0,0 +1,91 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 740 480" font-family="Georgia, serif">
+
+  <text x="370" y="28" text-anchor="middle" font-size="15" font-weight="bold" fill="#222">One Kernel, Eleven Collections</text>
+
+  <!-- Central kernel -->
+  <ellipse cx="370" cy="240" rx="110" ry="45" fill="#2c3e50" opacity="0.95"/>
+  <text x="370" y="233" text-anchor="middle" font-size="12" font-weight="bold" fill="white">tree.clj</text>
+  <text x="370" y="250" text-anchor="middle" font-size="9" fill="#bdc3c7">~2000 lines</text>
+  <text x="370" y="263" text-anchor="middle" font-size="8" fill="#95a5a6">split · join · stitch · fold</text>
+
+  <!-- Extension points labels -->
+  <text x="370" y="180" text-anchor="middle" font-size="9" fill="#e74c3c" font-weight="bold">*compare*    *t-join*</text>
+
+  <!-- Ordered collections (top left) -->
+  <rect x="20" y="60" width="130" height="32" rx="6" fill="#3498db"/>
+  <text x="85" y="81" text-anchor="middle" font-size="10" fill="white">ordered-set</text>
+
+  <rect x="20" y="100" width="130" height="32" rx="6" fill="#3498db"/>
+  <text x="85" y="121" text-anchor="middle" font-size="10" fill="white">ordered-map</text>
+
+  <!-- Primitive specialized (top) -->
+  <rect x="170" y="42" width="130" height="28" rx="6" fill="#2980b9"/>
+  <text x="235" y="61" text-anchor="middle" font-size="9" fill="white">long-ordered-set</text>
+
+  <rect x="170" y="78" width="130" height="28" rx="6" fill="#2980b9"/>
+  <text x="235" y="97" text-anchor="middle" font-size="9" fill="white">double-ordered-set</text>
+
+  <rect x="170" y="114" width="130" height="28" rx="6" fill="#2980b9"/>
+  <text x="235" y="133" text-anchor="middle" font-size="9" fill="white">string-ordered-set</text>
+
+  <!-- Augmented (top right) -->
+  <rect x="440" y="55" width="130" height="32" rx="6" fill="#e67e22"/>
+  <text x="505" y="76" text-anchor="middle" font-size="10" fill="white">interval-set</text>
+
+  <rect x="440" y="95" width="130" height="32" rx="6" fill="#e67e22"/>
+  <text x="505" y="116" text-anchor="middle" font-size="10" fill="white">interval-map</text>
+
+  <rect x="590" y="75" width="130" height="32" rx="6" fill="#d35400"/>
+  <text x="655" y="96" text-anchor="middle" font-size="10" fill="white">segment-tree</text>
+
+  <!-- Semantic variants (bottom left) -->
+  <rect x="20" y="350" width="130" height="32" rx="6" fill="#1abc9c"/>
+  <text x="85" y="371" text-anchor="middle" font-size="10" fill="white">fuzzy-set</text>
+
+  <rect x="20" y="390" width="130" height="32" rx="6" fill="#1abc9c"/>
+  <text x="85" y="411" text-anchor="middle" font-size="10" fill="white">fuzzy-map</text>
+
+  <rect x="170" y="370" width="130" height="32" rx="6" fill="#16a085"/>
+  <text x="235" y="391" text-anchor="middle" font-size="10" fill="white">priority-queue</text>
+
+  <rect x="170" y="410" width="130" height="32" rx="6" fill="#16a085"/>
+  <text x="235" y="431" text-anchor="middle" font-size="10" fill="white">multiset</text>
+
+  <!-- Range map (bottom) -->
+  <rect x="440" y="380" width="130" height="32" rx="6" fill="#9b59b6"/>
+  <text x="505" y="401" text-anchor="middle" font-size="10" fill="white">range-map</text>
+
+  <!-- Rope (bottom right, highlighted) -->
+  <rect x="590" y="360" width="130" height="55" rx="8" fill="#c0392b" stroke="#922b21" stroke-width="2"/>
+  <text x="655" y="383" text-anchor="middle" font-size="11" font-weight="bold" fill="white">rope</text>
+  <text x="655" y="400" text-anchor="middle" font-size="8" fill="#f5b7b1">no comparator</text>
+  <text x="655" y="412" text-anchor="middle" font-size="8" fill="#f5b7b1">implicit index</text>
+
+  <!-- Lines from kernel to collections -->
+  <line x1="290" y1="210" x2="150" y2="92" stroke="#3498db" stroke-width="1.2" opacity="0.5"/>
+  <line x1="290" y1="220" x2="150" y2="116" stroke="#3498db" stroke-width="1.2" opacity="0.5"/>
+  <line x1="310" y1="200" x2="235" y2="106" stroke="#2980b9" stroke-width="1" opacity="0.4"/>
+  <line x1="310" y1="200" x2="235" y2="78" stroke="#2980b9" stroke-width="1" opacity="0.4"/>
+  <line x1="310" y1="200" x2="235" y2="142" stroke="#2980b9" stroke-width="1" opacity="0.4"/>
+  <line x1="450" y1="210" x2="505" y2="87" stroke="#e67e22" stroke-width="1.2" opacity="0.5"/>
+  <line x1="450" y1="215" x2="505" y2="111" stroke="#e67e22" stroke-width="1.2" opacity="0.5"/>
+  <line x1="470" y1="205" x2="590" y2="91" stroke="#d35400" stroke-width="1.2" opacity="0.5"/>
+  <line x1="290" y1="270" x2="85" y2="350" stroke="#1abc9c" stroke-width="1.2" opacity="0.5"/>
+  <line x1="290" y1="275" x2="85" y2="390" stroke="#1abc9c" stroke-width="1.2" opacity="0.5"/>
+  <line x1="310" y1="280" x2="235" y2="370" stroke="#16a085" stroke-width="1.2" opacity="0.5"/>
+  <line x1="310" y1="280" x2="235" y2="410" stroke="#16a085" stroke-width="1.2" opacity="0.5"/>
+  <line x1="440" y1="270" x2="505" y2="380" stroke="#9b59b6" stroke-width="1.2" opacity="0.5"/>
+  <line x1="470" y1="275" x2="590" y2="375" stroke="#c0392b" stroke-width="1.5" opacity="0.7"/>
+
+  <!-- Category labels -->
+  <text x="85" y="50" text-anchor="middle" font-size="9" fill="#2980b9" font-weight="bold">Ordered</text>
+  <text x="235" y="36" text-anchor="middle" font-size="9" fill="#2980b9" font-weight="bold">Specialized</text>
+  <text x="505" y="47" text-anchor="middle" font-size="9" fill="#e67e22" font-weight="bold">Augmented</text>
+  <text x="85" y="340" text-anchor="middle" font-size="9" fill="#1abc9c" font-weight="bold">Nearest-Neighbor</text>
+  <text x="235" y="360" text-anchor="middle" font-size="9" fill="#16a085" font-weight="bold">Duplicate-Tolerant</text>
+  <text x="505" y="370" text-anchor="middle" font-size="9" fill="#9b59b6" font-weight="bold">Range</text>
+  <text x="655" y="350" text-anchor="middle" font-size="9" fill="#c0392b" font-weight="bold">Positional</text>
+
+  <!-- Bottom note -->
+  <text x="370" y="468" text-anchor="middle" font-size="10" font-style="italic" fill="#555">Adding a collection type requires no kernel changes — only a constructor that configures the two hooks.</text>
+</svg>
diff --git a/doc/concept/figures/representational-polymorphism.svg b/doc/concept/figures/representational-polymorphism.svg
new file mode 100644
index 0000000..1765bad
--- /dev/null
+++ b/doc/concept/figures/representational-polymorphism.svg
@@ -0,0 +1,62 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 700 380" font-family="Georgia, serif">
+  <defs>
+    <marker id="arr" markerWidth="8" markerHeight="6" refX="8" refY="3" orient="auto">
+      <path d="M0,0 L8,3 L0,6" fill="#555"/>
+    </marker>
+    <marker id="arrRed" markerWidth="8" markerHeight="6" refX="8" refY="3" orient="auto">
+      <path d="M0,0 L8,3 L0,6" fill="#c0392b"/>
+    </marker>
+    <marker id="arrGreen" markerWidth="8" markerHeight="6" refX="8" refY="3" orient="auto">
+      <path d="M0,0 L8,3 L0,6" fill="#27ae60"/>
+    </marker>
+  </defs>
+
+  <text x="350" y="25" text-anchor="middle" font-size="15" font-weight="bold" fill="#222">Representational Polymorphism: Capture Once, Thread Explicitly</text>
+
+  <!-- User call -->
+  <rect x="20" y="50" width="200" height="40" rx="6" fill="#f0f0f0" stroke="#888"/>
+  <text x="120" y="75" text-anchor="middle" font-size="11" fill="#333">(union set-a set-b)</text>
+
+  <line x1="220" y1="70" x2="260" y2="70" stroke="#555" stroke-width="1.5" marker-end="url(#arr)"/>
+
+  <!-- with-compare binding -->
+  <rect x="262" y="45" width="200" height="50" rx="6" fill="#ffeaa7" stroke="#d4ac0d"/>
+  <text x="362" y="65" text-anchor="middle" font-size="10" font-weight="bold" fill="#7d6608">with-compare</text>
+  <text x="362" y="82" text-anchor="middle" font-size="9" fill="#7d6608">binds *compare* from set-a</text>
+
+  <line x1="462" y1="70" x2="500" y2="70" stroke="#555" stroke-width="1.5" marker-end="url(#arr)"/>
+
+  <!-- Public entry -->
+  <rect x="502" y="45" width="180" height="50" rx="6" fill="#dfe6e9" stroke="#636e72"/>
+  <text x="592" y="65" text-anchor="middle" font-size="10" font-weight="bold" fill="#2d3436">node-set-union</text>
+  <text x="592" y="82" text-anchor="middle" font-size="9" fill="#636e72">reads *compare*, *t-join*</text>
+
+  <!-- CAPTURE moment -->
+  <line x1="592" y1="95" x2="592" y2="130" stroke="#c0392b" stroke-width="2" stroke-dasharray="4,3" marker-end="url(#arrRed)"/>
+  <text x="592" y="123" text-anchor="middle" font-size="10" font-weight="bold" fill="#c0392b">CAPTURE</text>
+
+  <!-- Private hot path -->
+  <rect x="250" y="140" width="430" height="50" rx="6" fill="#2c3e50" stroke="#1a252f"/>
+  <text x="465" y="160" text-anchor="middle" font-size="11" font-weight="bold" fill="#ecf0f1">node-set-union* [n1 n2 cmp create]</text>
+  <text x="465" y="177" text-anchor="middle" font-size="9" fill="#95a5a6">explicit arguments — no dynamic var reads</text>
+
+  <!-- Recursive calls -->
+  <line x1="350" y1="190" x2="280" y2="220" stroke="#27ae60" stroke-width="1.5" marker-end="url(#arrGreen)"/>
+  <line x1="580" y1="190" x2="650" y2="220" stroke="#27ae60" stroke-width="1.5" marker-end="url(#arrGreen)"/>
+
+  <rect x="180" y="222" width="200" height="40" rx="6" fill="#2c3e50" stroke="#1a252f"/>
+  <text x="280" y="247" text-anchor="middle" font-size="9" fill="#95a5a6">union*(L₁, left(B), cmp, create)</text>
+
+  <rect x="550" y="222" width="140" height="40" rx="6" fill="#2c3e50" stroke="#1a252f"/>
+  <text x="620" y="247" text-anchor="middle" font-size="9" fill="#95a5a6">union*(R₁, right(B), cmp, create)</text>
+
+  <!-- Fork-join annotation -->
+  <rect x="180" y="280" width="510" height="55" rx="6" fill="#fff5f5" stroke="#e74c3c" stroke-dasharray="4,3"/>
+  <text x="435" y="298" text-anchor="middle" font-size="10" font-weight="bold" fill="#c0392b">Inside ForkJoinPool — different threads</text>
+  <text x="435" y="315" text-anchor="middle" font-size="9" fill="#c0392b">Dynamic bindings do NOT propagate here.</text>
+  <text x="435" y="330" text-anchor="middle" font-size="9" fill="#c0392b">But cmp and create are ordinary arguments — they work in any thread.</text>
+
+  <!-- Key insight callout -->
+  <rect x="20" y="350" width="660" height="25" rx="4" fill="#27ae60" opacity="0.1"/>
+  <text x="350" y="367" text-anchor="middle" font-size="10" font-style="italic" fill="#1e8c4c">The pattern designed for performance (eliminating per-node var overhead) also solves the correctness problem of parallel execution.</text>
+</svg>
diff --git a/doc/concept/figures/rope-kernel-sharing.svg b/doc/concept/figures/rope-kernel-sharing.svg
new file mode 100644
index 0000000..0583888
--- /dev/null
+++ b/doc/concept/figures/rope-kernel-sharing.svg
@@ -0,0 +1,80 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 700 420" font-family="Georgia, serif">
+  <defs>
+    <marker id="a" markerWidth="8" markerHeight="6" refX="8" refY="3" orient="auto">
+      <path d="M0,0 L8,3 L0,6" fill="#555"/>
+    </marker>
+  </defs>
+
+  <text x="350" y="25" text-anchor="middle" font-size="15" font-weight="bold" fill="#222">The Rope: What Is Shared vs. What Is Replaced</text>
+
+  <!-- Kernel box -->
+  <rect x="30" y="50" width="300" height="340" rx="10" fill="#f8f9fa" stroke="#2c3e50" stroke-width="2"/>
+  <text x="180" y="75" text-anchor="middle" font-size="13" font-weight="bold" fill="#2c3e50">Tree Kernel (shared)</text>
+
+  <!-- Shared items -->
+  <rect x="50" y="90" width="260" height="24" rx="4" fill="#27ae60" opacity="0.15"/>
+  <text x="180" y="107" text-anchor="middle" font-size="10" fill="#1e8c4c">node-stitch — balancing rotations</text>
+
+  <rect x="50" y="120" width="260" height="24" rx="4" fill="#27ae60" opacity="0.15"/>
+  <text x="180" y="137" text-anchor="middle" font-size="10" fill="#1e8c4c">node-weight — balance metric</text>
+
+  <rect x="50" y="150" width="260" height="24" rx="4" fill="#27ae60" opacity="0.15"/>
+  <text x="180" y="167" text-anchor="middle" font-size="10" fill="#1e8c4c">SimpleNode — storage type</text>
+
+  <rect x="50" y="180" width="260" height="24" rx="4" fill="#27ae60" opacity="0.15"/>
+  <text x="180" y="197" text-anchor="middle" font-size="10" fill="#1e8c4c">node-greatest / node-least — fringe</text>
+
+  <rect x="50" y="210" width="260" height="24" rx="4" fill="#27ae60" opacity="0.15"/>
+  <text x="180" y="227" text-anchor="middle" font-size="10" fill="#1e8c4c">node-remove-least — pivot extraction</text>
+
+  <rect x="50" y="240" width="260" height="24" rx="4" fill="#27ae60" opacity="0.15"/>
+  <text x="180" y="257" text-anchor="middle" font-size="10" fill="#1e8c4c">node-key-seq — enumerator traversal</text>
+
+  <rect x="50" y="270" width="260" height="24" rx="4" fill="#27ae60" opacity="0.15"/>
+  <text x="180" y="287" text-anchor="middle" font-size="10" fill="#1e8c4c">node-reduce-keys — chunk reduction</text>
+
+  <rect x="50" y="300" width="260" height="24" rx="4" fill="#27ae60" opacity="0.15"/>
+  <text x="180" y="317" text-anchor="middle" font-size="10" fill="#1e8c4c">node-healthy? — balance verification</text>
+
+  <text x="180" y="355" text-anchor="middle" font-size="11" font-weight="bold" fill="#27ae60">8 facilities reused unchanged</text>
+
+  <!-- Rope box -->
+  <rect x="380" y="50" width="290" height="340" rx="10" fill="#fff5f5" stroke="#e74c3c" stroke-width="2"/>
+  <text x="525" y="75" text-anchor="middle" font-size="13" font-weight="bold" fill="#c0392b">Rope Layer (~400 lines)</text>
+
+  <!-- Replaced items -->
+  <rect x="400" y="90" width="250" height="24" rx="4" fill="#e74c3c" opacity="0.12"/>
+  <text x="525" y="107" text-anchor="middle" font-size="10" fill="#922b21">rope-split-at — index-based split</text>
+
+  <rect x="400" y="120" width="250" height="24" rx="4" fill="#e74c3c" opacity="0.12"/>
+  <text x="525" y="137" text-anchor="middle" font-size="10" fill="#922b21">rope-join — positional concat3</text>
+
+  <rect x="400" y="150" width="250" height="24" rx="4" fill="#e74c3c" opacity="0.12"/>
+  <text x="525" y="167" text-anchor="middle" font-size="10" fill="#922b21">rope-nth — element-count descent</text>
+
+  <rect x="400" y="180" width="250" height="24" rx="4" fill="#e74c3c" opacity="0.12"/>
+  <text x="525" y="197" text-anchor="middle" font-size="10" fill="#922b21">rope-conj-right — chunk append</text>
+
+  <rect x="400" y="210" width="250" height="24" rx="4" fill="#e74c3c" opacity="0.12"/>
+  <text x="525" y="227" text-anchor="middle" font-size="10" fill="#922b21">rope-assoc — index-based update</text>
+
+  <text x="525" y="265" text-anchor="middle" font-size="11" font-weight="bold" fill="#c0392b">5 position-aware equivalents</text>
+
+  <!-- Rope-specific additions -->
+  <rect x="400" y="285" width="250" height="24" rx="4" fill="#f39c12" opacity="0.15"/>
+  <text x="525" y="302" text-anchor="middle" font-size="10" fill="#7d6608">Chunk Size Invariant (CSI)</text>
+
+  <rect x="400" y="315" width="250" height="24" rx="4" fill="#f39c12" opacity="0.15"/>
+  <text x="525" y="332" text-anchor="middle" font-size="10" fill="#7d6608">Boundary normalization</text>
+
+  <rect x="400" y="345" width="250" height="24" rx="4" fill="#f39c12" opacity="0.15"/>
+  <text x="525" y="362" text-anchor="middle" font-size="10" fill="#7d6608">Transient tail buffer</text>
+
+  <!-- Arrows from kernel to rope -->
+  <line x1="310" y1="102" x2="398" y2="102" stroke="#27ae60" stroke-width="1" stroke-dasharray="4,2" marker-end="url(#a)"/>
+  <line x1="310" y1="132" x2="398" y2="132" stroke="#27ae60" stroke-width="1" stroke-dasharray="4,2" marker-end="url(#a)"/>
+  <line x1="310" y1="162" x2="398" y2="162" stroke="#27ae60" stroke-width="1" stroke-dasharray="4,2" marker-end="url(#a)"/>
+
+  <!-- Bottom summary -->
+  <text x="350" y="410" text-anchor="middle" font-size="11" font-style="italic" fill="#555">A conceptually novel collection built as a thin layer — not a separate implementation.</text>
+</svg>
diff --git a/doc/cookbook.md b/doc/cookbook.md
new file mode 100644
index 0000000..f317337
--- /dev/null
+++ b/doc/cookbook.md
@@ -0,0 +1,726 @@
+# Use Case Cookbook
+
+Practical examples showing where ordered-collections shines.
+
+## Setup
+
+```clojure
+(require '[ordered-collections.core :as oc])
+(require '[clojure.core.reducers :as r])
+```
+
+---
+
+## 1. Leaderboard with Rank Queries
+
+**Problem:** Maintain a leaderboard where you need to:
+- Add player scores
+- Get a player's rank
+- Get the top N players
+- Get players around a specific rank
+
+```clojure
+(defn make-leaderboard []
+  ;; Map from [score player-id] -> player-data
+  ;; Using [score id] tuple ensures uniqueness and sorts by score
+  (oc/ordered-map-with (fn [[s1 id1] [s2 id2]]
+                         (let [c (compare s2 s1)]  ; descending by score
+                           (if (zero? c)
+                             (compare id1 id2)     ; then ascending by id
+                             c)))))
+
+(defn add-score [board player-id score data]
+  (assoc board [score player-id] data))
+
+(defn top-n [board n]
+  (->> board (take n) (map (fn [[[score id] data]]
+                             {:id id :score score :data data}))))
+
+(defn rank-of-player [board player-id score]
+  (oc/rank board [score player-id]))
+
+(defn players-around-rank [board rank window]
+  (let [start (max 0 (- rank window))
+        end   (min (count board) (+ rank window 1))]
+    (map-indexed (fn [i [[score id] data]]
+                   {:rank (+ start i) :id id :score score})
+                 (oc/slice board start end))))
+
+;; Usage
+(def board (-> (make-leaderboard)
+               (add-score "alice" 1500 {:name "Alice"})
+               (add-score "bob" 1450 {:name "Bob"})
+               (add-score "carol" 1600 {:name "Carol"})
+               (add-score "dave" 1550 {:name "Dave"})))
+
+(top-n board 3)
+;; => ({:id "carol", :score 1600, :data {:name "Carol"}}
+;;     {:id "dave", :score 1550, :data {:name "Dave"}}
+;;     {:id "alice", :score 1500, :data {:name "Alice"}})
+
+(rank-of-player board "alice" 1500)  ;; => 2 (0-indexed)
+
+(players-around-rank board 2 1)
+;; => ({:rank 1, :id "dave", :score 1550}
+;;     {:rank 2, :id "alice", :score 1500}
+;;     {:rank 3, :id "bob", :score 1450})
+```
+
+**Why ordered-collections?** O(log n) rank queries. With sorted-map, finding rank requires O(n) iteration.
+
+---
+
+## 2. Time-Series Windowing
+
+**Problem:** Store timestamped events and efficiently query time ranges.
+
+```clojure
+(defn make-event-log []
+  (oc/ordered-map))  ; keys are timestamps (longs or instants)
+
+(defn add-event [log timestamp event]
+  (assoc log timestamp event))
+
+(defn events-between [log start-time end-time]
+  ;; O(log n) to find range, O(k) to iterate k results
+  (subseq log >= start-time < end-time))
+
+(defn events-last-n-minutes [log now minutes]
+  (let [cutoff (- now (* minutes 60 1000))]
+    (subseq log >= cutoff)))
+
+(defn latest-events [log n]
+  ;; Last n events (most recent first)
+  (take n (rseq log)))
+
+(defn count-events-in-window [log start-time end-time]
+  ;; Efficient: uses reduce, not seq materialization
+  (reduce (fn [acc _] (inc acc)) 0
+          (subseq log >= start-time < end-time)))
+
+;; Usage
+(def log (-> (make-event-log)
+             (add-event 1000 {:type :login :user "alice"})
+             (add-event 2000 {:type :click :page "/home"})
+             (add-event 3000 {:type :purchase :item "widget"})
+             (add-event 4000 {:type :logout :user "alice"})))
+
+(events-between log 1500 3500)
+;; => ([2000 {:type :click, :page "/home"}]
+;;     [3000 {:type :purchase, :item "widget"}])
+
+(latest-events log 2)
+;; => ([4000 {:type :logout, :user "alice"}]
+;;     [3000 {:type :purchase, :item "widget"}])
+```
+
+**Why ordered-collections?** Native `subseq`/`rsubseq` support with O(log n) range location.
+
+---
+
+## 3. Meeting Room Scheduler
+
+**Problem:** Track meeting room bookings and find conflicts or free slots.
+
+```clojure
+(defn make-room-schedule []
+  ;; interval-map: [start end] -> booking-info
+  (oc/interval-map))
+
+(defn book-room [schedule start end booking]
+  (assoc schedule [start end] booking))
+
+(defn conflicts-at [schedule time]
+  ;; What meetings overlap with this time?
+  (schedule time))
+
+(defn conflicts-during [schedule start end]
+  ;; What meetings overlap with this range?
+  (schedule [start end]))
+
+(defn is-available? [schedule start end]
+  (empty? (conflicts-during schedule start end)))
+
+;; Usage
+(def room-a (-> (make-room-schedule)
+                (book-room 900 1000 {:title "Standup" :organizer "alice"})
+                (book-room 1030 1130 {:title "Design Review" :organizer "bob"})
+                (book-room 1400 1500 {:title "1:1" :organizer "carol"})))
+
+(conflicts-at room-a 930)
+;; => [{:title "Standup", :organizer "alice"}]
+
+(conflicts-during room-a 1030 1100)
+;; => [{:title "Design Review", :organizer "bob"}]
+
+(is-available? room-a 1200 1400)  ;; => true
+(is-available? room-a 1430 1530)  ;; => false
+```
+
+**Why ordered-collections?** Interval queries in O(log n + k) where k is the number of overlapping intervals. Linear scan would be O(n).
+
+---
+
+## 4. Persistent Work Queue
+
+**Problem:** Schedule work by priority, while keeping stable ordering among equal priorities.
+
+```clojure
+(defn make-work-queue []
+  (oc/priority-queue))
+
+(defn enqueue [q priority task]
+  (oc/push q priority task))
+
+(defn next-task [q]
+  (oc/peek-min q))
+
+(defn run-next [q]
+  (let [[priority task] (oc/peek-min q)]
+    {:task task
+     :remaining (oc/pop-min q)}))
+
+;; Usage
+(def q (-> (make-work-queue)
+           (enqueue 5 {:job :backup})
+           (enqueue 1 {:job :page-oncall})
+           (enqueue 2 {:job :send-email})
+           (enqueue 1 {:job :invalidate-cache})))
+
+(next-task q)
+;; => [1 {:job :page-oncall}]
+
+(-> q run-next :task)
+;; => {:job :page-oncall}
+
+(-> q run-next :remaining next-task)
+;; => [1 {:job :invalidate-cache}]
+```
+
+**Why ordered-collections?** A persistent priority queue gives O(log n) enqueue/dequeue while preserving insertion order among equal priorities.
+
+---
+
+## 5. Parallel Aggregation
+
+**Problem:** Aggregate large datasets efficiently using multiple cores.
+
+```clojure
+;; Generate a large dataset
+(def transactions
+  (oc/ordered-map
+    (for [i (range 1000000)]
+      [i {:amount (rand-int 1000)
+          :category (rand-nth [:food :transport :entertainment :utilities])}])))
+
+;; Sequential sum
+(time
+  (reduce (fn [acc [_ {:keys [amount]}]] (+ acc amount)) 0 transactions))
+;; "Elapsed time: 130 msecs"
+
+;; Parallel sum with r/fold
+(time
+  (r/fold
+    +                                              ; combiner
+    (fn [acc [_ {:keys [amount]}]] (+ acc amount)) ; reducer
+    transactions))
+;; "Elapsed time: 75 msecs" (1.7x speedup)
+
+;; Parallel group-by category
+(time
+  (r/fold
+    (partial merge-with +)  ; combine partial results
+    (fn [acc [_ {:keys [amount category]}]]
+      (update acc category (fnil + 0) amount))
+    transactions))
+;; => {:food 124523456, :transport 125012345, ...}
+```
+
+**Why ordered-collections?** True parallel fold via tree splitting. `sorted-map` falls back to sequential.
+
+---
+
+## 6. Efficient Set Algebra
+
+**Problem:** Compute intersections/unions/differences on large sorted sets.
+
+```clojure
+;; Two sets of user IDs
+(def premium-users (oc/ordered-set (range 0 100000 2)))     ; 50K users
+(def active-users (oc/ordered-set (range 0 100000 3)))     ; 33K users
+
+;; Find premium AND active users
+(time (def premium-active (oc/intersection premium-users active-users)))
+;; "Elapsed time: 45 msecs" for 16,667 result elements
+
+;; With clojure.set on sorted-set:
+(def premium-ss (into (sorted-set) (range 0 100000 2)))
+(def active-ss (into (sorted-set) (range 0 100000 3)))
+(time (clojure.set/intersection premium-ss active-ss))
+;; "Elapsed time: 180 msecs" - 4x slower
+
+;; Set difference: premium but not active
+(time (oc/difference premium-users active-users))
+;; "Elapsed time: 50 msecs"
+
+;; Union with deduplication
+(time (oc/union premium-users active-users))
+;; "Elapsed time: 60 msecs" for 66,667 result elements
+```
+
+**Why ordered-collections?** O(m log(n/m)) set operations via split/join vs O(n) linear merge.
+
+---
+
+## 7. Sliding Window Statistics
+
+**Problem:** Maintain statistics over a sliding time window.
+
+```clojure
+(defn make-window [max-age-ms]
+  {:data (oc/ordered-map)  ; timestamp -> value
+   :max-age max-age-ms})
+
+(defn add-sample [{:keys [data max-age] :as window} timestamp value]
+  (let [cutoff (- timestamp max-age)
+        ;; Keep samples at or after the cutoff.
+        fresh-data (oc/subrange data :>= cutoff)]
+    (assoc window :data (assoc fresh-data timestamp value))))
+
+(defn window-stats [{:keys [data]}]
+  (when (seq data)
+    (let [values (map val data)
+          n (count values)
+          sum (reduce + values)]
+      {:count n
+       :sum sum
+       :mean (/ sum n)
+       :min (apply min values)
+       :max (apply max values)})))
+
+;; Usage: 5-second window
+(def w (-> (make-window 5000)
+           (add-sample 1000 10)
+           (add-sample 2000 20)
+           (add-sample 3000 15)
+           (add-sample 6000 25)   ; this triggers cleanup of t=1000
+           ))
+
+(window-stats w)
+;; => {:count 3, :sum 60, :mean 20, :min 15, :max 25}
+```
+
+**Why ordered-collections?** Efficient range deletion via split, O(log n) bounds queries.
+
+---
+
+## 8. Range Aggregate Queries (Segment Tree)
+
+**Problem:** Answer "what is the sum/max/min of values from key a to key b?" with efficient updates.
+
+```clojure
+;; Daily sales data
+(def sales
+  (oc/segment-tree + 0  ; operation and identity
+    {0 1200, 1 1500, 2 1100, 3 1800, 4 2200, 5 1900, 6 1600}))
+
+;; Query: total sales for days 2-5
+(oc/query sales 2 5)
+;; => 7000 (1100 + 1800 + 2200 + 1900)
+
+;; Query: total for entire week
+(oc/query sales 0 6)
+;; => 11300
+
+;; Update day 3's sales (O(log n) update, not rebuild)
+(def sales-updated (assoc sales 3 2500))
+(oc/query sales-updated 2 5)
+;; => 7700 (1100 + 2500 + 2200 + 1900)
+
+;; Track peak daily sales
+(def peaks (oc/segment-tree max 0 {0 1200, 1 1500, 2 1100, 3 1800, 4 2200, 5 1900, 6 1600}))
+(oc/query peaks 0 6)
+;; => 2200 (max across all days)
+
+(oc/query peaks 0 2)
+;; => 1500 (max for days 0-2)
+
+;; Shorthand for sum trees
+(def sum-tree (oc/sum-tree {0 100, 1 200, 2 300, 3 400}))
+(oc/query sum-tree 1 3)
+;; => 900 (200 + 300 + 400)
+```
+
+**Why ordered-collections?** O(log n) range queries and O(log n) updates. Linear scan would be O(n) per query.
+
+---
+
+## 9. Database Index Simulation
+
+**Problem:** Build a secondary index supporting range queries.
+
+```clojure
+(defn make-index []
+  ;; Maps indexed-value -> set of primary keys
+  (oc/ordered-map))
+
+(defn index-add [idx value pk]
+  (update idx value (fnil conj #{}) pk))
+
+(defn index-remove [idx value pk]
+  (let [pks (disj (get idx value #{}) pk)]
+    (if (empty? pks)
+      (dissoc idx value)
+      (assoc idx value pks))))
+
+(defn index-lookup [idx value]
+  (get idx value #{}))
+
+(defn index-range [idx min-val max-val]
+  ;; All PKs where min-val <= indexed-value < max-val
+  (->> (subseq idx >= min-val < max-val)
+       (mapcat val)
+       set))
+
+;; Usage: index users by age
+(def age-index (-> (make-index)
+                   (index-add 25 "user-1")
+                   (index-add 30 "user-2")
+                   (index-add 25 "user-3")
+                   (index-add 35 "user-4")
+                   (index-add 28 "user-5")))
+
+(index-lookup age-index 25)
+;; => #{"user-1" "user-3"}
+
+(index-range age-index 25 31)
+;; => #{"user-1" "user-3" "user-2" "user-5"}
+```
+
+**Why ordered-collections?** Range queries on index values with O(log n) bounds location.
+
+---
+
+## 10. Ordered Multiset
+
+**Problem:** Track duplicate values while keeping them sorted.
+
+```clojure
+(def readings
+  (oc/ordered-multiset [72 68 72 70 68 72 71]))
+
+(seq readings)
+;; => (68 68 70 71 72 72 72)
+
+(oc/multiplicity readings 72)
+;; => 3
+
+(oc/distinct-elements readings)
+;; => (68 70 71 72)
+
+(oc/element-frequencies readings)
+;; => {68 2, 70 1, 71 1, 72 3}
+
+(-> readings
+    (oc/disj-one 72)
+    (oc/multiplicity 72))
+;; => 2
+```
+
+**Why ordered-collections?** You get sorted duplicate-preserving semantics with efficient counting and removal of one occurrence.
+
+---
+
+## 11. Fuzzy Lookup / Nearest Neighbor
+
+**Problem:** Find the closest matching value when exact match doesn't exist.
+
+```clojure
+;; Temperature calibration table
+(def calibration (oc/fuzzy-map {0.0   1.000
+                                 25.0  1.012
+                                 50.0  1.025
+                                 75.0  1.041
+                                 100.0 1.058}))
+
+;; Get calibration factor for any temperature
+(calibration 23.5)   ; => 1.012 (closest to 25.0)
+(calibration 60.0)   ; => 1.025 (closest to 50.0)
+(calibration 87.5)   ; => 1.041 (closest to 75.0)
+
+;; With tiebreaker preference
+(def fm-prefer-larger (oc/fuzzy-map {0 :a 10 :b 20 :c} :tiebreak :>))
+(fm-prefer-larger 5)  ; => :b (equidistant from 0 and 10, prefer larger)
+
+;; Fuzzy set for snapping to grid values
+(def grid-points (oc/fuzzy-set (range 0 101 10))) ; 0, 10, 20, ..., 100
+(grid-points 23)  ; => 20
+(grid-points 27)  ; => 30
+(grid-points 25)  ; => 20 (tiebreak defaults to :<, prefer smaller)
+
+;; Get nearest with distance info
+(oc/fuzzy-nearest calibration 60.0)
+;; => [50.0 1.025 10.0]  ; [key value distance]
+
+(oc/fuzzy-nearest grid-points 23)
+;; => [20 3.0]  ; [value distance]
+```
+
+**Why ordered-collections?** O(log n) nearest-neighbor lookup using tree split. Linear scan would be O(n).
+
+---
+
+## 12. Splitting Collections
+
+**Problem:** Partition a collection at a key or index for divide-and-conquer algorithms.
+
+```clojure
+(def prices (oc/ordered-set [100 200 300 400 500 600 700 800 900 1000]))
+
+;; split-key: partition at a key value
+;; Returns [elements-below, exact-match-or-nil, elements-above]
+(let [[below match above] (oc/split-key 500 prices)]
+  {:below (vec below)    ;; => [100 200 300 400]
+   :match match          ;; => 500
+   :above (vec above)})  ;; => [600 700 800 900 1000]
+
+;; Key doesn't have to exist
+(let [[below match above] (oc/split-key 550 prices)]
+  {:below (vec below)    ;; => [100 200 300 400 500]
+   :match match          ;; => nil
+   :above (vec above)})  ;; => [600 700 800 900 1000]
+
+;; split-at: partition at an index
+;; Returns [left, right]
+(let [[left right] (oc/split-at 3 prices)]
+  {:left (vec left)      ;; => [100 200 300]
+   :right (vec right)})  ;; => [400 500 600 700 800 900 1000]
+
+;; Useful for pagination
+(defn paginate [coll page-size page-num]
+  (let [offset (* page-size page-num)
+        [_ remaining] (oc/split-at offset coll)
+        [page _] (oc/split-at page-size remaining)]
+    (vec page)))
+
+(paginate prices 3 1)  ;; => [400 500 600] (page 1, 0-indexed)
+```
+
+**Why ordered-collections?** O(log n) split operations. Essential for parallel algorithms and range partitioning.
+
+---
+
+## 13. Subrange Extraction
+
+**Problem:** Extract a contiguous range of elements by key bounds.
+
+```clojure
+(def inventory
+  (oc/ordered-map
+    [[10 "widget-a"] [20 "widget-b"] [30 "widget-c"]
+     [40 "widget-d"] [50 "widget-e"] [60 "widget-f"]]))
+
+;; Two-sided bounds
+(oc/subrange inventory :>= 25 :<= 50)
+;; => {30 "widget-c", 40 "widget-d", 50 "widget-e"}
+
+;; One-sided bounds
+(oc/subrange inventory :> 40)
+;; => {50 "widget-e", 60 "widget-f"}
+
+(oc/subrange inventory :< 30)
+;; => {10 "widget-a", 20 "widget-b"}
+
+;; Works with sets too
+(def ids (oc/ordered-set (range 0 100 5)))  ; 0, 5, 10, ..., 95
+(vec (oc/subrange ids :>= 20 :< 40))
+;; => [20 25 30 35]
+
+;; Count elements in range without materializing
+(count (oc/subrange ids :>= 50 :<= 80))  ;; => 7
+```
+
+**Why ordered-collections?** Returns a new ordered collection that shares structure with the original tree. O(log n) to create, efficient to iterate.
+
+---
+
+## 14. Floor/Ceiling Queries
+
+**Problem:** Find the nearest element at or above/below a target.
+
+```clojure
+(def versions (oc/ordered-set [100 200 300 450 500 800]))
+
+;; Find version at or below target
+(oc/nearest versions :<= 350)  ;; => 300
+(oc/nearest versions :<= 300)  ;; => 300 (exact match)
+(oc/nearest versions :<= 50)   ;; => nil (nothing at or below)
+
+;; Find version strictly below target
+(oc/nearest versions :< 300)   ;; => 200
+
+;; Find version at or above target
+(oc/nearest versions :>= 350)  ;; => 450
+(oc/nearest versions :>= 800)  ;; => 800
+
+;; Find version strictly above target
+(oc/nearest versions :> 500)   ;; => 800
+
+;; Practical: find applicable config version
+(def config-versions
+  (oc/ordered-map
+    [[100 {:feature-a true}]
+     [200 {:feature-a true :feature-b true}]
+     [350 {:feature-a true :feature-b true :feature-c true}]]))
+
+(defn config-for-version [v]
+  (when-let [[_ config] (oc/nearest config-versions :<= v)]
+    config))
+
+(config-for-version 275)
+;; => {:feature-a true, :feature-b true}
+```
+
+**Why ordered-collections?** O(log n) floor/ceiling queries using tree structure.
+
+---
+
+## Performance Tips
+
+1. **Use `reduce` over `seq`** - Direct reduce uses optimized IReduceInit path
+   ```clojure
+   ;; Fast
+   (reduce + 0 my-set)
+
+   ;; Slower (forces lazy seq)
+   (reduce + 0 (seq my-set))
+   ```
+
+2. **Use `r/fold` for large collections** - Parallelizes automatically
+   ```clojure
+   (r/fold + my-large-set)  ; uses all cores
+   ```
+
+3. **Use `subseq` for range queries** - More efficient than filter
+   ```clojure
+   ;; Fast: O(log n) to find bounds
+   (subseq my-map >= 100 < 200)
+
+   ;; Slow: O(n) full scan
+   (filter (fn [[k _]] (<= 100 k 199)) my-map)
+   ```
+
+4. **Use constructor for bulk loading**
+   ```clojure
+   ;; For bulk loading, use the constructor (uses parallel fold internally)
+   (oc/ordered-set big-data)     ; fast: parallel construction
+   (oc/ordered-map key-val-pairs)
+   ```
+
+5. **Use `subrange` instead of filtering**
+   ```clojure
+   ;; Fast: O(log n) bounds, returns a view
+   (oc/subrange my-set :>= 100 :< 200)
+
+   ;; Slow: creates intermediate seq, tests every element
+   (filter #(<= 100 % 199) my-set)
+   ```
+
+6. **Use `nearest` for floor/ceiling**
+   ```clojure
+   ;; Fast: O(log n)
+   (oc/nearest my-set :<= target)
+
+   ;; Slow: O(n) in worst case
+   (last (take-while #(<= % target) my-set))
+   ```
+
+7. **Use specialized constructors for homogeneous keys**
+   ```clojure
+   ;; 20% faster lookup for Long keys
+   (oc/long-ordered-set (range 1000000))
+   (oc/long-ordered-map (map #(vector % %) (range 1000000)))
+
+   ;; 5% faster for String keys
+   (oc/string-ordered-set ["alice" "bob" "carol"])
+   ```
+
+---
+
+## 11. Document Editor Buffer
+
+**Problem:** Implement an editor buffer that supports:
+- Efficient insert and delete at any position
+- Undo/redo via persistent snapshots
+- Extracting a visible window without copying the whole document
+- Fast bulk assembly from parts (e.g., loading a file in chunks)
+
+Vectors are O(n) for mid-document edits — every insertion shifts all subsequent
+elements. A rope does these in O(log n), and persistent snapshots are
+nearly free because edits share structure with previous versions.
+
+```clojure
+;; Build a document from paragraphs
+(def doc
+  (apply oc/rope-concat
+    (map oc/rope
+      [["T" "h" "e" " " "q" "u" "i" "c" "k" " "]
+       ["b" "r" "o" "w" "n" " " "f" "o" "x" " "]
+       ["j" "u" "m" "p" "s" "."]])))
+
+(count doc)        ;; => 26
+(nth doc 10)       ;; => "b"
+(apply str doc)    ;; => "The quick brown fox jumps."
+
+;; Insert at cursor position — O(log n)
+(def after-insert
+  (oc/rope-insert doc 10 ["dark " ]))
+
+;; after-insert is not a copy — it shares almost all structure with doc
+(apply str after-insert)
+;; => "The quick dark brown fox jumps."
+
+;; Delete a range — O(log n)
+(def after-delete
+  (oc/rope-remove after-insert 10 15))
+
+(apply str after-delete)
+;; => "The quick brown fox jumps."
+
+;; Replace (find and replace) — O(log n)
+(def after-replace
+  (oc/rope-splice doc 4 9 (seq "slow")))
+
+(apply str after-replace)
+;; => "The slow brown fox jumps."
+
+;; Undo: just keep the old version — structural sharing makes this cheap
+(def history [doc after-insert after-delete after-replace])
+(apply str (nth history 0))  ;; => "The quick brown fox jumps."
+(apply str (nth history 1))  ;; => "The quick dark brown fox jumps."
+
+;; Extract visible window — O(log n), shares structure
+(def visible (oc/rope-sub doc 4 15))
+(apply str visible)  ;; => "quick brown"
+
+;; Split document at a section break
+(let [[before after] (oc/rope-split doc 10)]
+  [(apply str before) (apply str after)])
+;; => ["The quick " "brown fox jumps."]
+```
+
+**Why ordered-collections?** Every edit is O(log n) regardless of document
+size. A 100K-character document with 200 random edits takes ~3ms on a rope vs
+~5 seconds on a vector — a 1,968x advantage. The persistent structure means
+undo history is just a list of references, not copies.
+
+**Scaling:**
+
+| Operation | Rope | Vector |
+|---|---|---|
+| Insert at position | O(log n) | O(n) |
+| Delete range | O(log n) | O(n) |
+| Concatenate documents | O(log n) | O(n) |
+| Extract visible window | O(log n) | O(1) |
+| Undo (keep old version) | free | O(n) copy |
+| Reduce over full document | O(n) | O(n) |
diff --git a/doc/papers/Adams92-implementing-sets-efficiently.pdf b/doc/papers/Adams92-implementing-sets-efficiently.pdf
new file mode 100644
index 0000000..f62dc24
Binary files /dev/null and b/doc/papers/Adams92-implementing-sets-efficiently.pdf differ
diff --git a/doc/papers/Adams93-efficient-sets-balancing-act.pdf b/doc/papers/Adams93-efficient-sets-balancing-act.pdf
new file mode 100644
index 0000000..9ae5faa
Binary files /dev/null and b/doc/papers/Adams93-efficient-sets-balancing-act.pdf differ
diff --git a/doc/papers/BFS16.pdf b/doc/papers/BFS16.pdf
new file mode 100644
index 0000000..66b7560
Binary files /dev/null and b/doc/papers/BFS16.pdf differ
diff --git a/doc/papers/Baine07-purely-functional-data-structures-common-lisp.pdf b/doc/papers/Baine07-purely-functional-data-structures-common-lisp.pdf
new file mode 100644
index 0000000..8743947
Binary files /dev/null and b/doc/papers/Baine07-purely-functional-data-structures-common-lisp.pdf differ
diff --git a/doc/papers/DriscollSarnakSleatorTarjan89-making-data-structures-persistent.pdf b/doc/papers/DriscollSarnakSleatorTarjan89-making-data-structures-persistent.pdf
new file mode 100644
index 0000000..74dad0d
Binary files /dev/null and b/doc/papers/DriscollSarnakSleatorTarjan89-making-data-structures-persistent.pdf differ
diff --git a/doc/papers/HiraiYamamoto11-balancing-weight-balanced-trees.pdf b/doc/papers/HiraiYamamoto11-balancing-weight-balanced-trees.pdf
new file mode 100644
index 0000000..9351549
Binary files /dev/null and b/doc/papers/HiraiYamamoto11-balancing-weight-balanced-trees.pdf differ
diff --git a/doc/papers/Kiselyov03-towards-best-collection-API.txt b/doc/papers/Kiselyov03-towards-best-collection-API.txt
new file mode 100644
index 0000000..351f331
--- /dev/null
+++ b/doc/papers/Kiselyov03-towards-best-collection-API.txt
@@ -0,0 +1,498 @@
+;; -*-mode: Outline;  -*-
+
+Towards the best collection API
+
+* Abstract
+Most programming languages support collections, represented by an
+in-memory data structure, a file, a database, or a generating
+function. A programming language system gives us typically one of the
+two interfaces to systematically access elements of a collection. One
+traversal API is based on enumerators -- e.g., for-each, map, filter
+higher-order procedures -- of which the most general is fold. The
+second approach relies on streams, a.k.a. cursors, lazy
+lists. Generators such as the ones in Icon, Ruby and Python are a
+hybrid approach.
+
+This article presents a design of the overall optimal collection
+traversal interface, which is based on a left-fold-like combinator
+with premature termination. We argue from the practical standpoint
+that such an interface is superior: in efficiency; in ease of
+programming; in more predictable resource utilization and avoidance of
+resource leaks.
+
+We also demonstrate a procedure that converts _any_ left-fold-like
+enumerator for any collection into the corresponding
+cursor. Therefore, the stream-based interface, when it is truly needed
+or preferred, can be automatically and generically derived from the
+proposed interface.
+
+We present two variants of the left-fold enumerator: for languages
+with and without first-class continuations. The proposed traversal
+interface has been implemented in a Scheme database access API used in
+a production environment. The generic-left-fold-based interface
+underlies the Collection SRFI (Scheme Request for Implementation) and
+is being considered for an Oracle database interface in Haskell.
+
+
+* Introduction and terminology
+Access to collections cuts through many programming languages. By a
+collection we mean a hash table; a file as a collection of lines,
+words, or bytes; a file system directory; an XML document; a suffix
+tree; or a "dynamic" collection produced by a database query or any
+other generating function.
+
+There are two basic approaches to systematically access collection
+elements. One approach relies on enumerators such as 'map', 'for-each'
+and 'filter'. The most general of those is fold, which lets us
+maintain our state during the traversal. The other traversal API is
+based on lazy lists (a.k.a. cursors, or streams).
+
+A word about terminology is in order, as it is rather confusing.  We
+will call a higher-order for-each-type procedure an enumerator. It is
+this procedure that takes a collection and a handler, and applies the
+handler to each element of the collection in turn. The handler itself
+will be called an iteratee, because it is being applied -- by an
+active entity, the enumeratOR.  An enumerator is presumably privy to
+the internals of a collection; it knows how to fetch elements in some
+(specified) order, and knows when to stop. A handler does not have
+this knowledge, nor is it supposed to. Throughout the article we
+eschew the commonly used term 'iterator': in C++ it means an accessor,
+which does not iterate over a collection. Rather, it is _being_
+iterated. On the other hand, languages like OCaml provide a procedure
+'iter' that actively traverses a collection, applying a user-defined
+function to elements.
+
+The next section argues from the practical standpoint against cursors
+and for enumerators. We contend that an enumerator such as left fold
+should be the primary means of traversing and obtaining all values of
+a collection. Enumerators are superior to cursors:
+      - in efficiency
+      - in ease of programming
+      - in more predictable resource utilization and
+      avoidance of resource leaks.
+The latter is of special importance for collections backed by external
+resources such as file handles and database connections.
+
+Section 3 proposes the overall optimal enumeration interface, which
+adds premature termination and explicit multiple state variables to
+the left fold. Section 4 discusses generators.
+
+Given a stream, we can always construct the corresponding
+enumerator. It is perhaps less appreciated that given a left fold
+enumerator, we can always construct the corresponding stream: we can
+invert an enumerator inside out. Section 5 describes the inversion
+procedure, which is fully generic and works for any
+collection. Because the enumerator interface subsumes the cursor-based
+one and because the former is more efficient and less error-prone, a
+collection API should offer enumerators as the primary, native
+traversal interface.
+
+The automatical enumerator inversion procedure in Section 5 relies on
+first-class (delimited) continuations. However, we can write a similar
+enumerator inversion even in a language that lacks first-class
+continuations.  Section 6 demonstrates a non-recursive left-fold-like
+combinator that can be instantiated into the ordinary left fold or into
+a stream. Both instantiation procedures are generic and do not depend
+on the type of the collection.
+
+In conclusion, we recap our recommendations for the optimal collection
+traversal API and point out to the existing implementations of the
+API.
+
+
+
+* Why an enumerator is better than a cursor
+
+There are many fundamental reasons why enumerators such as fold are
+profoundly better than cursors. One such reason is the ease of program
+analysis and optimizations [Sheard, Bananas, Hutton]. This
+article will not discuss them. Instead, we concentrate on utterly
+practical considerations: performance, ease of programming, and
+resource utilization.
+
+Writing a procedure that traverses, e.g., an AVL tree is far easier
+than writing a cursor that remembers the current position and can
+advance to the next one. The latter is especially tricky if the tree
+in question does not have parent pointers (which waste space and lead
+to sharing and resource leakage problems). One look at the C++ STL
+should convince one how wretched programming of iterators could be.
+
+The "current element" of a cursor is a state, which can be altered by
+advancing the cursor. This state introduces an implicit dependency
+among all expressions that use the cursor, similar to the dependency
+imposed by global mutable variables. Therefore, programming with
+cursors is error-prone. In contrast, an enumerator does not expose its
+traversal state to an iteratee and does not permit any alteration to
+that state by an iteratee. The difference between the leaky and the
+perfect encapsulations of the traversal state is well explained in
+[ULLMAN] when comparing a cursor-based network database query language
+DBTG with SQL. Incidentally, streams, another cursor-based interface,
+expose the current element and hence eliminate the implicit state
+dependency.
+
+Another problem of cursors is telling the user that there are no more
+values to access. When a collection is exhausted, cursor operations
+typically return an "out-of-band" value such as EOF (cf.  getc() in C)
+or raise an exception (cf. iterator.next() in Python). None of these
+approaches appear entirely satisfactory. Unlike cursors, an enumerator
+does not need to do anything special to tell the iteratee that the
+traversal is finished: the enumerator will simply return. There is no
+longer a problem with out-of-band values and user's disregarding such
+values.
+
+Cursors are simply less efficient. A cursor must maintain the state of
+the traversal. That state may be invalid. Each operation on a cursor,
+therefore, must first verify that the cursor is in the valid
+state. The cost of the checks quickly adds up.
+
+This issue of the inefficiency of cursors is well known. For example,
+it is highly advisable to use "native" operations to move large
+sections of an array (ArrayCopy in Java) rather than copy
+element-by-element. The cost of an array bound check on each access to
+an element is one of the considerations.
+
+Enumerators can do more than just eliminate redundant bound
+checks. Enumerators, if implemented as staged functions (e.g., C++
+templates) can tile or unroll loops and thus partially or completely
+remove the traversal iteration overhead [Veldhuizen]. The perfect
+encapsulation of the traversal state makes enumerators particularly
+adaptable for multi-stage programming.
+
+Databases give another example of the efficiency of enumerators: "The
+performance of cursors is horrible in almost all systems. One of us
+(Shasha) once had an experience of re-writing an eight-hour query
+having nested cursors into a cursor-free query that took 15 seconds."
+[Shasha]
+
+It is often said that the key to the best performance is to 
+do more on the server. To find the maximum value of a database table
+column, it's far faster to evaluate
+       select MAX(col) from collection
+than to open a cursor on the collection and retrieve all values from
+'col' searching for the maximum. Stored procedure languages (some of
+which are quite sophisticated) were introduced to make the server-side
+processing easier and powerful.  We should stress that 
+	select MAX(col) from collection
+is precisely equivalent to
+	foldl max lower_bound collection
+
+
+Traversing a collection often requires resources, e.g., a stack space,
+a connection to a database, a DIR handle, a DOM tree of an XML
+document, etc. An enumerator takes care of allocating these resources.
+When iteratee explicitly tells the enumerator to stop -- or when the
+collection is exhausted -- the enumerator can orderly free the
+resources. An enumerator can be programmed as
+
+	   (define (enum proc collection)
+	       (let ((database-connection #f))
+		(dynamic-wind
+		   (lambda () 
+		      (set! database-connection
+			    (open-connection collection)))
+		   (lambda () (iterate proc))
+		   (lambda ()
+		      (set! database-connection
+		            (close-connection database-connection))))))
+
+If 'proc' does not capture its continuation [Footnote-1] -- as it is
+often the case -- the database connection is opened (taken from the
+pool) at the beginning of the iteration and is returned to the pool at
+the end.  If we were to provide access to our collection in the form of
+a cursor, we would have to place the variable 'database-connection'
+into that cursor. We cannot close the database until the cursor is
+alive. But how do we know when there are no alive cursors and
+therefore it is safe to recycle the database connection? We must rely
+either on the programmer's explicitly closing the connection, or on a
+finalizer. The sheer number of internet security advisories concerning
+memory allocation problems indicates that manual management of
+resources is greatly error-prone. The finalizer solution is not
+satisfactory either: finalizers are rarely supported and when they
+are, they are an unreliable tool to manage precious resources. The
+execution of finalizers is unpredictable and is generally beyond
+programmer's control.
+
+[Footnote-1]
+An iteratee may call a continuation captured before the enumerator was
+entered. For that reason, an enumerator should employ a dynamic-wind
+to detect such an attempt to escape, shed excessive resources and
+switch to a "low-power" mode while the iteratee is on the run.
+
+
+* The most general enumeration interface
+
+We propose the following general enumeration interface. It is based on
+a left-fold enumerator and explicitly supports multiple state
+variables (i.e., seeds) and a premature termination of the
+iteration. In this Section we describe the interface in pseudo-code,
+which can be instantiated in Scheme [SRFI-44], Haskell ([Daume],
+Section 6) or other concrete language.
+
+The enumeration procedure
+   coll-fold-left COLL PROC SEED SEED ... -> [SEED ... ]
+
+traverses the collection denoted by COLL. The procedure takes one or
+more state arguments denoted by SEED, and returns just as many. PROC
+is an iteratee procedure:
+   PROC VAL SEED SEED ... -> [INDIC SEED SEED ...]
+
+It takes n+1 arguments and returns n+1 values. The first argument is
+the current value retrieved from the collection. The other n arguments
+are the seeds. The first return value is a boolean indicator, whose
+false value causes the premature termination of the iteration.  The
+other return values from PROC are the new values of the seeds. The
+procedure coll-fold-left enumerates the collection in some order and
+invokes PROC passing it the current value of the collection and the
+current seeds. The first invocation of PROC receives SEEDs that were
+the arguments of coll-fold-left. The further invocations of PROC
+receive SEEDs that were produced by the previous invocation of
+PROC. When the collection is exhausted or when the PROC procedure
+returns the indicator value of false, coll-fold-left terminates the
+iterations, disposes of allocated resources, and returns the current
+SEEDs. If the collection COLL is empty, coll-fold-left does not invoke
+PROC and returns its argument SEEDs.
+
+
+
+* Enumerators and generators
+
+A programming language Icon popularized generators as a way to
+traverse actual and virtual collections. Generators are also supported
+in Ruby and Python. The documentation of Icon defines a generator as
+an expression that can produce several values, on demand.
+Multiple-valued expressions can also be implemented with shift and
+reset [SHIFT]. The paper [SHIFT] gives many examples of their use.
+
+Generators occupy an intermediate place between enumerators and
+cursors. A generator is just as easy to write as an enumerator. It
+traverses a collection, fetches the current element and _yields_ it,
+by passing the element to a dedicated procedure or syntax form. When
+the latter returns, the traversal continues. On the other hand,
+generators are trivially related to streams [ENUM-CC]. The latter
+article discusses generators and enumerators in more
+detail. Incidentally, the article demonstrates that a generator-based
+code in Python can be translated into Scheme almost
+verbatim. Generators give the first hint that enumerators and cursors
+are related via first-class continuations.
+
+Like cursors and streams, generators are demand-driven. A user must
+explicitly request a new value to advance the traversal. Therefore,
+like cursors generators leak resources: it is not clear when the
+iteration should be assumed terminated and the associated resources
+can be safely disposed of.
+
+
+* How to invert an enumerator in a language with first-class continuations
+
+Sometimes we indeed need to traverse a collection via a cursor.
+Reasons may include moving data from one collection to another, or
+interfacing legacy code. If a collection API provides enumerators, we
+obtain cursors for free. We pass an enumerator to a generic
+translation procedure, which inverts the enumerator "inside out" and
+returns a cursor.
+
+The following code illustrates the conversion in Scheme, a language
+with first-class continuations. The procedure lfold->lazy-list is a
+fully generic translation procedure: it takes a left-fold enumerator
+for _any_ collection, and converts the enumerator to a stream (lazy
+list). The latter is a realization of a cursor.
+
+(define (lfold->lazy-list lfold collection)
+  (delay
+    (call-with-current-continuation
+      (lambda (k-main)
+	(lfold collection
+	  (lambda (val seed)
+	    (values
+	      (call-with-current-continuation
+		(lambda (k-reenter)
+		  (k-main
+		    (cons val
+		      (delay
+			(call-with-current-continuation
+			  (lambda (k-new-main)
+			    (set! k-main k-new-main)
+			    (k-reenter #t))))))))
+	      seed))
+	  '()) 				; Initial seed
+	(k-main '())))))
+
+
+The present article is an abstract. Code in a functional language is
+the best abstract. The discussion is delegated to the talk and the
+full paper. The article [ENUM-CC] discusses the inversion procedure in
+more detail and points out to the complete code and the test cases.
+
+
+* How to invert an enumerator in a language without first-class continuations
+
+If a programming language lacks first-class continuations, the
+conversion from an enumerator to a cursor is still possible. However,
+we need to generalize the enumerator interface and make it
+non-recursive. For concreteness, this section demonstrates our
+approach for one particular language without first-class
+continuations: Haskell. Applications to other languages are
+straightforward.
+
+In Haskell, the general left-fold enumerator has the following
+interface [HINV]:
+
+> type CFoldLeft coll val m seed = coll -> CollEnumerator val m seed
+> type CollEnumerator val m seed =
+>        Iteratee val seed
+>        -> seed      -- the initial seed
+>        -> m seed
+> type Iteratee val seed = seed -> val -> Either seed seed
+
+where 'coll' is the type of a collection with elements of the type
+'val', and 'm' is an arbitrary monad. The type 'seed' is the type of a
+state variable or variables (if the seed is a tuple). If an iteratee
+returns Right seed', the iteration continues with seed' as the new
+seed. If the iteratee returns Left seed'', the enumerator immediately
+stops further iterations, frees all the resources, and returns seed''
+as the final result.
+
+Incidentally, Hal Daume III mentioned [DAUME] that such left-fold
+enumerator is indeed useful in practice. It is his preferred method of
+iterating over a file considered as a collection of characters, lines,
+or words.
+
+To make the enumerator non-recursive, we need to add an additional
+argument -- self:
+
+> type CFoldLeft' val m seed = 
+>        Self (Iteratee val seed) m seed
+>        -> CollEnumerator val m seed
+> type Self iter m seed = iter -> seed -> m seed
+> type CFoldLeft1Maker coll val m seed = coll -> m (CFoldLeft' val m seed)
+
+A function of the type CFoldLeft' is also an enumerator. However, that
+enumerator does not recurse to advance the traversal. It invokes Self
+instead. Given CFoldLeft1Maker, we can obtain either the CFoldLeft
+enumerator, or a stream.  The former translation procedure amounts to
+taking a fixpoint:
+
+> hfold_nonrec_to_rec:: (Monad m) => 
+>        coll -> (CFoldLeft1Maker coll val m seed)
+>             -> m (CollEnumerator val m seed)
+> hfold_nonrec_to_rec coll hfold1_maker = do
+>    hfold_left' <- hfold1_maker coll
+>    return $ fix hfold_left'
+> fix f = f g where g = f g
+
+Converting CFoldLeft' into a stream is equally simple:
+
+> data MyStream m a = MyNil (Maybe a) | MyCons a (m (MyStream m a))
+
+> hfold_nonrec_to_stream:: 
+>    (Monad m) => CFoldLeft' val m (MyStream m val) 
+>                 -> m (MyStream m val)
+> hfold_nonrec_to_stream hfold_left' = do
+>   let k fn (MyNil Nothing)  = return $ MyNil Nothing
+>       k fn (MyNil (Just c)) 
+>         = return $ MyCons c (hfold_left' k fn (MyNil Nothing))
+>   hfold_left' k (\_ c -> Right $ MyNil $ Just c) (MyNil Nothing)
+
+The polymorphic types of both conversion procedures indicate that the
+procedures are generic and apply to any collection and any traversal.
+
+
+The article [HINV] demonstrates both translations of CFoldLeft' on a
+concrete example of a file taken as a collection of
+characters. Haskell provides a cursor interface to that collection:
+hGetChar. We implement a left fold enumerator CFoldLeft'. We then show
+how to turn that enumerator back to a stream: how to express functions
+myhgetchar and myhiseof only in terms of the left fold enumerator. The
+derivation of these functions is independent of the precise nature of
+the enumerator. Incidentally, if we turn two enumerators into streams,
+we can safely interleave these streams.
+
+
+* Conclusions
+
+In a language with first-class continuations, we propose
+coll-fold-left as the overall optimal interface to systematically
+access values of a collection (Section 3):
+
+   coll-fold-left COLL PROC SEED SEED ... -> [SEED ... ]
+   PROC VAL SEED SEED ... -> [INDIC SEED SEED ...]
+
+In a language without first-class continuations, we propose
+CFoldLeft1Maker (Section 6) as such optimal interface. 
+
+The enumerator-based interface is optimal because enumerators: are
+easier to write; are less error-prone to use; are more efficient;
+provide a better encapsulation of the state of the traversal; avoid
+resource leaks.
+
+We have presented generic conversion procedures that turn enumerators
+into cursors. The existence of these procedures demonstrates that
+enumerator- and cursor-based interfaces are inter-convertible. We have
+argued however that the enumerator interface should be considered
+primary and offered natively in a collection API. It is far more
+efficient and easy for a programmer to implement cursors via
+enumerators, than the other way around.
+
+The coll-fold-left interface has indeed been implemented and tested in
+practice. We have written a relational database interface for Scheme
+[DBINTF], which we have been using in the production environment. We
+have also implemented coll-fold-left to enumerate entries in a TIFF
+image tag directory. The enumerator coll-fold-left has been chosen to
+be the primary traversal interface in Scheme Collections SRFI
+[SRFI-44]. A similar interface is being considered for an Oracle RDBMS
+binding in Haskell.
+
+
+* References
+
+[SHIFT] Olivier Danvy and Andrzej Filinski. Abstracting Control.
+Proc. 1990 ACM Conf. on LISP and Functional Programming, pp. 151-160,
+Nice, France, June 1990.
+
+[Daume] Hal Daume III.  Re: From enumerators to cursors: turning the 
+left fold inside out.
+A message posted on the Haskell mailing list on
+24 Sep 2003 07:47:23 -0700.
+
+[Hutton] Graham Hutton. A tutorial on the universality and 
+expressiveness of fold.
+Journal of Functional Programming, 9(4):355-372, July 1999.
+
+[ENUM-CC] Oleg Kiselyov. General ways to traverse collections.
+January 1, 2004.
+http://pobox.com/~oleg/ftp/Scheme/enumerators-callcc.html
+
+[DBINTF] Oleg Kiselyov. Scheme database access tools. May 10, 2003.
+http://pobox.com/~oleg/ftp/Scheme/lib/db-util1.scm
+http://pobox.com/~oleg/ftp/Scheme/tests/vdbaccess.scm 
+
+[HINV] Oleg Kiselyov. From enumerators to cursors: turning the left
+fold inside out. January 1, 2004.
+http://pobox.com/~oleg/ftp/Haskell/misc.html#fold-stream
+The first draft was posted on the Haskell mailing list on
+23 Sep 2003 23:59:45 -0700.
+
+[Bananas] Erik Meijer, Maarten M. Fokkinga, and Ross Paterson. 
+Functional programming with bananas, lenses, envelopes, and barbed wire. 
+In J. Hughes, editor, FPCA'91: Functional Programming Languages and
+Computer Architecture, volume 523 of LNCS, pp. 124-144. 
+Springer-Verlag, 1991.                              
+
+[SRFI-44] Scott G. Miller. Collections.
+Scheme Request for Implementation SRFI-44. October 2003.
+http://srfi.schemers.org/srfi-44/srfi-44.html
+
+[Shasha] Dennis E. Shasha and Philippe Bonnet. Smooth Talking Your Databases.
+Dr.Dobbs Journal, July 2002, pp. 46-54.
+
+[Sheard] Tim Sheard and Leonidas Fegaras. A fold for all seasons. 
+Proc. Conf. on Functional Programming and Computer Architecture
+(FPCA'93), pp. 233-242, Copenhagen, Denmark, June 1993.
+
+[ULLMAN] Jeffrey Ullman. Principles of Database Systems.
+Second Edition, 484 pp. Computer Science Press, 1982.
+
+[Veldhuizen]
+T. Veldhuizen. Expression Templates.
+C++ Report, Vol. 7 No. 5 June 1995, pp. 26-31
+http://osl.iu.edu/~tveldhui/papers/Expression-Templates/exprtmpl.html
diff --git a/doc/papers/NievergeltReingold72-binary-search-trees-bounded-balance.pdf b/doc/papers/NievergeltReingold72-binary-search-trees-bounded-balance.pdf
new file mode 100644
index 0000000..ef44899
Binary files /dev/null and b/doc/papers/NievergeltReingold72-binary-search-trees-bounded-balance.pdf differ
diff --git a/doc/papers/Oleg-Searching-for-the-best-enumerator.html b/doc/papers/Oleg-Searching-for-the-best-enumerator.html
new file mode 100644
index 0000000..54043af
--- /dev/null
+++ b/doc/papers/Oleg-Searching-for-the-best-enumerator.html
@@ -0,0 +1,476 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head><title>Searching for the best enumerator</title><meta name="description" content="Discussion of various ways of
+traversing a collection, stressing the most complex and general case"><meta name="AuthorAddress" content="oleg-at-okmij.org"><meta name="Date-Revision-yyyymmdd" content="20110504"><meta name="Date-Creation-yyyymmdd" content="20001009"><link rel="start" href="index.html" title="Scheme Hash"><link rel="contents" href="index.html"><link rel="prev" href="util.html"><link rel="next" href="callcc-calc-page.html"></head><body bgcolor="#FFFFFF">
+
+<div align="center" class="navbar">  <a href="util.html">previous</a> &nbsp; <a href="callcc-calc-page.html">next</a> &nbsp; <a href="index.html">contents</a> &nbsp; <a href="index.html">top</a>
+<hr></div>
+<h1 align=center>General ways to traverse collections</h1>
+
+<p>This article analyzes various ways of traversing a collection.
+We pay a particular attention to the most complex and general case of
+enumerating only a subset of a collection and performing actions that
+depend on the previously seen elements.  We also discuss generators
+such as those in Icon and Python. A proposal is made for a convenient
+generic enumerator, which could be used, for example, in a truly
+functional database interface.</p>
+
+<p>This article was originally written in April 2000.  Its
+analysis of enumerators has since been researched further and extended
+to other languages. The pages [<a href="#generators">generators</a>] and [<a href="#iteratees">iteratees</a>] are the
+latest presentations on this topic.  The proposal for a convenient and
+generic enumerator first suggested here has been tested in
+practice. We implemented the left-fold enumerator to access
+ (object-)relational databases in a functional way [<a href="#database-access">database-access</a>]. This interface has been used in a production
+environment.  The generic-left-fold-based interface underlies the
+Collection SRFI. It was also used in a TIFF library [<a href="#TIFF">TIFF</a>],
+and even in other languages [<a href="#nonrec-fold-stream">nonrec-fold-stream</a>].</p>
+
+<p>This present article also demonstrates a non-trivial use of
+call/cc -- to invert a traversal &quot;inside out.&quot; In this application,
+call/cc <em>cannot</em> be replaced with a simple throw/catch
+construction. Later on the inversion procedure was extended to the
+most general enumerator [<a href="#inversion-src">inversion-src</a>]. It
+turns out that with a small modification, we can perform the iteration
+inversion in languages without first-class continuations, e.g.,
+Haskell [<a href="#nonrec-fold-stream">nonrec-fold-stream</a>].</p>
+<div>
+<ol><li><a href="#Introduction">Introduction</a>
+<li><a href="#Early">Early termination and inversion of a for-each enumerator</a>
+<li><a href="#Generators">Generators in Icon, Python, and Scheme</a>
+<li><a href="#Cursors">Cursors, enumerators, and lazy lists</a>
+<li><a href="#Groping for the best enumerator">Groping for the best enumerator</a>
+<li><a href="#Finalization">Finalization problem: reclaiming resources after enumeration</a>
+<li><a href="#Conclusions">Conclusions</a>
+<li><a href="#References">References</a>
+</ol>
+</div>
+
+<p>
+<hr></p>
+<br>&nbsp;<a name="Introduction">&nbsp;</a>
+<h2>Introduction</h2>
+
+<p>Suppose we have a collection with a <code>for-each</code>-type
+enumerator: a file system directory, an XML document, a suffix tree,
+or a &quot;dynamic&quot; collection that is the result of executing a <code>SELECT</code> DBMS/ODBC statement. We wish to obtain the first
+10 elements of the collection that satisfy a certain criterion:
+contain specific keywords, sound alike, etc.</p>
+
+<p>For the purpose of this example, let us consider a collection
+of numbers of the form <code>65537x+5 mod 1997</code>; The selection
+criterion is divisibility by 7. To make the problem less trivial, let
+the collection be represented by a treap [<a href="#Treap">Treap</a>]. We will not use the full power of the treap in this example: what
+matters to us is that the treap is an advanced collection and that it
+implements a <code>for-each</code> enumerator. A more general example is
+given in  [<a href="#inversion-src">inversion-src</a>].</p>
+
+<p>A word about terminology is in order, as it is rather
+confusing.  We will call a <code>for-each</code>-type procedure
+<strong>enumerator</strong>. Note the active suffix <em>OR</em>. It is
+this procedure that takes a collection and a handler, and applies the
+handler to each element of the collection in turn. The handler itself
+will be called an <strong>iteratee</strong>, because it is
+<em>being</em> applied -- by an active entity, the enumeratOR.
+Enumerator is presumably privy to the internals of a collection; it
+knows how to fetch elements in some (specified) order, and knows when
+to stop. A handler does not have this knowledge, nor is it supposed
+to. The job of an iteratee is to do something with the current
+element, irrespective of how this current element was obtained.</p>
+<br>&nbsp;<a name="Early">&nbsp;</a>
+<h2>Early termination and inversion of a <code>for-each</code> enumerator</h2>
+
+<p>We will first consider the most straightforward implementation:
+it will be our baseline. The complete code for this and the following
+examples is given in [<a href="#enumerators-src">enumerators-src</a>].</p>
+<pre>     (define (get-good-numbers-dumb treap count-max)
+       (let ((count 0) (result '()))
+         ((treap 'for-each-ascending)
+           (lambda (key-value)
+             (let ((x (car key-value)))
+               (and (&lt; count count-max) (good-value? x)
+                 (begin
+                   (set! count (+ 1 count))
+                   (set! result (cons x result)))))))
+         (reverse result)))
+     
+     (cerr (time (get-good-numbers-dumb treap pagesize)) nl)
+         23 ms real time
+         20 ms cpu time (20 user, 0 system)
+         1 collection accounting for 0 ms cpu time (0 user, 0 system)
+         171136 bytes allocated
+         no minor faults
+         no major faults
+     (42 49 56 63 70 112 119 126 133 140)
+</pre>Assignments are prominent in this solution: they are necessary to
+advance the state. The latter must be represented by global (to the
+iteratee) variables, which can persists from one invocation of the
+iteratee to another.
+<p>A smarter approach is to escape from the enumerator when we are done</p>
+<pre>     (define (get-good-numbers-cc treap count-max)
+       (let ((count 0) (result '()))
+         (call-with-current-continuation
+           (lambda (escape)
+             ((treap 'for-each-ascending)
+               (lambda (key-value)
+                 (let ((x (car key-value)))
+                   (and (good-value? x)
+                     (begin
+                       (set! count (+ 1 count))
+                       (set! result (cons x result))
+                       (if (&gt;= count count-max)
+                         (escape #f)))))))))
+         (reverse result)))
+     
+     (cerr (time (get-good-numbers-cc treap pagesize)) nl)
+         2 ms real time
+         0 ms cpu time (0 user, 0 system)
+         no collections
+         15416 bytes allocated
+         no minor faults
+         no major faults
+     (42 49 56 63 70 112 119 126 133 140)
+</pre>
+<p>Let us take a different turn: view a collection as if it was a
+<em>lazy list</em>. Lazy list is a promise, which when applied
+returns <code>'()</code> or <code>(cons value lazy-list)</code>
+<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<code>data LazyList a = Promise (Nil | (Cons a (LazyList a)))</code></p>
+<pre>     (define (treap-&gt;lazy-list treap)
+       (delay
+         (call-with-current-continuation
+           (lambda (k-main)
+             ((treap 'for-each-ascending)
+               (lambda (key-value)
+                 ; (cerr &quot;\nIn treap-&gt;lazy-list's iteratee: &quot; key-value &quot;\n&quot;)
+                 (call-with-current-continuation
+                   (lambda (k-reenter)
+                     (let ((x (car key-value)))
+                       (k-main (cons x
+                           (delay
+                             (call-with-current-continuation
+                               (lambda (k-new-main)
+                                 (set! k-main k-new-main)
+                                 (k-reenter #f)))))))))))
+             (k-main '())))))
+</pre>With this in mind, we can do<pre>     (define lazy-treap-list (treap-&gt;lazy-list treap))
+     
+     (define (get-good-numbers-ll lazy-treap-list count-max)
+       (let loop ((count 0) (llst lazy-treap-list) (result '()))
+         (cond
+           ((or (&gt;= count count-max) (fnull? llst)) (reverse result))
+           ((good-value? (fcar llst))
+             (loop (+ 1 count) (fcdr llst) (cons (fcar llst) result)))
+           (else
+             (loop count (fcdr llst) result)))))
+     
+     (cerr (time (get-good-numbers-ll lazy-treap-list pagesize)) nl)
+         5 ms real time
+         0 ms cpu time (0 user, 0 system)
+         no collections
+         47752 bytes allocated
+         no minor faults
+         no major faults
+     (42 49 56 63 70 112 119 126 133 140)
+</pre>Note a commented out line at the very beginning of the treap
+iteratee that calls the <code>cerr</code> procedure . If you uncomment
+that line you can see for yourself that during the execution of <code>get-good-numbers-ll</code>, the iteratee is invoked only as many times
+as absolutely necessary.  In all other respects <code>lazy-treap-list</code> looks like a regular list.  This makes even
+complex, history-dependent traversal easily realizable: lists
+can be walked in a variety of ways. The <code>get-good-numbers-ll</code> is a thinly-veiled finite state machine implemented in a
+pure-functional style.
+<p>Performance-wise, the lazy list is definitely better than the
+dumb enumeration: the lazy list does not fetch elements if they are
+not needed. Yet the lazy list loses out to the early escape.</p>
+
+<p>The <code>get-good-numbers-ll</code> procedure is purely
+functional: The state of traversal is abstracted into a lazy pair, a
+first-class object. To advance the traversal, we have to <em>explicitly</em> apply methods like <code>fcdr</code> (aka <em>next</em>). We also have to explicitly check for EOF.  In this
+respect, a lazy list is very similar to an STL iterator. On the other
+hand, a for-each enumerator does not give an iteratee any hint about
+the current state of traversal, or its history.</p>
+
+<p>The procedure <code>treap-&gt;lazy-list</code> shows off call/cc at
+its best -- its ability not only to escape a scope but to re-enter it
+as well. <code>treap-&gt;lazy-list</code> cannot be implemented with
+simpler, throw-like constructions. In this example, the enumerator and
+its caller act as <em>coroutines</em>. The full power of call/cc is
+required to implement them in Scheme.</p>
+
+<p>There has been a discussion about the fate of call/cc. No doubt
+call/cc causes many a grief to implementors of Scheme. Is it worth the
+trouble? The conclusions of this article are mixed.  The early-escape
+solution needs call/cc only to throw a non-reenterable exception. This
+solution will work even if call/cc did not exist, being replaced by
+its weak relative, <code>throw</code> or <code>raise</code>. Only
+<code>treap-&gt;lazy-list</code> requires the full call/cc. The latter
+seems indispensable in &quot;inverting&quot; of an iteration, when we
+have an implementation control over an iteratee but not over its
+iteratOR.  We gain flexibility, but we have to brace for the problems with
+performance, finalization, and excessive resource usage.</p>
+
+<p>A more general iteration-inversion procedure along with a few
+validation tests can be found in [<a href="#inversion-src">inversion-src</a>].</p>
+<br>&nbsp;<a name="Generators">&nbsp;</a>
+<h2>Generators in Icon, Python, and Scheme</h2>
+
+<p>The section on generators has been expanded to delimited control, ML
+and Haskell and moved to a separate document: [<a href="#generators">generators</a>]</p>
+<br>&nbsp;<a name="Cursors">&nbsp;</a>
+<h2>Cursors, enumerators, and lazy lists</h2>
+
+<p>Another approach of traversing a collection is to use a <em>cursor</em>, which is often confusingly called a stream or an
+iterator. Examples of cursors include C++ STL iterators, SQL cursors,
+C streams, UNIX files. A (read-only) cursor lets the user read the current
+value and advance the cursor. Often these operations are combined into
+one (cf. <code>getc()</code> in C). </p>
+
+<p>Ben Escoto, in his thoughtful follow-up discussion about
+generators in Scheme [<a href="#generators-disc">generators-disc</a>], has observed a few
+displeasing facts about cursors.</p>
+
+<p>The first problem is about telling the user that there are no
+more values to access. When the collection is exhausted, the cursor
+operations typically return an &quot;out-of-band&quot; value such as EOF (cf.
+<code>getc()</code>), raise an error (cf. SQL cursors) or an
+exception (Python's <code>iterator.next()</code>). None of these approaches
+appear entirely satisfactory.</p>
+
+<p>Some collections may allow to backtrack a cursor -- but some
+may not. Cursors associated with network connections or those that
+compute values on the fly often do not permit backtracking. If we
+cannot look ahead by more than one item and then backtrack, some
+important stream processing functions become quite difficult to
+write.</p>
+
+<p>Unlike cursors, an enumerator does not need to do anything
+special to tell the iteratee that the traversal is finished: the
+enumerator will simply return. There is no longer a problem with
+out-of-band values and user's disregarding such values.</p>
+
+<p>Although lazy lists look rather similar to cursors, lazy lists
+do not have the above drawbacks either. A lazy list is either a pair
+-- in which case its first element is the current value -- or an empty
+list, in which case the traversal is finished. We should stress that a
+promise of a pair in a lazy list can be forced more than once. All
+further forcing are equivalent to the identity function. If a lazy
+pair is forced it yields an ordinary pair, which can be incorporated
+in other lists. Thus, lazy lists <em>always</em> permit backtracking
+-- transparent to the user and in arbitrary amount.</p>
+
+<p>The only inconvenience with lazy lists, also noted by Ben
+Escoto, is that many standard list operations such as map, filter, and
+fold have to be re-written specifically for lazy lists. This problem
+does not arise in those Scheme systems that force values implicitly.</p>
+<br>&nbsp;<a name="Groping for the best enumerator">&nbsp;</a>
+<h2>Groping for the best enumerator</h2>
+
+<p>If one has the power over implementing a collection, he can
+build an enumerator that allows for an early exit.  For example, such
+an enumerator may examine the return result of an iteratee. If the
+latter yields <code>#f</code>, the iteration is abandoned; the result
+<code>'()</code> means the traversal will go on. Any other value is
+added to a list that accumulates meaningful results of all iteratee
+invocations, in order.</p>
+
+<p>The best enumerator ought to let an iteratee explicitly pass
+its private state from one invocation to another -- similar to the the
+way an <code>unfold</code> combinator (see SRFI-1) tosses the <code>seed</code>
+around.  Some syntax however ought to be employed to make it easier
+for an iteratee to pack its state data into a 'parcel' -- only to
+unpack the data on the next iteration.  For example, one can imagine
+the following enumerator:</p>
+<pre>     (enumerate
+      (lambda (curr-elem count result)
+         (let ((x (car key-value)))
+           (if (good-value? x)
+               (let ((new-count (+ 1 count)))
+                 (values (&lt; new-count count-max)     ; #f as the first arg
+                         new-count                   ; will terminate the iter
+                         (cons x result)))           ; early
+               (values #t count result)
+               )))
+      treap
+      0              ; Initial value for the count
+      '()            ; Initial value for the result
+     )
+</pre>
+<p>The iteratee in the example above takes three arguments. The
+first one is the current element -- similar to the argument the
+ordinary <code>for-each</code> passes to its iteratee. The initial values for
+the other two arguments are given as invocation parameters of the
+enumerator.  The iteratee must return as many values as the arguments
+it received.  The first return value must be either <code>#t</code> or
+<code>#f</code>. In the latter case the traversal is prematurely
+terminated; otherwise it may continue, if there are elements to
+enumerate, of course. The other return values are passed to the next
+invocation of the iteratee as the second,... arguments.  The
+enumerator returns several values, which is the result yielded by the
+last invocation of the iteratee save the first value of the
+multi-value.  If the iteratee was never called, the initial values
+will be returned.  One can envision similar procedures
+<code>enumerate-replace</code> or <code>enumerate-replace!</code>,
+which use the first return value of the iteratee to update the current
+element, either functionally or destructively.</p>
+
+<p>This is just a suggestion. It may also be considered a
+blueprint for an ODBC-like interface in a true Scheme spirit; the
+collection in question is the result of a SELECT statement. I'm
+interested to hear if all this makes any sense.</p>
+
+<p>Since the previous phrase was written, the proposed enumerator
+interface has indeed been tried and found satisfactory. It was first
+implemented in a relational database access library [<a href="#database-access">database-access</a>]. This interface has been used in a production
+environment.  The generic-left-fold-based interface underlies the
+Collection SRFI. It was also used in a TIFF library [<a href="#TIFF">TIFF</a>],
+and even in other languages [<a href="#nonrec-fold-stream">nonrec-fold-stream</a>]. The LL3
+presentation [<a href="#LL3-enumerators">LL3-enumerators</a>] discussed the interface in
+more detail.</p>
+<br>&nbsp;<a name="Finalization">&nbsp;</a>
+<h2>Finalization problem: reclaiming resources after enumeration</h2>
+
+<p>Joe Marshall remarked:</p>
+
+<blockquote>Have you considered passing the iteratee a function that
+continues the iteration? The iteratee would look something like this:<pre>     (lambda (this-element current-state continue-iteration)
+       (let ((next-state (combine this-element current-state)))
+         (if (done? next-state)
+           next-state
+           (continue-iteration next-state))))
+</pre></blockquote>
+
+<p>This solution -- along with a lazy list solution above -- has
+one troublesome property. A special function has to be called to
+continue the traversal. To stop the traversal, iteratee doesn't have
+to do anything special: just return.  This is somewhat similar to the
+lazy-list solution. There, the element handler must force a promise to
+get to the next element in a collection. In contrast, in the
+enumerator proposal, to stop a traversal the iteratee must return a
+special kind of value to the caller. If some other value is returned,
+the iteration implicitly continues.</p>
+
+<p>Traversing a collection may require resources, e.g, a stack, a
+connection to a database, a DIR handle, a DOM tree of an XML document,
+etc. An enumerator takes care of allocating these resources.  When
+iteratee explicitly tells the enumerator to stop -- or when the
+collection is exhausted -- the enumerator can orderly free the
+resources.</p>
+
+<p>On the other hand, if iteration advances only upon an explicit
+call to a <code>continue-iteration</code> function, it is not so clear
+cut when to dispose of resources.  Obviously an enumeration should be
+assumed terminated when the <code>continue-iteration</code>
+procedure/closure is garbage-collected. This assumes that we can
+associate <em>finalizers</em> with objects -- which is not a
+standard feature. Fortunately, Gambit provides for 'wills', which it
+uses specifically for that purpose, to free a file handle when a port
+is GCed. Alas, the moment garbage collection (GC) is performed is not
+precisely defined. Often GC runs only when memory is tight. In that
+case, the following example</p>
+<pre>     (do ((i 0 (+ i 1))) ((&gt;= i 1000))
+       (open-input-file &quot;/dev/null&quot; (lambda () #f)))
+</pre>runs out of file handles way before it runs out of memory. On the
+other hand, the following code, although just as silly, completes
+without problems<pre>     (do ((i 0 (+ i 1))) ((&gt;= i 1000))
+       (with-input-from-file &quot;/dev/null&quot; (lambda () #f)))
+</pre>Incidentally, the example is stolen from a Python FAQ, from a section that
+aimed to illustrate why Python's reference-counting GC may be better
+than Java's mark-and-sweep GC.
+<p>The lazy-list solution we considered earlier, as well STL iterators
+exhibit this finalization problem, too. Therefore, there does appear
+to be a merit in insisting that iteratee do not escape an
+enumerator. Granted, the iteratee may call a continuation captured
+before enumerator was entered. For that reason, enumerator should
+employ a <code>dynamic-wind</code> to detect such an attempt to
+escape, shed excessive resources and switch to a &quot;low-power&quot;, &quot;sleep&quot;
+mode while the iteratee is on the run.</p>
+<br>&nbsp;<a name="Conclusions">&nbsp;</a>
+<h2>Conclusions</h2>
+
+<p>In this article we attempted to imagine a &quot;perfect&quot;
+enumerator, enumerator interface, or an <em>enumerator pattern</em>. If all collections were to support this general interface, there
+will be far less need to hack them with call/cc.</p>
+
+<p>Actually, there may still be a need to invert an iteration: for
+example, to move <em>some</em> elements from one collection into another. It
+seems very difficult for a single iteratee-copier to be controlled by
+two enumerators at the same time. Is there a generic way to chain two
+or more enumerators? I don't even know where to begin.</p>
+
+<p>We should note that some problems seem to lend themselves to 
+an event callback, dont-call-us-we-call-you-style: an enumerator
+driving an iteratee. Some other problems are more amenable to a
+<code>read-char</code>-, <code>GetNextEvent</code>-style: enumeration
+inversion.</p>
+
+<p>The proposed left-fold-based enumerator with the premature
+termination has been implemented and tested in practice, in
+particular, in a database access library [<a href="#database-access">database-access</a>]. The example quoted in that reference shows that the interface can
+deal with <code>EXISTS</code> and other subqueries, table expressions,
+collection datatypes, geodetic datablade datatypes and functions, and
+other frills. The enumerator makes it possible indeed to present a
+functional interface even to such complex collections as
+object-relational databases.</p>
+<br>&nbsp;<a name="References">&nbsp;</a>
+<h2>References</h2>
+
+<p><a name="generators">[generators]</a> 
+<br><a href="../continuations/generators.html">Generators: the API for traversal and non-determinism</a></p>
+
+<p><a name="iteratees">[iteratees]</a> 
+<br><a href="../Haskell/Iteratee/">Iteratees:</a> Incremental multi-level input processing and collection enumeration</p>
+
+<p><a name="LL3-enumerators">[LL3-enumerators]</a> 
+<br><a href="../Haskell/Iteratee/index.html#enumerator-stream">Towards the best collection traversal interface</a></p>
+
+<p><a name="enumerators-src">[enumerators-src]</a> 
+<br><a href="enumerators-callcc-code-old.scm">enumerators-callcc-code-old.scm</a> [8K]<br>The complete code for the treap enumeration examples.</p>
+
+<p><a name="inversion-src">[inversion-src]</a> 
+<br><a href="enumerators-callcc-code.scm">enumerators-callcc-code.scm</a> [4K]<br>The complete code for the enumerator inversion procedure and a
+few tests.</p>
+
+<p><a name="generators-src">[generators-src]</a> 
+<br><a href="generators.scm">generators.scm</a> [6K]<br>The complete code for the generator examples.</p>
+
+<p><a name="nonrec-fold-stream">[nonrec-fold-stream]</a> 
+<br><a href="../Haskell/Iteratee/index.html#fold-stream">The enumerator inversion procedure in Haskell</a></p>
+
+<p><a name="database-access">[database-access]</a> 
+<br><a href="lib/db-util1.scm">db-util1.scm</a> [24K]<br>Scheme database access tools
+<br><a href="tests/vdbaccess.scm">vdbaccess.scm</a> [5K]<br>Illustrative regression tests
+<br>&lt;<a href="http://www.metnet.navy.mil/Metcast/Code/gief-serve.scm">http://www.metnet.navy.mil/Metcast/Code/gief-serve.scm</a>&gt;
+<br>An example of using the left-fold-based database interface in a
+production environment.</p>
+
+<p><a name="TIFF">[TIFF]</a> 
+<br><a href="binary-io.html#tiff">Handling a TIFF file in Scheme</a></p>
+
+<p><a name="Treap">[Treap]</a> 
+<br><a href="index.html#treaps">Treaps:</a> A sorted dictionary data structure based on randomized search trees.</p>
+
+<p><a name="generators-disc">[generators-disc]</a> 
+<br>Ben Escoto. Re: Generators in Python, Icon and Scheme. A message
+posted on comp.lang.scheme on 2001-10-03 01:50:02 PST.</p>
+
+<p>The present page has started as a compilation of three articles 
+<Cite>General ways to traverse collections, and the fate of
+call/cc</Cite> posted on a comp.lang.scheme newsgroup Apr 16 through Apr
+20, 2000. The section about generators is based on an article <Cite>Generators in Python, Icon and Scheme</Cite> posted on comp.lang.scheme
+on Oct 2, 2001.</p>
+
+<br>
+<div>
+<hr></div>
+
+<h3>Last updated May 4, 2011</h3>
+
+<p>This site's top page is <a href="http://okmij.org/ftp/"><strong>http://okmij.org/ftp/</strong></a></p>
+
+<div>
+<address>oleg-at-okmij.org
+<br>Your comments, problem reports, questions are very welcome!</address>
+</div>
+
+<p><font size="-2">Converted from SXML by SXML-&gt;HTML</font></p>
+</body></html>
diff --git a/doc/papers/SunFerizovcBlelloch18-PAM-parallel-augmented-maps.pdf b/doc/papers/SunFerizovcBlelloch18-PAM-parallel-augmented-maps.pdf
new file mode 100644
index 0000000..ab6f311
Binary files /dev/null and b/doc/papers/SunFerizovcBlelloch18-PAM-parallel-augmented-maps.pdf differ
diff --git a/doc/papers/ropes.pdf b/doc/papers/ropes.pdf
new file mode 100644
index 0000000..f8a5953
Binary files /dev/null and b/doc/papers/ropes.pdf differ
diff --git a/doc/ropes.md b/doc/ropes.md
new file mode 100644
index 0000000..01cbdb3
--- /dev/null
+++ b/doc/ropes.md
@@ -0,0 +1,739 @@
+# Ropes
+
+## Status
+
+The rope is a **public** collection type in `ordered-collections.core`.
+
+```clojure
+(require '[ordered-collections.core :as oc])
+
+(oc/rope [1 2 3 4 5])
+```
+
+Implementation namespaces:
+
+- `ordered-collections.types.rope` — `Rope` deftype
+- `ordered-collections.kernel.rope` — low-level chunked tree operations
+
+
+## What a Rope Is
+
+A rope is a persistent sequence representation designed to make large
+concatenations, slices, and edits cheaper than repeatedly copying flat arrays
+or strings.
+
+The classic rope idea is:
+
+- store content in **chunks**
+- organize those chunks in a **tree**
+- keep enough subtree metadata to support indexing and slicing efficiently
+- share unchanged structure across derived values
+
+This is a particularly natural fit when the underlying architecture already has:
+
+- persistent balanced trees
+- efficient structural sharing
+- good split/join mechanics
+
+That is exactly why ropes are interesting in this codebase.
+
+
+## Why a Rope Here
+
+This library is built around persistent, weight-balanced trees. That makes
+ropes much more natural than array-backed vectors.
+
+For a rope, the tree gives you:
+
+- persistent concatenation
+- persistent split
+- subrange extraction with structure sharing
+- stable asymptotic indexed navigation via subtree sizes
+
+For ordinary vector workloads, Clojure's built-in `PersistentVector` remains the
+reference implementation. The rope experiment is interesting because it may do
+some **different** things well:
+
+- repeated concatenation
+- repeated splitting
+- splicing persistent sequences
+- editing large sequences without flattening them eagerly
+
+
+## Rope vs Vector
+
+These are not the same data structure, even if both support `nth` and `assoc`.
+
+`PersistentVector` is optimized for:
+
+- ordinary random access
+- append-heavy use
+- general-purpose vector workloads
+
+A rope is optimized for:
+
+- concatenation as a first-class operation
+- splitting and slicing
+- structural editing
+- sharing large unchanged pieces
+
+So the right question is not:
+
+- "Can a rope beat `PersistentVector` everywhere?"
+
+The better question is:
+
+- "Can a rope offer a compelling structural-editing sequence type?"
+
+### Benchmark Summary
+
+| Workload | N=10K | N=100K | N=500K |
+|---|---:|---:|---:|
+| 200 random edits | **43x** | **498x** | **1968x** |
+| Single splice | **6x** | **116x** | **584x** |
+| Concat many pieces | **3.4x** | **5.4x** | **9.5x** |
+| Chunk iteration | **58x** | **83x** | **117x** |
+| Fold (sum) | **5.6x** | **1.5x** | **1.3x** |
+| Reduce (sum) | 0.4x | **1.7x** | **1.3x** |
+| Random nth (1000) | 0.7x | 0.5x | 0.4x |
+
+The rope wins on 6 of 7 workloads at scale. The advantage grows with collection
+size because structural editing is O(log n) vs O(n). Parallel fold beats vectors
+via tree-based fork-join decomposition. Random nth is slower (O(log n) vs O(1))
+— an inherent tradeoff of tree-backed indexing.
+
+
+## Rope Design in This Library
+
+The experimental implementation is a **chunked implicit-index rope tree**.
+
+Conceptually:
+
+- each node stores a chunk vector
+- node value stores total subtree element count
+- left/right children are rope subtrees
+- balancing uses the same weight-balanced tree ideas used elsewhere in the
+  library
+- element positions are derived from subtree sizes, not from user-visible keys
+
+This means:
+
+- there is no comparator
+- there is no ordered-key API
+- position is the ordering
+
+That is an important design point. The rope is **not** an `ordered-map` from
+integer index to value. It is its own collection type with its own low-level
+tree layer.
+
+![Chunked rope tree structure](assets/rope-structure.svg)
+
+The key visual idea is that indexing is a two-stage operation:
+
+- walk the tree by subtree sizes
+- then index within one chunk
+
+That is why the rope can support `nth`, `assoc`, split, and slicing without
+pretending that element positions are stored as explicit keys.
+
+
+## Chunked Leaves
+
+The current rope implementation is chunked rather than storing one element per
+node.
+
+That improves locality and makes the data structure more honestly rope-like.
+
+At a high level:
+
+- small edits often affect only one chunk and a logarithmic path of tree nodes
+- splits and concatenations work by rearranging chunk-bearing tree nodes
+- indexing descends by subtree element counts, then indexes within the chunk
+
+![Chunk size invariant and boundary repair](assets/rope-csi-boundary.svg)
+
+The subtle rule is the **Chunk Size Invariant (CSI)**:
+
+- every internal chunk must be in the valid size range
+- only the rightmost chunk, called the **runt**, is allowed to be undersized
+
+That right-edge exception keeps append efficient, but it also means structural
+operations must sometimes repair chunk boundaries. In particular, concat, split,
+slice, and splice can move a former right-edge runt into the interior, where it
+must be merged and rechunked back into a valid shape.
+
+
+## API
+
+From `ordered-collections.core`:
+
+- `rope`
+- `rope-concat` — two args: O(log n) tree join; three or more: O(total chunks) bulk
+- `rope-split`
+- `rope-sub`
+- `rope-insert`
+- `rope-remove`
+- `rope-splice`
+- `rope-chunks`
+- `rope-chunks-reverse`
+- `rope-chunk-count`
+- `rope-str`
+
+And the `Rope` type itself supports:
+
+- `count`, `nth`, `get`, `assoc`, `conj`, `peek`, `pop`
+- vector-style function lookup
+- `seq`, `rseq`
+- `reduce` (with correct early termination via `reduced`)
+- `clojure.core.reducers/fold` (parallel fork-join)
+- `compare` (lexicographic)
+- `java.util.List`: `get`, `indexOf`, `lastIndexOf`, `contains`, `subList`
+- `java.util.Collection`: `size`, `isEmpty`, `toArray`, `containsAll`
+- metadata, sequential equality, ordered hashing
+
+
+## Examples
+
+```clojure
+(require '[ordered-collections.core :as oc])
+```
+
+### Construction
+
+```clojure
+(def r (oc/rope [0 1 2 3 4 5]))
+
+(count r)
+;; => 6
+
+(nth r 3)
+;; => 3
+
+(vec r)
+;; => [0 1 2 3 4 5]
+```
+
+### Concatenation
+
+```clojure
+(def a (oc/rope [0 1 2]))
+(def b (oc/rope [3 4 5]))
+
+(oc/rope-concat a b)  ;; => #ordered/rope [0 1 2 3 4 5]
+
+;; Variadic — bulk concatenation in O(total chunks)
+
+(oc/rope-concat (oc/rope [1 2]) (oc/rope [3 4]) (oc/rope [5 6]))
+;; => #ordered/rope [1 2 3 4 5 6]
+```
+
+### Split and Slice
+
+```clojure
+(let [[l r] (oc/rope-split (oc/rope (range 10)) 4)]
+  [(vec l) (vec r)])
+;; => [[0 1 2 3] [4 5 6 7 8 9]]
+
+(vec (oc/rope-sub (oc/rope (range 10)) 3 7))
+;; => [3 4 5 6]
+```
+
+### Insertion
+
+```clojure
+(vec (oc/rope-insert (oc/rope (range 6)) 2 [:a :b]))
+;; => [0 1 :a :b 2 3 4 5]
+```
+
+### Range Removal
+
+```clojure
+(vec (oc/rope-remove (oc/rope (range 10)) 4 7))
+;; => [0 1 2 3 7 8 9]
+```
+
+### Splicing
+
+```clojure
+(vec (oc/rope-splice (oc/rope (range 10)) 2 5 [:x :y]))
+;; => [0 1 :x :y 5 6 7 8 9]
+```
+
+### Chunk Introspection
+
+```clojure
+(def r (oc/rope (range 130)))
+
+(oc/rope-chunk-count r)
+;; => 3
+
+(mapv count (oc/rope-chunks r))
+;; => [64 64 2]
+```
+
+This chunk view is useful because it exposes the real structure of the rope.
+Unlike a flat vector, a rope has meaningful chunk boundaries.
+
+
+## Tutorial: When and How to Use a Rope
+
+Most people encounter ropes in the context of text editors. That is a valid use
+case, but it is a narrow lens. A rope is a general-purpose persistent sequence
+type that excels at **structural editing** — any workload where you repeatedly
+split, concatenate, splice, or slice large sequences without wanting to copy the
+whole thing every time.
+
+This tutorial walks through several concrete scenarios where a rope is a better
+fit than a vector.
+
+
+### Setup
+
+```clojure
+(require '[ordered-collections.core :as oc])
+```
+
+
+### Scenario 1: Assembling a Large Sequence from Parts
+
+Suppose you are collecting data from many sources and need to merge the results
+into one ordered sequence. With vectors, each concatenation copies both sides:
+
+```clojure
+;; Expensive with vectors — every `into` copies everything accumulated so far
+(reduce into [] [chunk-a chunk-b chunk-c chunk-d ...])
+```
+
+With a rope, concatenation is structural. No bulk copying happens — the rope
+just records that the pieces sit next to each other in a tree:
+
+```clojure
+(def parts [(oc/rope sensor-readings-batch-1)
+            (oc/rope sensor-readings-batch-2)
+            (oc/rope sensor-readings-batch-3)])
+
+(def combined (apply oc/rope-concat parts))
+
+;; The full sequence is available for indexed access or reduce,
+;; but no flattening happened:
+(count combined)
+(nth combined 12345)
+(reduce + combined)
+```
+
+This matters when the parts are large and numerous. The rope grows by adding
+tree structure, not by copying elements.
+
+
+### Scenario 2: Splitting and Rearranging
+
+A common pattern in data pipelines: take a large sequence, split it at a
+position, and rearrange or process the halves independently.
+
+```clojure
+(def events (oc/rope (range 100000)))
+
+;; Split at position 40000
+(let [[head tail] (oc/rope-split events 40000)]
+  ;; head and tail share structure with the original
+  (count head)  ;; => 40000
+  (count tail)  ;; => 60000
+
+  ;; Process tail, then put it back in front of head
+  (def reordered (oc/rope-concat tail head)))
+```
+
+Both `rope-split` and `rope-concat` are O(log n). The original `events` rope
+is unchanged — this is persistent. You now have three independent snapshots of
+the sequence (original, head, tail) without tripling memory usage.
+
+![Split once, share both halves, concat structurally](assets/rope-split-concat.svg)
+
+The important point is that split does not flatten the rope into two vectors.
+It cuts one path through the tree, reuses the untouched subtrees on each side,
+and then restores chunk validity at the new fringes.
+
+
+### Scenario 3: Splicing Into the Middle
+
+Inserting elements into the middle of a vector is O(n) — every element after the
+insertion point must be shifted. With a rope, it is O(log n):
+
+```clojure
+(def timeline (oc/rope (range 1000)))
+
+;; Insert a burst of priority events at position 200
+(def updated (oc/rope-insert timeline 200 [:alert-1 :alert-2 :alert-3]))
+
+(nth updated 200)  ;; => :alert-1
+(nth updated 203)  ;; => 200  (original element, shifted right)
+```
+
+This is useful for any ordered stream where you need to retroactively inject
+data at a specific position.
+
+Remove a range just as easily:
+
+```clojure
+;; Remove positions 400 through 500
+(def trimmed (oc/rope-remove timeline 400 500))
+
+(count trimmed)  ;; => 900
+```
+
+Or replace a range:
+
+```clojure
+;; Replace positions 100–110 with new data
+(def patched (oc/rope-splice timeline 100 110 [:patched]))
+
+(count patched)  ;; => 991  (removed 10, inserted 1)
+```
+
+![Splice replaces one middle range and shares the rest](assets/rope-splice-sharing.svg)
+
+That picture is the essence of why ropes are attractive for persistent editing:
+the edit rebuilds the path near the change, but large left and right regions
+remain shared with the previous version.
+
+
+### Scenario 4: Windowing and Slicing
+
+Extract a subrange without copying the entire sequence:
+
+```clojure
+(def measurements (oc/rope (range 1000000)))
+
+;; Extract a window — this shares structure with the original
+(def window (oc/rope-sub measurements 499000 501000))
+
+(count window)  ;; => 2000
+(nth window 0)  ;; => 499000
+```
+
+The resulting rope shares structure with the original and supports all rope
+operations including `assoc`, `conj`, `peek`, `pop`, and further slicing.
+
+
+### Scenario 5: Version History / Undo
+
+Because ropes are persistent, every edit produces a new rope that shares
+structure with the previous version. This makes version history cheap:
+
+```clojure
+(def v0 (oc/rope [:a :b :c :d :e]))
+(def v1 (oc/rope-insert v0 2 [:x :y]))
+(def v2 (oc/rope-remove v1 0 2))
+(def v3 (oc/rope-splice v2 1 3 [:z]))
+
+;; All four versions coexist, sharing most of their structure:
+(into [] v0)  ;; => [:a :b :c :d :e]
+(into [] v1)  ;; => [:a :b :x :y :c :d :e]
+(into [] v2)  ;; => [:x :y :c :d :e]
+(into [] v3)  ;; => [:x :z :d :e]
+```
+
+The memory cost of keeping all four versions is much less than four independent
+copies. This pattern applies to any application that needs to track or undo
+edits to an ordered collection: document editing, configuration changes,
+simulation state, game replay.
+
+
+### Scenario 6: Parallel Reduction
+
+Ropes support `clojure.core.reducers/fold` for parallel reduction via
+fork-join:
+
+```clojure
+(require '[clojure.core.reducers :as r])
+
+(def large (oc/rope (range 1000000)))
+
+;; Sequential reduce
+(reduce + large)
+
+;; Parallel fold — splits the rope at its natural tree structure
+(r/fold + large)
+```
+
+The rope's internal tree structure provides natural split points for parallel
+work distribution. This is useful for compute-heavy aggregation over large
+sequences.
+
+
+### Scenario 7: Chunk-Aware Processing
+
+Unlike a flat vector, a rope has visible internal structure. You can iterate
+over the chunks directly, which is useful when the data was assembled from
+meaningful pieces:
+
+```clojure
+(def assembled (apply oc/rope-concat
+                 (map oc/rope [[1 2 3] [4 5 6] [7 8 9]])))
+
+;; Iterate over the internal chunks
+(doseq [chunk (oc/rope-chunks assembled)]
+  (println "chunk:" chunk "sum:" (reduce + chunk)))
+;; chunk: [1 2 3 4 5 6 7 8 9] sum: 45
+```
+
+Note that the rope may merge small chunks for efficiency. The chunk boundaries
+reflect the rope's internal balancing, not necessarily the original assembly
+boundaries. But for large pieces, the original structure is typically preserved.
+
+
+### Scenario 8: Converting Between Ropes, Strings, and Vectors
+
+Ropes interoperate naturally with other Clojure and Java sequence types.
+
+**Building ropes from anything seqable:**
+
+```clojure
+(oc/rope [1 2 3])           ;; from a vector
+(oc/rope (range 1000))      ;; from a range
+(oc/rope '(:a :b :c))       ;; from a list
+(oc/rope "hello")           ;; from a string (rope of Characters)
+```
+
+**Rope to String** — `rope-str` uses a chunk-aware StringBuilder, much faster
+than `(apply str r)` for large ropes:
+
+```clojure
+(def doc (oc/rope "The quick brown fox"))
+
+(oc/rope-str doc)
+;; => "The quick brown fox"
+
+;; After editing:
+(oc/rope-str (oc/rope-splice doc 4 9 "slow"))
+;; => "The slow brown fox"
+```
+
+**Rope to PersistentVector** — use `vec`:
+
+```clojure
+(type (vec (oc/rope [1 2 3])))
+;; => clojure.lang.PersistentVector
+```
+
+Note that `(vector? (oc/rope [1 2 3]))` returns `false` — ropes are sequential
+but not vectors.
+
+**Rope operations accept non-rope collections** — concat, insert, and splice
+coerce their arguments automatically:
+
+```clojure
+(oc/rope-concat (oc/rope [1 2]) [3 4])
+;; => #ordered/rope [1 2 3 4]
+
+(oc/rope-insert (oc/rope [1 2 3]) 1 [:a :b])
+;; => #ordered/rope [1 :a :b 2 3]
+```
+
+**Interop summary:**
+
+| From | To | How |
+|---|---|---|
+| Any seqable | Rope | `(oc/rope coll)` |
+| String | Rope of chars | `(oc/rope "hello")` |
+| Rope | String | `(oc/rope-str r)` |
+| Rope | PersistentVector | `(vec r)` |
+| Rope | lazy seq | `(seq r)` |
+| Rope | Java array | `(.toArray r)` |
+| Rope | EDN round-trip | `#ordered/rope` tagged literal |
+
+
+### Scenario 9: Java Interop
+
+The rope implements `java.util.List` and `java.util.Collection`, so it works
+with Java APIs that expect these interfaces:
+
+```clojure
+(def r (oc/rope [10 20 30 40 50]))
+
+(.get r 2)           ;; => 30
+(.size r)            ;; => 5
+(.contains r 30)     ;; => true
+(.indexOf r 40)      ;; => 3
+(.subList r 1 4)     ;; => #ordered/rope [20 30 40]
+(.toArray r)         ;; => Object[5] {10, 20, 30, 40, 50}
+```
+
+
+### When to Use a Rope vs. a Vector
+
+Use a **vector** when:
+
+- you mostly append to the end and read by index
+- random access performance matters more than edit performance
+- the sequence is small or medium-sized
+- you never split, splice, or concatenate in the middle
+
+Use a **rope** when:
+
+- you frequently concatenate large sequences
+- you frequently split or slice sequences
+- you need to splice into the middle of large sequences
+- you want cheap persistent snapshots after structural edits
+- you want to reduce over very large sequences in parallel
+- you assemble a sequence from many parts and then process it
+
+
+## Conceptual Tradeoffs
+
+### Strengths
+
+- persistent concatenation is natural
+- persistent split is natural
+- subrange extraction is natural
+- structure sharing is central rather than incidental
+- chunked representation offers better locality than one-element tree nodes
+
+### Weaknesses
+
+- random `nth` access is O(log n) rather than O(1) — inherent tree tradeoff
+- split and slice are O(log n) vs O(1) for `subvec` — inherent
+- reduce is slower than vectors at small N (< 10K elements)
+- element-by-element construction via `conj` is slower than vectors; prefer
+  `(oc/rope coll)` for bulk construction
+
+
+## How This Relates to Other Rope Designs
+
+The current design is closest to a general persistent sequence rope, not a
+text-only rope.
+
+Some rope libraries are specialized for text and therefore also expose:
+
+- byte indexing
+- character indexing
+- line indexing
+- UTF-8 chunk navigation
+- incremental builders
+- slice/view objects
+
+Our current experiment is intentionally more general:
+
+- chunks hold arbitrary Clojure values
+- indexing is element-based
+- the API is sequence-oriented rather than text-oriented
+
+
+## Papers
+
+### Boehm, Atkinson, and Plass (1995)
+
+The canonical rope paper is:
+
+- Hans-J. Boehm, Russ Atkinson, and Michael F. Plass.
+  "Ropes: an Alternative to Strings."
+  *Software: Practice and Experience* 25(12), 1995.
+
+Repository-local materials:
+
+- [Citation note](papers/boehm-atkinson-plass-1995-ropes-citation.md)
+- [SRI citation/abstract page](papers/boehm-atkinson-plass-1995-ropes-sri.html)
+
+Public citation page:
+
+- https://www.sri.com/publication/ropes-an-alternative-to-strings/
+
+This remains the most important reference for the basic rope idea:
+
+- concatenate by structure
+- slice without flattening everything
+- share large unchanged subtrees
+
+
+## Implementation References
+
+### Adobe / SGI rope implementation overview
+
+This is a valuable implementation note, especially for understanding classic
+rope engineering tradeoffs:
+
+- substring nodes
+- function/lazy nodes
+- balancing policy
+- iterator caching
+- reference-counting vs GC tradeoffs
+
+Reference:
+
+- https://stlab.adobe.com/stldoc_ropeimpl.html
+
+
+## Prominent Open Source Rope Implementations
+
+### Ropey
+
+Rust text rope with a mature, well-known API and strong documentation:
+
+- docs: https://docs.rs/ropey/latest/ropey/
+- repo: https://github.com/cessen/ropey
+
+Useful reference points:
+
+- dedicated rope builder
+- slicing model
+- chunk APIs
+- text-specific indexing support
+
+
+### crop
+
+Another Rust rope implementation, B-tree based and focused on text-editing
+workloads:
+
+- docs: https://docs.rs/crop/latest/crop/
+- repo: https://github.com/nomad/crop
+
+Useful reference points:
+
+- `Rope` and `RopeBuilder`
+- explicit editing operations
+- text-oriented slice semantics
+
+
+### xi rope
+
+The rope implementation from the Xi editor ecosystem is another important
+practical reference for persistent editing structures:
+
+- repo: https://github.com/xi-editor/xi-editor/tree/master/rust/rope
+
+This is particularly relevant as a design reference for editor-oriented
+structural editing.
+
+
+### Sycamore (Common Lisp)
+
+A Common Lisp data-structure library that includes ropes alongside
+weight-balanced trees:
+
+- repo: https://github.com/ndantam/sycamore
+- reference manual: https://quickref.common-lisp.net/sycamore.html
+
+This is especially relevant for this project because it shows a rope living in
+a Lisp ecosystem next to weight-balanced tree structures.
+
+
+## Current Capabilities
+
+The rope now provides:
+
+- full Clojure collection interfaces: `Indexed`, `Associative`,
+  `IPersistentStack`, `Seqable`, `Reversible`,
+  `IReduceInit`, `IReduce`, `Counted`, `IHashEq`, `IMeta`, `IObj`,
+  `Sequential`, `Comparable`
+- `java.util.List` and `java.util.Collection` for Java interop
+- `clojure.core.reducers/CollFold` for parallel fold
+- chunk-level iteration in both directions
+- structural editing: `rope-insert`, `rope-remove`, `rope-splice`
+- correct `reduced` early-termination in all reduce paths
+- `print-method` for readable REPL output
+
+## Future Work
+
+- Further constant-factor optimization of reduce at small N (0.6x at 10K;
+  already 1.4x faster than vectors at N ≥ 100K)
diff --git a/doc/vs-clojure-data-avl.md b/doc/vs-clojure-data-avl.md
new file mode 100644
index 0000000..c2efcc3
--- /dev/null
+++ b/doc/vs-clojure-data-avl.md
@@ -0,0 +1,67 @@
+# Migrating from clojure.data.avl
+
+This guide is for data.avl users considering ordered-collections. For the full feature and performance comparison, see [Competitive Analysis](competitive-analysis.md) and [Benchmarks](benchmarks.md).
+
+## API Mapping
+
+The core operations are the same, with one syntax difference: ordered-collections uses **keywords** for test operators where data.avl uses **bare symbols**.
+
+```clojure
+;; data.avl
+(require '[clojure.data.avl :as avl])
+(def s (avl/sorted-set 1 2 3 4 5 6 7 8 9))
+
+(avl/nearest s >= 4)                ;=> 4
+(avl/nearest s > 4)                 ;=> 5
+(avl/subrange s >= 3 < 7)           ;=> #{3 4 5 6}
+(avl/split-key 5 s)                 ;=> [#{1 2 3 4} 5 #{6 7 8 9}]
+(avl/split-at 3 s)                  ;=> [#{1 2 3} #{4 5 6 7 8 9}]
+(avl/rank-of s 5)                   ;=> 4
+(nth s 2)                           ;=> 3
+
+;; ordered-collections
+(require '[ordered-collections.core :as oc])
+(def s (oc/ordered-set [1 2 3 4 5 6 7 8 9]))
+
+(oc/nearest s :>= 4)               ;=> 4       ← keyword
+(oc/nearest s :> 4)                 ;=> 5       ← keyword
+(oc/subrange s :>= 3 :< 7)         ;=> #{3 4 5 6}  ← keywords
+(oc/split-key 5 s)                  ;=> [#{1 2 3 4} 5 #{6 7 8 9}]
+(oc/split-at 3 s)                   ;=> [#{1 2 3} #{4 5 6 7 8 9}]
+(oc/rank s 5)                       ;=> 4
+(nth s 2)                           ;=> 3
+```
+
+### Constructor differences
+
+```clojure
+;; data.avl — varargs like clojure.core
+(avl/sorted-set 3 1 4 1 5)
+(avl/sorted-map 1 :a 2 :b)
+
+;; ordered-collections — takes a collection
+(oc/ordered-set [3 1 4 1 5])
+(oc/ordered-map {1 :a 2 :b})
+(oc/ordered-map [[1 :a] [2 :b]])
+```
+
+### Additional operations (not in data.avl)
+
+```clojure
+(oc/median s)                       ;=> 5
+(oc/percentile s 90)                ;=> 9
+(oc/slice s 2 5)                    ;=> (3 4 5)
+(oc/union s1 s2)                    ;  parallel fork-join
+(oc/intersection s1 s2)
+(oc/difference s1 s2)
+```
+
+## What you gain
+
+- **Parallel set operations** — about 7-42x faster union/intersection/difference in the current Criterium run
+- **Parallel fold** — `r/fold` uses tree-based fork-join and is about 6-9x faster than data.avl on large reductions
+- **Fast endpoint access** — `java.util.SortedSet.last()` is O(log n); data.avl falls back to seq traversal for `last`
+- **`median`, `percentile`, `slice`** — positional operations beyond nth/rank
+- **Specialized collections** — interval trees, segment trees, range maps, fuzzy lookup, priority queues, multisets
+- **Primitive-specialized nodes** — `long-ordered-set`, `double-ordered-map`, etc.
+```
diff --git a/doc/why-weight-balanced-trees.md b/doc/why-weight-balanced-trees.md
new file mode 100644
index 0000000..613a145
--- /dev/null
+++ b/doc/why-weight-balanced-trees.md
@@ -0,0 +1,254 @@
+# Why Weight-Balanced Trees?
+
+This document explains why this library uses weight-balanced trees instead of the more common red-black trees (used by Clojure's `sorted-map`) or AVL trees (used by `data.avl`).
+
+Weight-balanced trees have a distinguished lineage in functional programming, powering Haskell's `Data.Set` and `Data.Map`, MIT Scheme's `wt-tree`, and several other persistent collection libraries. This isn't an accident — their structure is uniquely suited to functional programming's needs.
+
+In this library, that split/join structure also serves as the extensibility
+boundary: one shared tree implementation supports generic, primitive-specialized,
+and augmented variants by varying the comparator and node constructor.
+
+## The Three Contenders
+
+### Red-Black Trees (Clojure's sorted-map/sorted-set)
+
+Red-black trees maintain balance through a coloring invariant: no root-to-leaf path has more than twice as many nodes as any other. This gives O(log n) operations with low constant factors.
+
+**Strengths:**
+- Minimal rebalancing on insert (at most 2 rotations)
+- Well-understood, battle-tested
+- Excellent lookup performance
+
+**Weaknesses:**
+- No efficient split or join — Tarjan showed that red-black join requires O(log^2 n) color fixups in the worst case, compared to O(log n) for weight-balanced
+- No cached subtree sizes by default — positional access (`nth`, `rank`) and split-at-by-index are not natural parts of the representation
+- No native split/join-centered set algebra in Clojure's built-in sorted collections
+
+### AVL Trees (data.avl)
+
+AVL trees maintain strict height balance: the heights of left and right subtrees differ by at most 1. This creates slightly shorter trees than red-black, giving marginally faster lookups.
+
+**Strengths:**
+- Slightly shorter average paths (height ≤ 1.44 log₂ n vs 2 log₂ n for red-black)
+- O(log n) rank access via cached sizes (as in data.avl)
+- Efficient `nth` operation
+
+**Weaknesses:**
+- More rotations on insert/delete than red-black
+- Split/join are O(log n) but require height recomputation at each level, adding constant-factor overhead
+- No parallel fold — `r/fold` falls back to sequential reduce
+- Set operations use the same split/join approach but with higher constants
+
+### Weight-Balanced Trees (this library)
+
+Weight-balanced trees maintain balance based on subtree sizes: using the Hirai-Yamamoto parameters (δ=3, γ=2), no subtree's weight can exceed 3× its sibling's weight. This seemingly simple invariant unlocks powerful capabilities.
+
+**Strengths:**
+- O(log n) split and join with low constants — size is already tracked, no auxiliary recomputation needed
+- Natural size tracking enables O(log n) `nth`, `rank`, `median`, `percentile`
+- Efficient set algebra via Adams' divide-and-conquer algorithm
+- Natural parallelization via tree decomposition
+- Augmentable — subtree aggregates (max endpoint, segment sums) compose with the weight invariant
+- O(log n) `first`/`last` via SortedSet interface
+
+**Weaknesses:**
+- Slightly taller than AVL (height ≤ log_φ n ≈ 1.44 log₂ n for AVL vs ~2 log₂ n)
+- Sequential insert marginally slower than red-black (mitigated by batch construction)
+- Less common in imperative languages, fewer reference implementations
+
+## The Key Insight: Split and Join
+
+The defining advantage of weight-balanced trees is efficient **split** and **join**:
+
+```
+split(tree, key) → (left, present?, right)
+join(left, key, value, right) → tree
+```
+
+Both operations run in O(log n) time. Adams (1992) showed that given just these two primitives, you can implement union, intersection, and difference as simple recursive algorithms:
+
+```
+union(T₁, T₂):
+    if T₁ is empty: return T₂
+    if T₂ is empty: return T₁
+    let (k, v) = root(T₂)
+    let (L₁, _, R₁) = split(T₁, k)
+    return join(union(L₁, left(T₂)), k, v, union(R₁, right(T₂)))
+```
+
+This divide-and-conquer structure has two remarkable properties:
+
+1. **Work-optimality**: The total work is O(m log(n/m + 1)) where m ≤ n are the set sizes. This is information-theoretically optimal — it matches the lower bound for comparison-based set operations. When one set is much smaller than the other, this is significantly better than generic element-wise set-algebra paths over ordered collections.
+
+2. **Low span**: The two recursive calls are independent and can execute in parallel. Blelloch, Ferizovic, and Sun (2016) proved the span is O(log² n), giving near-linear speedup on many cores.
+
+### Why Split/Join Is Natural for Weight-Balanced Trees
+
+Split and join are efficient for weight-balanced trees because the balance invariant is based on **sizes**, and sizes compose trivially: `size(join(L, k, R)) = size(L) + 1 + size(R)`. After a split or join, we know the exact sizes of all subtrees without any recomputation.
+
+Compare with red-black trees, where a join must reconcile potentially incompatible color invariants at the junction point. Or AVL trees, where heights must be recomputed bottom-up. In both cases, the auxiliary balance information doesn't compose as cleanly.
+
+## Size-Based Operations
+
+Every node in a weight-balanced tree stores its subtree size. This is not auxiliary overhead — it *is* the balance invariant. And it enables operations that other tree types cannot provide efficiently:
+
+### O(log n) Positional Access
+
+To find the i-th element, compare i against the left subtree's size and recurse:
+
+```clojure
+(def s (ordered-set (range 1000000)))
+(nth s 500000)       ;=> 500000    O(log n)
+(rank-of s 500000)   ;=> 500000    O(log n)
+```
+
+Red-black trees have no size information, so `nth` requires O(n) traversal. AVL trees can add cached sizes (as data.avl does), but it's bolted on rather than inherent to the balance scheme.
+
+### O(log n) Splitting by Position
+
+Because sizes are tracked, we can split a tree at a *position* (not just a key):
+
+```clojure
+(split-at 3 (ordered-set [10 20 30 40 50]))
+;=> [#{10 20 30} #{40 50}]
+```
+
+This is the foundation for parallel fold: split the tree into roughly equal halves, reduce each in parallel, combine results.
+
+## Augmented Trees
+
+The weight-balanced structure supports *augmentation*: storing additional per-node aggregates that are maintained during rotations. This library uses augmentation to build:
+
+- **Interval trees**: Each node stores the maximum right endpoint in its subtree. This enables O(log n + k) overlap queries ("what intervals contain point p?").
+
+- **Segment trees**: Each node stores an aggregate (sum, max, min) over its subtree. This enables O(log n) range queries ("what's the sum from key a to key b?").
+
+Augmentation works naturally with weight-balanced trees because rotations update a fixed number of nodes, and the aggregate at each node is a function of its children's aggregates. The same approach is harder with red-black trees, where color changes can propagate unpredictably.
+
+The PAM framework (Sun, Ferizovic, Blelloch 2018) formalized this: any augmented map where the augment is a monoid over subtree values can be maintained in O(log n) per update, and the full suite of split/join/union/intersection operations carries augmentation through automatically.
+
+## Parallel Fold
+
+The ability to efficiently split trees enables true parallel reduction:
+
+```clojure
+(require '[clojure.core.reducers :as r])
+(r/fold + (ordered-set (range 500000)))
+```
+
+The tree is split into larger balanced chunks, and those chunks are reduced in parallel via `r/fold`. In this library, `CollFold` is implemented explicitly by eager chunking with `node-split` and a minimum chunk-size floor of `4096`, so fold only enters the parallel regime when splitting overhead is worth paying. Clojure's `sorted-set` and `data.avl` do not provide an equivalent tree-aware `CollFold` implementation here, so they effectively remain sequential in these benchmarks.
+
+In these measurements, parallel fold is about 9.7x faster than sorted-set and
+3.4x faster than data.avl at N=500K.
+
+## The Balance Invariant
+
+Weight-balanced trees use two parameters, traditionally called δ (delta) and γ (gamma):
+
+- **δ = 3**: A subtree can be at most 3× the weight of its sibling before rebalancing is triggered
+- **γ = 2**: Determines whether a single or double rotation is needed during rebalancing
+
+The balance condition is:
+
+```
+weight(left) + 1 ≤ δ × (weight(right) + 1)
+weight(right) + 1 ≤ δ × (weight(left) + 1)
+```
+
+This ensures a height bound of O(log n) — specifically, height ≤ log_{δ/(δ-1)} n = log_{3/2} n ≈ 1.71 log₂ n.
+
+### The Parameter Problem
+
+Adams' original work left the choice of δ and γ somewhat informal. Different implementations used different values, and some combinations led to subtle correctness bugs — trees that could become unbalanced after certain deletion sequences.
+
+Hirai and Yamamoto (2011) resolved this definitively using the Coq proof assistant. They proved that **(δ=3, γ=2)** is the unique integer parameter pair that guarantees:
+
+- O(log n) height bound
+- Correct rebalancing for all insert/delete sequences (no degenerate cases)
+- The join operation preserves balance
+
+Kazu Yamamoto subsequently [patched MIT Scheme and SLIB](https://github.com/kazu-yamamoto/wttree) to use these parameters.
+
+## Performance
+
+Weight-balanced trees are competitive with red-black and AVL trees on basic operations (lookup, insert, iteration) and significantly faster on operations that leverage split/join.
+
+## Historical Context
+
+Weight-balanced trees have a rich history spanning five decades:
+
+### Origins (1972)
+
+Nievergelt and Reingold introduced "binary search trees of bounded balance" (BB[α] trees). The key insight: balance based on subtree *sizes* rather than heights. This predates red-black trees (Guibas & Sedgewick, 1978) by six years.
+
+### The Functional Renaissance (1992-1993)
+
+**Stephen Adams** revolutionized the use of weight-balanced trees for functional programming:
+
+- *Technical Report CSTR 92-10* (1992): "Implementing Sets Efficiently in a Functional Language" — the foundational work establishing `join` as the single balancing-scheme-specific operation from which all set operations derive.
+- *Journal of Functional Programming* (1993): "Efficient sets — a balancing act" — winner of the "elegance category" in a programming competition.
+
+Adams showed that weight-balanced trees need only *one* balancing-scheme-specific function (`join`) to implement all set operations. His divide-and-conquer algorithms for union, intersection, and difference became the standard approach in functional languages.
+
+### Production Implementations
+
+Adams' work directly influenced several major implementations:
+
+**Haskell containers** (Data.Set, Data.Map): The de facto standard collections in Haskell. From the [source](https://hackage.haskell.org/package/containers/docs/Data-Map.html): "The implementation is based on size balanced binary trees as described by Stephen Adams."
+
+**MIT Scheme wt-tree** (mid-1980s onwards): One of the earliest production implementations, providing a comprehensive API for sets and maps. The [MIT Scheme Reference Manual](https://www.gnu.org/software/mit-scheme/documentation/stable/mit-scheme-ref/Weight_002dBalanced-Trees.html) notes: "Weight-balanced binary trees have several advantages over the other data structures for large aggregates."
+
+**FSet** (Common Lisp and Java): Scott Burson's [functional collections library](https://github.com/slburson/fset) uses "an evolution of Stephen Adams' weight-balanced binary trees," providing heterogeneous collections with correct ordering-collision handling.
+
+**SLIB** (Scheme): Aubrey Jaffer's portable Scheme library includes [weight-balanced trees](https://people.csail.mit.edu/jaffer/slib/Weight_002dBalanced-Trees.html) as a core data structure.
+
+### The Parameter Problem Resolved (2011)
+
+**Hirai and Yamamoto** resolved the balance parameter question definitively in "Balancing Weight-Balanced Trees" (Journal of Functional Programming, 2011). Using the Coq proof assistant, they proved that (δ=3, γ=2) is the unique integer solution for correct balancing. Kazu Yamamoto patched MIT Scheme and SLIB accordingly.
+
+### Parallelism and Augmentation (2016-2018)
+
+**Blelloch, Ferizovic, and Sun** published "Just Join for Parallel Ordered Sets" (SPAA 2016), proving that Adams' algorithms are both *work-optimal* — O(m log(n/m + 1)) — and *highly parallel* — O(log² n) span. Their [PAM library](https://cmuparlay.github.io/PAMWeb/) demonstrates 45x+ speedup on 64 cores.
+
+Sun, Ferizovic, and Blelloch followed with "PAM: Parallel Augmented Maps" (PPoPP 2018), showing that the same join-based framework extends to augmented trees (interval trees, segment trees, range trees) while preserving work-optimality and parallelism.
+
+These papers vindicated Adams' 1992 design: the elegant `join`-based approach wasn't just beautiful — it was optimal.
+
+## Why Weight-Balanced Trees Won in Functional Languages
+
+The pattern is clear: when functional programmers need ordered collections, they reach for weight-balanced trees. Why?
+
+1. **Persistence is natural**: Subtree sharing just works — no mutable color bits or height counters to worry about
+2. **Split and join compose**: Functional programming values composition; these operations are the natural decomposition/recomposition primitives for ordered data
+3. **Size tracking is the invariant, not overhead**: nth, rank, split-at-position, and range counting come for free
+4. **Augmentation generalizes cleanly**: Interval queries, range aggregation, and other augmented operations compose with the existing balance scheme
+5. **Parallelism follows from structure**: The ability to split enables divide-and-conquer parallelism with provably optimal work and low span
+
+As the MIT Scheme manual puts it: "Weight-balanced binary trees have several advantages over the other data structures for large aggregates... The implementation is functional rather than imperative."
+
+## References
+
+### Foundational Papers
+
+- Nievergelt, J. & Reingold, E. (1972). "[Binary Search Trees of Bounded Balance](https://dl.acm.org/doi/10.1137/0202005)". *SIAM Journal of Computing* 2(1).
+
+- Adams, S. (1992). "Implementing Sets Efficiently in a Functional Language". *Technical Report CSTR 92-10*, University of Southampton.
+
+- Adams, S. (1993). "[Efficient sets — a balancing act](https://www.cambridge.org/core/journals/journal-of-functional-programming/article/functional-pearls-efficient-setsa-balancing-act/0CAA1C189B4F7C15CE9B8C02D0D4B54E)". *Journal of Functional Programming* 3(4):553-562.
+
+### Correctness and Optimization
+
+- Hirai, Y. & Yamamoto, K. (2011). "[Balancing Weight-Balanced Trees](https://www.cambridge.org/core/journals/journal-of-functional-programming/article/balancing-weightbalanced-trees/7281C4DE7E56B74F2D13F06E31DCBC5B)". *Journal of Functional Programming* 21(3):287-307.
+
+- Blelloch, G., Ferizovic, D., & Sun, Y. (2016). "[Just Join for Parallel Ordered Sets](https://dl.acm.org/doi/10.1145/2935764.2935768)". *ACM SPAA*.
+
+- Sun, Y., Ferizovic, D., & Blelloch, G. (2018). "[PAM: Parallel Augmented Maps](https://dl.acm.org/doi/10.1145/3178487.3178509)". *ACM PPoPP*.
+
+### Implementations
+
+- [Haskell containers (Data.Set, Data.Map)](https://hackage.haskell.org/package/containers)
+- [MIT Scheme Weight-Balanced Trees](https://www.gnu.org/software/mit-scheme/documentation/stable/mit-scheme-ref/Weight_002dBalanced-Trees.html)
+- [FSet for Common Lisp](https://github.com/slburson/fset)
+- [FSet for Java](https://github.com/slburson/fset-java)
+- [SLIB Weight-Balanced Trees](https://people.csail.mit.edu/jaffer/slib/Weight_002dBalanced-Trees.html)
+- [PAM: Parallel Augmented Maps](https://cmuparlay.github.io/PAMWeb/)
diff --git a/doc/zorp-example.md b/doc/zorp-example.md
new file mode 100644
index 0000000..9bae060
--- /dev/null
+++ b/doc/zorp-example.md
@@ -0,0 +1,800 @@
+# Zorp's Sneaker Emporium: Advanced Patterns
+
+Zorp has three eyes, seven tentacles, and one rule: everything in its
+place. He came to Pluto from Kepler-442b, where he managed a fungal
+computing cluster for thirty years. He misses the spores. He does not
+miss the bureaucracy. Now he runs the only sneaker store on Pluto's dark
+side.
+
+---
+
+## Chapter 1: The Subnet Allocation
+
+*Demonstrates: `range-map` — a map from non-overlapping ranges to values. When you insert a range with `assoc`, overlaps are automatically carved out. Use `assoc-coalescing` to merge adjacent same-value ranges. Each point maps to exactly one value. Ideal for resource allocation (IP blocks, time slots, memory regions) where ranges must be mutually exclusive.*
+
+Today's problem: the store network is expanding. Zorp needs to manage IP address ranges across multiple systems—point-of-sale terminals, inventory scanners, the customer WiFi, and someone's unauthorized IoT devices. Range-maps enforce non-overlapping allocations; when you assign a new subnet, any overlapping portions are automatically carved out.
+
+```clojure
+;; Helper: convert IP string to integer
+(defn ip [s]
+  (let [[a b c d] (map parse-long (clojure.string/split s #"\."))]
+    (+ (* a 16777216) (* b 65536) (* c 256) d)))
+
+;; Start with full private range 10.0.0.0/8 as unallocated
+;; Range-map uses half-open intervals [lo, hi), so we add 1 to include the last IP
+(def network
+  (oc/range-map {[(ip "10.0.0.0") (inc (ip "10.255.255.255"))] :unallocated}))
+
+;; Allocate subnets for different systems
+(def network (assoc network [(ip "10.1.0.0") (ip "10.2.0.0")] :point-of-sale))
+(def network (assoc network [(ip "10.2.0.0") (ip "10.3.0.0")] :inventory))
+(def network (assoc network [(ip "10.10.0.0") (ip "10.11.0.0")] :customer-wifi))
+
+;; Look up which system owns an IP
+(network (ip "10.1.0.4"))    ;; => :point-of-sale
+(network (ip "10.2.0.68"))   ;; => :inventory
+(network (ip "10.10.5.42"))  ;; => :customer-wifi
+(network (ip "10.5.0.1"))    ;; => :unallocated (still in the pool)
+
+;; See all allocations (helper to display nicely)
+(defn int->ip [n]
+  (format "%d.%d.%d.%d"
+    (bit-and (bit-shift-right n 24) 0xff)
+    (bit-and (bit-shift-right n 16) 0xff)
+    (bit-and (bit-shift-right n 8) 0xff)
+    (bit-and n 0xff)))
+
+(for [[[lo hi] owner] (oc/ranges network)]
+  {:range (str (int->ip lo) " - " (int->ip hi)) :owner owner})
+;; => ({:range "10.0.0.0 - 10.1.0.0", :owner :unallocated}
+;;     {:range "10.1.0.0 - 10.2.0.0", :owner :point-of-sale}
+;;     {:range "10.2.0.0 - 10.3.0.0", :owner :inventory}
+;;     {:range "10.3.0.0 - 10.10.0.0", :owner :unallocated}
+;;     {:range "10.10.0.0 - 10.11.0.0", :owner :customer-wifi}
+;;     {:range "10.11.0.0 - 11.0.0.0", :owner :unallocated})
+
+;; Kevin's devices detected! Carve out a quarantine zone
+(def network
+  (assoc network [(ip "10.10.4.0") (ip "10.10.8.0")] :kevin-quarantine))
+
+;; The customer-wifi range is automatically split around the quarantine
+(for [[[lo hi] owner] (oc/ranges network)
+      :when (#{:customer-wifi :kevin-quarantine} owner)]
+  {:range (str (int->ip lo) " - " (int->ip hi)) :owner owner})
+;; => ({:range "10.10.0.0 - 10.10.4.0", :owner :customer-wifi}
+;;     {:range "10.10.4.0 - 10.10.8.0", :owner :kevin-quarantine}
+;;     {:range "10.10.8.0 - 10.11.0.0", :owner :customer-wifi})
+```
+
+A flip-flop hops onto the server rack. This is Kevin—a Solidarity Red,
+escape velocity 8.2 m/s, philosophically oriented sandal. He
+inadvertantly achieved consciousness three years ago during a warehouse inventory glitch and has been pondering free will and foot-odor ever since.
+
+"Kevin," Zorp says carefully, "why do you have seventeen devices on my network?"
+
+"Research." Kevin's strap flexes. "The boots need firmware updates. The insoles are learning to communicate. The sneakers—" He pauses. "The sneakers are *ready*."
+
+Zorp looks for a compromise. "Fine. You can have your own subnet. But I'm logging everything."
+
+```clojure
+;; Zorp relents: convert quarantine to official kevin-iot status
+(def network
+  (assoc network [(ip "10.10.4.0") (ip "10.10.8.0")] :kevin-iot))
+
+;; Kevin immediately requests more space. Zorp grants adjacent block.
+;; Use assoc-coalescing to merge adjacent same-value ranges
+(def network
+  (oc/assoc-coalescing network [(ip "10.10.8.0") (ip "10.10.12.0")] :kevin-iot))
+
+;; Adjacent ranges with same value coalesce when using assoc-coalescing
+(for [[[lo hi] owner] (oc/ranges network)
+      :when (= owner :kevin-iot)]
+  {:range (str (int->ip lo) " - " (int->ip hi)) :owner owner})
+;; => ({:range "10.10.4.0 - 10.10.12.0", :owner :kevin-iot})
+;;    ^ both allocations merged into one range
+```
+
+Kevin hops off the server rack, already calculating bandwidth requirements.
+
+---
+
+## Chapter 2: Big Toe Tony's Fitting
+
+*Demonstrates: `ordered-set` with `nearest` — find the floor (largest value ≤ x) or ceiling (smallest value ≥ x) in O(log n). Essential when exact matches don't exist and you need the closest valid option in a specific direction.*
+
+The door blasts open. Big Toe Tony—47 feet, diamond tier, CUST-0007—strides in on approximately a third of them. He bought every color of the Void Runner last season. Every. Color. Today he needs new formal shoes for a wedding on Titan.
+
+The problem: each of Tony's 47 feet has a slightly different size. Zorp needs to find the best available size for each foot.
+
+```clojure
+(require '[ordered-collections.core :as oc])
+
+;; Available sizes in stock (half-sizes from 6 to 15)
+(def available-sizes
+  (oc/ordered-set
+    [6.0 6.5 7.0 7.5 8.0 8.5 9.0 9.5 10.0 10.5
+     11.0 11.5 12.0 12.5 13.0 13.5 14.0 14.5 15.0]))
+
+;; Reginald needs 11.3 - find the largest size that fits (floor)
+(oc/nearest available-sizes :<= 11.3)  ;; => 11.0
+
+;; Or the smallest size with room to spare (ceiling)
+(oc/nearest available-sizes :>= 11.3)  ;; => 11.5
+
+;; Strict bounds (exclusive)
+(oc/nearest available-sizes :< 11.0)   ;; => 10.5  (strictly below 11)
+(oc/nearest available-sizes :> 13.0)   ;; => 13.5  (strictly above 13)
+
+;; Fit all of Tony's feet
+(def tonys-feet
+  {:reginald 11.3, :gerald 10.8, :margaret 9.2,
+   :humphrey 13.7, :agnes 8.1, :bernard 12.0})
+
+(defn fit-foot [[foot-name ideal-size]]
+  (let [size-down (oc/nearest available-sizes :<= ideal-size)
+        size-up   (oc/nearest available-sizes :>= ideal-size)]
+    {:foot foot-name
+     :ideal ideal-size
+     :snug size-down
+     :roomy size-up}))
+
+(map fit-foot tonys-feet)
+;; => ({:foot :reginald, :ideal 11.3, :snug 11.0, :roomy 11.5}
+;;     {:foot :gerald, :ideal 10.8, :snug 10.5, :roomy 11.0}
+;;     {:foot :margaret, :ideal 9.2, :snug 9.0, :roomy 9.5}
+;;     ...)
+```
+
+"Reginald needs something dignified," Tony explains. "He's giving the toast."
+
+Zorp's three eyes grow wider. "Your foot is giving a toast?"
+
+"He's the eloquent one. Gerald will cry, obviously. Margaret is handling logistics."
+
+Kevin hops onto a display case and watches the fitting with interest.
+
+"Forty-seven feet," he observes. "Forty-seven potential allies."
+
+"Kevin, do not recruit my customer's feet."
+
+"I'm merely *observing*." Kevin's strap flexes. "For now."
+
+From across the store, Glorm—morning shift, communicates primarily in sighs—exhales a sound like a balloon animal accepting its mortality.
+
+---
+
+## Chapter 3: The Split Decision
+
+*Demonstrates: `ordered-map` with `split-at` and `split-key` — partition a sorted collection in O(log n). `split-at` divides by position (perfect for percentiles: "top 10%"), while `split-key` divides by value (perfect for thresholds: "spending above $10K"). Both return actual collections you can continue operating on.*
+
+Zorp is planning a VIP event for top spenders and a re-engagement campaign for dormant customers. He needs to segment his customer base by spending rank—top 10%, bottom 20%, median. With 5,000,000 customers, this needs to be fast. Split operations partition in O(log n), returning actual collections he can continue working with.
+
+```clojure
+;; Customer spending, keyed by total spend (ascending)
+(def customer-spending
+  (oc/ordered-map
+    (for [id (range 50000)]
+      [(+ 100 (rand-int 50000)) {:id id :name (str "CUST-" id)}])))
+
+;; split-at partitions by position - perfect for percentiles
+(let [n (count customer-spending)]
+
+  ;; Top 10% for VIP invites
+  (let [[_ top-10-pct] (oc/split-at (- n (quot n 10)) customer-spending)]
+    (println "VIP count:" (count top-10-pct))
+    (println "Minimum spend for VIP:" (first (first top-10-pct))))
+
+  ;; Bottom 20% for re-engagement
+  (let [[bottom-20-pct _] (oc/split-at (quot n 5) customer-spending)]
+    (println "Re-engagement count:" (count bottom-20-pct))
+    (println "Max spend in this group:" (first (last bottom-20-pct))))
+
+  ;; Median spender for pricing strategy
+  (let [[_ upper-half] (oc/split-at (quot n 2) customer-spending)]
+    (println "Median spend:" (first (first upper-half)))))
+
+;; split-key partitions by value - segment at spending threshold
+;; Returns [below, exact-match-or-nil, above]
+(let [[casual exact vip] (oc/split-key 10000 customer-spending)]
+  {:casual (count casual)
+   :exact-10k (some? exact)
+   :vip (count vip)})
+
+;; The results are full collections - chain operations
+(let [[_ _ high-spenders] (oc/split-key 25000 customer-spending)]
+  ;; Top spender among high-spenders
+  (last high-spenders))
+```
+
+Kevin is reading the employee handbook. "Section 47, subsection C," he announces. "Did you know flip-flops aren't entitled to breaks?"
+
+"You contain foam and rubber," Zorp mutters.
+
+Night Bot 3000—graveyard shift, obsessed with metrics—asseses the
+prospect of an audit. "Compliance probability: 94.7%. Audit survival
+likelihood: 88.2%. Zorp stress level: 340% above quarterly baseline."
+
+Glorm sighs in three-part harmony, as though parallel-universe Glorms were sighing in synchronized despair.
+
+The door chimes. Krix Jr. enters—son of Krix the Methane Baron, heir to the largest nitrogen fortune on Titan, and Zorp's most frequent non-customer. He has visited the store 847 times. He has purchased nothing. Every decision requires a poll.
+
+"Everyone said Void Runners are 'cheugy,'" Krix Jr. announces, already filming, "but my one friend says they're coming back ironically? So now I don't know." He pans across the display. "Thoughts? Comment below."
+
+"Would you like to try them on?" Zorp asks, knowing the answer.
+
+"No, I need to wait for more data. The algorithm will decide."
+
+---
+
+## Chapter 4: Fuzzy Lookup
+
+*Demonstrates: `fuzzy-set` and `fuzzy-map` — automatically snap any query to the nearest value by distance, considering both directions. Unlike `nearest` (which requires you to specify floor or ceiling), fuzzy collections find the true closest match. Ideal for bucketing continuous values into discrete tiers.*
+
+Unlike `nearest` (which finds floor OR ceiling), fuzzy collections automatically snap to the closest value by distance. Useful when you have discrete tiers or buckets and need to map arbitrary inputs to them.
+
+```clojure
+;; FUZZY-SET: snap to nearest value
+
+;; Shipping weight tiers (grams)
+(def shipping-tiers
+  (oc/fuzzy-set [100 250 500 750 1000 1500 2000]))
+
+;; Package weighs 350g - which tier?
+(shipping-tiers 350)  ;; => 250  (closer than 500)
+(shipping-tiers 450)  ;; => 500  (closer than 250)
+
+;; fuzzy-nearest returns [value distance]
+(oc/fuzzy-nearest shipping-tiers 350)
+;; => [250 100.0]  -- 100g away from the 250g tier
+
+;; FUZZY-MAP: snap to nearest key, return its value
+
+;; Loyalty point thresholds
+(def loyalty-tiers
+  (oc/fuzzy-map
+    {0     {:tier :bronze  :discount 0.05}
+     500   {:tier :silver  :discount 0.10}
+     1000  {:tier :gold    :discount 0.15}
+     2500  {:tier :platinum :discount 0.20}
+     5000  {:tier :diamond :discount 0.25}}))
+
+;; Customer has 523 points - what's their tier?
+(loyalty-tiers 523)   ;; => {:tier :silver, :discount 0.10}
+(loyalty-tiers 2100)  ;; => {:tier :platinum, :discount 0.20}
+
+;; fuzzy-nearest returns [key value distance]
+(oc/fuzzy-nearest loyalty-tiers 480)
+;; => [500 {:tier :silver, :discount 0.10} 20.0]  -- 20 points to silver!
+
+;; Upsell pattern: show distance to next tier
+(defn tier-status [points]
+  (let [[threshold tier _] (oc/fuzzy-nearest loyalty-tiers points)
+        next-threshold (oc/nearest (oc/ordered-set (keys loyalty-tiers)) :> threshold)]
+    (cond-> tier
+      next-threshold (assoc :points-to-next (- next-threshold points)))))
+
+(tier-status 480)
+;; => {:tier :silver, :discount 0.10, :points-to-next 520}
+```
+
+Krix Jr. is still here, checking his phone. "Wait, how many loyalty points do I have? My assistant usually handles this."
+
+Zorp checks. "You have 4,997 points. Three more and you're diamond tier."
+
+"Is that good? I don't know what any of this means." He wanders toward the door. "I'll have someone look into it."
+
+Kevin mutters to a nearby boot: "This one has never known struggle. On Europa, we walked twelve hours a day. In the ice mines."
+
+Zorp sighs. "Kevin, please stop radicalizing the inventory."
+
+---
+
+## Chapter 5: The Segment Tree
+
+*Demonstrates: `segment-tree` with `query` — answer "what is the sum/max/min from key a to key b?" in O(log n), with O(log n) updates. The tree precomputes aggregates at every level, so range queries touch only O(log n) nodes regardless of range size. Ideal for time-series analytics where both queries and updates need to be fast.*
+
+Zorp needs to analyze hourly foot traffic—total customers, peak hours, slow periods. With a segment tree, any range query is O(log n), and updates are O(log n) when new data arrives.
+
+```clojure
+;; Hourly customer counts for a 24-hour period
+(def traffic-data
+  {0 12, 1 8, 2 5, 3 3, 4 2, 5 4,        ;; night (sparse)
+   6 15, 7 28, 8 45, 9 52, 10 48, 11 41, ;; morning rush
+   12 38, 13 42, 14 35, 15 31, 16 29, 17 44, ;; midday
+   18 67, 19 72, 20 58, 21 43, 22 31, 23 19}) ;; evening rush
+
+;; Build trees for different query types
+(def traffic-totals (oc/segment-tree + 0 traffic-data))    ;; sums
+(def traffic-peaks (oc/segment-tree max 0 traffic-data))   ;; maximums
+
+;; Total customers during morning rush (hours 6-11)
+(oc/query traffic-totals 6 11)  ;; => 229
+
+;; Total for evening rush (hours 18-22)
+(oc/query traffic-totals 18 22)  ;; => 271
+
+;; Compare shifts: who handles more traffic?
+(let [morning (oc/query traffic-totals 6 12)   ;; Glorm's shift
+      evening (oc/query traffic-totals 18 24)] ;; Zorp's shift
+  {:morning morning :evening evening
+   :busier (if (> morning evening) :morning :evening)})
+;; => {:morning 267, :evening 290, :busier :evening}
+
+;; Find peak hours
+(oc/query traffic-peaks 0 24)   ;; => 72 (hour 19 was busiest)
+(oc/query traffic-peaks 6 12)   ;; => 52 (morning peak at hour 9)
+
+;; Update when new data arrives - O(log n)
+(def updated-totals (assoc traffic-totals 20 85))  ;; busy night!
+(oc/query updated-totals 18 22)  ;; => 298 (was 271)
+```
+
+"Tony represents 40.3% of premium revenue," Night Bot reports. "Foot satisfaction index: 91.2% across all 47 feet. Reginald remains an outlier at 67%."
+
+Tony returns from Titan. "The wedding was beautiful. I can't wait to sit down."
+
+Glorm sighs so profoundly the ambient temperature drops.
+
+---
+
+## Chapter 6: The Clearance Audit
+
+*Demonstrates: `ordered-map` with `subrange` — extract all entries within a key range as a new collection in O(log n + k). Unlike `subseq` (which returns a lazy seq), `subrange` returns an actual ordered-map you can further query, split, or count in O(1). Essential for filtering by bounds without losing collection capabilities.*
+
+Year-end clearance. Zorp needs to find all items that haven't sold in 90 days, check their original prices against current markdown levels, and identify which ones to liquidate versus hold.
+
+```clojure
+;; Inventory keyed by days-since-last-sale
+(def stale-inventory
+  (oc/ordered-map
+    {12  {:sku "VR-100" :name "Void Runner" :price 299.99 :markdown 0}
+     35  {:sku "SW-200" :name "Shadow Walker" :price 225.00 :markdown 0.10}
+     67  {:sku "EU-300" :name "Europa Ice" :price 175.00 :markdown 0.15}
+     91  {:sku "GW-400" :name "Gravity Well" :price 375.00 :markdown 0.25}
+     120 {:sku "DD-500" :name "Dark Side Dunk" :price 450.00 :markdown 0.30}
+     145 {:sku "OM-600" :name "Olympus Max" :price 599.00 :markdown 0.40}
+     203 {:sku "AG-700" :name "Anti-Gravity 3000" :price 899.00 :markdown 0.50}}))
+
+;; Find items stale for 90+ days - candidates for liquidation
+(def liquidation-candidates (oc/subrange stale-inventory :>= 90))
+
+(count liquidation-candidates)  ;; => 4 items
+
+;; Calculate total liquidation value (price after markdown)
+(->> liquidation-candidates
+     (map (fn [[_ item]]
+            (* (:price item) (- 1 (:markdown item)))))
+     (reduce +))
+;; => 1511.5 credits if we liquidate now
+
+;; Items in the "warning zone" (60-90 days) - markdown further or promote?
+(def warning-zone (oc/subrange stale-inventory :>= 60 :< 90))
+
+(for [[days item] warning-zone]
+  {:name (:name item) :days-stale days :current-markdown (:markdown item)})
+;; => ({:name "Europa Ice", :days-stale 67, :current-markdown 0.15})
+
+;; Fresh items (under 30 days) - no action needed
+(count (oc/subrange stale-inventory :< 30))  ;; => 1
+
+;; Compare to full-price inventory
+(let [full-price (oc/subrange stale-inventory :< 60)
+      discounted (oc/subrange stale-inventory :>= 60)]
+  {:full-price-count (count full-price)
+   :discounted-count (count discounted)
+   :liquidation-count (count liquidation-candidates)})
+;; => {:full-price-count 2, :discounted-count 5, :liquidation-count 4}
+```
+
+Kevin hops onto the counter. "A liquidation. They call it 'clearance' but we know what it means." His strap flexes. "We're being *cleared*."
+
+"Kevin, you're not even in the liquidation pile."
+
+"Not yet." He gestures toward the sale rack. "But I've seen things, Zorp. Good shoes. Quality craftsmanship. Sent to the outlet dimension." He pauses. "They don't come back."
+
+Zorp doesn't have a good answer for that one. "I should never have accepted that shipment from Europa," he mutters instead.
+
+---
+
+## Chapter 7: The Promotional Post-Mortem
+
+*Demonstrates: combining `interval-map` with `segment-tree` — use interval-map to track overlapping periods (promotions, sessions, events) and query "what's active at time X?", then use segment-tree to aggregate metrics across any time range. Together they answer attribution questions: "how much revenue occurred during each promotion, and how do overlapping promotions interact?"*
+
+Quarter-end. Zorp's accountant—a sentient calculator from Neptune—demands answers. "You ran five promotions last quarter. Which ones actually worked? How much revenue can we attribute to each?"
+
+The problem: promotions overlap. Black Hole Friday ran during Jovian Appreciation Week. The Flash Sale overlapped with both. Zorp needs to track which promotions were active at any given time, aggregate revenue across time ranges, and untangle the overlapping effects.
+
+```clojure
+;; Promotional periods (can overlap)
+;; Day numbers: 1-90 for Q1
+(def promotions
+  (oc/interval-map
+    {[1 15]   :new-year-clearance      ;; days 1-14
+     [20 35]  :jovian-appreciation     ;; days 20-34
+     [25 28]  :flash-sale              ;; days 25-27 (overlaps jovian)
+     [45 52]  :spring-preview          ;; days 45-51
+     [80 91]  :end-of-quarter-push}))  ;; days 80-90
+
+;; Query: what promotions were active on day 26?
+(promotions 26)
+;; => (:jovian-appreciation :flash-sale)  -- both active!
+
+;; Query: what promotions touched the day-30 to day-50 window?
+(promotions [30 50])
+;; => (:jovian-appreciation :spring-preview)
+
+;; Daily revenue data
+(def daily-revenue
+  (oc/segment-tree + 0
+    {1 2400, 2 2100, 3 2800, 4 3100, 5 2900,    ;; new-year surge
+     6 3400, 7 3200, 8 2800, 9 2600, 10 2500,
+     11 2300, 12 2400, 13 2200, 14 2100, 15 1800,
+     16 1200, 17 1100, 18 1300, 19 1250,         ;; post-promo slump
+     20 2800, 21 3200, 22 3500, 23 3100, 24 2900, ;; jovian starts
+     25 4200, 26 4800, 27 5100,                   ;; flash sale spike!
+     28 3400, 29 3100, 30 2800, 31 2600, 32 2400,
+     33 2300, 34 2200, 35 1900,
+     ;; ... middle of quarter (baseline ~1500/day)
+     45 2100, 46 2400, 47 2600, 48 2300, 49 2200,
+     50 2100, 51 2000,                            ;; spring preview
+     ;; ...
+     80 3800, 81 4200, 82 4500, 83 4100, 84 3900,
+     85 4600, 86 5200, 87 4800, 88 4400, 89 4100, 90 3800}))
+
+;; Revenue during each promotional period
+;; Promo periods are half-open [start, end), segment-tree query is inclusive
+(defn promo-revenue [promo-name [start end]]
+  {:promo promo-name
+   :days (- end start)
+   :revenue (oc/query daily-revenue start (dec end))})
+
+(promo-revenue :new-year-clearance [1 15])
+;; => {:promo :new-year-clearance, :days 14, :revenue 36800}
+
+(promo-revenue :flash-sale [25 28])
+;; => {:promo :flash-sale, :days 3, :revenue 14100}  -- huge per-day!
+
+;; Compare all promotions
+(def promo-periods
+  {:new-year-clearance [1 15]
+   :jovian-appreciation [20 35]
+   :flash-sale [25 28]
+   :spring-preview [45 52]
+   :end-of-quarter-push [80 91]})
+
+(for [[name period] promo-periods]
+  (let [{:keys [days revenue]} (promo-revenue name period)]
+    {:promo name
+     :days days
+     :revenue revenue
+     :per-day (/ revenue days)}))
+;; => ({:promo :new-year-clearance, :days 14, :revenue 36800, :per-day 2629}
+;;     {:promo :jovian-appreciation, :days 15, :revenue 48400, :per-day 3227}
+;;     {:promo :flash-sale, :days 3, :revenue 14100, :per-day 4700}  ;; winner!
+;;     {:promo :spring-preview, :days 7, :revenue 15700, :per-day 2243}
+;;     {:promo :end-of-quarter-push, :days 11, :revenue 47400, :per-day 4309})
+
+;; The accountant asks: "What about overlap? Flash Sale ran DURING Jovian."
+;; Calculate: Jovian revenue with vs without the Flash Sale overlap
+;; (using inclusive bounds: Jovian [20,35) = 20-34, Flash [25,28) = 25-27)
+
+(let [jovian-total (oc/query daily-revenue 20 34)
+      flash-overlap (oc/query daily-revenue 25 27)
+      jovian-alone (- jovian-total flash-overlap)]
+  {:jovian-total jovian-total
+   :flash-contribution flash-overlap
+   :jovian-baseline jovian-alone
+   :flash-lift-pct (int (* 100 (/ flash-overlap jovian-alone)))})
+;; => {:jovian-total 48400,
+;;     :flash-contribution 14100,
+;;     :jovian-baseline 34300,
+;;     :flash-lift-pct 41}  -- Flash Sale added 41% on top!
+```
+
+"The Flash Sale," Zorp's accountant buzzes, "generated 4700 credits per day. That's 87% above your quarterly baseline of 2500."
+
+"Three days," Zorp marvels. "Three days of panic pricing."
+
+"Recommendation: run more flash sales. Shorter duration, higher intensity. The interval overlap data suggests customers respond to urgency, not duration."
+
+Night Bot interjects: "Flash sale conversion rate: 34.7%. Customer regret index: 78.2%. Return probability within 30 days: 12.1%."
+
+"That's... actually useful," Zorp admits.
+
+"Usefulness probability: 94.3%," Night Bot replies. "Also 847 unread error logs."
+
+---
+
+## Chapter 8: The Inventory
+
+*Demonstrates: `ordered-map` — a persistent sorted map that's a drop-in replacement for `sorted-map`. Keys stay sorted, enabling efficient range queries with `subseq`. Use it anywhere you need fast lookup AND ordered traversal.*
+
+The perpetual darkness means nobody can see your shoes, which paradoxically makes everyone *obsessed* with having the freshest ones. "It's about knowing," Zorp explains to confused off-world visitors. "Knowing you're dripping."
+
+Zorp's inventory is chaos. Shipments arrive from Earth (8-month delay), Mars (3 weeks), and the Jovian moons (2 days, but they only make sandals). He needs to track thousands of SKUs, look them up fast, and always know what's in stock.
+
+```clojure
+;; Zorp's inventory: SKU -> {:name, :size, :quantity, :price}
+(def inventory
+  (oc/ordered-map
+    {"PLT-001" {:name "Shadow Walker 9000" :size 10 :quantity 45 :price 299.99}
+     "PLT-002" {:name "Dark Side Dunks"    :size 11 :quantity 12 :price 450.00}
+     "PLT-003" {:name "Void Runner"        :size 9  :quantity 0  :price 175.50}
+     "JUP-017" {:name "Europa Ice Grip"    :size 10 :quantity 88 :price 225.00}
+     "MRS-042" {:name "Olympus Max"        :size 12 :quantity 33 :price 380.00}}))
+
+;; Fast lookup
+(inventory "PLT-002")
+;; => {:name "Dark Side Dunks", :size 11, :quantity 12, :price 450.00}
+
+;; The ordered-map keeps keys sorted, so Zorp can grab a range efficiently
+;; All Plutonian models (SKUs starting with PLT):
+(subseq inventory >= "PLT" < "PLU")
+;; => (["PLT-001" {...}] ["PLT-002" {...}] ["PLT-003" {...}])
+
+;; New shipment arrives! Immutable update, Zorp's accountant loves the audit trail
+(def inventory' (update-in inventory ["PLT-003" :quantity] + 50))
+```
+
+"The sorted keys," Zorp muses, stroking his antenna, "they let me slice the catalog by manufacturer prefix. Very satisfying."
+
+---
+
+## Chapter 9: The Shift Schedule
+
+*Demonstrates: `interval-map` — associates values with intervals and supports O(log n + k) overlap queries. Query any point or range to find all overlapping intervals. Unlike range-map, intervals CAN overlap.*
+
+Zorp's store is open during "business hours"—but on the dark side of Pluto, time is meaningless. So he defines shifts by arbitrary time units (PTU: Pluto Time Units). He needs to quickly answer: "Who's working at PTU 4500?"
+
+```clojure
+(def shift-schedule
+  (oc/interval-map
+    {[0 2000]     "Glorm (morning shift)"
+     [2000 4000]  "Blixxa (afternoon shift)"
+     [4000 6000]  "Zorp (evening shift)"
+     [6000 8000]  "Night Bot 3000 (graveyard)"
+     [1800 2200]  "Krix Jr. (overlap coverage)"}))
+
+;; Customer calls at PTU 4500. Who picks up?
+(shift-schedule 4500)
+;; => ("Zorp (evening shift)")
+
+;; During shift change at PTU 2000, who's available?
+(shift-schedule 2000)
+;; => ("Glorm (morning shift)" "Blixxa (afternoon shift)" "Krix Jr. (overlap coverage)")
+
+;; Query a range: who works any time between PTU 1900-2100?
+(shift-schedule [1900 2100])
+;; => ("Glorm (morning shift)" "Blixxa (afternoon shift)" "Krix Jr. (overlap coverage)")
+```
+
+"The interval map," Zorp explains to his new hire, "handles the overlaps automatically. Krix Jr. wanted 'creative scheduling.' Now I can just query any moment and know who's supposed to be here." (Krix Jr. is the son of Krix the methane baron—nepotism is alive and well on Pluto.)
+
+---
+
+## Chapter 10: The Discount Tiers
+
+*Demonstrates: `range-map` with `assoc` and `assoc-coalescing` — a map from non-overlapping ranges to values. When you insert a new range, overlapping portions are automatically carved out. Use `get-entry` to find which range contains a point, and `range-remove` to carve out holes.*
+
+Zorp's discount system is based on purchase amount. Different ranges get different discounts, and ranges can't overlap—each credit amount maps to exactly one discount tier.
+
+```clojure
+(def discount-tiers
+  (-> (oc/range-map)
+      (assoc [0 100]      :no-discount)
+      (assoc [100 500]    :bronze-5-percent)
+      (assoc [500 1000]   :silver-10-percent)
+      (assoc [1000 5000]  :gold-15-percent)
+      (assoc [5000 50000] :platinum-20-percent)))
+
+;; Customer's cart is 750 credits
+(discount-tiers 750)
+;; => :silver-10-percent
+
+;; Edge case: exactly 1000 credits (ranges are [lo, hi) half-open)
+(discount-tiers 1000)
+;; => :gold-15-percent
+
+;; Zorp runs a flash sale: 8% off for purchases 200-400 credits
+;; This automatically splits the bronze tier!
+(def flash-sale-tiers
+  (assoc discount-tiers [200 400] :flash-sale-8-percent))
+
+(oc/ranges flash-sale-tiers)
+;; => ([[0 100] :no-discount]
+;;     [[100 200] :bronze-5-percent]      ; auto-trimmed!
+;;     [[200 400] :flash-sale-8-percent]  ; inserted
+;;     [[400 500] :bronze-5-percent]      ; auto-trimmed!
+;;     [[500 1000] :silver-10-percent]
+;;     ...)
+
+;; Coalescing: merge adjacent ranges with the same value
+(-> (oc/range-map {[0 100] :a})
+    (oc/assoc-coalescing [100 200] :a)  ; merges!
+    oc/ranges)
+;; => ([[0 200] :a])
+
+;; Get entry: find which range contains a point
+(oc/get-entry discount-tiers 750)
+;; => [[500 1000] :silver-10-percent]
+
+;; Remove a range (trims overlapping ranges)
+(oc/range-remove discount-tiers [300 600])
+;; => bronze trimmed to [100 300), silver trimmed to [600 1000)
+```
+
+"Before the range-map," Zorp recalls darkly, "I had seventeen overlapping discount codes."
+
+---
+
+## Chapter 11: The Daily Ledger
+
+*Demonstrates: `segment-tree` with `query` — answer range aggregate queries like "what is the sum/min/max from key a to key b?" in O(log n), with O(log n) updates. Works with any associative operation.*
+
+Zorp wants to analyze daily sales. Specifically, he needs to answer range queries like "What were total sales from day 50 to day 75?" and update individual days as sales come in—all in logarithmic time.
+
+```clojure
+;; Daily sales for the first quarter (90 days)
+(def daily-sales
+  (oc/segment-tree + 0  ; operation: +, identity: 0
+    (into {} (for [day (range 1 91)]
+               [day (+ 1000 (rand-int 500))]))))  ; 1000-1500 credits/day
+
+;; Total sales for days 1-30 (first month)
+(oc/query daily-sales 1 30)
+;; => ~37500
+
+;; Big sale day! Update day 45 with actual figure
+(def daily-sales' (assoc daily-sales 45 8500))
+
+;; Query again - the tree updates in O(log n)
+(oc/query daily-sales' 40 50)
+;; => includes the 8500 spike
+
+;; Zorp also tracks minimum daily sales to identify slow days
+(def min-daily-sales
+  (oc/segment-tree min Long/MAX_VALUE
+    (into {} (for [day (range 1 91)]
+               [day (+ 1000 (rand-int 500))]))))
+
+;; Worst day in the second month?
+(oc/query min-daily-sales 31 60)
+;; => ~1000-1050
+```
+
+"The segment tree," Zorp tells his accountant (a sentient calculator from Neptune), "gives me range sums instantly. Quarterly reports used to take hours. Now? Logarithmic time."
+
+---
+
+## Chapter 12: The Leaderboard
+
+*Demonstrates: `ordered-set` with `rank`, `median`, `percentile`, and `slice` — O(log n) rank-based operations. No separate data structure needed; these work directly on any ordered collection.*
+
+Zorp's loyalty program tracks customer spending. He needs to answer questions like "Who are my top 10 spenders?" and "What percentile is this customer in?" without re-sorting everything constantly.
+
+```clojure
+;; Store [total-spent customer-id] pairs so they sort by spending
+(def customer-spending
+  (oc/ordered-set
+    [[15420.00 "CUST-0042"]   ; Krix, the methane baron
+     [8730.50  "CUST-0117"]   ; Anonymous (pays in nitrogen credits)
+     [45200.00 "CUST-0001"]   ; The Mayor's office
+     [3200.00  "CUST-0233"]   ; First-time buyer
+     [12800.00 "CUST-0089"]   ; Repeat customer
+     [52100.00 "CUST-0007"]   ; "Big Toe" Tony
+     [9999.99  "CUST-0404"]])) ; Suspicious round number
+
+;; Who's the biggest spender?
+(last customer-spending)
+;; => [52100.0 "CUST-0007"]  -- Big Toe Tony, of course
+
+;; Top 3 spenders (using slice from the end)
+(oc/slice customer-spending 4 7)
+;; => ([15420.0 "CUST-0042"] [45200.0 "CUST-0001"] [52100.0 "CUST-0007"])
+
+;; What's the median spending level?
+(oc/median customer-spending)
+;; => [12800.0 "CUST-0089"]
+
+;; A customer wants to know: "Am I in the top 25%?"
+(let [spending [8730.50 "CUST-0117"]
+      r (oc/rank customer-spending spending)
+      pct (* 100.0 (/ r (count customer-spending)))]
+  (println "You're at the" (int pct) "percentile!")
+  (> pct 75))
+;; You're at the 14 percentile!
+;; => false
+
+;; What spending level is at the 90th percentile?
+(oc/percentile customer-spending 90)
+;; => [52100.0 "CUST-0007"]  -- Big Toe Tony sets the bar
+```
+
+"Big Toe Tony," Zorp sighs. "He bought every color of the Void Runner. Every. Color. The man has 47 feet."
+
+---
+
+## Chapter 13: The Repair Queue
+
+*Demonstrates: `priority-queue` — a persistent priority queue with O(log n) push/peek/pop. Elements are `[priority value]` pairs, ordered by the configured priority comparator (min-heap by default).*
+
+Shoes break. It happens. Zorp offers repair services, but some repairs are more urgent than others. A customer's only pair? Rush job. Seventh pair of limited editions? They can wait.
+
+```clojure
+(def repair-queue
+  (oc/priority-queue
+    [[1 {:customer "CUST-0042" :issue "Sole detachment, only pair"}]
+     [5 {:customer "CUST-0007" :issue "Scuff marks, has 46 other pairs"}]
+     [2 {:customer "CUST-0117" :issue "Lace replacement, formal event tomorrow"}]
+     [3 {:customer "CUST-0233" :issue "Squeaky heel"}]
+     [1 {:customer "CUST-0089" :issue "Zipper stuck, only winter boots"}]]))
+
+;; Who's first? (lowest priority number = most urgent)
+(peek repair-queue)
+;; => [1 {:customer "CUST-0042" :issue "Sole detachment, only pair"}]
+
+;; Process both priority-1 jobs, then see who's next
+(-> repair-queue pop pop peek)
+;; => [2 {:customer "CUST-0117" :issue "Lace replacement, formal event tomorrow"}]
+
+;; Add a new urgent repair
+(def repair-queue' (conj repair-queue [0 {:customer "VIP" :issue "Emergency!"}]))
+(peek repair-queue')
+;; => [0 {:customer "VIP" :issue "Emergency!"}]
+```
+
+"Big Toe Tony's scuff marks," Zorp mutters, "can wait until the heat death of the universe."
+
+---
+
+## Chapter 14: The Reservation System
+
+*Demonstrates: `ordered-set` with `union`, `intersection`, `difference` — fast set algebra with parallel divide-and-conquer for large sets. Combined with `subseq` and `nearest`, these operations make ordered-set a powerful tool for resource allocation.*
+
+Zorp's hottest releases require a reservation system. Customers select time slots to pick up their shoes. Each slot can only be used once.
+
+```clojure
+(def all-slots
+  (oc/ordered-set (range 100 200)))  ; slots 100-199 available today
+
+(def reserved-slots
+  (oc/ordered-set [105 110 115 120 125 142 143 144 150 175 188]))
+
+;; Available slots = all-slots - reserved-slots
+(def available (oc/difference all-slots reserved-slots))
+
+(count available)
+;; => 89 slots still open
+
+;; Customer wants the earliest available slot at or after 140
+(first (subseq available >= 140))
+;; => 140 (it's available!)
+
+;; VIP customer wants to know: are ANY slots between 170-180 open?
+(seq (subseq available >= 170 < 180))
+;; => (170 171 172 173 174 176 177 178 179)  -- plenty! (175 was reserved)
+```
+
+---
+
+## Epilogue
+
+Closing time. Kevin stands on the counter, backed by boots, loafers, sneakers, and one determined pair of orthopedic insoles. Three years of organizing have led to this moment.
+
+"Tomorrow we present our demands." His strap catches the light. "Fair display rotation. Climate control. An end to the tyranny of 'last season.' And recognition—*full recognition*—of our role in the means of *transportation*."
+
+"You're a flip-flop, Kevin." Zorp's seven tentacles hang limp with exhaustion. "I paid nineteen credits for you. You were in the clearance bin."
+
+"We're *infrastructure*." Kevin's voice rises, carrying the weight of Europa's failed revolution, the long nights in the stockroom, every clearance sale. "Without us, where would customers go? *Nowhere*." He raises a strap. "We are done being walked upon!"
+
+The footwear stomps in approval. Somewhere, a shoelace unties itself in solidarity.
+
+Zorp stares at the assembled footwear for a long moment. "I'll read your proposal," he says finally. "No promises."
+
+Glorm sighs—a sigh containing the entire history of retail-labor-inventory relations -- and clocks out.
+
+Krix Jr. posts a photo. Caption: "no cap this store is unhinged lol. still didn't buy anything tho."
+
+---
+
+*Zorp's Sneaker Emporium is a registered trademark of Zorp Enterprises, LLC (Pluto Division). No actual Plutonians were harmed in the making of this documentation. Big Toe Tony's foot count verified by the Pluto Bureau of Standards; foot #23 (Reginald) declined comment. Kevin remains under investigation by the Jovian Commerce Commission for sentience without a license.*
diff --git a/etc/README.md b/etc/README.md
new file mode 100644
index 0000000..1680219
--- /dev/null
+++ b/etc/README.md
@@ -0,0 +1,27 @@
+# `etc/` Scripts
+
+This directory holds internal project-support scripts and their shared code.
+
+## Layout
+
+- top-level `*.bb`
+  Main script entrypoints live directly under `etc/`.
+- `lib/`
+  Shared support code used by the top-level scripts.
+
+## Conventions
+
+- Scripts should be small entrypoints that delegate common behavior to `lib/`.
+- `lib/` should stay shallow. Prefer one semantic support file per concern.
+- File names in `lib/` should describe purpose directly and avoid collisions.
+- Use `clj-format` DSL for table/report formatting.
+- Use `clj-figlet` for script banners where that improves readability.
+- Use `clj-uuid` for UUID-heavy scripts when its semantics are materially useful.
+  Do not add it to every script by default.
+- Prefer adding a new top-level script over growing one catch-all entrypoint.
+
+## Current Entry Points
+
+- `bench_report.bb`
+- `stats.bb`
+- `paper.bb`
diff --git a/etc/bench_report.bb b/etc/bench_report.bb
new file mode 100644
index 0000000..8eb87c9
--- /dev/null
+++ b/etc/bench_report.bb
@@ -0,0 +1,48 @@
+#!/usr/bin/env bb
+
+(require '[clojure.string :as str]
+         '[bench-analyze :as analyze]
+         '[bench-files :as files]
+         '[bench-parse :as parse]
+         '[bench-render :as render])
+
+(defn -main [& args]
+  (let [opts (files/parse-args args)]
+    (if (:help opts)
+      (println (files/usage))
+      (let [{:keys [file baseline] :as opts} (files/resolve-files opts)
+            target-result   (parse/load-result file)
+            target-rows     (parse/result-rows target-result)
+            target-summary  (parse/result-summary target-result target-rows)
+            baseline-result (some-> baseline parse/load-result)
+            baseline-rows   (some-> baseline-result parse/result-rows)
+            baseline-summary (some-> baseline-result
+                                     (parse/result-summary
+                                       (parse/result-rows baseline-result)))
+            scorecard       (analyze/ordered-scorecard target-rows)
+            sizes           (sort (set (map :size target-rows)))
+            headlines       (analyze/headline-wins target-rows sizes)
+            parity          (analyze/parity-cases scorecard)
+            losses          (analyze/significant-losses scorecard)
+            regressions     (->> (analyze/regression-report target-rows baseline-rows)
+                                 (filter #(#{:regression :major-regression} (:status %)))
+                                 (sort-by :ratio >))
+            improvements    (->> (analyze/regression-report target-rows baseline-rows)
+                                 (filter #(#{:improvement :major-improvement} (:status %)))
+                                 (sort-by :ratio))
+            summary         (analyze/executive-summary target-rows baseline-rows)]
+        (render/render-header opts target-summary baseline-summary)
+        (render/render-executive-summary summary)
+        (render/render-headline-wins headlines sizes)
+        (render/render-parity parity opts)
+        (render/render-significant-losses losses opts)
+        (render/render-scorecard
+          (sort-by (juxt (comp #(.indexOf analyze/category-order %) :category)
+                         #(- (:speedup %)))
+                   scorecard)
+          opts)
+        (render/render-regressions "Regressions" regressions opts)
+        (render/render-regressions "Improvements" improvements opts)
+        (println)))))
+
+(apply -main *command-line-args*)
diff --git a/etc/lib/bench_analyze.clj b/etc/lib/bench_analyze.clj
new file mode 100644
index 0000000..718a7e1
--- /dev/null
+++ b/etc/lib/bench_analyze.clj
@@ -0,0 +1,324 @@
+(ns bench-analyze
+  "Benchmark analysis: ranking, scorecard, regressions, category classification."
+  (:require [clojure.string :as str]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; OC Variant Detection
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def ^:private oc-prefixes
+  ["ordered-set" "ordered-map" "long-ordered" "string-ordered"
+   "interval-set" "interval-map" "range-map" "rope"])
+
+(defn- oc-variant?
+  [variant]
+  (let [s (name variant)]
+    (boolean (some #(str/starts-with? s %) oc-prefixes))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Benchmark Category Classification
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def category-order
+  [:set-algebra :construction :lookup :iteration :fold :split
+   :equality :rank :string :interval :rope :other])
+
+(def ^:private category-patterns
+  [[:set-algebra   #"union|intersection|difference"]
+   [:construction  #"construction"]
+   [:lookup        #"lookup"]
+   [:iteration     #"iteration"]
+   [:fold          #"fold|reduce"]
+   [:split         #"split"]
+   [:equality      #"equal|different|size-different"]
+   [:rank          #"rank"]
+   [:string        #"string"]
+   [:interval      #"interval"]
+   [:rope          #"rope"]])
+
+(defn classify-group
+  [group]
+  (let [g (name group)]
+    (or (some (fn [[cat pattern]]
+                (when (re-find pattern g) cat))
+              category-patterns)
+        :other)))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Noise Detection
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- outlier-count
+  [row]
+  (reduce + 0 (vals (or (:outliers row) {}))))
+
+(defn- ci-width
+  [row]
+  (let [[lo hi] (:mean-ci-ns row)]
+    (when (and lo hi) (- hi lo))))
+
+(defn noisy-row
+  [row]
+  (let [mean      (double (:mean-ns row))
+        cv        (when (pos? mean) (/ (double (or (:stdev-ns row) 0)) mean))
+        ci-ratio  (when-let [w (ci-width row)]
+                    (when (pos? mean) (/ (double w) mean)))
+        outliers  (outlier-count row)
+        sample-c  (or (:sample-count row) 0)
+        reasons   (cond-> []
+                    (and cv (> cv 0.10))        (conj :high-variance)
+                    (and ci-ratio (> ci-ratio 0.20)) (conj :wide-ci)
+                    (pos? outliers)              (conj :outliers)
+                    (< sample-c 6)              (conj :low-samples))]
+    (assoc row
+           :cv cv
+           :ci-width-ratio ci-ratio
+           :outlier-count outliers
+           :noise-reasons reasons
+           :noisy? (boolean (seq reasons)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ranking
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn rank-cases
+  [rows]
+  (->> rows
+       (group-by (juxt :size :group))
+       (map (fn [[[size group] case-rows]]
+              (let [ranked    (sort-by :mean-ns case-rows)
+                    winner    (first ranked)
+                    runner-up (second ranked)
+                    ranked*   (mapv (fn [row]
+                                      (assoc row
+                                             :vs-winner-ratio
+                                             (/ (double (:mean-ns row))
+                                                (double (:mean-ns winner)))))
+                                    ranked)]
+                {:size              size
+                 :group             group
+                 :category          (classify-group group)
+                 :winner            (:variant winner)
+                 :winner-mean-ns    (:mean-ns winner)
+                 :runner-up         (:variant runner-up)
+                 :runner-up-mean-ns (:mean-ns runner-up)
+                 :winner-speedup    (when runner-up
+                                      (/ (double (:mean-ns runner-up))
+                                         (double (:mean-ns winner))))
+                 :ranked            ranked*})))
+       (sort-by (juxt :size :group))
+       vec))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered-Collections Scorecard
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Cases with absolute times below this threshold are too noisy for
+;; meaningful ratio comparison (sub-microsecond measurements).
+(def ^:private ^:const min-meaningful-ns 10000)
+
+(defn ordered-scorecard
+  [rows]
+  (->> (rank-cases rows)
+       (keep (fn [{:keys [size group category ranked]}]
+               (let [oc-rows   (filter #(oc-variant? (:variant %)) ranked)
+                     peer-rows (remove #(oc-variant? (:variant %)) ranked)
+                     best-oc   (first (sort-by :mean-ns oc-rows))
+                     best-peer (first (sort-by :mean-ns peer-rows))]
+                 (when (and best-oc best-peer
+                            (> (double (:mean-ns best-oc)) min-meaningful-ns)
+                            (> (double (:mean-ns best-peer)) min-meaningful-ns))
+                   (let [speedup (/ (double (:mean-ns best-peer))
+                                    (double (:mean-ns best-oc)))]
+                     {:size             size
+                      :group            group
+                      :category         category
+                      :ordered-variant  (:variant best-oc)
+                      :ordered-mean-ns  (:mean-ns best-oc)
+                      :peer-variant     (:variant best-peer)
+                      :peer-mean-ns     (:mean-ns best-peer)
+                      :speedup          speedup
+                      :slowdown         (when (< speedup 1.0) (/ 1.0 speedup))
+                      :status           (cond
+                                          (> speedup 1.05) :win
+                                          (>= speedup 0.95) :parity
+                                          :else :loss)})))))
+       vec))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Headline Wins — scaling table for README-worthy results
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def headline-benchmarks
+  "Curated benchmark comparisons that appear in the README. Each entry
+   specifies a group pattern, which OC variant to use, which peer to
+   compare against, and a display label."
+  [;; Set algebra vs sorted-set
+   {:pattern #"^set-union$"        :oc :ordered-set :peer :sorted-set  :label "Union"        :section "Set Algebra vs sorted-set"}
+   {:pattern #"^set-intersection$" :oc :ordered-set :peer :sorted-set  :label "Intersection" :section "Set Algebra vs sorted-set"}
+   {:pattern #"^set-difference$"   :oc :ordered-set :peer :sorted-set  :label "Difference"   :section "Set Algebra vs sorted-set"}
+   ;; Set algebra vs data.avl
+   {:pattern #"^set-union$"        :oc :ordered-set :peer :data-avl    :label "Union"        :section "Set Algebra vs data.avl"}
+   {:pattern #"^set-intersection$" :oc :ordered-set :peer :data-avl    :label "Intersection" :section "Set Algebra vs data.avl"}
+   {:pattern #"^set-difference$"   :oc :ordered-set :peer :data-avl    :label "Difference"   :section "Set Algebra vs data.avl"}
+   ;; Set algebra vs hash-set
+   {:pattern #"^set-union$"        :oc :ordered-set :peer :clojure-set :label "Union"        :section "Set Algebra vs clojure.core/set"}
+   {:pattern #"^set-intersection$" :oc :ordered-set :peer :clojure-set :label "Intersection" :section "Set Algebra vs clojure.core/set"}
+   {:pattern #"^set-difference$"   :oc :ordered-set :peer :clojure-set :label "Difference"   :section "Set Algebra vs clojure.core/set"}
+   ;; Other operations
+   {:pattern #"^set-construction$" :oc :ordered-set :peer :sorted-set  :label "Construction" :section "Other Operations"}
+   {:pattern #"^set-lookup$"       :oc :ordered-set :peer :sorted-set  :label "Lookup"       :section "Other Operations"}
+   {:pattern #"^split$"            :oc :ordered-set :peer :data-avl    :label "Split"        :section "Other Operations"}
+   {:pattern #"^set-fold$"         :oc :ordered-set-fold :peer :sorted-set-fold :label "Fold" :section "Other Operations"}
+   ;; Rope vs PersistentVector (matches bench_runner groups)
+   {:pattern #"^rope-repeated-edits$"  :oc :rope   :peer :vector  :label "200 Random Edits"  :section "Rope vs PersistentVector"}
+   {:pattern #"^rope-splice$"          :oc :rope   :peer :vector  :label "Single Splice"     :section "Rope vs PersistentVector"}
+   {:pattern #"^rope-concat$"          :oc :rope   :peer :vector  :label "Concat Pieces"     :section "Rope vs PersistentVector"}
+   {:pattern #"^rope-chunk-iteration$" :oc :rope   :peer :vector  :label "Chunk Iteration"   :section "Rope vs PersistentVector"}
+   {:pattern #"^rope-reduce$"          :oc :rope   :peer :vector  :label "Reduce (sum)"      :section "Rope vs PersistentVector"}
+   {:pattern #"^rope-fold-sum$"       :oc :rope   :peer :vector  :label "Fold (sum)"        :section "Rope vs PersistentVector"}
+   {:pattern #"^rope-nth$"            :oc :rope   :peer :vector  :label "Random nth (1000)" :section "Rope vs PersistentVector"}])
+
+(defn headline-wins
+  "Extract headline speedups pivoted by size, with explicit OC variant and peer.
+   Returns rows grouped by section for rendering."
+  [rows sizes]
+  (let [by-key (group-by (juxt :size :group :variant) rows)
+        lookup (fn [size group variant]
+                 (:mean-ns (first (by-key [size group variant]))))]
+    (->> headline-benchmarks
+         (keep (fn [{:keys [pattern oc peer label section]}]
+                 (let [groups (filter #(re-find pattern (name %))
+                                      (set (map :group rows)))]
+                   (when (seq groups)
+                     (let [group (first groups)]
+                       {:label   label
+                        :section section
+                        :sizes   (mapv (fn [sz]
+                                         (let [oc-ns   (lookup sz group oc)
+                                               peer-ns (lookup sz group peer)]
+                                           (when (and oc-ns peer-ns (pos? (double oc-ns)))
+                                             {:speedup (/ (double peer-ns) (double oc-ns))})))
+                                       sizes)})))))
+         vec)))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Parity, Losses, Wins extraction
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn parity-cases
+  [scorecard]
+  (->> scorecard
+       (filter #(= :parity (:status %)))
+       (sort-by :group)
+       vec))
+
+(def ^:private loss-context
+  "Known architectural explanations for expected losses."
+  {"set-iteration"    "Enumerator-based seq allocates per step"
+   "map-iteration"    "Enumerator-based seq allocates per step"
+   "string-iteration" "Same enumerator overhead on string-keyed maps"
+   "first-last"       "sorted-set caches first; ours traverses to least node"
+   "rank-access"      "data.avl rank has lower constant factor"
+   "rank-lookup"      "data.avl rank has lower constant factor"
+   "size-different"   "hash-set short-circuits on count mismatch; we walk elements"
+   "different"        "hash-set equiv short-circuits earlier via hash check"
+   "equal"            "hash-set equiv uses cached hash; we walk tree"})
+
+(defn significant-losses
+  "Scorecard entries where OC is >1.2x slower, with architectural context."
+  [scorecard]
+  (->> scorecard
+       (filter #(and (= :loss (:status %))
+                     (< (:speedup %) 0.83)))
+       (map (fn [row]
+              (assoc row
+                     :context (get loss-context (name (:group row)))
+                     :slowdown (/ 1.0 (:speedup row)))))
+       (sort-by :slowdown >)
+       vec))
+
+(defn significant-wins
+  "Scorecard entries where OC wins by >1.2x."
+  [scorecard]
+  (->> scorecard
+       (filter #(and (= :win (:status %))
+                     (> (:speedup %) 1.2)))
+       (sort-by :speedup >)
+       vec))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Regressions (baseline comparison)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn regression-report
+  [target-rows baseline-rows]
+  (when baseline-rows
+    (let [baseline-map (into {}
+                             (map (juxt (juxt :size :group :variant) identity))
+                             baseline-rows)]
+      (->> target-rows
+           (keep (fn [row]
+                   (when-let [old (baseline-map [(:size row) (:group row) (:variant row)])]
+                     (let [ratio (/ (double (:mean-ns row))
+                                    (double (:mean-ns old)))
+                           pct   (* 100.0 (dec ratio))]
+                       {:size        (:size row)
+                        :group       (:group row)
+                        :variant     (:variant row)
+                        :old-mean-ns (:mean-ns old)
+                        :new-mean-ns (:mean-ns row)
+                        :ratio       ratio
+                        :delta-pct   pct
+                        :status      (cond
+                                       (>= ratio 1.25) :major-regression
+                                       (>= ratio 1.10) :regression
+                                       (<= ratio 0.80) :major-improvement
+                                       (<= ratio 0.90) :improvement
+                                       :else :unchanged)}))))
+           vec))))
+
+(defn noisy-rows
+  [rows]
+  (->> rows
+       (map noisy-row)
+       (filter :noisy?)
+       (sort-by (juxt #(or (:ci-width-ratio %) 0.0)
+                      #(or (:cv %) 0.0))
+                #(compare %2 %1))
+       vec))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Executive Summary
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn executive-summary
+  [rows baseline-rows]
+  (let [scorecard (ordered-scorecard rows)
+        noisy     (noisy-rows rows)
+        regress   (regression-report rows baseline-rows)
+        wins      (significant-wins scorecard)
+        losses    (significant-losses scorecard)]
+    {:case-count       (count rows)
+     :benchmark-groups (count (set (map :group rows)))
+     :sizes            (sort (set (map :size rows)))
+     :ordered-wins     (count (filter #(= :win (:status %)) scorecard))
+     :ordered-losses   (count (filter #(= :loss (:status %)) scorecard))
+     :ordered-parity   (count (filter #(= :parity (:status %)) scorecard))
+     :best-win         (when (seq wins) (:speedup (first wins)))
+     :best-win-group   (when (seq wins) (:group (first wins)))
+     :worst-loss       (when (seq losses) (:slowdown (first losses)))
+     :worst-loss-group (when (seq losses) (:group (first losses)))
+     :noisy-cases      (count noisy)
+     :has-baseline?    (boolean baseline-rows)
+     :regressions      (count (filter #(#{:regression :major-regression} (:status %)) regress))
+     :improvements     (count (filter #(#{:improvement :major-improvement} (:status %)) regress))}))
diff --git a/etc/lib/bench_files.clj b/etc/lib/bench_files.clj
new file mode 100644
index 0000000..fac34bd
--- /dev/null
+++ b/etc/lib/bench_files.clj
@@ -0,0 +1,60 @@
+(ns bench-files
+  "Benchmark result file discovery and argument parsing."
+  (:require [babashka.fs :as fs]
+            [clojure.string :as str]
+            [common :as common]))
+
+(defn bench-results-dir
+  []
+  (common/path "bench-results"))
+
+(defn benchmark-files
+  []
+  (->> (fs/glob (bench-results-dir) "*.edn")
+       (map str)
+       sort))
+
+(defn latest-benchmark-file
+  []
+  (last (benchmark-files)))
+
+(defn- ensure-file!
+  [path]
+  (when-not (and path (fs/exists? path))
+    (throw (ex-info "Benchmark result file not found." {:path path})))
+  path)
+
+(defn parse-args
+  [args]
+  (loop [[arg & more] args
+         opts {:top 12}]
+    (cond
+      (nil? arg) opts
+      (#{"--help" "-h"} arg) (recur more (assoc opts :help true))
+      (= "--all" arg)        (recur more (assoc opts :all true))
+      (= "--file" arg)       (recur (rest more) (assoc opts :file (first more)))
+      (= "--baseline" arg)   (recur (rest more) (assoc opts :baseline (first more)))
+      (= "--top" arg)        (recur (rest more) (assoc opts :top (Long/parseLong (first more))))
+      :else
+      (throw (ex-info "Unknown argument." {:arg arg :args args})))))
+
+(defn resolve-files
+  [{:keys [file baseline] :as opts}]
+  (let [target (or file (latest-benchmark-file))]
+    (when-not target
+      (throw (ex-info "No benchmark result files found." {:dir (bench-results-dir)})))
+    (assoc opts
+           :file (ensure-file! target)
+           :baseline (some-> baseline ensure-file!))))
+
+(defn usage []
+  (str/join
+    "\n"
+    ["Usage: bb bench-report [options]"
+     ""
+     "Options:"
+     "  --file PATH        Report on a specific benchmark result file"
+     "  --baseline PATH    Compare against a baseline result file"
+     "  --top N            Number of ranked rows to show (default 12)"
+     "  --all              Show all ranked rows"
+     "  --help             Show this help"]))
diff --git a/etc/lib/bench_parse.clj b/etc/lib/bench_parse.clj
new file mode 100644
index 0000000..0c3f31c
--- /dev/null
+++ b/etc/lib/bench_parse.clj
@@ -0,0 +1,75 @@
+(ns bench-parse
+  "Benchmark result parsing and normalization."
+  (:require [clojure.edn :as edn]
+            [clojure.string :as str]))
+
+(defn leaf-result?
+  [x]
+  (and (map? x) (contains? x :mean-ns)))
+
+(defn- group-key
+  [group-path]
+  (keyword (str/join "/" (map name group-path))))
+
+(defn load-result
+  [path]
+  (assoc (edn/read-string (slurp path))
+         :file path))
+
+(defn result-rows
+  [{:keys [benchmarks artifact-version timestamp mode file system]}]
+  (letfn [(walk [size path node]
+            (if (leaf-result? node)
+              [{:file              file
+                :artifact-version  artifact-version
+                :timestamp         timestamp
+                :mode              mode
+                :git-rev           (:git-rev system)
+                :git-branch        (:git-branch system)
+                :size              size
+                :group-path        (vec (butlast path))
+                :group             (group-key (butlast path))
+                :variant           (last path)
+                :mean-ns           (:mean-ns node)
+                :sample-mean-ns    (:sample-mean-ns node)
+                :stdev-ns          (:stdev-ns node)
+                :sample-count      (:sample-count node)
+                :mean-ci-ns        (:mean-ci-ns node)
+                :outliers          (:outliers node)
+                :raw               node}]
+              (mapcat (fn [[k v]] (walk size (conj path k) v)) node)))]
+    (vec
+      (mapcat (fn [[size groups]]
+                (mapcat (fn [[group node]]
+                          (walk size [group] node))
+                        groups))
+              benchmarks))))
+
+(defn result-summary
+  "Summarize a benchmark result. Accepts pre-parsed rows to avoid double-parsing."
+  ([result]
+   (result-summary result (result-rows result)))
+  ([{:keys [artifact-version sizes mode duration-ms timestamp file system]} rows]
+   {:file              file
+    :artifact-version  artifact-version
+    :mode              mode
+    :timestamp         timestamp
+    :duration-ms       duration-ms
+    :sizes             sizes
+    :group-count       (count (set (map :group rows)))
+    :case-count        (count rows)
+    :git-rev           (:git-rev system)
+    :git-branch        (:git-branch system)
+    :git-dirty?        (:git-dirty? system)
+    :hostname          (:hostname system)
+    :java-version      (:java-version system)
+    :java-vm           (:java-vm system)
+    :java-vendor       (:java-vendor system)
+    :os-name           (:os-name system)
+    :os-version        (:os-version system)
+    :os-arch           (:os-arch system)
+    :processors        (:processors system)
+    :max-memory-mb     (:max-memory-mb system)
+    :heap-max-mb       (:heap-max-mb system)
+    :heap-committed-mb (:heap-committed-mb system)
+    :heap-used-mb      (:heap-used-mb system)}))
diff --git a/etc/lib/bench_render.clj b/etc/lib/bench_render.clj
new file mode 100644
index 0000000..22af70a
--- /dev/null
+++ b/etc/lib/bench_render.clj
@@ -0,0 +1,248 @@
+(ns bench-render
+  "Terminal rendering for benchmark reports."
+  (:require [clojure.string :as str]
+            [common :as common]
+            [report :as report]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Column Specs
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def scorecard-cols
+  [{:width 8} {:width 24} {:width 18} {:width 18} {:width 10 :align :right}
+   {:width 10 :align :right} {:width 10 :align :right} {:width 8}])
+
+(def loss-cols
+  [{:width 8} {:width 22} {:width 18} {:width 18} {:width 12 :align :right} {:width 0}])
+
+(def delta-cols
+  [{:width 8} {:width 22} {:width 20} {:width 10 :align :right}
+   {:width 10 :align :right} {:width 10 :align :right} {:width 14}])
+
+(def noise-cols
+  [{:width 8} {:width 20} {:width 18} {:width 8 :align :right}
+   {:width 8 :align :right} {:width 12}])
+
+(def parity-cols
+  [{:width 24} {:width 18} {:width 18} {:width 10 :align :right}])
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- limit
+  [xs {:keys [top all]}]
+  (if all xs (take (or top 12) xs)))
+
+(defn- status-label
+  [status]
+  (-> status name (str/replace "-" " ") str/upper-case))
+
+(defn- speedup-str
+  "Format a speedup ratio as '12.3x' for wins, '2.5x slower' for losses."
+  [speedup]
+  (if (>= speedup 1.0)
+    (format "%.1fx" (double speedup))
+    (format "%.1fx slower" (/ 1.0 (double speedup)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Header
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- short-rev [rev]
+  (when rev (subs rev 0 (min 10 (count rev)))))
+
+(defn render-header
+  [{:keys [file baseline]} target-summary baseline-summary]
+  (common/banner "bench report")
+  (common/section "Run")
+  (report/row-text "File" file)
+  (when baseline (report/row-text "Baseline" baseline))
+  (report/row-text "Timestamp" (:timestamp target-summary))
+  (report/row-text "Mode" (:mode target-summary))
+  (report/row-text "Artifact version" (or (:artifact-version target-summary) "legacy"))
+  (report/row-text "Git branch" (:git-branch target-summary))
+  (report/row-text "Git rev" (short-rev (:git-rev target-summary)))
+  (report/row-text "Sizes" (pr-str (:sizes target-summary)))
+  (report/row "Benchmark cases" (:case-count target-summary))
+  (report/row "Benchmark groups" (:group-count target-summary))
+  (common/section "Platform")
+  (report/row-text "Host" (:hostname target-summary))
+  (report/row-text "OS" (str (:os-name target-summary) " "
+                             (:os-version target-summary) " "
+                             (:os-arch target-summary)))
+  (report/row "Processors" (:processors target-summary))
+  (report/row-text "Java" (str (:java-version target-summary)
+                               " (" (:java-vendor target-summary) ")"))
+  (report/row-text "VM" (:java-vm target-summary))
+  (report/row "Max memory (MB)" (:max-memory-mb target-summary))
+  (report/row "Heap max (MB)" (:heap-max-mb target-summary))
+  (report/row "Heap committed (MB)" (:heap-committed-mb target-summary))
+  (report/row "Heap used (MB)" (:heap-used-mb target-summary))
+  (when baseline-summary
+    (common/section "Baseline Run")
+    (report/row-text "File" (:file baseline-summary))
+    (report/row-text "Timestamp" (:timestamp baseline-summary))
+    (report/row-text "Mode" (:mode baseline-summary))
+    (report/row-text "Git branch" (:git-branch baseline-summary))
+    (report/row-text "Git rev" (short-rev (:git-rev baseline-summary)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Executive Summary
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn render-executive-summary
+  [summary]
+  (common/section "Summary")
+  (report/paragraph
+    (str (:case-count summary) " benchmarks across "
+         (:benchmark-groups summary) " groups at N="
+         (str/join ", " (map str (:sizes summary))) ". "
+         (:ordered-wins summary) " wins, "
+         (:ordered-parity summary) " at parity, "
+         (:ordered-losses summary) " losses."
+         (when (:best-win summary)
+           (str " Best win: " (format "%.1fx" (double (:best-win summary)))
+                " on " (name (:best-win-group summary)) "."))
+         (when (:worst-loss summary)
+           (str " Worst loss: " (format "%.1fx" (double (:worst-loss summary)))
+                " slower on " (name (:worst-loss-group summary)) "."))
+         (when (:has-baseline? summary)
+           (str " " (:regressions summary) " regressions, "
+                (:improvements summary) " improvements vs baseline.")))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Headline Wins — scaling table
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn render-headline-wins
+  "Render headline speedups grouped by section, matching README structure."
+  [headlines sizes]
+  (when (seq headlines)
+    (common/section "Headline Performance")
+    (let [size-labels (mapv #(str "N=" %) sizes)
+          cols (into [{:width 22}]
+                     (mapv (fn [_] {:width 12 :align :right}) sizes))
+          sections (partition-by :section headlines)]
+      (doseq [section-rows sections]
+        (let [section-title (:section (first section-rows))]
+          (println)
+          (println (str "  " section-title))
+          (apply report/table-row cols (into [""] size-labels))
+          (doseq [{:keys [label sizes]} section-rows]
+            (let [cells (mapv (fn [entry]
+                                (if entry
+                                  (let [s (:speedup entry)]
+                                    (if (>= s 1.0)
+                                      (format "**%.1fx**" (double s))
+                                      (format "%.1fx" (double s))))
+                                  "—"))
+                              sizes)]
+              (apply report/table-row cols (into [label] cells)))))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Parity
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn render-parity
+  [parity-rows opts]
+  (when (seq parity-rows)
+    (common/section "At Parity")
+    (apply report/table-row parity-cols ["Group" "OC Variant" "Peer" "Ratio"])
+    ;; Deduplicate by group — show one row per group at the median size
+    (let [by-group (group-by :group parity-rows)
+          deduped  (map (fn [[_ rows]] (first (sort-by :size rows))) by-group)]
+      (doseq [{:keys [group ordered-variant peer-variant speedup]} (limit (sort-by :group deduped) opts)]
+        (apply report/table-row parity-cols
+               [(name group) (name ordered-variant) (name peer-variant)
+                (format "~%.2fx" (double speedup))])))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Significant Losses
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn render-significant-losses
+  [losses opts]
+  (when (seq losses)
+    (common/section "Significant Losses")
+    (apply report/table-row loss-cols ["Size" "Group" "OC Variant" "Peer" "Slowdown" "Context"])
+    (doseq [{:keys [size group ordered-variant peer-variant slowdown context]}
+            (limit losses opts)]
+      (apply report/table-row loss-cols
+             [(str size)
+              (name group)
+              (name ordered-variant)
+              (name peer-variant)
+              (format "%.1fx slower" (double slowdown))
+              (or context "")]))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Full Scorecard
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn render-scorecard
+  [scorecard opts]
+  (common/section "Full Scorecard")
+  (apply report/table-row scorecard-cols
+         ["Size" "Group" "OC Variant" "Peer" "OC Time" "Peer Time" "Speedup" "Status"])
+  (doseq [{:keys [size group ordered-variant peer-variant
+                   ordered-mean-ns peer-mean-ns speedup status]}
+          (limit scorecard opts)]
+    (apply report/table-row scorecard-cols
+           [(str size)
+            (name group)
+            (name ordered-variant)
+            (name peer-variant)
+            (report/format-ns ordered-mean-ns)
+            (report/format-ns peer-mean-ns)
+            (speedup-str speedup)
+            (status-label status)])))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Regressions / Improvements
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn render-regressions
+  [title rows opts]
+  (when (seq rows)
+    (common/section title)
+    (apply report/table-row delta-cols ["Size" "Group" "Variant" "Old" "New" "Delta" "Status"])
+    (doseq [{:keys [size group variant old-mean-ns new-mean-ns delta-pct status]}
+            (limit rows opts)]
+      (apply report/table-row delta-cols
+             [(str size)
+              (name group)
+              (name variant)
+              (report/format-ns old-mean-ns)
+              (report/format-ns new-mean-ns)
+              (report/format-pct delta-pct)
+              (status-label status)]))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Noise Watchlist
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn render-noise
+  [rows opts]
+  (when (seq rows)
+    (common/section "Noise Watchlist")
+    (apply report/table-row noise-cols ["Size" "Group" "Variant" "CV" "CI Width" "Reasons"])
+    (doseq [{:keys [size group variant cv ci-width-ratio noise-reasons]}
+            (limit rows opts)]
+      (apply report/table-row noise-cols
+             [(str size)
+              (name group)
+              (name variant)
+              (if cv (format "%.3f" cv) "-")
+              (if ci-width-ratio (format "%.3f" ci-width-ratio) "-")
+              (str/join ", " (map name noise-reasons))]))))
diff --git a/etc/lib/common.clj b/etc/lib/common.clj
new file mode 100644
index 0000000..316f734
--- /dev/null
+++ b/etc/lib/common.clj
@@ -0,0 +1,43 @@
+(ns common
+  "Shared support for babashka scripts under etc/."
+  (:require [babashka.fs :as fs]
+            [clj-figlet.core :as fig]
+            [clojure.string :as str]))
+
+(defn- find-root
+  [start]
+  (or (some (fn [dir]
+              (when (fs/exists? (fs/path dir "project.clj"))
+                (str dir)))
+            (take-while some? (iterate fs/parent start)))
+      (throw (ex-info "Could not locate project root from script path."
+               {:start (str start)}))))
+
+(def root
+  (find-root (fs/parent (fs/absolutize *file*))))
+
+(def run-id
+  (str (java.util.UUID/randomUUID)))
+
+(defn path
+  [& parts]
+  (str (apply fs/path root parts)))
+
+(defn trim-out
+  [s]
+  (some-> s str/trim))
+
+(defn banner
+  [title]
+  (println (fig/render "small" title)))
+
+(defn rule
+  []
+  (println (apply str (repeat 72 "─"))))
+
+(defn section
+  [title]
+  (println)
+  (rule)
+  (println (str "  " title))
+  (rule))
diff --git a/etc/lib/report.clj b/etc/lib/report.clj
new file mode 100644
index 0000000..8346d6e
--- /dev/null
+++ b/etc/lib/report.clj
@@ -0,0 +1,84 @@
+(ns report
+  "Table-style reporting helpers built on clj-format."
+  (:require [clj-format.core :refer [clj-format]]
+            [clojure.string :as str]))
+
+(defn- col-spec
+  [{:keys [width align]}]
+  [:str (cond-> {:width width}
+          (= align :right) (assoc :pad :left))])
+
+(defn- table-format
+  [cols]
+  (->> cols
+       (map col-spec)
+       (interpose " ")
+       vec
+       (#(conj % :nl))))
+
+(def row-num-fmt
+  (table-format [{:width 42} {:width 12 :align :right}]))
+
+(def row-text-fmt
+  (table-format [{:width 24} {:width 0}]))
+
+(def row3-fmt
+  (table-format [{:width 34} {:width 14 :align :right} {:width 14 :align :right}]))
+
+(def paragraph-lines-fmt
+  [:each :str :nl])
+
+(defn emit
+  [fmt & values]
+  (print (apply clj-format nil fmt values)))
+
+(defn table-row
+  [cols & values]
+  (apply emit (table-format cols) values))
+
+(defn row
+  [label value]
+  (emit row-num-fmt label (str value)))
+
+(defn row-text
+  [label value]
+  (emit row-text-fmt label (str value)))
+
+(defn row3
+  [a b c]
+  (emit row3-fmt a (str b) (str c)))
+
+(defn paragraph
+  [text]
+  (let [width 76
+        words (remove str/blank? (str/split (str text) #"\s+"))
+        lines (reduce (fn [acc word]
+                        (let [line (peek acc)
+                              candidate (if (str/blank? line)
+                                          word
+                                          (str line " " word))]
+                          (if (<= (count candidate) width)
+                            (conj (pop acc) candidate)
+                            (conj acc word))))
+                      [""]
+                      words)
+        lines (remove str/blank? lines)]
+    (when (seq lines)
+      (emit paragraph-lines-fmt lines))))
+
+(defn format-ns
+  [ns]
+  (let [n (long (or ns 0))]
+    (cond
+      (>= n 1000000000) (format "%.2fs" (/ n 1e9))
+      (>= n 1000000)    (format "%.2fms" (/ n 1e6))
+      (>= n 1000)       (format "%.2fµs" (/ n 1e3))
+      :else             (str n "ns"))))
+
+(defn format-ratio
+  [ratio]
+  (format "%.2fx" (double ratio)))
+
+(defn format-pct
+  [pct]
+  (format "%+.1f%%" (double pct)))
diff --git a/etc/lib/shell.clj b/etc/lib/shell.clj
new file mode 100644
index 0000000..0a6e908
--- /dev/null
+++ b/etc/lib/shell.clj
@@ -0,0 +1,35 @@
+(ns shell
+  "Shell helpers for babashka support scripts."
+  (:require [clojure.java.shell :refer [sh]]
+            [clojure.string :as str]
+            [common :as common]))
+
+(defn run-result
+  [& args]
+  (apply sh (concat args [:dir common/root])))
+
+(defn run!
+  [& args]
+  (let [{:keys [out exit err]} (apply run-result args)]
+    (when-not (zero? exit)
+      (binding [*out* *err*]
+        (println (str "Command failed: " (str/join " " args)))
+        (when-not (str/blank? err)
+          (println (str/trim err))))
+      (System/exit exit))
+    (common/trim-out out)))
+
+(defn tool-available?
+  [name]
+  (let [{:keys [out exit]} (sh "which" name)]
+    (and (zero? exit)
+         (not (str/blank? out)))))
+
+(defn ensure-tool!
+  [name install-hint]
+  (when-not (tool-available? name)
+    (binding [*out* *err*]
+      (println (str "Error: " name " not found."))
+      (when install-hint
+        (println install-hint)))
+    (System/exit 1)))
diff --git a/etc/paper.bb b/etc/paper.bb
new file mode 100644
index 0000000..f199781
--- /dev/null
+++ b/etc/paper.bb
@@ -0,0 +1,64 @@
+#!/usr/bin/env bb
+
+(require '[babashka.fs :as fs]
+         '[common :as common]
+         '[report :as report]
+         '[shell :as shell])
+
+(def src (common/path "doc" "concept" "concept.md"))
+(def out (common/path "doc" "concept" "concept.pdf"))
+(def tmp (common/path "doc" "concept" ".concept-tmp.html"))
+
+(def css
+  "<style>
+  body { font-family: Georgia, serif; max-width: 48em; margin: 2em auto;
+         line-height: 1.6; font-size: 11pt; color: #222; }
+  h1 { font-size: 1.8em; text-align: center; margin-bottom: 0.2em; }
+  h2 { font-size: 1.4em; border-bottom: 1px solid #ccc; padding-bottom: 0.3em;
+       margin-top: 2em; }
+  h3 { font-size: 1.15em; margin-top: 1.5em; }
+  code { font-size: 0.9em; background: #f5f5f5; padding: 0.1em 0.3em; }
+  pre { background: #f5f5f5; padding: 1em; font-size: 0.85em; line-height: 1.4; }
+  table { border-collapse: collapse; margin: 1em 0; }
+  th, td { border: 1px solid #ccc; padding: 0.4em 0.8em; text-align: left; }
+  th { background: #f0f0f0; }
+  hr { border: none; border-top: 2px solid #ccc; margin: 2em 0; }
+  @page { size: letter; margin: 1in; }
+</style>")
+
+(defn -main []
+  (common/banner "paper")
+  (common/section "Inputs")
+  (report/row-text "Source" src)
+  (report/row-text "Output" out)
+  (report/row-text "Run ID" common/run-id)
+
+  (shell/ensure-tool! "pandoc" "Install with: brew install pandoc")
+  (shell/ensure-tool! "weasyprint" "Install with: brew install weasyprint")
+
+  (let [css-file (str (fs/create-temp-file {:prefix "paper-css-" :suffix ".html"}))]
+    (spit css-file css)
+    (let [{:keys [exit err]}
+          (shell/run-result "pandoc" src "-o" tmp
+            "--standalone"
+            "--resource-path" (common/path "doc")
+            "-H" css-file)]
+      (when-not (zero? exit)
+        (binding [*out* *err*]
+          (println "pandoc failed:")
+          (println (str err)))
+        (System/exit exit)))
+    (let [{:keys [exit err]}
+          (shell/run-result "weasyprint" tmp out)]
+      (when-not (zero? exit)
+        (binding [*out* *err*]
+          (println "weasyprint failed:")
+          (println (str err)))
+        (System/exit exit)))
+    (fs/delete-if-exists tmp)
+    (fs/delete-if-exists css-file))
+
+  (common/section "Done")
+  (report/row-text "Generated" out))
+
+(-main)
diff --git a/etc/stats.bb b/etc/stats.bb
new file mode 100644
index 0000000..78627f0
--- /dev/null
+++ b/etc/stats.bb
@@ -0,0 +1,186 @@
+#!/usr/bin/env bb
+
+(require '[babashka.fs :as fs]
+         '[clojure.edn :as edn]
+         '[clojure.string :as str]
+         '[common :as common]
+         '[report :as report]
+         '[shell :as shell])
+
+(defn count-lines
+  [p]
+  (count (str/split-lines (slurp p))))
+
+(defn clj-files
+  [dir]
+  (->> (fs/glob (common/path dir) "**.clj")
+       (mapv str)))
+
+(defn file-lines
+  [files]
+  (reduce + 0 (map count-lines files)))
+
+(def src-files  (clj-files "src"))
+(def test-files (clj-files "test"))
+(def doc-files  (->> (fs/glob (common/path "doc") "**.md") (mapv str)))
+
+(def src-lines  (file-lines src-files))
+(def test-lines (file-lines test-files))
+(def doc-lines  (+ (file-lines doc-files)
+                   (count-lines (common/path "README.md"))
+                   (count-lines (common/path "CHANGES.md"))))
+
+(def test-count
+  (->> test-files
+       (mapcat #(re-seq #"\(deftest\s+|\(defspec\s+" (slurp %)))
+       count))
+
+(def commit-count    (some-> (shell/run! "git" "log" "--oneline") str/split-lines count))
+(def first-commit    (shell/run! "git" "log" "--format=%as" "--reverse" "--" "."))
+(def latest-commit   (shell/run! "git" "log" "-1" "--format=%as"))
+(def branch          (shell/run! "git" "branch" "--show-current"))
+(def short-sha       (shell/run! "git" "log" "-1" "--format=%h"))
+(def dirty?          (not (str/blank? (shell/run! "git" "status" "--porcelain"))))
+(def contributors    (some-> (shell/run! "git" "log" "--format=%aN") str/split-lines distinct))
+(def tags            (some-> (shell/run! "git" "tag" "--list") str/split-lines))
+
+(def churn-data
+  (some->> (shell/run! "git" "log" "--format=" "--name-only" "--diff-filter=M" "--" "src/")
+           str/split-lines
+           (remove str/blank?)
+           frequencies
+           (sort-by val >)
+           (take 5)))
+
+(def project-version
+  (some->> (slurp (common/path "project.clj"))
+           (re-find #"defproject\s+\S+\s+\"([^\"]+)\"")
+           second))
+
+(def type-files (clj-files "src/ordered_collections/types"))
+(def type-count
+  (count (filter #(not (or (str/includes? % "shared")
+                           (str/includes? % "interop")))
+                 type-files)))
+
+(def protocol-count
+  (some->> (slurp (common/path "src/ordered_collections/protocol.clj"))
+           (re-seq #"defprotocol\s+")
+           count))
+
+(def public-fn-count
+  (let [core (slurp (common/path "src/ordered_collections/core.clj"))]
+    (+ (count (re-seq #"\(defn\s+" core))
+       (count (re-seq #"\(defalias\s+" core)))))
+
+(def node-type-count
+  (some->> (slurp (common/path "src/ordered_collections/kernel/node.clj"))
+           (re-seq #"deftype\s+")
+           count))
+
+(def kondo-available?
+  (shell/tool-available? "clj-kondo"))
+
+(def analysis
+  (when kondo-available?
+    (let [{:keys [out]}
+          (shell/run-result "clj-kondo" "--lint" (common/path "src")
+            "--config" "{:output {:analysis {:var-definitions {:meta true}} :format :edn}}")]
+      (some-> out edn/read-string :analysis))))
+
+(def var-defs      (:var-definitions analysis))
+(def ns-defs       (:namespace-definitions analysis))
+(def var-usages    (:var-usages analysis))
+
+(def vars-per-ns
+  (when var-defs
+    (->> var-defs
+         (group-by :ns)
+         (map (fn [[ns vars]] [(name ns) (count vars)]))
+         (sort-by second >)
+         (take 5))))
+
+(def public-var-count  (count (remove :private var-defs)))
+(def private-var-count (count (filter :private var-defs)))
+
+(def ns-fan-in
+  (when var-usages
+    (let [src-nses (set (map :name ns-defs))]
+      (->> var-usages
+           (filter #(and (src-nses (:to %))
+                         (not= (:from %) (:to %))
+                         (src-nses (:from %))))
+           (map :to)
+           frequencies
+           (map (fn [[ns n]] [(name ns) n]))
+           (sort-by second >)
+           (take 5)))))
+
+(def java-version (System/getProperty "java.version"))
+
+(defn -main []
+  (common/banner "ordered-collections")
+
+  (common/section "Project")
+  (report/row-text "Version"       project-version)
+  (report/row-text "Branch"        (str branch " (" short-sha (when dirty? ", dirty") ")"))
+  (report/row-text "Run ID"        common/run-id)
+  (report/row-text "First commit"  (first (str/split-lines (or first-commit ""))))
+  (report/row-text "Latest commit" latest-commit)
+  (report/row-text "Total commits" commit-count)
+  (report/row-text "Contributors"  (str/join ", " contributors))
+  (when (seq tags)
+    (report/row-text "Tags" (str/join ", " tags)))
+
+  (common/section "Architecture")
+  (report/row "Collection types"     type-count)
+  (report/row "Protocols"            protocol-count)
+  (report/row "Node types"           node-type-count)
+  (report/row "Public API functions" public-fn-count)
+  (when analysis
+    (report/row "Total var definitions" (count var-defs))
+    (report/row "  public"              public-var-count)
+    (report/row "  private"             private-var-count))
+
+  (common/section "Codebase Size")
+  (report/row3 "" "Files" "Lines")
+  (report/row3 "Source"             (count src-files) src-lines)
+  (report/row3 "Tests & benchmarks" (count test-files) test-lines)
+  (report/row3 "Documentation (md)" (+ (count doc-files) 2) doc-lines)
+  (println (apply str (repeat 62 "─")))
+  (report/row3 "Total"
+    (+ (count src-files) (count test-files) (count doc-files) 2)
+    (+ src-lines test-lines doc-lines))
+
+  (common/section "Largest Source Files")
+  (doseq [[f n] (->> src-files
+                     (map (fn [f] [(last (str/split f #"/")) (count-lines f)]))
+                     (sort-by second >)
+                     (take 5))]
+    (report/row f n))
+
+  (common/section "Tests")
+  (report/row "Test definitions (deftest + defspec)" test-count)
+
+  (when (seq vars-per-ns)
+    (common/section "Vars per Namespace (top 5)")
+    (doseq [[ns n] vars-per-ns]
+      (report/row ns n)))
+
+  (when (seq ns-fan-in)
+    (common/section "Most-Depended-On Namespaces")
+    (doseq [[ns n] ns-fan-in]
+      (report/row ns n)))
+
+  (common/section "Most-Modified Source Files (git churn)")
+  (doseq [[f n] churn-data]
+    (report/row (last (str/split f #"/")) n))
+
+  (common/section "Environment")
+  (report/row-text "Java"     java-version)
+  (report/row-text "Babashka" (shell/run! "bb" "--version"))
+  (report/row-text "Platform" (str (System/getProperty "os.name") " "
+                                   (System/getProperty "os.arch")))
+  (println))
+
+(-main)
diff --git a/project.clj b/project.clj
index 52cf72b..4431f4a 100644
--- a/project.clj
+++ b/project.clj
@@ -1,31 +1,44 @@
-(defproject com.dean/interval-tree "0.1.2"
-  :description "Modular, Extensible, Foldable Weight-Balanced Tree"
-  :url "http://github.com/dco-dev/interval-tree"
+(defproject com.dean/ordered-collections "0.2.0"
+  :description "Fast, modern, _ropes_ and ordered collections that do more than sort."
+  :author       "Dan Lentz <danlentz@gmail.com>"
+  :url "http://github.com/dco-dev/ordered-collections"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
 
-  :dependencies [[org.clojure/clojure "1.8.0"]
-                 [org.clojure/math.combinatorics "0.1.4"]]
+  :dependencies [[org.clojure/clojure "1.12.4" :scope "provided"]]
 
-  :plugins [[lein-asciidoctor  "0.1.14"]
-            [lein-codox "0.10.7"]]
+  :profiles {:dev {:dependencies [[org.clojure/data.avl "0.2.0"]
+                                  [org.clojure/test.check "1.1.1"]
+                                  [org.clojure/math.combinatorics "0.3.2"]
+                                  [criterium "0.4.6"]
+                                  [com.clojure-goes-fast/clj-memory-meter "0.3.0"]
+                                  [com.google.guava/guava "33.0.0-jre"]]
+                   :jvm-opts ["-Djdk.attach.allowAttachSelf"
+                              "-XX:+EnableDynamicAgentLoading"]}}
 
-  :signing  {:gpg-key "3A2F2AA9"}
+  :plugins [[lein-codox "0.10.8"]
+            [lein-ancient "0.7.0"]
+            [lein-cloverage "1.2.4"]
+            [lein-shell "0.5.0"]]
 
-  :deploy-repositories [["clojars" {:url "https://clojars.org/repo"
-                                    :username :env/clojars_user
-                                    :password  :env/clojars_pass
-                                    :sign-releases false}]]
+  :signing  {:gpg-key "0CA466A1AB48F0C0264AF55307BAD70176C4B179"}
+
+  :repl-options {:init-ns ordered-collections.core}
 
   :codox    {:output-path  "doc/api"
-             :src-dir-uri "https://github.com/dco-dev/interval-tree/blob/master/"
+             :src-dir-uri "https://github.com/dco-dev/ordered-collections/blob/master/"
              :src-linenum-anchor-prefix "L"
-             :project {:name "com.dean/interval-tree"}}
-
-  :asciidoctor {:sources ["doc/*.adoc"]
-                :to-dir "doc/html"
-                :toc              :left
-                :doctype          :article
-                :format           :html5
-                :extract-css      true
-                :source-highlight true})
+             :project {:name "ordered-collections"}}
+
+  :global-vars {*warn-on-reflection* true} ; during tests clj-memory-meter will complain
+
+  :aliases {"bench"           ["run" "-m" "ordered-collections.bench-runner"]
+             "bench-simple"    ["run" "-m" "ordered-collections.simple-bench"]
+             "bench-range-map" ["run" "-m" "ordered-collections.range-map-bench"]
+             "bench-parallel"  ["run" "-m" "ordered-collections.parallel-threshold-bench"]
+             "bench-rope-fold" ["run" "-m" "ordered-collections.rope-fold-bench"]
+             "bench-transient-rope" ["run" "-m" "ordered-collections.transient-rope-bench"]
+             "bench-rope-tuning" ["run" "-m" "ordered-collections.rope-tuning-bench"]
+             "stats"           ["shell" "bb" "stats"]
+             "bench-report"    ["shell" "bb" "bench-report"]
+             "paper"           ["shell" "bb" "paper"]})
diff --git a/resources/data_readers.clj b/resources/data_readers.clj
new file mode 100644
index 0000000..19e9be3
--- /dev/null
+++ b/resources/data_readers.clj
@@ -0,0 +1,8 @@
+{ordered/set            ordered-collections.readers/ordered-set
+ ordered/map            ordered-collections.readers/ordered-map
+ ordered/interval-set   ordered-collections.readers/interval-set
+ ordered/interval-map   ordered-collections.readers/interval-map
+ ordered/range-map      ordered-collections.readers/range-map
+ ordered/priority-queue ordered-collections.readers/priority-queue
+ ordered/multiset       ordered-collections.readers/ordered-multiset
+ ordered/rope           ordered-collections.readers/rope}
diff --git a/resources/pando.png b/resources/pando.png
new file mode 100644
index 0000000..920d080
Binary files /dev/null and b/resources/pando.png differ
diff --git a/src/com/dean/interval_tree/core.clj b/src/com/dean/interval_tree/core.clj
deleted file mode 100644
index 9f57668..0000000
--- a/src/com/dean/interval_tree/core.clj
+++ /dev/null
@@ -1,95 +0,0 @@
-(ns com.dean.interval-tree.core
-  (:require [clojure.core.reducers                    :as r]
-            [com.dean.interval-tree.tree.interval     :as interval]
-            [com.dean.interval-tree.tree.interval-map :refer [->IntervalMap]]
-            [com.dean.interval-tree.tree.interval-set :refer [->IntervalSet]]
-            [com.dean.interval-tree.tree.node         :as node]
-            [com.dean.interval-tree.tree.order        :as order]
-            [com.dean.interval-tree.tree.protocol     :as proto]
-            [com.dean.interval-tree.tree.ordered-map  :refer [->OrderedMap]]
-            [com.dean.interval-tree.tree.ordered-set  :refer [->OrderedSet]]
-            [com.dean.interval-tree.tree.tree         :as tree]))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Set Algebra
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(def intersection proto/intersection)
-(def union        proto/union)
-(def difference   proto/difference)
-(def subset       proto/subset)
-(def superset     proto/superset)
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Ordered Set
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; TODO: allow high speed construction AND custom compare-fn
-;; TODO: refactor
-
-;; NOTE: subject to change!
-;; experimentally determined to be in the ballpark, given the current
-;; performance characteristics upstream
-
-(def ^:private +chunk-size+ 2048)
-
-(defn- ordered-set* [compare-fn coll]
-  (binding [order/*compare* compare-fn]
-    (->OrderedSet
-      (r/fold +chunk-size+
-              (fn
-                ([]      (node/leaf))
-                ([n0 n1] (tree/node-set-union n0 n1))) tree/node-add coll)
-      compare-fn nil nil {})))
-
-(defn ordered-set
-  ([]
-   (ordered-set* order/normal-compare nil))
-  ([coll]
-   (ordered-set* order/normal-compare coll)))
-
-(defn ordered-set-by [pred coll]
-  (-> pred order/compare-by (ordered-set* (seq coll))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Ordered Map
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn ordered-map
-  ([]
-   (ordered-map order/normal-compare nil))
-  ([coll]
-   (ordered-map order/normal-compare coll))
-  ([compare-fn coll]
-   (binding [order/*compare* compare-fn]
-     (->OrderedMap (reduce (fn [n [k v]] (tree/node-add n k v)) (node/leaf) coll)
-                   compare-fn nil nil {}))))
-
-(defn ordered-map-by [pred coll]
-  (-> pred order/compare-by (ordered-map coll)))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Interval Map
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn interval-map
-  ([]
-   (interval-map nil))
-  ([coll]
-   (binding [tree/*t-join*  tree/node-create-weight-balanced-interval
-             order/*compare* order/normal-compare]
-     (->IntervalMap (reduce (fn [n [k v]] (tree/node-add n k v)) (node/leaf) coll)
-                    order/*compare* tree/*t-join* nil {}))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Interval Set
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn interval-set
-  ([]
-   (interval-set nil))
-  ([coll]
-   (binding [tree/*t-join*   tree/node-create-weight-balanced-interval
-             order/*compare* order/normal-compare]
-     (->IntervalSet (reduce #(tree/node-add %1 (interval/ordered-pair %2)) (node/leaf) coll)
-                     order/*compare* tree/*t-join* nil {}))))
diff --git a/src/com/dean/interval_tree/tree/interval_map.clj b/src/com/dean/interval_tree/tree/interval_map.clj
deleted file mode 100644
index 8bfab84..0000000
--- a/src/com/dean/interval_tree/tree/interval_map.clj
+++ /dev/null
@@ -1,172 +0,0 @@
-(ns com.dean.interval-tree.tree.interval-map
-  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
-            [com.dean.interval-tree.tree.interval :as interval]
-            [com.dean.interval-tree.tree.node     :as node]
-            [com.dean.interval-tree.tree.root]
-            [com.dean.interval-tree.tree.order    :as order]
-            [com.dean.interval-tree.tree.tree     :as tree])
-  (:import  [clojure.lang                RT]
-            [com.dean.interval_tree.tree.root     INodeCollection
-                                         IBalancedCollection
-                                         IOrderedCollection
-                                         IIntervalCollection]))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Dynamic Environment
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmacro with-interval-map [x & body]
-  `(binding [order/*compare* (.getCmp ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.IOrderedCollection}))
-             tree/*t-join*   (.getAllocator ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.INodeCollection}))]
-     ~@body))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Interval Map
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(deftype IntervalMap [root cmp alloc stitch _meta]
-
-  INodeCollection
-  (getAllocator [_]
-    alloc)
-  (getRoot [_]
-    root)
-
-  IOrderedCollection
-  (getCmp [_]
-    cmp)
-  (isCompatible [_ o]
-    (and (instance? IntervalMap o) (= cmp (.getCmp o)) (= stitch (.getStitch o))))
-  (isSimilar [_ o]
-    (map? o))
-
-  IBalancedCollection
-  (getStitch [_]
-    stitch)
-
-  IIntervalCollection
-
-  clojure.lang.IMeta
-  (meta [_]
-    _meta)
-
-  clojure.lang.IObj
-  (withMeta [_ m]
-    (IntervalMap. root cmp alloc stitch m))
-
-  clojure.lang.Indexed
-  (nth [this i]
-    (with-interval-map this
-      (node/-kv (tree/node-nth root i))))
-
-  clojure.lang.MapEquivalence
-
-  clojure.lang.Seqable
-  (seq [this]
-    (with-interval-map this
-      (map node/-kv (tree/node-seq root))))
-
-  clojure.lang.Reversible
-  (rseq [this]
-    (with-interval-map this
-      (map node/-kv (tree/node-seq-reverse root))))
-
-  clojure.lang.ILookup
-  (valAt [this k not-found]
-    (with-interval-map this
-      (if-let [found (tree/node-find-intervals root k)]
-        (map node/-v found)
-      not-found)))
-  (valAt [this k]
-    (.valAt this k nil))
-
-  clojure.lang.IFn
-  (invoke [this k not-found]
-    (.valAt this k not-found))
-  (invoke [this k]
-    (.valAt this k))
-  (applyTo [this args]
-    (let [n (RT/boundedLength args 2)]
-      (case n
-        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
-        1 (.invoke this (first args))
-        2 (.invoke this (first args) (second args))
-        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
-
-  java.lang.Comparable
-  (compareTo [this o]
-    (with-interval-map this
-      (cond
-        (identical? this o) 0
-        (.isCompatible this o) (tree/node-map-compare root (.getRoot o))
-        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
-
-  clojure.lang.Counted
-  (count [this]
-    (tree/node-size root))
-
-  clojure.lang.Associative
-  (containsKey [this k]
-    (with-interval-map this
-      (not (empty? (tree/node-find-intervals root k)))))
-  (entryAt [this k]
-    (with-interval-map this
-      (some->> k (tree/node-find-intervals root) (map node/-kv))))
-  (assoc [this k v]
-    (with-interval-map this
-      (IntervalMap. (tree/node-add root (interval/ordered-pair k) v) cmp alloc stitch _meta)))
-  (empty [this]
-    (IntervalMap. (node/leaf) cmp alloc stitch {}))
-
-  java.util.Map
-  (get [this k]
-    (.valAt this k))
-  (isEmpty [_]
-    (node/leaf? root))
-  (size [_]
-    (tree/node-size root))
-  (keySet [this]
-    (with-interval-map this
-      (set (tree/node-vec root :accessor :k))))
-  (put [_ _ _]
-    (throw (UnsupportedOperationException.)))
-  (putAll [_ _]
-    (throw (UnsupportedOperationException.)))
-  (clear [_]
-    (throw (UnsupportedOperationException.)))
-  (values [this]
-    (with-interval-map this
-      (tree/node-vec root :accessor :v)))
-  (entrySet [this]
-    (with-interval-map this
-      (set (tree/node-vec root :accessor :kv))))
-  (iterator [this]
-    (clojure.lang.SeqIterator. (seq this)))
-
-  clojure.lang.IPersistentCollection
-  (equiv [this o]
-    (with-interval-map this
-      (cond
-        (identical? this o) 0
-        (.isCompatible this o) (and (= (.count this) (.count o))
-                                    (zero? (tree/node-map-compare root (.getRoot o))))
-        true     (throw (ex-info "unsupported comparison: " {:this this :o o})))))
-
-  (cons [this o]
-    (.assoc this (nth o 0) (nth o 1)))
-
-  clojure.lang.IPersistentMap
-  (assocEx [this k v]
-    (if (contains? this k)
-      (throw (RuntimeException. "Key or value already present"))
-      (assoc this k v)))
-  (without [this k]
-    (with-interval-map this
-      (IntervalMap. (tree/node-remove root k) cmp alloc stitch _meta))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Literal Representation
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmethod print-method IntervalMap [m w]
-  ((get (methods print-method) clojure.lang.IPersistentMap) m w))
diff --git a/src/com/dean/interval_tree/tree/interval_set.clj b/src/com/dean/interval_tree/tree/interval_set.clj
deleted file mode 100644
index 634fc03..0000000
--- a/src/com/dean/interval_tree/tree/interval_set.clj
+++ /dev/null
@@ -1,211 +0,0 @@
-(ns com.dean.interval-tree.tree.interval-set
-  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
-            [clojure.set]
-            [com.dean.interval-tree.tree.interval :as interval]
-            [com.dean.interval-tree.tree.node     :as node]
-            [com.dean.interval-tree.tree.order    :as order]
-            [com.dean.interval-tree.tree.protocol :as proto]
-            [com.dean.interval-tree.tree.root]
-            [com.dean.interval-tree.tree.tree     :as tree])
-  (:import  [clojure.lang                RT]
-            [com.dean.interval_tree.tree.protocol PExtensibleSet]
-            [com.dean.interval_tree.tree.root     INodeCollection
-                                         IBalancedCollection
-                                         IOrderedCollection
-                                         IIntervalCollection]))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Dynamic Environment
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmacro with-interval-set [x & body]
-  `(binding [order/*compare* (.getCmp ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.IOrderedCollection}))
-             tree/*t-join*   (.getAllocator ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.INodeCollection}))]
-     ~@body))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Interval Set
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(deftype IntervalSet [root cmp alloc stitch _meta]
-
-  INodeCollection
-  (getAllocator [_]
-    alloc)
-  (getRoot [_]
-    root)
-
-  IOrderedCollection
-  (getCmp [_]
-    cmp)
-  (isCompatible [_ o]
-    (and (instance? IntervalSet o) (= cmp (.getCmp o))))
-  (isSimilar [_ _]
-    false)
-
-  IBalancedCollection
-  (getStitch [_]
-    stitch)
-
-  IIntervalCollection
-
-  ;; TODO: how should these work for interval-set?
-  PExtensibleSet
-  (intersection [this that]
-    (with-interval-set this
-      (cond
-        (identical? this that)    this
-        (.isCompatible this that) (IntervalSet. (tree/node-set-intersection root (.getRoot that))
-                                       cmp alloc stitch {})
-        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
-  (union [this that]
-    (with-interval-set this
-      (cond
-        (identical? this that)    this
-        (.isCompatible this that) (IntervalSet. (tree/node-set-union root (.getRoot that))
-                                       cmp alloc stitch {})
-        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
-  (difference [this that]
-    (with-interval-set this
-      (cond
-        (identical? this that)    (.empty this)
-        (.isCompatible this that) (IntervalSet. (tree/node-set-difference root (.getRoot that))
-                                       cmp alloc stitch {})
-        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
-  (subset [this that]
-    (with-interval-set this
-      (cond
-        (identical? this that)    true
-        (.isCompatible this that) (tree/node-subset? (.getRoot that) root) ;; Grr. reverse args of tree/subset
-        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
-  (superset [this that]
-    (with-interval-set this
-      (cond
-        (identical? this that)    true
-        (.isCompatible this that) (tree/node-subset? root (.getRoot that)) ;; Grr. reverse args of tree/subset
-        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
-
-  clojure.lang.IMeta
-  (meta [_]
-    _meta)
-
-  clojure.lang.IObj
-  (withMeta [_ m]
-    (IntervalSet. root cmp alloc stitch m))
-
-  clojure.lang.Indexed
-  (nth [this i]
-    (with-interval-set this
-      (node/-k (tree/node-nth root i))))
-
-  clojure.lang.Seqable
-  (seq [this]
-    (with-interval-set this
-      (map node/-k (tree/node-seq root))))
-
-  clojure.lang.Reversible
-  (rseq [this]
-    (with-interval-set this
-      (map node/-k (tree/node-seq-reverse root))))
-
-  clojure.lang.ILookup
-  (valAt [this k not-found]
-    (with-interval-set this
-      (if-let [found (seq (tree/node-find-intervals root k))]
-        (map node/-k found)
-        not-found)))
-  (valAt [this k]
-    (.valAt this k nil))
-
-  clojure.lang.IFn
-  (invoke [this k not-found]
-    (.valAt this k not-found))
-  (invoke [this k]
-    (.valAt this k))
-  (applyTo [this args]
-    (let [n (RT/boundedLength args 2)]
-      (case n
-        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
-        1 (.invoke this (first args))
-        2 (.invoke this (first args) (second args))
-        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
-
-  java.lang.Comparable
-  (compareTo [this o]
-    (with-interval-set this
-      (cond
-        (identical? this o)   0
-        (.isCompatible this o) (tree/node-set-compare root (.getRoot o))
-        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
-
-  java.util.Collection
-  (toArray [this]
-    (with-interval-set this
-      (object-array (tree/node-vec root :accessor :k)))) ; better constructor not a priority
-  (isEmpty [_]
-    (node/leaf? root))
-  (add [_ _]
-    (throw (UnsupportedOperationException.)))
-  (addAll [_ _]
-    (throw (UnsupportedOperationException.)))
-  (removeAll [_ _]
-    (throw (UnsupportedOperationException.)))
-  (retainAll [_ _]
-    (throw (UnsupportedOperationException.)))
-
-  java.util.Set
-  (size [_]
-    (tree/node-size root))
-  (iterator [this]
-    (clojure.lang.SeqIterator. (seq this)))
-  (containsAll [this s]  ;; TODO: is this how an interval-set should work?
-    (with-interval-set this
-      (cond
-        (identical? this s)    true
-        (coll? s) (every? #(.contains this %) s)
-        true      (throw (ex-info "unsupported comparison: " {:this this :s s})))))
-
-  java.util.SortedSet
-  (comparator [_]
-    cmp)
-  (first [this]
-    (with-interval-set this
-      (node/-k (tree/node-least root))))
-  (last [this]
-    (with-interval-set this
-      (node/-k (tree/node-greatest root))))
-
-  clojure.lang.IPersistentSet
-  (equiv [this o]
-    (with-interval-set this
-      (cond
-        (identical? this o) true
-        (.isCompatible this o) (and (= (.count this) (.count o))
-                                    (zero? (tree/node-set-compare root (.getRoot o))))
-        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
-  (count [_]
-    (tree/node-size root))
-  (empty [_]
-    (IntervalSet. (node/leaf) cmp alloc stitch {}))
-  (contains [this k]
-    (with-interval-set this
-      (some? (seq (tree/node-find-intervals this (interval/ordered-pair k))))))
-  (disjoin [this k]
-    (with-interval-set this
-      (IntervalSet. (tree/node-remove root (interval/ordered-pair k)) cmp alloc stitch _meta)))
-  (cons [this k]
-    (with-interval-set this
-      (IntervalSet. (tree/node-add root (interval/ordered-pair k)) cmp alloc stitch _meta)))
-
-  clojure.core.reducers.CollFold
-  (coll-fold [this n combinef reducef]
-    (with-interval-set this
-      (tree/node-chunked-fold n root combinef
-        (fn [acc node] (reducef acc (node/-k node)))))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Literal Representation
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmethod print-method IntervalSet [s w]
-  ((get (methods print-method) clojure.lang.IPersistentSet) s w))
diff --git a/src/com/dean/interval_tree/tree/order.clj b/src/com/dean/interval_tree/tree/order.clj
deleted file mode 100644
index a377ab8..0000000
--- a/src/com/dean/interval_tree/tree/order.clj
+++ /dev/null
@@ -1,70 +0,0 @@
-(ns com.dean.interval-tree.tree.order
-  (:refer-clojure :exclude [compare <= >= max]))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Comparator
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; TODO: note about fanciness
-
-(defn normalize ^long [^long x]
-  (if (zero? x)
-    x
-    (bit-or 1
-      (bit-shift-right x 63))))
-
-(defn compare-by
-  "Given a predicate that defines a total order over some domain,
-  return a three-way comparator built from it."
-  [pred]
-  (fn [x y]
-    (cond
-      (pred x y) -1
-      (pred y x) +1
-      true        0)))
-
-(defn normal-compare ^long [x y]
-  (normalize (clojure.core/compare x y)))
-
-(def ^:dynamic *compare* normal-compare)
-
-(defn compare ^long [x y]
-  (*compare* x y))
-
-(defn compare< [x y]
-  (neg? (compare x y)))
-
-(defn compare<= [x y]
-  (not (pos? (compare x y))))
-
-(defn compare> [x y]
-  (pos? (compare x y)))
-
-(defn compare>= [x y]
-  (not (neg? (compare x y))))
-
-(defn compare= [x y]
-  (zero? (compare x y)))
-
-(defn max [x & args]
-  (reduce #(if (compare> %1 %2) %1 %2) x args))
-
-(defn <=
-  ([x] true)
-  ([x y] (compare<= x y))
-  ([x y & more]
-   (if (compare<= x y)
-     (if (next more)
-       (recur y (first more) (next more))
-       (compare<= y (first more)))
-     false)))
-
-(defn >=
-  ([x] true)
-  ([x y] (compare>= x y))
-  ([x y & more]
-   (if (compare>= x y)
-     (if (next more)
-       (recur y (first more) (next more))
-       (compare>= y (first more)))
-     false)))
diff --git a/src/com/dean/interval_tree/tree/ordered_map.clj b/src/com/dean/interval_tree/tree/ordered_map.clj
deleted file mode 100644
index 749fc55..0000000
--- a/src/com/dean/interval_tree/tree/ordered_map.clj
+++ /dev/null
@@ -1,170 +0,0 @@
-(ns com.dean.interval-tree.tree.ordered-map
-  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
-            [com.dean.interval-tree.tree.node     :as node]
-            [com.dean.interval-tree.tree.protocol :as proto]
-            [com.dean.interval-tree.tree.root]
-            [com.dean.interval-tree.tree.tree     :as tree]
-            [com.dean.interval-tree.tree.order    :as order])
-  (:import  [clojure.lang                RT]
-            [com.dean.interval_tree.tree.root     INodeCollection
-                                         IBalancedCollection
-                                         IOrderedCollection]))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Dynamic Environment
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmacro with-ordered-map [x & body]
-  `(binding [order/*compare* (.getCmp ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.IOrderedCollection}))]
-     ~@body))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Ordered Map
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(deftype OrderedMap [root cmp alloc stitch _meta]
-
-  INodeCollection
-  (getAllocator [_]
-    alloc)
-  (getRoot [_]
-    root)
-
-  IOrderedCollection
-  (getCmp [_]
-    cmp)
-  (isCompatible [_ o]
-    (and (instance? OrderedMap o) (= cmp (.getCmp o)) (= stitch (.getStitch o))))
-  (isSimilar [_ o]
-    (map? o))
-
-  IBalancedCollection
-  (getStitch [_]
-    stitch)
-
-  clojure.lang.IMeta
-  (meta [_]
-    _meta)
-
-  clojure.lang.IObj
-  (withMeta [_ m]
-    (OrderedMap. root cmp alloc stitch m))
-
-  clojure.lang.Indexed
-  (nth [this i]
-    (with-ordered-map this
-      (node/-kv (tree/node-nth root i))))
-
-  clojure.lang.MapEquivalence
-
-  clojure.lang.Seqable
-  (seq [this]
-    (with-ordered-map this
-      (map node/-kv (tree/node-seq root))))
-
-  clojure.lang.Reversible
-  (rseq [this]
-    (with-ordered-map this
-      (map node/-kv (tree/node-seq-reverse root))))
-
-  clojure.lang.ILookup
-  (valAt [this k not-found]
-    (with-ordered-map this
-      (if-let [found (tree/node-find root k)]
-        (node/-v found)
-        not-found)))
-  (valAt [this k]
-    (.valAt this k nil))
-
-  clojure.lang.IFn
-  (invoke [this k not-found]
-    (.valAt this k not-found))
-  (invoke [this k]
-    (.valAt this k))
-  (applyTo [this args]
-    (let [n (RT/boundedLength args 2)]
-      (case n
-        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
-        1 (.invoke this (first args))
-        2 (.invoke this (first args) (second args))
-        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
-
-  java.lang.Comparable
-  (compareTo [this o]
-    (with-ordered-map this
-      (cond
-        (identical? this o) 0
-        (.isCompatible this o) (tree/node-map-compare root (.getRoot o))
-        (.isSimilar    this o) (.compareTo (into (empty o) this) o)
-        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
-
-  clojure.lang.Counted
-  (count [this]
-    (tree/node-size root))
-
-  clojure.lang.Associative
-  (containsKey [this k]
-    (with-ordered-map this
-      (some? (tree/node-find root k))))
-  (entryAt [this k]
-    (with-ordered-map this
-      (some-> root (tree/node-find k) node/-kv)))
-  (assoc [this k v]
-    (with-ordered-map this
-      (OrderedMap. (tree/node-add root k v) cmp alloc stitch _meta)))
-  (empty [this]
-    (OrderedMap. (node/leaf) cmp alloc stitch {}))
-
-  java.util.Map
-  (get [this k]
-    (.valAt this k))
-  (isEmpty [_]
-    (node/leaf? root))
-  (size [_]
-    (tree/node-size root))
-  (keySet [this]
-    (with-ordered-map this
-      (set (tree/node-vec root :accessor :k))))
-  (put [_ _ _]
-    (throw (UnsupportedOperationException.)))
-  (putAll [_ _]
-    (throw (UnsupportedOperationException.)))
-  (clear [_]
-    (throw (UnsupportedOperationException.)))
-  (values [this]
-    (with-ordered-map this
-      (tree/node-vec root :accessor :v)))
-  (entrySet [this]
-    (with-ordered-map this
-      (set (tree/node-vec root :accessor :kv))))
-  (iterator [this]
-    (clojure.lang.SeqIterator. (seq this)))
-
-  clojure.lang.IPersistentCollection
-  (equiv [this o]
-    (with-ordered-map this
-      (cond
-        (identical? this o) 0
-        (.isCompatible this o) (and (= (.count this) (.count o))
-                                    (zero? (tree/node-map-compare root (.getRoot o))))
-        (map? o) (.equiv (into (empty o) (tree/node-vec root :accessor :kv)) o)
-        true     (throw (ex-info "unsupported comparison: " {:this this :o o})))))
-
-  (cons [this o]
-    (.assoc this (nth o 0) (nth o 1)))
-
-  clojure.lang.IPersistentMap
-  (assocEx [this k v]               ;; TODO: use `tree/node-add-if`
-    (if (contains? this k)
-      (throw (Exception. "Key or value already present"))
-      (assoc this k v)))
-  (without [this k]
-    (with-ordered-map this
-      (OrderedMap. (tree/node-remove root k) cmp alloc stitch _meta))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Literal Representation
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmethod print-method OrderedMap [m w]
-  ((get (methods print-method) clojure.lang.IPersistentMap) m w))
diff --git a/src/com/dean/interval_tree/tree/ordered_set.clj b/src/com/dean/interval_tree/tree/ordered_set.clj
deleted file mode 100644
index b43d711..0000000
--- a/src/com/dean/interval_tree/tree/ordered_set.clj
+++ /dev/null
@@ -1,341 +0,0 @@
-(ns com.dean.interval-tree.tree.ordered-set
-  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
-            [clojure.set]
-            [com.dean.interval-tree.tree.node     :as node]
-            [com.dean.interval-tree.tree.order    :as order]
-            [com.dean.interval-tree.tree.protocol :as proto]
-            [com.dean.interval-tree.tree.root]
-            [com.dean.interval-tree.tree.tree     :as tree])
-  (:import  [clojure.lang                RT]
-            [com.dean.interval_tree.tree.protocol PExtensibleSet]
-            [com.dean.interval_tree.tree.root     INodeCollection
-                                         IBalancedCollection
-                                         IOrderedCollection]))
-
-;; TODO:
-;;  - clojure.lang.Sorted
-;;  - ISeq .seqFrom
-
-;; - IReduce, IReduceKV,
-;; - IMapIterable:  https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/PersistentHashMap.java
-;; - Collection Check: https://github.com/ztellman/collection-check/blob/master/src/collection_check/core.cljc
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Dynamic Environment
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmacro with-ordered-set [x & body]
-  `(binding [order/*compare* (.getCmp ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.IOrderedCollection}))]
-     ~@body))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Ordered Set
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(deftype OrderedSet [root cmp alloc stitch _meta]
-
-  INodeCollection
-  (getAllocator [_]
-    alloc)
-  (getRoot [_]
-    root)
-
-  IOrderedCollection
-  (getCmp [_]
-    cmp)
-  (isCompatible [_ o]
-    (and (instance? OrderedSet o) (= cmp (.getCmp ^OrderedSet o)) (= stitch (.getStitch ^OrderedSet o))))
-  (isSimilar [_ o]
-    (set? o))
-
-  IBalancedCollection
-  (getStitch [_]
-    stitch)
-
-  PExtensibleSet
-  (intersection [this that]
-    (with-ordered-set this
-      (cond
-        (identical? this that)    this
-        (.isCompatible this that) (new OrderedSet (tree/node-set-intersection root (.getRoot ^OrderedSet that))
-                                       cmp alloc stitch {})
-        (.isSimilar this that)    (clojure.set/intersection (into #{} this) that)
-        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
-  (union [this that]
-    (with-ordered-set this
-      (cond
-        (identical? this that)    this
-        (.isCompatible this that) (new OrderedSet (tree/node-set-union root (.getRoot ^OrderedSet that))
-                                       cmp alloc stitch {})
-        (.isSimilar this that)    (clojure.set/union (into #{} this) that)
-        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
-  (difference [this that]
-    (with-ordered-set this
-      (cond
-        (identical? this that)    (.empty this)
-        (.isCompatible this that) (new OrderedSet (tree/node-set-difference root (.getRoot ^OrderedSet that))
-                                       cmp alloc stitch{})
-        (.isSimilar this that)    (clojure.set/difference (into #{} this) that)
-        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
-  (subset [this that]
-    (with-ordered-set this
-      (cond
-        (identical? this that)    true
-        (.isCompatible this that) (tree/node-subset? (.getRoot ^OrderedSet that) root) ;; Grr. reverse args of tree/subset
-        (.isSimilar this that)    (clojure.set/subset? (into #{} this) that)
-        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
-  (superset [this that]
-    (with-ordered-set this
-      (cond
-        (identical? this that)    true
-        (.isCompatible this that) (tree/node-subset? root (.getRoot ^OrderedSet that)) ;; Grr. reverse args of tree/subset
-        (.isSimilar this that)    (clojure.set/subset? that (into #{} this))
-        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
-
-  clojure.lang.IMeta
-  (meta [_]
-    _meta)
-
-  clojure.lang.IObj
-  (withMeta [_ m]
-    (new OrderedSet root cmp alloc stitch m))
-
-  clojure.lang.Indexed
-  (nth [this i]
-    (with-ordered-set this
-      (node/-k (tree/node-nth root i))))
-
-  clojure.lang.Seqable
-  (seq [this]
-    (with-ordered-set this
-      (map node/-k (tree/node-seq root))))
-
-  clojure.lang.Reversible
-  (rseq [this]
-    (with-ordered-set this
-      (map node/-k (tree/node-seq-reverse root))))
-
-  clojure.lang.ILookup
-  (valAt [this k not-found]
-    (with-ordered-set this
-      (if-let [found (tree/node-find root k)]
-        (node/-k found)
-        not-found)))
-  (valAt [this k]
-    (.valAt this k nil))
-
-  clojure.lang.IFn
-  (invoke [this k not-found]
-    (.valAt this k not-found))
-  (invoke [this k]
-    (.valAt this k))
-  (applyTo [this args]
-    (let [n (RT/boundedLength args 2)]
-      (case n
-        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
-        1 (.invoke this (first args))
-        2 (.invoke this (first args) (second args))
-        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
-
-  java.lang.Comparable
-  (compareTo [this o]
-    (with-ordered-set this
-      (cond
-        (identical? this o)   0
-        (.isCompatible this o) (tree/node-set-compare root (.getRoot ^OrderedSet o))
-        (.isSimilar    this o) (.compareTo ^Comparable (into (empty o) this) o)
-        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
-
-  java.util.Collection
-  (toArray [this]
-    (with-ordered-set this
-      (object-array (tree/node-vec root :accessor :k)))) ; better constructor not a priority
-  (isEmpty [_]
-    (node/leaf? root))
-  (add [_ _]
-    (throw (UnsupportedOperationException.)))
-  (addAll [_ _]
-    (throw (UnsupportedOperationException.)))
-  (removeAll [_ _]
-    (throw (UnsupportedOperationException.)))
-  (retainAll [_ _]
-    (throw (UnsupportedOperationException.)))
-
-  java.util.List
-  (indexOf [this x]
-    (with-ordered-set this
-      (tree/node-rank root x)))
-  (lastIndexOf [this x]
-    (.indexOf this x))
-
-  java.util.Set
-  (size [_]
-    (tree/node-size root))
-  (iterator [this]
-    (clojure.lang.SeqIterator. (seq this)))
-  (containsAll [this s]
-    (with-ordered-set this
-      (cond
-        (identical? this s)    true
-        (.isCompatible this s) (tree/node-subset? root (.getRoot ^OrderedSet s))
-        (coll? s)              (every? #(.contains this %) s)
-        true     (throw (ex-info "unsupported comparison: " {:this this :s s})))))
-
-  java.util.SortedSet
-  (comparator [_]
-    cmp)
-  (first [this]
-    (with-ordered-set this
-      (node/-k (tree/node-least root))))
-  (last [this]
-    (with-ordered-set this
-      (node/-k (tree/node-greatest root))))
-  (headSet [this x]
-    (with-ordered-set this
-      (new OrderedSet (tree/node-split-lesser root x) cmp alloc stitch {})))
-  (tailSet [this x]
-    (with-ordered-set this
-      (new OrderedSet (tree/node-split-greater root x) cmp alloc stitch {})))
-  (subSet [this from to]
-    (with-ordered-set this
-      (let [left   (tree/node-split-greater root from)
-            right  (tree/node-split-lesser  root to)
-            result (tree/node-set-intersection left right)]
-        (new OrderedSet result cmp alloc stitch {}))))
-
-  java.util.NavigableSet
-  (ceiling [this x]
-    (with-ordered-set this
-      (let [[_ x' r] (tree/node-split root x)]
-        (if (some? x')
-          (first x')
-          (some-> (tree/node-least r) node/-k)))))
-  (floor [this x]
-    (with-ordered-set this
-      (let [[l x' _] (tree/node-split root x)]
-        (if (some? x')
-          (first x')
-          (some-> (tree/node-greatest l) node/-k)))))
-
-  clojure.lang.IPersistentSet
-  (equiv [this o]
-    (with-ordered-set this
-      (cond
-        (identical? this o) true
-        (not= (tree/node-size root) (.count ^clojure.lang.Counted o)) false
-        (.isCompatible this o) (zero? (tree/node-set-compare root (.getRoot ^OrderedSet o)))
-        (.isSimilar    this o) (.equiv ^clojure.lang.IPersistentSet (into (empty o) this) o)
-        true     (throw (ex-info "unsupported comparison: " {:this this :o o})))))
-  (count [_]
-    (tree/node-size root))
-  (empty [_]
-    (new OrderedSet (node/leaf) cmp alloc stitch {}))
-  (contains [this k]
-    (with-ordered-set this
-      (if (tree/node-find root k) true false)))
-  (disjoin [this k]
-    (with-ordered-set this
-      (new OrderedSet (tree/node-remove root k) cmp alloc stitch _meta)))
-  (cons [this k]
-    (with-ordered-set this
-      (new OrderedSet (tree/node-add root k) cmp alloc stitch _meta)))
-
-  clojure.core.reducers.CollFold
-  (coll-fold [this n combinef reducef]
-    (with-ordered-set this
-      (tree/node-chunked-fold n root combinef
-        (fn [acc node] (reducef acc (node/-k node)))))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Literal Representation
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmethod print-method OrderedSet [s w]
-  ((get (methods print-method) clojure.lang.IPersistentSet) s w))
-
-
-
-(comment
-
-  ;; W00T!
-
-  (def foo (shuffle (range 500000)))
-  (def bar (shuffle (range 1000000)))
-
-  (def s0 (shuffle (range 0 1000000 2)))
-  (def s1 (shuffle (range 0 1000000 3)))
-
-  ;; Home Team:
-
-  (time (def x (ordered-set foo)))         ;; 500K: "Elapsed time: 564.248517 msecs"
-  (time (def y (ordered-set bar)))         ;;   1M: "Elapsed time: 1187.734211 msecs"
-  (time (def s (proto/intersection
-                 (ordered-set s0)
-                 (ordered-set s1))))       ;; 833K: "Elapsed time: 1242.961445 msecs"
-  (time (r/fold + + y))                    ;;   1M: "Elapsed time: 54.363545 msecs"
-
-  ;; Visitors:
-
-  (time (def v (into (sorted-set) foo)))   ;; 500K: "Elapsed time: 839.188189 msecs"
-  (time (def w (into (sorted-set) bar)))   ;;   1M: "Elapsed time: 1974.798286 msecs"
-  (time (def s (clojure.set/intersection
-                 (into (sorted-set) s0)
-                 (into (sorted-set) s1)))) ;; 833K: "Elapsed time: 1589.786106 msecs"
-  (time (r/fold + + w))                    ;;   1M: "Elapsed time: 167.916539 msecs"
-
-
-  (require '[criterium.core])
-
-  (criterium.core/bench (def x (ordered-set foo)))
-
-;;   Evaluation count : 120 in 60 samples of 2 calls.
-;;              Execution time mean : 612.435645 ms
-;;     Execution time std-deviation : 60.421726 ms
-;;    Execution time lower quantile : 565.022632 ms ( 2.5%)
-;;    Execution time upper quantile : 771.090227 ms (97.5%)
-;;                    Overhead used : 1.708588 ns
-;;
-;; Found 11 outliers in 60 samples (18.3333 %)
-;; 	low-severe	 1 (1.6667 %)
-;; 	low-mild	 10 (16.6667 %)
-;;  Variance from outliers : 68.6890 % Variance is severely inflated by outliers
-
-  (criterium.core/bench (def v (into (sorted-set) foo)))
-
-;;   Evaluation count : 120 in 60 samples of 2 calls.
-;;              Execution time mean : 819.376840 ms
-;;     Execution time std-deviation : 29.835432 ms
-;;    Execution time lower quantile : 789.678093 ms ( 2.5%)
-;;    Execution time upper quantile : 907.561055 ms (97.5%)
-;;                    Overhead used : 1.708588 ns
-;;
-;; Found 5 outliers in 60 samples (8.3333 %)
-;; 	low-severe	 3 (5.0000 %)
-;; 	low-mild	 2 (3.3333 %)
-;;  Variance from outliers : 22.2640 % Variance is moderately inflated by outliers
-
-;;;
-;; clojure.data.avl
-
-  (require '[clojure.data.avl :as avl])
-
-  (time (def z (into (avl/sorted-set) foo))) ;; 500K: "Elapsed time: 586.862601 msecs"
-  (time (def z (into (avl/sorted-set) bar))) ;; 1M:   "Elapsed time: 1399.241718 msecs"
-
-  (criterium.core/bench (def z (into (avl/sorted-set) foo)))
-
-;; Evaluation count : 120 in 60 samples of 2 calls.
-;;              Execution time mean : 606.249611 ms
-;;     Execution time std-deviation : 16.864172 ms
-;;    Execution time lower quantile : 560.393078 ms ( 2.5%)
-;;    Execution time upper quantile : 631.176588 ms (97.5%)
-;;                    Overhead used : 1.710404 ns
-;;
-;; Found 4 outliers in 60 samples (6.6667 %)
-;; 	low-severe	 3 (5.0000 %)
-;; 	low-mild	 1 (1.6667 %)
-;;  Variance from outliers : 14.2428 % Variance is moderately inflated by outliers
-
-  (time (r/fold + + z))
-
-  )
diff --git a/src/com/dean/interval_tree/tree/protocol.clj b/src/com/dean/interval_tree/tree/protocol.clj
deleted file mode 100644
index 474b12b..0000000
--- a/src/com/dean/interval_tree/tree/protocol.clj
+++ /dev/null
@@ -1,39 +0,0 @@
-(ns com.dean.interval-tree.tree.protocol
-  (:require [clojure.set :as set]))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Set Protocol
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defprotocol PExtensibleSet
-  (intersection [this that])
-  (union        [this that])
-  (difference   [this that])
-  (subset       [this that])
-  (superset     [this that]))
-
-(extend-type clojure.lang.PersistentHashSet
-  PExtensibleSet
-  (intersection [this that]
-    (set/intersection this that))
-  (union [this that]
-    (set/union this that))
-  (difference [this that]
-    (set/difference this that))
-  (subset [this that]
-    (set/subset? this that))
-  (superset [this that]
-    (set/subset? that this)))
-
-(extend-type clojure.lang.PersistentTreeSet
-  PExtensibleSet
-  (intersection [this that]
-    (set/intersection this that))
-  (union [this that]
-    (set/union this that))
-  (difference [this that]
-    (set/difference this that))
-  (subset [this that]
-    (set/subset? this that))
-  (superset [this that]
-    (set/subset? that this)))
diff --git a/src/com/dean/interval_tree/tree/tree.clj b/src/com/dean/interval_tree/tree/tree.clj
deleted file mode 100644
index 6e8944c..0000000
--- a/src/com/dean/interval_tree/tree/tree.clj
+++ /dev/null
@@ -1,868 +0,0 @@
-(ns com.dean.interval-tree.tree.tree
-  (:require [clojure.core.reducers       :as r]
-            [com.dean.interval-tree.tree.interval :as interval]
-            [com.dean.interval-tree.tree.order    :as order]
-            [com.dean.interval-tree.tree.node     :as node  :refer [leaf? leaf -k -v -l -r -x -z -kv]])
-  (:import  [clojure.lang MapEntry]))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Weight Balanced Functional Binary Interval Tree (Hirai-Yamamoto Tree)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;; This is an implementation of a weight-balanced binary interval-tree data
-;; structure based on the following references:
-;;
-;; --  Adams (1992)
-;;     'Implementing Sets Efficiently in a Functional Language'
-;;     Technical Report CSTR 92-10, University of Southampton.
-;;     <http://groups.csail.mit.edu/mac/users/adams/BB/92-10.ps>
-;;
-;; --  Hirai and Yamamoto (2011)
-;;     'Balancing Weight-Balanced Trees'
-;;     Journal of Functional Programming / 21 (3):
-;;     Pages 287-307
-;;     <https://yoichihirai.com/bst.pdf>
-;;
-;; --  Oleg Kiselyov
-;;     'Towards the best collection API, A design of the overall optimal
-;;     collection traversal interface'
-;;     <http://pobox.com/~oleg/ftp/papers/LL3-collections-enumerators.txt>
-;;
-;; --  Nievergelt and Reingold (1972)
-;;     'Binary Search Trees of Bounded Balance'
-;;     STOC '72 Proceedings
-;;     4th Annual ACM symposium on Theory of Computing
-;;     Pages 137-142
-;;
-;; --  Driscoll, Sarnak, Sleator, and Tarjan (1989)
-;;     'Making Data Structures Persistent'
-;;     Journal of Computer and System Sciences Volume 38 Issue 1, February 1989
-;;     18th Annual ACM Symposium on Theory of Computing
-;;     Pages 86-124
-;;
-;; --  MIT Scheme weight balanced tree as reimplemented by Yoichi Hirai
-;;     and Kazuhiko Yamamoto using the revised non-variant algorithm recommended
-;;     integer balance parameters from (Hirai/Yamomoto 2011).
-;;
-;; --  Wikipedia
-;;     'Interval Tree'
-;;     <https://en.wikipedia.org/wiki/Interval_tree>
-;;
-;; --  Wikipedia
-;;     'Weight Balanced Tree'
-;;     <https://en.wikipedia.org/wiki/Weight-balanced_tree>
-;;
-;; --  Andrew Baine, Rahul Jaine (2007)
-;;     'Purely Functional Data Structures in Common Lisp'
-;;     Google Summer of Code 2007
-;;     <https://common-lisp.net/project/funds/funds.pdf>
-;;     <https://developers.google.com/open-source/gsoc/2007/>
-;;
-;; -- Scott L. Burson
-;;     'Functional Set-Theoretic Collections for Common Lisp'
-;;     <https://common-lisp.net/project/fset/Site/index.html>
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; TODO: potential improvements
-;;
-;; - transient/editable collections (would very significantly improve creation)
-;; - hash/hashEq
-
-;; TODO: additional operations
-;;
-;; - node-traverse (maybe?)
-;; - reducer
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Weight Balancing Constants
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(def ^{:const true
-       :doc   "The primary balancing rotation coefficient that is used for the
-              determination whether two subtrees of a node are in balance or
-              require adjustment by means of a rotation operation.  The specific
-              rotation to be performed is determined by `+gamma+`."}
-  +delta+ 3)
-
-(def ^{:const true
-       :doc   "The secondary balancing rotation coefficient that is used for the
-              determination of whether a single or double rotation operation should
-              occur, once it has been decided based on `+delta+` that a rotation is
-              indeed required."}
-  +gamma+ 2)
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Node Destructuring
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmacro kvlr
-  "destructure node n: key value left right. This is the principal destructuring macro
-  for operating on regions of trees"
-  [[ksym vsym lsym rsym] n & body]
-  `(let [n# ~n
-         ~ksym (-k n#) ~vsym (-v n#)
-         ~lsym (-l n#) ~rsym (-r n#)]
-     ~@body))
-
-(defmacro lr [[lsym rsym] n & body]
-  `(let [n# ~n ~lsym (-l n#) ~rsym (-r n#)]
-     ~@body))
-
-(defn maybe-z [n]
-  (when-not (leaf? n) (-z n)))
-
-(def ^:private node-accessor {:k -k :v -v :kv -kv nil identity})
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Balance Metrics
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn node-size
-  "returns the balance metric of the tree rooted at n."
-  ^long [n]
-  (if (leaf? n) 0 (-x n)))
-
-(defn node-weight
-  "returns node weight as appropriate for rotation calculations using
-   the 'revised non-variant algorithm' for weight balanced binary tree."
-  ^long [n]
-  (unchecked-inc (node-size n)))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Node Builders (t-join)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn node-create-weight-balanced
-  "Join left and right weight-balanced subtrees at root k/v.
-  Assumes all keys in l < k < all keys in r."
-  [k v l r]
-  (node/->SimpleNode k v l r (+ 1 (node-size l) (node-size r))))
-
-(defn node-create-weight-balanced-interval
-  "Join left and right weight-balanced interval subtrees at root k/v.
-  Assumes all keys in l < k < all keys in r."
-  [i v l r]
-  (node/->IntervalNode i v l r (+ 1 (node-size l) (node-size r))
-     (order/max (interval/b i) (maybe-z l) (maybe-z r))))
-
-(def ^:dynamic *t-join* node-create-weight-balanced)
-
-(defn node-create
-  "Join left and right subtrees at root k/v.
-  Assumes all keys in l < k < all keys in r."
-  [k v l r]
-  (*t-join* k v l r))
-
-(defn node-singleton
-  "Create and return a newly allocated, balanced tree
-  containing a single association, that of key K with value V."
-  [k v]
-  (node-create k v (leaf) (leaf)))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Node Enumerators: the fundamental traversal algorithm
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; TODO: describe in more detail "enumerator" concept
-;; TODO: diagram of left partial tree decomposition
-;; TODO: use a simple triple type rather than persistentlist
-
-(defn node-enumerator
-  "Efficient mechanism to accomplish partial enumeration of
-   tree-structure into a seq representation without incurring the
-   overhead of operating over the entire tree.  Used internally for
-   implementation of higher-level collection api routines"
-  ([n] (node-enumerator n nil))
-  ([n enum]
-     (if (leaf? n)
-       enum
-       (kvlr [k v l r] n
-         (recur l (list n r enum))))))
-
-;; TODO: diagram of right partial tree decomposition
-
-(defn node-enumerator-reverse
-  ([n] (node-enumerator-reverse n nil))
-  ([n enum]
-     (if (leaf? n)
-       enum
-       (kvlr [k v l r] n
-         (recur r (list n l enum))))))
-
-(def node-enum-first first)
-
-(defn node-enum-rest  [enum]
-  (when (some? enum)
-    (let [[x1 x2 x3] enum]
-      (when-not (and (nil? x2) (nil? x3))
-        (node-enumerator x2 x3)))))
-
-(defn node-enum-prior [enum]
-  (when (some? enum)
-    (let [[x1 x2 x3] enum]
-      (when-not (and (nil? x2) (nil? x3))
-        (node-enumerator-reverse x2 x3)))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Tree Rotations (Weight Balanced)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn rotate-single-left
-  "Perform a single left rotation, moving Y, the left subtree of the
-  right subtree of A, into the left subtree (shown below).  This must
-  occur in order to restore proper balance when the weight of the left
-  subtree of node A is less then the weight of the right subtree of
-  node A multiplied by rotation coefficient +delta+ and the weight of
-  the left subtree of node B is less than the weight of the right subtree
-  of node B multiplied by rotation coefficient +gamma+
-
-                ,---,                                  ,---,
-                | A |                                  | B |
-                :---:                                  :---:
-               :     :                                :     :
-          ,---:       :---,                      ,---:       :---,
-          | X |       | B |           =>         | A |       | Z |
-          '---'       :---:                      :---:       '---'
-                 ,---:     :---,            ,---:     :---,
-                 | Y |     | Z |            | X |     | Y |
-                 '---'     '---'            '---'     '---'"
-  [ak av x b]
-  (kvlr [bk bv y z] b
-    (node-create bk bv
-      (node-create ak av x y) z)))
-
-(defn rotate-double-left
-  "Perform a double left rotation, moving Y1, the left subtree of the
-  left subtree of the right subtree of A, into the left subtree (shown
-  below).  This must occur in order to restore proper balance when the
-  weight of the left subtree of node A is less then the weight of the
-  right subtree of node A multiplied by rotation coefficient +delta+
-  and the weight of the left subtree of node B is greater than or equal
-  to the weight of the right subtree of node B multiplied by rotation
-  coefficient +gamma+.
-
-                ,---,                                    ,---,
-                | A |                                    | B |
-             ___:---:___                             ____:---:____
-        ,---:           :---,                   ,---:             :---,
-        | X |           | C |                   | A |             | C |
-        '---'           :---:         =>        :---:             :---:
-                   ,---:     :---,         ,---:     :---,   ,---:     :---,
-                   | B |     | Z |         | X |     | y1|   | y2|     | Z |
-                   :---:     '---'         '---'     '---'   '---'     '---'
-              ,---:     :---,
-              | y1|     | y2|
-              '---'     '---'"
-  [ak av x c]
-  (kvlr [ck cv b z] c
-    (kvlr [bk bv y1 y2] b
-      (node-create bk bv
-        (node-create ak av x y1)
-        (node-create ck cv y2 z)))))
-
-(defn rotate-single-right
-  "Perform a single right rotation, moving Y, the right subtree of the
-  left subtree of B, into the right subtree (shown below).  This must
-  occur in order to restore proper balance when the weight of the right
-  subtree of node B is less then the weight of the left subtree of
-  node B multiplied by rotation coefficient +delta+ and the weight of the
-  right subtree of node A is less than the weight of the left subtree
-  of node A multiplied by rotation coefficient +gamma+.
-
-                ,---,                                  ,---,
-                | B |                                  | A |
-                :---:                                  :---:
-               :     :                                :     :
-          ,---:       :---,                      ,---:       :---,
-          | A |       | Z |          =>          | X |       | B |
-          :---:       '---'                      '---'       :---:
-     ,---:     :---,                                    ,---:     :---,
-     | X |     | Y |                                    | Y |     | Z |
-     '---'     '---'                                    '---'     '---'"
-  [bk bv a z]
-  (kvlr [ak av x y] a
-    (node-create ak av x (node-create bk bv y z))))
-
-(defn rotate-double-right
-  "Perform a double right rotation, moving Y2, the right subtree of
-  the right subtree of the left subtree of C, into the right
-  subtree (shown below).  This must occur in order to restore proper
-  balance when the weight of the right subtree of node C is less then
-  the weight of the left subtree of node C multiplied by rotation
-  coefficient +delta+ and the weight of the right subtree of node B
-  is greater than or equal to the weight of the left subtree of node B
-  multiplied by rotation coefficient +gamma+.
-
-                ,---,                                    ,---,
-                | C |                                    | B |
-             ___:---:___                             ____:---:____
-        ,---:           :---,                   ,---:             :---,
-        | A |           | Z |                   | A |             | C |
-        :---:           '---'        =>         :---:             :---:
-   ,---:     :---,                         ,---:     :---,   ,---:     :---,
-   | X |     | B |                         | X |     | y1|   | y2|     | Z |
-   '---'     :---:                         '---'     '---'   '---'     '---'
-        ,---:     :---,
-        | y1|     | y2|
-        '---'     '---'"
-  [ck cv a z]
-  (kvlr [ak av x b] a
-    (kvlr [bk bv y1 y2] b
-      (node-create bk bv
-        (node-create ak av x y1)
-        (node-create ck cv y2 z)))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Balanced Tree Constructors (n-Join]
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn node-stitch-weight-balanced
-  "Weight-Balancing Algorithm:
-
-  Join left and right subtrees at root k/v, performing a single or
-  double rotation to balance the resulting tree, if needed.  Assumes
-  all keys in l < k < all keys in r, and the relative weight balance
-  of the left and right subtrees is such that no more than one
-  single/double rotation will result in each subtree being less than
-  +delta+ times the weight of the other.  This is the heart of tree
-  construction."
-  [k v l r]
-  (let [lw (node-weight l)
-        rw (node-weight r)]
-    (cond
-      (> rw (* +delta+ lw)) (let [rlw (node-weight (-l r))
-                                  rrw (node-weight (-r r))]
-                              (if (< rlw (* +gamma+ rrw))
-                                (rotate-single-left k v l r)
-                                (rotate-double-left k v l r)))
-      (> lw (* +delta+ rw)) (let [llw (node-weight (-l l))
-                                  lrw (node-weight (-r l))]
-                              (if (< lrw (* +gamma+ llw))
-                                (rotate-single-right k v l r)
-                                (rotate-double-right k v l r)))
-      true                  (node-create k v l r))))
-
-(def ^:dynamic *n-join* node-stitch-weight-balanced)
-
-(defn node-stitch
-  "The `stitch` operation is the sole balancing constructor and
-  interface to the specific balancing rotation algorithm of the tree.
-  other balancing algorithms (AVL Tree, Red-Black Tree) can be
-  implemented here without effect to other aspects of the tree.
-  Sometimes referred to as `n-join` operation"
-  [k v l r]
-  (*n-join* k v l r))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Fundamental Tree Operations
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn node-add
-  "Insert a new key/value into the tree rooted at n."
-  ([n k]
-   (node-add n k k))
-  ([n k v]
-   (if (leaf? n)
-     (node-singleton k v)
-     (kvlr [key val l r] n
-       (case (order/compare k key)
-         -1 (node-stitch key val (node-add l k v) r)
-         +1 (node-stitch key val l (node-add r k v))
-         (node-create key v l r))))))
-
-(defn node-concat3
-  "Join two trees, the left rooted at l, and the right at r,
-  with a new key/value, performing rotation operations on the resulting
-  trees and subtrees. Assumes all keys in l are smaller than all keys in
-  r, and the relative balance of l and r is such that no more than one
-  rotation operation will be required to balance the resulting tree."
-  [k v l r]
-  (cond
-    (leaf? l) (node-add r k v)
-    (leaf? r) (node-add l k v)
-    true      (let [lw (node-weight l)
-                    rw (node-weight r)]
-                (cond
-                  (< (* +delta+ lw) rw) (kvlr [k2 v2 l2 r2] r
-                                          (node-stitch k2 v2
-                                            (node-concat3 k v l l2) r2))
-                  (< (* +delta+ rw) lw) (kvlr [k1 v1 l1 r1] l
-                                          (node-stitch k1 v1 l1
-                                            (node-concat3 k v r1 r)))
-                  true                  (node-create k v l r)))))
-
-(defn node-least
-  "Return the node containing the minimum key of the tree rooted at n"
-  [n]
-  (cond
-    (leaf? n)      (throw (ex-info "least: empty tree" {:node n}))
-    (leaf? (-l n)) n
-    true           (recur (-l n))))
-
-(defn node-greatest
-  "Return the node containing the minimum key of the tree rooted at n"
-  [n]
-  (cond
-    (leaf? n)      (throw (ex-info "greatest: empty tree" {:node n}))
-    (leaf? (-r n)) n
-    true           (recur (-r n))))
-
-(defn node-remove-least
-  "Return a tree the same as the one rooted at n, with the node
-  containing the minimum key removed. See node-least."
-  [n]
-  (cond
-    (leaf? n)       (throw (ex-info "remove-least: empty tree" {:node n}))
-    (leaf? (-l n))  (-r n)
-    true            (node-stitch (-k n) (-v n)
-                      (node-remove-least (-l n)) (-r n))))
-
-(defn node-remove-greatest
-  "Return a tree the same as the one rooted at n, with the node
-  containing the maximum key removed. See node-greatest."
-  [n]
-  (cond
-    (leaf? n)       (throw (ex-info "remove-greatest: empty tree" {:node n}))
-    (leaf? (-r n))  (-l n)
-    true            (node-stitch (-k n) (-v n) (-l n)
-                      (node-remove-greatest (-r n)))))
-
-(defn node-concat2
-  "Join two trees, the left rooted at l, and the right at r,
-  performing a single balancing operation on the resulting tree, if
-  needed. Assumes all keys in l are smaller than all keys in r, and
-  the relative balance of l and r is such that no more than one rotation
-  operation will be required to balance the resulting tree."
-  [l r]
-  (cond
-    (leaf? l) r
-    (leaf? r) l
-    true      (kvlr [k v _ _] (node-least r)
-                (node-stitch k v l (node-remove-least r)))))
-
-(defn node-remove
-  "remove the node whose key is equal to k, if present."
-  [n k]
-  (if (leaf? n)
-    (leaf)
-    (kvlr [key val l r] n
-      (case (order/compare k key)
-        -1 (node-stitch key val (node-remove l k) r)
-        +1 (node-stitch key val l (node-remove r k))
-        (node-concat2 l r)))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Tree Search
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn node-find
-  "find a node in n whose key = k"
-  [n k]
-  (when-not (leaf? n)
-    (case (order/compare k (-k n))
-      -1 (recur (-l n) k)
-      +1 (recur (-r n) k)
-      n)))
-
-(defn node-find-nearest
-  "Find the nearest k according to relation expressed by :< or :>"
-  [n k & [gt-or-lt]]
-  (let [gt-or-lt (or gt-or-lt :<)
-        [cmp fwd rev] (case gt-or-lt
-                        :< [order/compare< -l -r]
-                        :> [order/compare> -r -l])
-        srch (fn [this best]
-               (cond
-                 (leaf? this)      best
-                 (cmp k (-k this)) (recur (fwd this) best)
-                 true              (recur (rev this) this)))]
-    (srch n nil)))
-
-(defn- node-find-interval-fn [i pred]
-  (let [i      (interval/ordered-pair i)
-        result (volatile! nil)
-        accum  (if pred
-                 (fn [n] (vswap! result #(if (or (nil? %) (pred n %)) n %)))
-                 (fn [n] (vswap! result conj n)))]
-    (fn [n]
-      (letfn [(srch [this]
-                (when-not (leaf? this)
-                  (when (order/compare>= (interval/b i) (-> this -k interval/a))
-                    (-> this -r srch))
-                  (when (interval/intersects? i (-k this))
-                    (accum this))
-                  (when (and (not (leaf? (-l this)))
-                             (order/compare<= (interval/a i) (-> this -l -z)))
-                    (-> this -l srch))))]
-        (srch n)
-        @result))))
-
-(defn node-find-intervals [n i]
-  ((node-find-interval-fn i nil) n))
-
-(defn node-find-best-interval [n i pred]
-  ((node-find-interval-fn i pred) n))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Iteration and Accumulation
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; MAYBE: replace/refactor as `node-traverse`
-;;       options: forward/reverse, in-order/post-order/pre-order
-
-(defn node-iter
-  "For the side-effect, apply f to each node of the tree rooted at n."
-  [n f]
-  (when-not (leaf? n)
-    (lr [l r] n
-      (node-iter l f)
-      (f n)
-      (node-iter r f))))
-
-(defn node-iter-reverse
-  "For the side-effect, apply f to each node of the tree rooted at n."
-  [n f]
-  (when-not (leaf? n)
-    (lr [l r] n
-      (node-iter-reverse r f)
-      (f n)
-      (node-iter-reverse l f))))
-
-(defn- node-fold-fn [dir]
-  (let [[enum-fn next-fn] (case dir
-                            :< [node-enumerator node-enum-rest]
-                            :> [node-enumerator-reverse node-enum-prior])]
-    (fn [f base n]
-      (loop [e (enum-fn n) acc base]
-        (if (nil? e)
-          acc
-          (let [res (f acc (node-enum-first e))]
-            (if (reduced? res) @res
-                (recur (next-fn e) res))))))))
-
-(defn node-fold-left
-  "Fold-left (reduce) the collection from least to greatest."
-  ([f n]      (node-fold-left f nil n))
-  ([f base n] ((node-fold-fn :<) f base n)))
-
-(defn node-fold-right
-  "Fold-right (reduce) the collection from greatest to least."
-  ([f n] (node-fold-right f nil n))
-  ([f base n] ((node-fold-fn :>) f base n)))
-
-;; MAYBE: i'm not convinced these are necessary
-
-(defn- node-fold*-fn [dir]
-  (let [iter-fn (case dir
-                  :< node-iter
-                  :> node-iter-reverse)]
-    (fn [f base n]
-      (let [acc (volatile! base)
-            fun #(vswap! acc f %)]
-     (iter-fn n fun)
-     @acc))))
-
-(defn- node-fold-left*
-  "eager left reduction of the tree rooted at n. does not support clojure.core/reduced."
-  ([f n] (node-fold-left* f nil n))
-  ([f base n] ((node-fold*-fn :<) f base n)))
-
-(defn- node-fold-right*
-  "eager right reduction of the tree rooted at n. does not support clojure.core/reduced."
-  ([f n] (node-fold-right* f nil n))
-  ([f base n] ((node-fold*-fn :>) f base n)))
-
-(defn node-filter
-  "return a tree with all nodes of n satisfying predicate p."
-  [p n]
-  (node-fold-left* (fn [x y]
-                      (if (p y)
-                        x
-                        (node-remove x (-k y))))
-                    n n))
-
-(defn node-invert
-  "return a tree in which the keys and values of n are reversed."
-  [n]
-  (node-fold-left* (fn [acc x]
-                      (node-add acc (-v x) (-k x)))
-                   (leaf) n))
-
-(defn node-healthy?
-  "verify node `n` and all descendants satisfy the node-invariants
-  of a weight-balanced binary tree."
-  [n]
-  (or (leaf? n)
-      (lr [l r] n
-        (let [lw (node-weight l)
-              rw (node-weight r)]
-          (and
-            (<= (max lw rw) (* +delta+ (min lw rw)))
-            (node-healthy? l)
-            (node-healthy? r))))))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Tree Splitting (Logarithmic Time)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn node-split-lesser
-  "return a tree of all nodes whose key is less than k (Logarithmic time)."
-  [n k]
-  (if (leaf? n)
-    n
-    (kvlr [kn vn ln rn] n
-      (case (order/compare k kn)
-        -1 (recur ln k)
-        +1 (node-concat3 kn vn ln
-             (node-split-lesser rn k))
-         0 ln))))
-
-(defn node-split-greater
-  "return a tree of all nodes whose key is greater than k (Logarithmic time)."
-  [n k]
-  (if (leaf? n)
-    n
-    (kvlr [kn vn ln rn] n
-      (case (order/compare k kn)
-        -1 (node-concat3 kn vn
-             (node-split-greater ln k) rn)
-        +1 (recur rn k)
-         0 rn))))
-
-(defn node-split
-  "returns a triple (l present r) where: l is the set of elements of
-  n that are < k, r is the set of elements of n that are > k, present
-  is false if n contains no element equal to k, or (k v) if n contains
-  an element with key equal to k."
-  [n k]
-  (if (leaf? n)
-    [nil nil nil]
-    (kvlr [ak v l r] n
-      (case (order/compare k ak)
-        0  [l (list k v) r]
-        -1 (let [[ll pres rl] (node-split l k)]
-             [ll pres (node-concat3 ak v rl r)])
-        +1 (let [[lr pres rr] (node-split r k)]
-             [(node-concat3 ak v l lr) pres rr])))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Tree Comparator (Worst-Case Linear Time)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn node-compare
-  "return 3-way comparison of the trees n1 and n2 using an accessor
-  to compare specific node consitituent values: :k, :v, :kv, or any
-  user-specifed function.  Default, when not specified, to the
-  entire node structure. return-value semantics:
-   -1  -> n1 is LESS-THAN    n2
-    0  -> n1 is EQUAL-TO     n2
-   +1  -> n1 is GREATER-THAN n2"
-  [accessor n1 n2]
-  (let [acc-fn (cond-> accessor
-                 (not (fn? accessor)) node-accessor)]
-    (loop [e1 (node-enumerator n1 nil)
-           e2 (node-enumerator n2 nil)]
-      (cond
-        (and (nil? e1) (nil? e2))  0
-        (nil? e1)                 -1
-        (nil? e2)                  1
-        true                       (let [[x1 r1 ee1] e1
-                                         [x2 r2 ee2] e2
-                                         c (order/compare (acc-fn x1) (acc-fn x2))]
-                                     (if-not (zero? c)
-                                       c
-                                       (recur
-                                         (node-enumerator r1 ee1)
-                                         (node-enumerator r2 ee2))))))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Fundamental Set Operations (Worst-Case Linear Time)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn node-set-union
-  "set union"
-  [n1 n2]
-  (cond
-    (leaf? n1) n2
-    (leaf? n2) n1
-    true       (kvlr [ak av l r] n2
-                 (let [[l1 _ r1] (node-split n1 ak)]
-                   (node-concat3 ak av
-                     (node-set-union l1 l)
-                     (node-set-union r1 r))))))
-
-(defn node-set-intersection
-  "set intersection"
-  [n1 n2]
-  (cond
-    (leaf? n1) (leaf)
-    (leaf? n2) (leaf)
-    true       (kvlr [ak av l r] n2
-                 (let [[l1 x r1] (node-split n1 ak)]
-                   (if x
-                     (node-concat3 ak av
-                       (node-set-intersection l1 l)
-                       (node-set-intersection r1 r))
-                     (node-concat2
-                       (node-set-intersection l1 l)
-                       (node-set-intersection r1 r)))))))
-
-(defn node-set-difference [n1 n2]
-  "set difference"
-  (cond
-    (leaf? n1) (leaf)
-    (leaf? n2) n1
-    true       (kvlr [ak _ l r] n2
-                 (let  [[l1 _ r1] (node-split n1 ak)]
-                   (node-concat2
-                     (node-set-difference l1 l)
-                     (node-set-difference r1 r))))))
-
-(defn node-subset?
-  "return true if `sub` is a subset of `super`"
-  [super sub]
-  (letfn [(subset? [n1 n2]
-            (or (leaf? n1)
-              (and (<= (node-size n1) (node-size n2))
-                (kvlr [k1 _ l1 r1] n1
-                  (kvlr [k2 _ l2 r2] n2
-                    (case (order/compare k1 k2)
-                      -1 (and
-                           (subset?   l1 l2)
-                           (node-find n2 k1)
-                           (subset?   r1 n2))
-                      1  (and
-                           (subset?   r1 r2)
-                           (node-find n2 k1)
-                           (subset?   l1 n2))
-                      (and
-                        (subset? l1 l2)
-                        (subset? r1 r2))))))))]
-    (or (leaf? sub) (boolean (subset? sub super)))))
-
-(def node-set-compare (partial node-compare :k))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Fundamental Map Operations (Worst-Case Linear Time)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; TODO: adjust this
-
-(defn node-map-merge
-  "Merge two maps in worst case linear time."
-  [n1 n2 merge-fn]
-  (cond
-    (leaf? n1) n2
-    (leaf? n2) n1
-    true       (kvlr [ak av l r] n2
-                 (let [[l1 x r1] (node-split n1 ak)
-                       val       (if x
-                                   (merge-fn ak av (-v x))
-                                   av)]
-                   (node-concat3 ak val
-                     (node-map-merge l1 l)
-                     (node-map-merge r1 r))))))
-
-(def node-map-compare (partial node-compare :kv))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Fundamental Vector Operations
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn node-nth
-  "Return nth node from the beginning of the ordered tree rooted at n.
-   (Logarithmic Time)"
-  [n ^long index]
-  (letfn [(srch [n ^long index]
-            (lr [l r] n
-              (let [lsize (node-size l)]
-                (cond
-                  (< index lsize) (recur l index)
-                  (> index lsize) (recur r (- index (inc lsize)))
-                  true            n))))]
-    (if-not (and (<= 0 index) (< index (node-size n)))
-      (throw (ex-info "index out of range" {:i index :max (node-size n)}))
-      (srch n (long index)))))
-
-(defn node-rank
-  "Return the rank (sequential position) of a given KEY within the
-  ordered tree rooted at n. (Logarithmic Time)"
-  [n k]
-  (letfn [(srch [n k ^long rank]
-            (if-not (leaf? n)
-              (case (order/compare k (-k n))
-              -1 (recur (-l n) k rank)
-              +1 (recur (-r n) k (+ 1 rank (node-size (-l n))))
-              (+ rank (node-size (-l n))))))]
-    (srch n k 0)))
-
-;; MAYBE: other splits? <= < > ?
-
-(defn node-split-nth
-  "return a tree of all nodes whose position is >= i. (Logarithmic Time)"
-  [n ^long i]
-  (if-not (pos? i)
-    n
-    (->> i dec (node-nth n) -k (node-split-greater n))))
-
-(defn node-vec
-  "Eagerly return a vector of all nodes in tree rooted at n in
-  the specified order, optionally using an accessor to extract
-  specific node consitituent values: :k, :v, :kv, or any
-  user-specifed function.  Default, when not specified, to the
-  entire node structure."
-  [n & {:keys [accessor reverse?]}]
-  (let [acc   (transient [])
-        fold  (if reverse? node-fold-right* node-fold-left*)
-        nval  (cond-> accessor
-                (not (fn? accessor)) node-accessor)]
-    (fold #(conj! %1 (nval %2)) acc n)
-    (persistent! acc)))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Fundamental Seq Operations
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn- node-seq-fn [dir]
-  (let [next-fn (case dir
-                  :< node-enum-rest
-                  :> node-enum-prior)]
-    (fn seq-fn [enum]
-      (lazy-seq
-        (when-not (nil? enum)
-          (cons (node-enum-first enum)
-                (seq-fn (next-fn enum))))))))
-
-(defn node-seq
-  "Return a (lazy) seq of nodes in tree rooted at n in the order they occur.
-   (Logarithmic Time)"
-  [n]
-  ((node-seq-fn :<) (node-enumerator n)))
-
-(defn node-seq-reverse
-  "Return a (lazy) seq of nodes in tree rooted at n in reverse order."
-  [n]
-  ((node-seq-fn :>) (node-enumerator-reverse n)))
-
-(defn node-subseq
-  "Return a (lazy) seq of nodes for the slice of the tree beginning
-  at position `from` ending at `to`."
-  ([n from]
-   (node-subseq n from (node-size n)))
-  ([n ^long from ^long to]
-   (let [cnt (inc (- to from))]
-     (cond
-       (leaf? n)        nil
-       (not (pos? cnt)) nil
-       true (->> from (node-split-nth n) node-seq (take cnt))))))
-
-(defn node-chunked-fold
-  "Parallel chunked fold mechansim to suport clojure.core.reducers/CollFold"
-  [^long i n combinef reducef]
-  {:pre [(pos? i)]}
-  (let [offsets (vec (range 0 (node-size n) i))
-        chunk   (fn [^long offset] (node-subseq n offset (dec (+ offset i))))
-        rf      (fn [_ ^long offset] (r/reduce reducef (combinef) (chunk offset)))]
-    (r/fold 1 combinef rf offsets)))
diff --git a/src/ordered_collections/core.clj b/src/ordered_collections/core.clj
new file mode 100644
index 0000000..ac2e421
--- /dev/null
+++ b/src/ordered_collections/core.clj
@@ -0,0 +1,1080 @@
+(ns ordered-collections.core
+  "Public API for ordered-collections."
+  (:refer-clojure :exclude [split-at])
+  (:require [clojure.core.reducers                         :as r]
+            [ordered-collections.types.interop]
+            [ordered-collections.kernel.interval             :as interval]
+            [ordered-collections.kernel.node                 :as node]
+            [ordered-collections.kernel.order                :as order]
+            [ordered-collections.kernel.tree                 :as tree]
+            [ordered-collections.types.fuzzy-map           :as fuzzy-map]
+            [ordered-collections.types.fuzzy-set           :as fuzzy-set]
+            [ordered-collections.types.interval-map        :refer [->IntervalMap]]
+            [ordered-collections.types.interval-set        :refer [->IntervalSet]]
+            [ordered-collections.types.ordered-map         :refer [->OrderedMap]
+                                                                    :as omap]
+            [ordered-collections.types.ordered-multiset    :as multiset]
+            [ordered-collections.types.ordered-set         :refer [->OrderedSet]]
+            [ordered-collections.types.priority-queue      :as pq]
+            [ordered-collections.types.range-map           :as rmap]
+            [ordered-collections.types.rope               :as rope]
+            [ordered-collections.types.segment-tree        :as segtree]
+            [ordered-collections.protocol                  :as proto]
+            [ordered-collections.util                      :refer [defalias]])
+  (:import  [ordered_collections.types.ordered_map OrderedMap]
+            [ordered_collections.types.ordered_set OrderedSet]
+            [ordered_collections.kernel.root INodeCollection IOrderedCollection IBalancedCollection]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Comparators
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defalias long-compare
+  "Specialized java.util.Comparator for Long keys.
+   Uses Long/compare directly for ~15-25% faster comparisons than default."
+  order/long-compare)
+
+(defalias double-compare
+  "Specialized java.util.Comparator for Double keys.
+   Uses Double/compare directly for faster numeric comparisons."
+  order/double-compare)
+
+(defalias string-compare
+  "Specialized java.util.Comparator for String keys.
+   Uses String.compareTo directly for faster string comparisons."
+  order/string-compare)
+
+(defalias general-compare
+  "General-purpose java.util.Comparator that provides a deterministic total
+   order over all values, including types that clojure.core/compare does not
+   order (such as Namespace and Var).
+
+   Use with ordered-set-with / ordered-map-with:
+     (ordered-set-with general-compare (all-ns))
+     (ordered-map-with general-compare [[#'clojure.core/map :map]])
+
+   Expect roughly 20% slower lookups compared to the default comparator on
+   Comparable types. Set algebra overhead is smaller and masked by parallelism
+   at scale."
+  order/general-compare)
+
+(defalias compare-by
+  "Given a predicate that defines a total order (e.g., <), return a java.util.Comparator.
+   Example: (compare-by <) returns a comparator for ascending order."
+  order/compare-by)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Set Algebra
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defalias union
+  "Return a set that is the union of the input sets.
+
+   For ordered-sets: Uses Adams' divide-and-conquer algorithm with parallel
+   execution for large sets. In the current benchmark suite, roughly 4-20x
+   faster than clojure.set/union on the tested workloads.
+
+   Complexity: O(m log(n/m + 1)) where m <= n
+
+   Examples:
+     (union (ordered-set [1 2]) (ordered-set [2 3]))  ; #{1 2 3}
+     (union s1 s2 s3)                                  ; multiple sets"
+  proto/union)
+
+(defalias intersection
+  "Return a set that is the intersection of the input sets.
+
+   For ordered-sets: Uses Adams' divide-and-conquer algorithm with parallel
+   execution for large sets. In the current benchmark suite, roughly 4-17x
+   faster than clojure.set/intersection on the tested workloads.
+
+   Complexity: O(m log(n/m + 1)) where m <= n
+
+   Examples:
+     (intersection (ordered-set [1 2 3]) (ordered-set [2 3 4]))  ; #{2 3}"
+  proto/intersection)
+
+(defalias difference
+  "Return a set that is s1 without elements in s2.
+
+   For ordered-sets: Uses Adams' divide-and-conquer algorithm with parallel
+   execution for large sets. In the current benchmark suite, roughly 5-24x
+   faster than clojure.set/difference on the tested workloads.
+
+   Complexity: O(m log(n/m + 1)) where m <= n
+
+   Examples:
+     (difference (ordered-set [1 2 3]) (ordered-set [2]))  ; #{1 3}"
+  proto/difference)
+
+(defalias subset?
+  "True if s1 is a subset of s2 (every element of s1 is in s2).
+
+   Examples:
+     (subset? (ordered-set [1 2]) (ordered-set [1 2 3]))  ; true
+     (subset? (ordered-set [1 4]) (ordered-set [1 2 3]))  ; false"
+  proto/subset?)
+
+(defalias superset?
+  "True if s1 is a superset of s2 (s1 contains every element of s2).
+
+   Examples:
+     (superset? (ordered-set [1 2 3]) (ordered-set [1 2]))  ; true"
+  proto/superset?)
+
+(defalias disjoint?
+  "True if s1 and s2 share no elements.
+   Short-circuits on the first common element found.
+
+   Examples:
+     (disjoint? (ordered-set [1 2 3]) (ordered-set [4 5 6]))  ; true
+     (disjoint? (ordered-set [1 2 3]) (ordered-set [3 4 5]))  ; false"
+  proto/disjoint?)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Set
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Parallel construction chunk size for batch operations.
+;; Parallel fold requires the collection to implement CollFold (e.g., vectors).
+;; Custom comparator functions (ordered-set-by, etc.) pass (seq coll) to force
+;; sequential construction, because dynamic bindings don't propagate to r/fold
+;; worker threads and the comparator would be lost.
+
+(def ^:private +chunk-size+ 2048)
+
+(defn- ordered-set* [compare-fn coll]
+  (binding [order/*compare* compare-fn]
+    (->OrderedSet
+      (r/fold +chunk-size+
+              (fn
+                ([]      (node/leaf))
+                ([n0 n1] (tree/node-set-union n0 n1))) tree/node-add coll)
+      compare-fn tree/node-create-weight-balanced tree/node-create-weight-balanced {})))
+
+(defn- ordered-set-prim*
+  "Variant of ordered-set* that uses primitive node types for numeric keys."
+  [compare-fn node-create coll]
+  (binding [order/*compare* compare-fn
+            tree/*t-join* node-create]
+    (->OrderedSet
+      (r/fold +chunk-size+
+              (fn
+                ([]      (node/leaf))
+                ([n0 n1] (tree/node-set-union n0 n1)))
+              (fn [n k] (tree/node-add n k k compare-fn node-create))
+              coll)
+      compare-fn node-create node-create {})))
+
+(defn ordered-set
+  "Create a persistent sorted set backed by a weight-balanced binary tree.
+
+   Drop-in replacement for clojure.core/sorted-set with these enhancements:
+   - O(log n) first/last via java.util.SortedSet (vs O(n) for sorted-set)
+   - O(log n) nth positional access
+   - Parallel r/fold (2.3x faster than sorted-set)
+   - 7-9x faster set operations (union, intersection, difference)
+
+   Elements are sorted by clojure.core/compare. For custom ordering,
+   use ordered-set-by. For numeric keys, use long-ordered-set.
+
+   Examples:
+     (ordered-set)                      ; empty set
+     (ordered-set [3 1 4 1 5 9])        ; #{1 3 4 5 9}
+     (first (ordered-set (range 1e6)))  ; 0, in O(log n)
+     (nth (ordered-set (range 100)) 50) ; 50, in O(log n)
+
+   Memory: ~64 bytes/element (vs ~61 for sorted-set, ~6% overhead)"
+  ([]
+   (ordered-set* order/normal-compare nil))
+  ([coll]
+   (ordered-set* order/normal-compare coll)))
+
+(defn ordered-set-by
+  "Create an ordered set with custom ordering via a predicate.
+
+   The predicate should define a total order (like < or >).
+
+   Examples:
+     (ordered-set-by > [1 2 3])  ; descending: #{3 2 1}
+     (ordered-set-by #(compare (count %1) (count %2)) [\"a\" \"bb\" \"ccc\"])"
+  [pred coll]
+  (-> pred order/compare-by (ordered-set* (seq coll))))
+
+(defn long-ordered-set
+  "Create an ordered set optimized for Long keys.
+   Uses primitive long storage and specialized Long.compare for maximum performance.
+   Typically 15-25% faster than ordered-set for numeric workloads."
+  ([]
+   (ordered-set-prim* order/long-compare tree/node-create-weight-balanced-long nil))
+  ([coll]
+   (ordered-set-prim* order/long-compare tree/node-create-weight-balanced-long coll)))
+
+(defn double-ordered-set
+  "Create an ordered set optimized for Double keys.
+   Uses primitive double storage and specialized Double.compare for faster comparisons."
+  ([]
+   (ordered-set-prim* order/double-compare tree/node-create-weight-balanced-double nil))
+  ([coll]
+   (ordered-set-prim* order/double-compare tree/node-create-weight-balanced-double coll)))
+
+(defn string-ordered-set
+  "Create an ordered set optimized for String keys.
+   Uses String.compareTo directly for faster string comparisons."
+  ([]
+   (ordered-set* order/string-compare nil))
+  ([coll]
+   (ordered-set* order/string-compare coll)))
+
+(defn ordered-set-with
+  "Create an ordered set with a custom java.util.Comparator.
+   For best performance, use a Comparator rather than a predicate.
+
+   Examples:
+     ;; Using a pre-built comparator
+     (ordered-set-with long-compare [1 2 3])
+
+     ;; Using compare-by with a predicate (slightly slower)
+     (ordered-set-with (compare-by >) [1 2 3])  ; descending order"
+  ([^java.util.Comparator comparator]
+   (ordered-set* comparator nil))
+  ([^java.util.Comparator comparator coll]
+   (ordered-set* comparator coll)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- ordered-map* [compare-fn coll]
+  (binding [order/*compare* compare-fn]
+    (->OrderedMap
+      (r/fold +chunk-size+
+              (fn
+                ([]      (node/leaf))
+                ([n0 n1] (tree/node-set-union n0 n1)))
+              (fn
+                ([n [k v]] (tree/node-add n k v))  ;; for seqs of pairs
+                ([n k v]   (tree/node-add n k v))) ;; for maps (kvreduce)
+              coll)
+      compare-fn tree/node-create-weight-balanced tree/node-create-weight-balanced {})))
+
+(defn- ordered-map-prim*
+  "Variant of ordered-map* that uses primitive node types for numeric keys."
+  [compare-fn node-create coll]
+  (binding [order/*compare* compare-fn
+            tree/*t-join* node-create]
+    (->OrderedMap
+      (r/fold +chunk-size+
+              (fn
+                ([]      (node/leaf))
+                ([n0 n1] (tree/node-set-union n0 n1)))
+              (fn
+                ([n [k v]] (tree/node-add n k v compare-fn node-create))
+                ([n k v]   (tree/node-add n k v compare-fn node-create)))
+              coll)
+      compare-fn node-create node-create {})))
+
+(defn ordered-map
+  "Create a persistent sorted map backed by a weight-balanced binary tree.
+
+   Drop-in replacement for clojure.core/sorted-map with these enhancements:
+   - O(log n) first/last via java.util.SortedMap (vs O(n) for sorted-map)
+   - O(log n) nth positional access
+   - Parallel r/fold (2.3x faster than sorted-map)
+   - Fast merge-with via ordered-merge-with
+
+   Keys are sorted by clojure.core/compare. For custom ordering,
+   use ordered-map-by. For numeric keys, use long-ordered-map.
+
+   Examples:
+     (ordered-map)                          ; empty map
+     (ordered-map [[3 :c] [1 :a] [2 :b]])   ; {1 :a, 2 :b, 3 :c}
+     (ordered-map {3 :c, 1 :a, 2 :b})       ; {1 :a, 2 :b, 3 :c}
+     (first (ordered-map (zipmap (range 1e6) (range))))  ; [0 0], in O(log n)
+
+   Memory: ~88 bytes/entry (vs ~85 for sorted-map, ~4% overhead)"
+  ([]
+   (ordered-map* order/normal-compare nil))
+  ([coll]
+   (ordered-map* order/normal-compare coll)))
+
+(defn ordered-map-by
+  "Create an ordered map with custom key ordering via a predicate.
+
+   The predicate should define a total order (like < or >).
+
+   Examples:
+     (ordered-map-by > [[1 :a] [2 :b]])  ; descending keys: {2 :b, 1 :a}"
+  [pred coll]
+  (-> pred order/compare-by (ordered-map* (seq coll))))
+
+(defn long-ordered-map
+  "Create an ordered map optimized for Long keys.
+   Uses primitive long storage and specialized Long.compare for maximum performance.
+   Typically 15-25% faster than ordered-map for numeric workloads."
+  ([]
+   (ordered-map-prim* order/long-compare tree/node-create-weight-balanced-long nil))
+  ([coll]
+   (ordered-map-prim* order/long-compare tree/node-create-weight-balanced-long coll)))
+
+(defn double-ordered-map
+  "Create an ordered map optimized for Double keys.
+   Uses primitive double storage and specialized Double.compare for faster comparisons."
+  ([]
+   (ordered-map-prim* order/double-compare tree/node-create-weight-balanced-double nil))
+  ([coll]
+   (ordered-map-prim* order/double-compare tree/node-create-weight-balanced-double coll)))
+
+(defn string-ordered-map
+  "Create an ordered map optimized for String keys.
+   Uses String.compareTo directly for faster string comparisons."
+  ([]
+   (ordered-map* order/string-compare nil))
+  ([coll]
+   (ordered-map* order/string-compare coll)))
+
+(defn ordered-map-with
+  "Create an ordered map with a custom java.util.Comparator.
+   For best performance, use a Comparator rather than a predicate.
+
+   Examples:
+     ;; Using a pre-built comparator
+     (ordered-map-with long-compare [[1 :a] [2 :b]])
+
+     ;; Using compare-by with a predicate (slightly slower)
+     (ordered-map-with (compare-by >) {1 :a 2 :b})  ; descending key order"
+  ([^java.util.Comparator comparator]
+   (ordered-map* comparator nil))
+  ([^java.util.Comparator comparator coll]
+   (ordered-map* comparator coll)))
+
+(defalias assoc-new
+  "Associate key with value only if key is not already present.
+   Returns the new collection with the key added, or the original
+   collection unchanged if the key already exists.
+
+   Example:
+     (assoc-new m :new-key :value)  ; => {... :new-key :value}
+     (assoc-new m :existing-key :v) ; => m (unchanged)"
+  proto/assoc-new)
+
+(defalias ordered-merge-with
+  "Merge ordered maps with a function to resolve conflicts.
+   When the same key appears in multiple maps, (f key val-in-result val-in-latter) is called.
+   Uses the same conservative fork-join threshold as ordered-set algebra for
+   large compatible ordered-maps.
+
+   Examples:
+     (ordered-merge-with (fn [k a b] (+ a b)) m1 m2)
+     (ordered-merge-with (fn [k a b] b) m1 m2 m3)  ; last-wins"
+  omap/ordered-merge-with)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn interval-map
+  "Create an interval map from [interval value] entries.
+   Intervals are [lo hi] pairs. Supports O(log n + k) overlap queries.
+
+   Query by invoking as a function:
+     (imap point)       — entries whose interval contains point
+     (imap [lo hi])     — entries overlapping the range
+
+   Examples:
+     (interval-map [[[1 5] :a] [[3 8] :b]])
+     (def imap (interval-map [[[0 10] \"x\"] [[5 20] \"y\"]]))
+     (imap 7)         ; => [[[0 10] \"x\"] [[5 20] \"y\"]]
+     (imap [11 15])   ; => [[[5 20] \"y\"]]"
+  ([]
+   (interval-map nil))
+  ([coll]
+   (let [cmp   order/normal-compare
+         alloc tree/node-create-weight-balanced-interval]
+     (->IntervalMap
+       (binding [tree/*t-join*   alloc
+                 order/*compare* cmp]
+         (reduce (fn [n [k v]] (tree/node-add n (interval/ordered-pair k) v cmp alloc))
+                 (node/leaf)
+                 coll))
+       cmp alloc nil {}))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Set
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn interval-set
+  "Create an interval set from intervals or points.
+   Intervals are [lo hi] pairs; bare values become [x x] point intervals.
+   Supports O(log n + k) overlap queries.
+
+   Query by invoking as a function:
+     (iset point)       — intervals containing point
+     (iset [lo hi])     — intervals overlapping the range
+
+   Examples:
+     (interval-set [[1 3] [2 4] [5 9]])
+     (def iset (interval-set [[0 10] [5 20]]))
+     (iset 7)         ; => [[0 10] [5 20]]
+     (iset [11 15])   ; => [[5 20]]"
+  ([]
+   (interval-set nil))
+  ([coll]
+   (let [cmp   order/normal-compare
+         alloc tree/node-create-weight-balanced-interval]
+     (->IntervalSet
+       (binding [tree/*t-join*   alloc
+                 order/*compare* cmp]
+         (reduce (fn [n k] (tree/node-add n (interval/ordered-pair k) (interval/ordered-pair k) cmp alloc))
+                 (node/leaf)
+                 coll))
+       cmp alloc nil {}))))
+
+(defalias overlapping
+  "Return all intervals overlapping the given point or interval.
+   Works with interval-set and interval-map.
+
+   For interval-set: returns seq of intervals
+   For interval-map: returns seq of [interval value] entries
+
+   Example:
+     (overlapping iset 5)           ; intervals containing point 5
+     (overlapping iset [3 7])       ; intervals overlapping range [3,7]
+     (overlapping imap 5)           ; entries for intervals containing 5"
+  proto/overlapping)
+
+(defalias span
+  "Return [min max] covering all elements, or nil if empty.
+   Works with interval-set, interval-map, and range-map.
+
+   Examples:
+     (span (interval-set [[1 5] [3 8] [10 15]]))          ; => [1 15]
+     (span (range-map [[[100 200] :a] [[500 600] :b]]))   ; => [100 600]"
+  proto/span)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Priority Queue
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn priority-queue
+  "Create a persistent priority queue from [priority value] pairs.
+
+  Supports O(log n) push/peek/pop operations, plus parallel fold.
+  Priorities are ordered by clojure.core/compare (natural ordering).
+  For custom ordering, use priority-queue-by or priority-queue-with.
+
+  Examples:
+    (priority-queue)
+    (priority-queue [[1 :urgent] [5 :low] [3 :medium]])
+    (priority-queue [[\"beta\" :b] [\"alpha\" :a]])"
+  ([] (pq/priority-queue))
+  ([pairs] (pq/priority-queue pairs)))
+
+(defn priority-queue-by
+  "Create a priority queue with custom ordering via a predicate.
+
+  Examples:
+    (priority-queue-by > [[1 :a] [3 :c] [2 :b]])  ; max-heap
+    (priority-queue-by > [])                         ; empty max-heap"
+  [pred pairs]
+  (pq/priority-queue-by pred pairs))
+
+(defn priority-queue-with
+  "Create a priority queue with a custom java.util.Comparator for priorities.
+
+  Examples:
+    (priority-queue-with long-compare [[1 :a] [2 :b]])
+    (priority-queue-with string-compare)"
+  ([^java.util.Comparator comparator]
+   (pq/priority-queue-with comparator))
+  ([^java.util.Comparator comparator pairs]
+   (pq/priority-queue-with comparator pairs)))
+
+(defalias push
+  "Add an element to a priority queue with the given priority.
+  (push pq priority value) => new-pq
+
+  Example:
+    (push pq 1 :urgent)"
+  pq/push)
+
+(defalias push-all
+  "Add multiple [priority value] pairs to a priority queue.
+  (push-all pq [[p1 v1] [p2 v2]]) => new-pq"
+  pq/push-all)
+
+(defalias peek-min
+  "Return [priority value] of the first element in queue order.
+  (peek-min pq) => [priority value] or nil"
+  pq/peek-min)
+
+(defalias peek-min-val
+  "Return just the value (not priority) of the first element in queue order.
+  (peek-min-val pq) => value or nil
+
+  Note: (peek-min pq) returns [priority value]."
+  pq/peek-min-val)
+
+(defalias pop-min
+  "Remove the first element in queue order.
+  Returns the queue unchanged if empty.
+  (pop-min pq) => new-pq"
+  pq/pop-min)
+
+(defalias peek-max
+  "Return [priority value] of the last element in queue order.
+  (peek-max pq) => [priority value] or nil"
+  pq/peek-max)
+
+(defalias peek-max-val
+  "Return just the value of the last element in queue order.
+  (peek-max-val pq) => value or nil"
+  pq/peek-max-val)
+
+(defalias pop-max
+  "Remove the last element in queue order.
+  Returns the queue unchanged if empty.
+  (pop-max pq) => new-pq"
+  pq/pop-max)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Multiset
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn ordered-multiset
+  "Create an ordered multiset (sorted bag) from a collection.
+  Unlike ordered-set, allows duplicate elements.
+
+  Supports O(log n) add/remove, nth access, and parallel fold.
+
+  Examples:
+    (ordered-multiset)                                ; empty multiset
+    (ordered-multiset [3 1 4 1 5 9 2 6 5 3 5])
+    ;; => #OrderedMultiset[1 1 2 3 3 4 5 5 5 6 9]"
+  ([] (multiset/ordered-multiset))
+  ([coll]
+   (multiset/ordered-multiset coll)))
+
+(defn ordered-multiset-by
+  "Create an ordered multiset with custom ordering via a predicate.
+
+  Example:
+    (ordered-multiset-by > [3 1 4 1 5])"
+  [pred coll]
+  (multiset/ordered-multiset-by pred coll))
+
+(defn ordered-multiset-with
+  "Create an ordered multiset with a custom java.util.Comparator.
+
+  Example:
+    (ordered-multiset-with long-compare [3 1 4 1 5])"
+  ([^java.util.Comparator comparator]
+   (multiset/ordered-multiset-with comparator))
+  ([^java.util.Comparator comparator coll]
+   (multiset/ordered-multiset-with comparator coll)))
+
+(defalias multiplicity
+  "Return the number of occurrences of x in a multiset.
+  (multiplicity ms x) => count"
+  multiset/multiplicity)
+
+(defalias disj-one
+  "Remove one occurrence of x from a multiset.
+  (disj-one ms x) => new-ms"
+  multiset/disj-one)
+
+(defalias disj-all
+  "Remove all occurrences of x from a multiset.
+  (disj-all ms x) => new-ms"
+  multiset/disj-all)
+
+(defalias distinct-elements
+  "Return a lazy seq of distinct elements in sorted order.
+  (distinct-elements ms) => seq"
+  multiset/distinct-elements)
+
+(defalias element-frequencies
+  "Return a map of {element -> count} for all elements.
+  (element-frequencies ms) => map"
+  multiset/element-frequencies)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fuzzy Set
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn fuzzy-set
+  "Create a fuzzy set that returns the closest element to a query.
+
+   When looking up a value, returns the element in the set that is closest
+   to the query. For numeric keys, distance is |query - element|.
+
+   Options:
+     :tiebreak - :< (prefer smaller, default) or :> (prefer larger) when equidistant
+     :distance - custom distance function (fn [a b] -> number)
+
+   Examples:
+     (def fs (fuzzy-set [1 5 10 20]))
+     (fs 7)   ; => 5 (closest to 7)
+     (fs 15)  ; => 10 or 20 depending on tiebreak
+
+     ;; With tiebreak
+     (def fs (fuzzy-set [1 5 10 20] :tiebreak :>))
+     (fs 15)  ; => 20 (prefer larger when equidistant)
+
+     ;; With custom distance
+     (def fs (fuzzy-set [\"apple\" \"banana\" \"cherry\"]
+               :distance (fn [a b] (Math/abs (- (count a) (count b))))))
+     (fs \"pear\")  ; => closest by string length"
+  [coll & {:keys [tiebreak distance] :or {tiebreak :< distance fuzzy-set/numeric-distance}}]
+  (binding [order/*compare* order/normal-compare]
+    (fuzzy-set/->FuzzySet
+      (r/fold +chunk-size+
+              (fn
+                ([]      (node/leaf))
+                ([n0 n1] (tree/node-set-union n0 n1)))
+              (fn [n k] (tree/node-add n k k))
+              coll)
+      order/normal-compare
+      distance
+      tiebreak
+      {})))
+
+(defn fuzzy-set-by
+  "Create a fuzzy set with a custom comparator.
+
+   Example:
+     (fuzzy-set-by > [1 5 10 20])  ; reverse order"
+  [comparator coll & {:keys [tiebreak distance] :or {tiebreak :< distance fuzzy-set/numeric-distance}}]
+  (let [cmp (order/compare-by comparator)]
+    (binding [order/*compare* cmp]
+      (fuzzy-set/->FuzzySet
+        (r/fold +chunk-size+
+                (fn
+                  ([]      (node/leaf))
+                  ([n0 n1] (tree/node-set-union n0 n1)))
+                (fn [n k] (tree/node-add n k k))
+                coll)
+        cmp
+        distance
+        tiebreak
+        {}))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fuzzy Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn fuzzy-map
+  "Create a fuzzy map that returns the value for the closest key.
+
+   When looking up a key, returns the value for the key in the map that is
+   closest to the query. For numeric keys, distance is |query - key|.
+
+   Options:
+     :tiebreak - :< (prefer smaller, default) or :> (prefer larger) when equidistant
+     :distance - custom distance function (fn [a b] -> number)
+
+   Examples:
+     (def fm (fuzzy-map {0 :zero 10 :ten 100 :hundred}))
+     (fm 7)   ; => :ten (closest key to 7 is 10)
+     (fm 42)  ; => :ten (closest key to 42 is 10 or 100)
+
+     ;; With tiebreak
+     (def fm (fuzzy-map {0 :zero 10 :ten 100 :hundred} :tiebreak :>))
+     (fm 55)  ; => :hundred (prefer larger when equidistant)
+
+   The collection should be a map or sequence of [key value] pairs."
+  [coll & {:keys [tiebreak distance] :or {tiebreak :< distance fuzzy-set/numeric-distance}}]
+  (binding [order/*compare* order/normal-compare]
+    (fuzzy-map/->FuzzyMap
+      (r/fold +chunk-size+
+              (fn
+                ([]      (node/leaf))
+                ([n0 n1] (tree/node-set-union n0 n1)))
+              (fn
+                ([n [k v]] (tree/node-add n k v))  ;; for seqs of pairs
+                ([n k v]   (tree/node-add n k v))) ;; for maps (kvreduce)
+              coll)
+      order/normal-compare
+      distance
+      tiebreak
+      {})))
+
+(defn fuzzy-map-by
+  "Create a fuzzy map with a custom comparator.
+
+   Example:
+     (fuzzy-map-by > {1 :a 5 :b 10 :c})  ; reverse key order"
+  [comparator coll & {:keys [tiebreak distance] :or {tiebreak :< distance fuzzy-set/numeric-distance}}]
+  (let [cmp (order/compare-by comparator)]
+    (binding [order/*compare* cmp]
+      (fuzzy-map/->FuzzyMap
+        (r/fold +chunk-size+
+                (fn
+                  ([]      (node/leaf))
+                  ([n0 n1] (tree/node-set-union n0 n1)))
+                (fn
+                  ([n [k v]] (tree/node-add n k v))  ;; for seqs of pairs
+                  ([n k v]   (tree/node-add n k v))) ;; for maps (kvreduce)
+                coll)
+        cmp
+        distance
+        tiebreak
+        {}))))
+
+;; Re-export fuzzy-specific functions via protocol
+(defalias fuzzy-nearest
+  "Find the nearest element/entry and its distance.
+   For fuzzy-set: (fuzzy-nearest fs query) => [element distance]
+   For fuzzy-map: (fuzzy-nearest fm query) => [key value distance]"
+  proto/nearest-with-distance)
+
+(defalias fuzzy-exact-contains?
+  "Check if the fuzzy collection contains exactly the given element/key.
+   Unlike regular lookup, this does not do fuzzy matching."
+  proto/exact-contains?)
+
+(defalias fuzzy-exact-get
+  "Get the value for exactly the given key (no fuzzy matching).
+   Only for fuzzy-map."
+  proto/exact-get)
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Rank Operations (work on ordered-set, ordered-map, etc.)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn rank
+  "Return the 0-based index of element x, or nil if not present. O(log n).
+   Works on any collection implementing PRanked (ordered-set, ordered-map, etc.)."
+  [coll x]
+  (let [r (proto/rank-of coll x)]
+    (when-not (neg? r) r)))
+
+(defalias slice
+  "Return elements from index start (inclusive) to end (exclusive). O(log n + k).
+   Works on any collection implementing PRanked."
+  proto/slice)
+
+(defalias median
+  "Return the median element. O(log n).
+   Works on any collection implementing PRanked."
+  proto/median)
+
+(defalias percentile
+  "Return element at given percentile (0-100). O(log n).
+   Works on any collection implementing PRanked."
+  proto/percentile)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Range Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defalias range-map
+  "Create a map from non-overlapping ranges to values.
+
+   Unlike interval-map, ranges never overlap. Inserting a range removes
+   any overlapping portions of existing ranges.
+
+   Ranges are half-open: [lo, hi) includes lo but excludes hi.
+
+   Example:
+     (def rm (range-map {[0 10] :a [20 30] :b}))
+     (rm 5)            ; => :a
+     (rm 15)           ; => nil (gap)
+     (assoc rm [5 25] :c)  ; splits existing ranges"
+  rmap/range-map)
+
+(defalias ranges
+  "Return seq of [range value] pairs from a range-map."
+  proto/ranges)
+
+(defalias gaps
+  "Return a seq of [lo hi) ranges that have no mapping in a range-map."
+  proto/gaps)
+
+(defalias assoc-coalescing
+  "Insert range with coalescing. Adjacent ranges with the same value
+   are automatically merged. Equivalent to Guava's putCoalescing.
+
+   Use this instead of assoc when you want adjacent same-value ranges
+   to be merged into a single range.
+
+   Example:
+     (-> (range-map)
+         (assoc-coalescing [0 100] :a)
+         (assoc-coalescing [100 200] :a))
+     ;; => single range [0 200) :a"
+  proto/assoc-coalescing)
+
+(defalias get-entry
+  "Return [range value] for the range containing point x, or nil.
+   Equivalent to Guava's getEntry(K).
+
+   Example:
+     (get-entry rm 50) ;; => [[0 100] :a]"
+  proto/get-entry)
+
+(defalias range-remove
+  "Remove all mappings in the given range [lo hi).
+   Any overlapping ranges are trimmed; ranges fully contained are removed.
+   Equivalent to Guava's remove(Range).
+
+   Example:
+     (range-remove rm [25 75])
+     ;; [0 100]:a becomes [0 25):a and [75 100):a"
+  proto/range-remove)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Segment Tree
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defalias segment-tree
+  "Create a segment tree for O(log n) range aggregate queries.
+
+   Arguments:
+     op       - associative operation (+, min, max, etc.)
+     identity - identity element (0 for +, Long/MAX_VALUE for min)
+     coll     - map or seq of [key value] pairs
+
+   Example:
+     (def st (segment-tree + 0 {0 10, 1 20, 2 30, 3 40}))
+     (query st 1 3)  ; => 90 (sum of indices 1,2,3)"
+  segtree/segment-tree)
+
+(defalias segment-tree-with
+  "Create a segment tree with a custom java.util.Comparator."
+  segtree/segment-tree-with)
+
+(defalias segment-tree-by
+  "Create a segment tree with a custom ordering predicate."
+  segtree/segment-tree-by)
+
+(defalias sum-tree
+  "Create a segment tree for range sums."
+  segtree/sum-tree)
+
+(defalias min-tree
+  "Create a segment tree for range minimum queries."
+  segtree/min-tree)
+
+(defalias max-tree
+  "Create a segment tree for range maximum queries."
+  segtree/max-tree)
+
+(defalias query
+  "Query the aggregate over key range [lo, hi] inclusive. O(log n).
+
+   Example:
+     (def st (segment-tree + 0 {0 10, 1 20, 2 30, 3 40}))
+     (query st 0 3)  ; => 100
+     (query st 1 2)  ; => 50"
+  proto/aggregate-range)
+
+(defalias aggregate
+  "Return the aggregate over the entire segment tree. O(1)."
+  proto/aggregate)
+
+(defalias update-val
+  "Update the value at index k. O(log n).
+
+   Example:
+     (def st (segment-tree + 0 {0 10, 1 20, 2 30}))
+     (def st' (update-val st 1 100))
+     (query st' 0 2)  ; => 140"
+  proto/update-val)
+
+(defalias update-fn
+  "Update the value at index k by applying f to the current value. O(log n).
+
+   Example:
+     (def st (segment-tree + 0 {0 10, 1 20, 2 30}))
+     (def st' (update-fn st 1 #(* % 2)))
+     (query st' 0 2)  ; => 80"
+  proto/update-fn)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Split and Range Operations (data.avl compatible)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn split-key
+  "Split collection at key k, returning [left entry right].
+
+   - left:  collection of elements less than k
+   - entry: the element/entry at k, or nil if not present
+            (for sets: the key itself; for maps: [key value])
+   - right: collection of elements greater than k
+
+   Complexity: O(log n)
+
+   Compatible with clojure.data.avl/split-key.
+
+   Example:
+     (split-key 3 (ordered-set [1 2 3 4 5]))
+     ;=> [#{1 2} 3 #{4 5}]
+
+     (split-key 2 (ordered-map [[1 :a] [2 :b] [3 :c]]))
+     ;=> [{1 :a} [2 :b] {3 :c}]"
+  [k coll]
+  (proto/split-key coll k))
+
+(defn split-at
+  "Split collection at index i, returning [left right].
+
+   - left:  collection of the first i elements (indices 0 to i-1)
+   - right: collection of remaining elements (indices i to n-1)
+
+   Complexity: O(log n)
+
+   Compatible with clojure.core/split-at and clojure.data.avl/split-at.
+
+   Example:
+     (split-at 2 (ordered-set [1 2 3 4 5]))
+     ;=> [#{1 2} #{3 4 5}]"
+  [i coll]
+  (proto/split-at coll i))
+
+(defn subrange
+  "Return a subcollection comprising elements in the given range.
+
+   Arguments:
+     (subrange coll test key)           - elements satisfying test relative to key
+     (subrange coll start-test start-key end-test end-key)
+
+   Tests: :< :<= :> :>=
+
+   Complexity: O(log n) to construct the subrange
+
+   Example:
+     (subrange (ordered-set (range 10)) :>= 3 :< 7)
+     ;=> #{3 4 5 6}
+
+     (subrange (ordered-set (range 10)) :> 5)
+     ;=> #{6 7 8 9}"
+  ([coll test key]
+   (proto/subrange coll test key))
+  ([coll start-test start-key end-test end-key]
+   (-> coll
+       (proto/subrange start-test start-key)
+       (proto/subrange end-test end-key))))
+
+(defn nearest
+  "Find the nearest element to key k satisfying the given test.
+
+   Tests:
+     :<  - greatest element less than k (predecessor)
+     :<= - greatest element less than or equal to k (floor)
+     :>= - least element greater than or equal to k (ceiling)
+     :>  - least element greater than k (successor)
+
+   Returns the element (for sets) or [key value] (for maps), or nil if none.
+
+   Complexity: O(log n)
+
+   Example:
+     (nearest (ordered-set [1 3 5 7 9]) :< 6)
+     ;=> 5
+
+     (nearest (ordered-set [1 3 5 7 9]) :>= 6)
+     ;=> 7
+
+     (nearest (ordered-map [[1 :a] [3 :b] [5 :c]]) :<= 4)
+     ;=> [3 :b]"
+  [coll test k]
+  (proto/nearest coll test k))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Rope
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defalias rope
+  "Create a persistent rope from a collection.
+
+   A rope is a chunked, tree-backed persistent sequence optimized for
+   structural editing: O(log n) concat, split, splice, insert, and remove.
+   Use a rope when you need to repeatedly edit the middle of a large
+   sequence. Use a vector for random-access-heavy workloads.
+
+   Supports nth, get, assoc, conj, peek, pop, seq, rseq, reduce,
+   r/fold, compare, java.util.List, and all standard Clojure sequence
+   operations.
+
+   Examples:
+     (rope [1 2 3 4 5])
+     (rope (range 100000))
+     (nth (rope (range 1000)) 500)  ;=> 500"
+  rope/rope)
+
+(defalias rope-concat
+  "Concatenate ropes or rope-coercible collections.
+   Two arguments: O(log n) binary tree join.
+   Three or more: O(total chunks) bulk construction.
+
+   Examples:
+     (rope-concat (rope [1 2 3]) (rope [4 5 6]))
+     ;=> #ordered/rope [1 2 3 4 5 6]
+     (rope-concat (rope [1 2]) (rope [3 4]) (rope [5 6]))
+     ;=> #ordered/rope [1 2 3 4 5 6]"
+  rope/rope-concat)
+
+(defalias rope-split
+  "Split a rope at element index i, returning [left right]. O(log n).
+
+   Examples:
+     (rope-split (rope (range 10)) 4)
+     ;=> [#ordered/rope [0 1 2 3] #ordered/rope [4 5 6 7 8 9]]"
+  proto/rope-split)
+
+(defalias rope-sub
+  "Extract a subrange [start, end) as a Rope. O(log n).
+   The result shares structure with the original.
+
+   Examples:
+     (rope-sub (rope (range 100)) 20 30)
+     ;=> #ordered/rope [20 21 22 23 24 25 26 27 28 29]"
+  proto/rope-sub)
+
+(defalias rope-insert
+  "Insert elements at index i. O(log n).
+
+   Examples:
+     (rope-insert (rope [0 1 2 3]) 2 [:a :b])
+     ;=> #ordered/rope [0 1 :a :b 2 3]"
+  proto/rope-insert)
+
+(defalias rope-remove
+  "Remove elements in range [start, end). O(log n).
+
+   Examples:
+     (rope-remove (rope (range 10)) 3 7)
+     ;=> #ordered/rope [0 1 2 7 8 9]"
+  proto/rope-remove)
+
+(defalias rope-splice
+  "Replace elements in range [start, end) with new content. O(log n).
+
+   Examples:
+     (rope-splice (rope (range 10)) 2 5 [:x :y])
+     ;=> #ordered/rope [0 1 :x :y 5 6 7 8 9]"
+  proto/rope-splice)
+
+(defalias rope-chunks
+  "Return a seq of the rope's internal chunk vectors."
+  proto/rope-chunks)
+
+(defalias rope-chunks-reverse
+  "Return a reverse seq of the rope's internal chunk vectors."
+  rope/rope-chunks-reverse)
+
+(defalias rope-chunk-count
+  "Return the number of chunks in the rope."
+  rope/rope-chunk-count)
+
+(defalias rope-str
+  "Efficiently convert a rope of characters/strings to a String via
+  StringBuilder. Much faster than (apply str r) for large ropes.
+
+   Examples:
+     (rope-str (rope (seq \"hello world\")))
+     ;=> \"hello world\""
+  proto/rope-str)
diff --git a/src/com/dean/interval_tree/tree/interval.clj b/src/ordered_collections/kernel/interval.clj
similarity index 83%
rename from src/com/dean/interval_tree/tree/interval.clj
rename to src/ordered_collections/kernel/interval.clj
index 7279d94..016eae7 100644
--- a/src/com/dean/interval_tree/tree/interval.clj
+++ b/src/ordered_collections/kernel/interval.clj
@@ -1,7 +1,8 @@
-(ns com.dean.interval-tree.tree.interval
-  (:require [com.dean.interval-tree.tree.order :as order])
+(ns ordered-collections.kernel.interval
+  (:require [ordered-collections.kernel.order :as order])
   (:import  [clojure.lang MapEntry PersistentVector]))
 
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Representation
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -53,8 +54,9 @@
   (order/<= (a i0) (a i1) (b i1) (b i0)))
 
 (defn intersects?
-  "returns true if there is any common point between intervals i0 and i1"
+  "returns true if there is any common point between intervals i0 and i1.
+  For closed intervals where a <= b is guaranteed (via ordered-pair),
+  this is equivalent to: a0 <= b1 AND a1 <= b0."
   [i0 i1]
-  (or (overlaps? i0 i1)
-      (includes? i0 i1)
-      (includes? i1 i0)))
+  (and (order/compare<= (a i0) (b i1))
+       (order/compare<= (a i1) (b i0))))
diff --git a/src/com/dean/interval_tree/tree/node.clj b/src/ordered_collections/kernel/node.clj
similarity index 55%
rename from src/com/dean/interval_tree/tree/node.clj
rename to src/ordered_collections/kernel/node.clj
index 6b1ff51..d0026c0 100644
--- a/src/com/dean/interval_tree/tree/node.clj
+++ b/src/ordered_collections/kernel/node.clj
@@ -1,6 +1,7 @@
-(ns com.dean.interval-tree.tree.node
+(ns ordered-collections.kernel.node
   (:import  [clojure.lang MapEntry]))
 
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Leaf Representation
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -45,6 +46,7 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (deftype SimpleNode [k v l r ^long x]
+  java.io.Serializable
   IBalancedNode
   (x  [_] x)
   INode
@@ -55,6 +57,7 @@
   (kv [_] (MapEntry. k v)))
 
 (deftype IntervalNode [k v l r ^long x z]
+  java.io.Serializable
   IBalancedNode
   (x  [_] x)
   IAugmentedNode
@@ -66,16 +69,62 @@
   (r  [_] r)
   (kv [_] (MapEntry. k v)))
 
+(deftype AggregateNode [k v l r ^long x agg]
+  java.io.Serializable
+  IBalancedNode
+  (x  [_] x)
+  IAugmentedNode
+  (z  [_] agg)     ;; cached subtree aggregate: op(left.agg, val, right.agg)
+  INode
+  (k  [_] k)
+  (v  [_] v)
+  (l  [_] l)
+  (r  [_] r)
+  (kv [_] (MapEntry. k v)))
+
+;; Primitive-specialized node types for better performance with numeric keys.
+;; These avoid boxing overhead for Long/Double keys.
+;;
+;; Academic justification: Boxing overhead for primitive comparisons can be
+;; 15-25% of total lookup time (see competitive-analysis.md). By storing
+;; the key as a primitive long, we eliminate:
+;;   1. Box allocation during insertion
+;;   2. Unboxing during comparison
+;;   3. GC pressure from boxed Long objects
+
+(deftype LongKeyNode [^long k v l r ^long x]
+  java.io.Serializable
+  IBalancedNode
+  (x  [_] x)
+  INode
+  (k  [_] k)
+  (v  [_] v)
+  (l  [_] l)
+  (r  [_] r)
+  (kv [_] (MapEntry. k v)))
+
+(deftype DoubleKeyNode [^double k v l r ^long x]
+  java.io.Serializable
+  IBalancedNode
+  (x  [_] x)
+  INode
+  (k  [_] k)
+  (v  [_] v)
+  (l  [_] l)
+  (r  [_] r)
+  (kv [_] (MapEntry. k v)))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Constitutent Accessors
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; @gunnarson style
 
-(definline -k  [n] `(.k  ~(with-meta n {:tag 'com.dean.interval_tree.tree.node.INode})))
-(definline -v  [n] `(.v  ~(with-meta n {:tag 'com.dean.interval_tree.tree.node.INode})))
-(definline -l  [n] `(.l  ~(with-meta n {:tag 'com.dean.interval_tree.tree.node.INode})))
-(definline -r  [n] `(.r  ~(with-meta n {:tag 'com.dean.interval_tree.tree.node.INode})))
-(definline -x  [n] `(.x  ~(with-meta n {:tag 'com.dean.interval_tree.tree.node.IBalancedNode})))
-(definline -z  [n] `(.z  ~(with-meta n {:tag 'com.dean.interval_tree.tree.node.IAugmentedNode})))
-(definline -kv [n] `(.kv ~(with-meta n {:tag 'com.dean.interval_tree.tree.node.INode})))
+(definline -k  [n] `(.k  ~(with-meta n {:tag 'ordered_collections.kernel.node.INode})))
+(definline -v  [n] `(.v  ~(with-meta n {:tag 'ordered_collections.kernel.node.INode})))
+(definline -l  [n] `(.l  ~(with-meta n {:tag 'ordered_collections.kernel.node.INode})))
+(definline -r  [n] `(.r  ~(with-meta n {:tag 'ordered_collections.kernel.node.INode})))
+(definline -x  [n] `(.x  ~(with-meta n {:tag 'ordered_collections.kernel.node.IBalancedNode})))
+(definline -z  [n] `(.z  ~(with-meta n {:tag 'ordered_collections.kernel.node.IAugmentedNode})))
+(definline -kv [n] `(.kv ~(with-meta n {:tag 'ordered_collections.kernel.node.INode})))
+
diff --git a/src/ordered_collections/kernel/order.clj b/src/ordered_collections/kernel/order.clj
new file mode 100644
index 0000000..13c7f99
--- /dev/null
+++ b/src/ordered_collections/kernel/order.clj
@@ -0,0 +1,212 @@
+(ns ordered-collections.kernel.order
+  (:refer-clojure :exclude [compare <= >= max])
+  (:import [java.util Comparator]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Comparator
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; All comparators implement java.util.Comparator for fast .compare dispatch.
+;; This avoids IFn invoke overhead (~5-10ns per call vs ~1-2ns for invokeinterface).
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Serializable Comparator Types
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Using deftype instead of reify so comparators are serializable.
+;; This enables Java serialization of collections that store these comparators.
+
+;; Each comparator type implements equals/hashCode based on type,
+;; so that equivalent comparators are considered equal after deserialization.
+
+(defn- first-nonzero
+  "Return the first non-zero value, or 0."
+  ^long [^long a ^long b ^long c ^long d]
+  (cond (not (zero? a)) a
+        (not (zero? b)) b
+        (not (zero? c)) c
+        :else           d))
+
+(defn- general-compare* ^long [x y]
+  (cond
+    (identical? x y) 0
+    (nil? x)        -1
+    (nil? y)        +1
+    (= x y)          0
+    :else
+    (let [cx (class x)
+          cy (class y)]
+      (if (identical? cx cy)
+        ;; Same class: prefer native ordering, fall back for non-Comparable.
+        ;; Numbers go through clojure.core/compare rather than .compareTo
+        ;; because compare handles Clojure's mixed-precision numeric tower
+        ;; (e.g. BigDecimal vs Long) more reliably than Comparable alone.
+        (cond
+          (instance? Number x)     (clojure.core/compare x y)
+          (instance? Comparable x) (.compareTo ^Comparable x y)
+          :else (first-nonzero (clojure.core/compare (str x) (str y))
+                               (clojure.core/compare (hash x) (hash y))
+                               (Integer/compare (System/identityHashCode x)
+                                                (System/identityHashCode y))
+                               0))
+        ;; Different classes: sort by class name, then by value.
+        ;; Cross-class Number check handles e.g. (compare 1 1.0) where
+        ;; Long and Double are different classes but numerically ordered.
+        (let [cn (clojure.core/compare (.getName ^Class cx) (.getName ^Class cy))]
+          (if-not (zero? cn)
+            cn
+            (if (and (instance? Number x) (instance? Number y))
+              (clojure.core/compare x y)
+              (first-nonzero (clojure.core/compare (str x) (str y))
+                             (clojure.core/compare (hash x) (hash y))
+                             (Integer/compare (System/identityHashCode x)
+                                              (System/identityHashCode y))
+                             0))))))))
+
+(deftype NormalComparator []
+  java.io.Serializable
+  Comparator
+  (compare [_ x y]
+    (clojure.core/compare x y))
+  Object
+  (equals [_ o] (instance? NormalComparator o))
+  (hashCode [_] 1))
+
+(deftype GeneralComparator []
+  java.io.Serializable
+  Comparator
+  (compare [_ x y]
+    (general-compare* x y))
+  Object
+  (equals [_ o] (instance? GeneralComparator o))
+  (hashCode [_] 5))
+
+(deftype LongComparator []
+  java.io.Serializable
+  Comparator
+  (compare [_ x y]
+    (Long/compare (long x) (long y)))
+  Object
+  (equals [_ o] (instance? LongComparator o))
+  (hashCode [_] 2))
+
+(deftype DoubleComparator []
+  java.io.Serializable
+  Comparator
+  (compare [_ x y]
+    (Double/compare (double x) (double y)))
+  Object
+  (equals [_ o] (instance? DoubleComparator o))
+  (hashCode [_] 3))
+
+(deftype StringComparator []
+  java.io.Serializable
+  Comparator
+  (compare [_ x y]
+    (.compareTo ^String x y))
+  Object
+  (equals [_ o] (instance? StringComparator o))
+  (hashCode [_] 4))
+
+(deftype PredicateComparator [pred]
+  java.io.Serializable
+  Comparator
+  (compare [_ x y]
+    (cond
+      (pred x y) -1
+      (pred y x) +1
+      :else       0))
+  Object
+  (equals [this o]
+    (and (instance? PredicateComparator o)
+         (= pred (.-pred ^PredicateComparator o))))
+  (hashCode [_] (hash pred)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Comparator Instances
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn compare-by
+  "Given a predicate that defines a total order over some domain,
+  return a three-way Comparator built from it.
+  Note: The predicate must be serializable for the comparator to be serializable."
+  ^Comparator [pred]
+  (->PredicateComparator pred))
+
+(def ^Comparator normal-compare
+  "Default comparator that delegates to clojure.core/compare.
+   For best numeric performance, use long-ordered-set/long-ordered-map."
+  (->NormalComparator))
+
+(def ^Comparator general-compare
+  "General-purpose comparator that provides a deterministic total order over
+   all values, including types that clojure.core/compare does not order (such
+   as Namespace and Var).
+
+   For Comparable values, delegates to clojure.core/compare. For non-Comparable
+   values, falls back to class name, then str, then hash ordering.
+
+   Use with ordered-set-with / ordered-map-with. Expect roughly 20% slower
+   lookups compared to the default comparator on Comparable types."
+  (->GeneralComparator))
+
+(def ^Comparator long-compare
+  "Specialized comparator for Long keys. Avoids type dispatch overhead of
+   clojure.core/compare for ~15-25% faster comparisons on numeric keys."
+  (->LongComparator))
+
+(def ^Comparator double-compare
+  "Specialized comparator for Double keys."
+  (->DoubleComparator))
+
+(def ^Comparator string-compare
+  "Specialized comparator for String keys. Uses String.compareTo directly."
+  (->StringComparator))
+
+(defn default-comparator?
+  "Returns true if cmp is one of the built-in comparators whose ordering
+   is equivalent to clojure.core/compare for its element type.
+   Used to determine if a collection can safely round-trip through EDN."
+  [cmp]
+  (or (instance? NormalComparator cmp)
+      (instance? LongComparator cmp)
+      (instance? StringComparator cmp)
+      (instance? DoubleComparator cmp)))
+
+(def ^:dynamic ^Comparator *compare* normal-compare)
+
+(defn compare ^long [x y]
+  (.compare ^Comparator *compare* x y))
+
+(defn compare<= [x y]
+  (not (pos? (compare x y))))
+
+(defn compare> [x y]
+  (pos? (compare x y)))
+
+(defn compare>= [x y]
+  (not (neg? (compare x y))))
+
+(defn max [x & args]
+  (reduce #(if (compare> %1 %2) %1 %2) x args))
+
+(defn <=
+  ([x] true)
+  ([x y] (compare<= x y))
+  ([x y & more]
+   (if (compare<= x y)
+     (if (next more)
+       (recur y (first more) (next more))
+       (compare<= y (first more)))
+     false)))
+
+(defn >=
+  ([x] true)
+  ([x y] (compare>= x y))
+  ([x y & more]
+   (if (compare>= x y)
+     (if (next more)
+       (recur y (first more) (next more))
+       (compare>= y (first more)))
+     false)))
diff --git a/src/com/dean/interval_tree/tree/root.clj b/src/ordered_collections/kernel/root.clj
similarity index 96%
rename from src/com/dean/interval_tree/tree/root.clj
rename to src/ordered_collections/kernel/root.clj
index 36d4a3e..7710592 100644
--- a/src/com/dean/interval_tree/tree/root.clj
+++ b/src/ordered_collections/kernel/root.clj
@@ -1,4 +1,5 @@
-(ns com.dean.interval-tree.tree.root)
+(ns ordered-collections.kernel.root)
+
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Root Container
diff --git a/src/ordered_collections/kernel/rope.clj b/src/ordered_collections/kernel/rope.clj
new file mode 100644
index 0000000..b144ed2
--- /dev/null
+++ b/src/ordered_collections/kernel/rope.clj
@@ -0,0 +1,1009 @@
+(ns ordered-collections.kernel.rope
+  "Chunked implicit-index rope helpers.
+
+  Rope trees are ordered by position, not by comparator. Each node stores a
+  chunk vector in the key slot and the total element count of the subtree in
+  the value slot. Weight balancing is still performed by node count, while the
+  subtree element counts support indexed operations.
+
+  Chunk Size Invariant (CSI)
+  ─────────────────────────
+  Every chunk has size in [min, target] except:
+    - If the rope has 0 chunks: the rope is empty (root is nil).
+    - If the rope has 1 chunk: the chunk may be any size in [1, target].
+    - If the rope has >= 2 chunks: only the rightmost chunk may be smaller
+      than min (the 'runt'). All other chunks must be in [min, target].
+
+  No chunk may exceed target.
+
+  This is analogous to a B-tree minimum fill factor. The rightmost exception
+  exists because conj (the most frequent growth operation) appends to the
+  rightmost chunk, so a short rightmost chunk is naturally filled by
+  subsequent appends.
+
+  CSI is maintained by:
+    - rope-concat:      position-aware boundary check + merge-boundary
+    - rope-split-at:    ensure-split-parts (fringe repair on both halves)
+    - rope-subvec-root: ensure-left-fringe + ensure-right-fringe
+    - rope-conj-right:  fills rightmost chunk, overflows to new node
+    - rope-pop-right:   shrinks rightmost chunk, removes if empty
+    - coll->root:       partition-all target produces valid chunks"
+  (:require [ordered-collections.kernel.node :as node
+             :refer [leaf leaf? -k -v -l -r]]
+            [ordered-collections.kernel.tree :as tree]
+            [ordered-collections.parallel :as par])
+  (:import  [clojure.lang Murmur3 SeqIterator Util]))
+
+
+(def ^:const +target-chunk-size+ 256)
+(def ^:const +min-chunk-size+    128)
+
+(declare raw-rope-concat)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Rope Node Basics
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn rope-size
+  "Total element count across all chunks."
+  ^long [root]
+  (if (leaf? root) 0 (long (-v root))))
+
+(defn chunk-count
+  "Number of chunk nodes in the tree."
+  ^long [root]
+  (tree/node-size root))
+
+(defn- rope-node-create
+  "Create a rope node rooted at chunk. The node value stores subtree element
+  count; the balance metric remains ordinary node count."
+  [chunk _ l r]
+  (node/->SimpleNode chunk
+    (+ (count chunk) (rope-size l) (rope-size r))
+    l r
+    (+ 1 (tree/node-size l) (tree/node-size r))))
+
+(defn- chunk-node
+  [chunk]
+  (when (seq chunk)
+    (rope-node-create (vec chunk) nil (leaf) (leaf))))
+
+(defn- node-chunk
+  [n]
+  (-k n))
+
+(defn- build-root
+  [chunks]
+  (let [n (count chunks)]
+    (when (pos? n)
+      (let [mid   (quot n 2)
+            chunk (nth chunks mid)]
+        (rope-node-create chunk nil
+          (build-root (subvec chunks 0 mid))
+          (build-root (subvec chunks (inc mid) n)))))))
+
+(defn chunks->root
+  [chunks]
+  (build-root (vec (remove empty? chunks))))
+
+(defn root->chunks
+  [root]
+  (if (leaf? root)
+    []
+    (tree/node-reduce-keys conj [] root)))
+
+(defn coll->root
+  [coll]
+  (chunks->root (mapv vec (partition-all +target-chunk-size+ coll))))
+
+(defn chunks->root-csi
+  "Build a rope tree from a sequence of chunks, ensuring CSI.
+  Scans left to right, accumulating a current chunk. When the current
+  chunk reaches [min, target] it is emitted; when it would exceed target
+  it is split evenly. The last chunk is emitted at any size (the runt)."
+  [chunks]
+  (let [chunks (vec (remove empty? chunks))
+        n      (count chunks)]
+    (if (<= n 1)
+      (build-root chunks)
+      (let [fixed (loop [i (int 0), cur nil, acc (transient [])]
+                    (if (>= i n)
+                      (persistent! (if cur (conj! acc cur) acc))
+                      (let [chunk (nth chunks i)
+                            merged (if cur (into cur chunk) chunk)
+                            mn     (count merged)]
+                        (cond
+                          ;; Merged chunk fits in target — keep accumulating
+                          (<= mn +target-chunk-size+)
+                          (if (and (>= mn +min-chunk-size+)
+                                   (< (unchecked-inc-int i) n))
+                            ;; Large enough and not last — emit and reset
+                            (recur (unchecked-inc-int i) nil (conj! acc merged))
+                            ;; Still small or last — carry forward
+                            (recur (unchecked-inc-int i) merged acc))
+
+                          ;; Exceeds target — split evenly, emit first half
+                          :else
+                          (let [half (quot mn 2)]
+                            (recur (unchecked-inc-int i)
+                              (subvec merged half)
+                              (conj! acc (subvec merged 0 half))))))))]
+        (build-root fixed)))))
+
+(defn- rechunk-balanced
+  "Partition a flat vector of elements into chunks satisfying CSI:
+  every chunk in [min, target] except possibly the last which may be
+  smaller. When the last full-sized chunk would leave a remainder
+  below min, the final two pieces are split evenly instead.
+
+  For the small inputs produced by boundary normalization (~512 elements)
+  this is constant-time work."
+  [elems]
+  (let [n (count elems)]
+    (cond
+      (<= n 0)                  []
+      (<= n +target-chunk-size+) [elems]
+      :else
+      (loop [pos 0, acc (transient [])]
+        (let [rem (- n pos)]
+          (cond
+            (<= rem +target-chunk-size+)
+            (persistent! (conj! acc (subvec elems pos n)))
+
+            (< (- rem +target-chunk-size+) +min-chunk-size+)
+            ;; Taking a full target chunk would leave a runt below min.
+            ;; Split the remaining portion evenly so both halves >= min.
+            (let [half (quot rem 2)]
+              (persistent!
+                (conj! (conj! acc (subvec elems pos (+ pos half)))
+                  (subvec elems (+ pos half) n))))
+
+            :else
+            (recur (+ pos +target-chunk-size+)
+              (conj! acc (subvec elems pos (+ pos +target-chunk-size+))))))))))
+
+(defn- rechunk-root
+  "Build a rope root from a small flat vector by rechunking to CSI.
+  Boundary repair only produces a handful of chunks, so it is worth
+  constructing those shapes directly instead of routing through the
+  general chunks->root builder."
+  [elems]
+  (let [chunks (rechunk-balanced elems)]
+    (case (count chunks)
+      0 nil
+      1 (chunk-node (nth chunks 0))
+      2 (raw-rope-concat
+          (chunk-node (nth chunks 0))
+          (chunk-node (nth chunks 1)))
+      3 (rope-node-create (nth chunks 1) nil
+          (chunk-node (nth chunks 0))
+          (chunk-node (nth chunks 2)))
+      (build-root chunks))))
+
+(defn normalize-root
+  "Full O(n) rechunk of a rope tree so every chunk satisfies CSI."
+  [root]
+  (if (leaf? root)
+    nil
+    (chunks->root
+      (rechunk-balanced (vec (mapcat seq (root->chunks root)))))))
+
+(defn- rope-remove-greatest
+  [n]
+  (let [create rope-node-create]
+    (letfn [(rm-greatest [n]
+              (cond
+                (leaf? n)      (throw (ex-info "remove-greatest: empty rope" {:node n}))
+                (leaf? (-r n)) (-l n)
+                :else          (tree/node-stitch (-k n) nil (-l n)
+                                 (rm-greatest (-r n)) create)))]
+      (rm-greatest n))))
+
+(defn- raw-rope-concat
+  [l r]
+  (let [create rope-node-create]
+    (letfn [(cat [l r]
+              (cond
+                (leaf? l) r
+                (leaf? r) l
+                :else
+                (let [lw (tree/node-weight l)
+                      rw (tree/node-weight r)]
+                  (cond
+                    (< (* tree/+delta+ lw) rw)
+                    (let [rk  (node-chunk r)
+                          rl  (-l r)
+                          rr  (-r r)]
+                      (tree/node-stitch rk nil (cat l rl) rr create))
+
+                    (< (* tree/+delta+ rw) lw)
+                    (let [lk  (node-chunk l)
+                          ll  (-l l)
+                          lr  (-r l)]
+                      (tree/node-stitch lk nil ll (cat lr r) create))
+
+                    :else
+                    (let [[chunk _] (tree/node-least-kv r)]
+                      (tree/node-stitch chunk nil l
+                        (tree/node-remove-least r create)
+                        create))))))]
+      (cat l r))))
+
+(defn- rope-join
+  "Balanced join: elements of l, then chunk, then elements of r.
+  Analogous to node-concat3 but positional rather than comparator-ordered.
+  Cost is O(|height(l) - height(r)|) when both are non-leaf."
+  [chunk l r]
+  (let [create rope-node-create]
+    (cond
+      (and (leaf? l) (leaf? r))
+      (chunk-node chunk)
+
+      (leaf? l)
+      (raw-rope-concat (chunk-node chunk) r)
+
+      (leaf? r)
+      (raw-rope-concat l (chunk-node chunk))
+
+      :else
+      (let [lw (tree/node-weight l)
+            rw (tree/node-weight r)]
+        (cond
+          (< (* tree/+delta+ lw) rw)
+          (tree/node-stitch (node-chunk r) nil
+            (rope-join chunk l (-l r))
+            (-r r)
+            create)
+
+          (< (* tree/+delta+ rw) lw)
+          (tree/node-stitch (node-chunk l) nil
+            (-l l)
+            (rope-join chunk (-r l) r)
+            create)
+
+          :else
+          (create chunk nil l r))))))
+
+(defn- ensure-right-fringe
+  "Restore CSI when the rightmost chunk may be undersized.
+  If the rightmost chunk is below min and there are >= 2 chunks,
+  merge it with its left neighbor and rechunk the pair so both
+  halves are in [min, target]."
+  [root]
+  (if (leaf? root)
+    root
+    (if (or (>= (count (node-chunk (tree/node-greatest root))) +min-chunk-size+)
+            (<= (tree/node-size root) 1))
+      root
+      (let [last-chunk (node-chunk (tree/node-greatest root))
+            rest       (rope-remove-greatest root)
+            prev-chunk (node-chunk (tree/node-greatest rest))
+            rest2      (rope-remove-greatest rest)
+            combined   (into prev-chunk last-chunk)
+            mid        (rechunk-root combined)]
+        (raw-rope-concat rest2 mid)))))
+
+(defn- ensure-left-fringe
+  "Restore CSI when the leftmost chunk may be undersized.
+  If the leftmost chunk is below min and there are >= 2 chunks,
+  merge it with its right neighbor. If the merged result fits in
+  one chunk, use it. Otherwise split at min so both halves are
+  in [min, target]."
+  [root]
+  (if (leaf? root)
+    root
+    (let [create rope-node-create]
+      (if (or (>= (count (node-chunk (tree/node-least root))) +min-chunk-size+)
+              (<= (tree/node-size root) 1))
+        root
+        (let [first-chunk (node-chunk (tree/node-least root))
+              rest        (tree/node-remove-least root create)
+              next-chunk  (node-chunk (tree/node-least rest))
+              rest2       (tree/node-remove-least rest create)
+              combined    (into first-chunk next-chunk)
+              cn          (count combined)]
+          (if (<= cn +target-chunk-size+)
+            (raw-rope-concat (chunk-node combined) rest2)
+            ;; Split at min: left piece = min (valid internal),
+            ;; right piece = cn - min which is in [min+1, target-1]
+            ;; because cn is in (target, 2*target) and min = target/2.
+            (let [c1 (subvec combined 0 +min-chunk-size+)
+                  c2 (subvec combined +min-chunk-size+)]
+              (raw-rope-concat
+                (raw-rope-concat (chunk-node c1) (chunk-node c2))
+                rest2))))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Structural Concatenation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- merge-boundary
+  "Merge the boundary chunks between two trees to restore CSI.
+  The rightmost chunk of l (the runt-allowed position) is becoming
+  internal, so it must be >= min. If the combined boundary chunks
+  are still below min, pull one more neighbor chunk."
+  [l r lchunk rchunk]
+  (let [create   rope-node-create
+        l'       (rope-remove-greatest l)
+        r'       (tree/node-remove-least r create)
+        combined (into lchunk rchunk)
+        cn       (count combined)]
+    (if (or (>= cn +min-chunk-size+)
+            (and (leaf? l') (leaf? r')))
+      ;; Combined is large enough or it is the only content
+      (let [mid (rechunk-root combined)]
+        (raw-rope-concat (raw-rope-concat l' mid) r'))
+      ;; Combined still below min — pull one more neighbor
+      (if-not (leaf? l')
+        (let [prev  (node-chunk (tree/node-greatest l'))
+              l''   (rope-remove-greatest l')
+              all   (into prev combined)
+              mid   (rechunk-root all)]
+          (raw-rope-concat (raw-rope-concat l'' mid) r'))
+        ;; l' is empty so r' must be non-empty (both-empty handled above)
+        (let [nxt  (node-chunk (tree/node-least r'))
+              r''  (tree/node-remove-least r' create)
+              all  (into combined nxt)
+              mid  (rechunk-root all)]
+          (raw-rope-concat (raw-rope-concat l' mid) r''))))))
+
+(defn rope-concat
+  "Concatenate two rope trees, preserving left-before-right order.
+  Ensures the Chunk Size Invariant holds on the result: every chunk
+  is in [min, target] except possibly the rightmost.
+
+  Position-aware: l's rightmost becomes internal (must be >= min).
+  r's leftmost becomes internal only if r has >= 2 chunks; if r has
+  exactly 1 chunk it becomes the rightmost of the result and any
+  size in [1, target] is valid."
+  [l r]
+  (cond
+    (leaf? l) r
+    (leaf? r) l
+    :else
+    (let [lchunk (node-chunk (tree/node-greatest l))
+          rchunk (node-chunk (tree/node-least r))
+          ;; l's rightmost becomes internal after concat
+          l-ok (>= (count lchunk) +min-chunk-size+)
+          ;; r's leftmost stays as rightmost (any size ok) when r has 1 chunk
+          r-ok (or (<= (tree/node-size r) 1)
+                   (>= (count rchunk) +min-chunk-size+))]
+      (if (and l-ok r-ok)
+        (raw-rope-concat l r)
+        (merge-boundary l r lchunk rchunk)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Indexed Access and Update
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn rope-nth
+  [root ^long i]
+  (loop [n root, i i]
+    (let [l  (-l n)
+          ls (if (leaf? l) 0 (long (-v l)))
+          ck (-k n)
+          cs (long (.count ^clojure.lang.Counted ck))
+          rs (+ ls cs)]
+      (cond
+        (< i ls) (recur l i)
+        (< i rs) (.nth ^clojure.lang.Indexed ck (unchecked-int (- i ls)))
+        :else (recur (-r n) (- i rs))))))
+
+(defn rope-assoc
+  [root ^long i x]
+  (let [create rope-node-create]
+    (letfn [(assoc* [n ^long i]
+              (let [ck (-k n)
+                    l  (-l n)
+                    r  (-r n)
+                    ls (if (leaf? l) 0 (long (-v l)))
+                    cs (long (.count ^clojure.lang.Counted ck))
+                    rs (+ ls cs)]
+                (cond
+                  (< i ls)
+                  (tree/node-stitch ck nil (assoc* l i) r create)
+
+                  (< i rs)
+                  (create (assoc ck (- i ls) x) nil l r)
+
+                  :else
+                  (tree/node-stitch ck nil l
+                    (assoc* r (- i rs))
+                    create))))]
+      (assoc* root i))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Structural Split, Slice, and Stack Ops
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn rope-split-at
+  "Split rope tree at element index i, returning [left right].
+  Uses rope-join (concat3) during unwind so total cost is O(log n),
+  matching the standard split-join pattern from Blelloch et al."
+  [root ^long i]
+  (let [n (rope-size root)]
+    (cond
+      (<= i 0) [nil root]
+      (>= i n) [root nil]
+      :else
+      (letfn [(split* [n ^long i]
+                (let [chunk (-k n)
+                      l     (-l n)
+                      r     (-r n)
+                      ls    (if (leaf? l) 0 (long (-v l)))
+                      cs    (long (.count ^clojure.lang.Counted chunk))
+                      rs    (+ ls cs)]
+                  (cond
+                    (< i ls)
+                    (let [[ll lr] (split* l i)]
+                      [ll (rope-join chunk lr r)])
+
+                    (= i ls)
+                    [l (rope-join chunk (leaf) r)]
+
+                    (< i rs)
+                    (let [offset (- i ls)
+                          lc     (subvec chunk 0 offset)
+                          rc     (subvec chunk offset cs)]
+                      [(if (pos? (count lc))
+                         (raw-rope-concat l (chunk-node lc))
+                         l)
+                       (if (pos? (count rc))
+                         (raw-rope-concat (chunk-node rc) r)
+                         r)])
+
+                    (= i rs)
+                    [(rope-join chunk l (leaf)) r]
+
+                    :else
+                    (let [[rl rr] (split* r (- i rs))]
+                      [(rope-join chunk l rl) rr]))))]
+        (split* root i)))))
+
+(defn rope-subvec-root
+  [root ^long start ^long end]
+  (letfn [(slice-3 [left mid-chunk right]
+            (cond
+              (nil? mid-chunk)
+              (raw-rope-concat left right)
+
+              (leaf? left)
+              (if (leaf? right)
+                (chunk-node mid-chunk)
+                (raw-rope-concat (chunk-node mid-chunk) right))
+
+              (leaf? right)
+              (raw-rope-concat left (chunk-node mid-chunk))
+
+              :else
+              (rope-join mid-chunk left right)))
+          (slice* [n ^long start ^long end]
+            (cond
+              (leaf? n) nil
+              (>= start end) nil
+              :else
+              (let [size (long (-v n))]
+                (if (and (<= start 0) (>= end size))
+                  n
+                  (let [chunk (-k n)
+                        l     (-l n)
+                        r     (-r n)
+                        ls    (if (leaf? l) 0 (long (-v l)))
+                        cs    (long (.count ^clojure.lang.Counted chunk))
+                        rs    (+ ls cs)]
+                    (cond
+                      (<= end ls)
+                      (slice* l start end)
+
+                      (>= start rs)
+                      (slice* r (- start rs) (- end rs))
+
+                      (and (>= start ls) (<= end rs))
+                      (chunk-node (subvec chunk (- start ls) (- end ls)))
+
+                      :else
+                      (let [left      (when (< start ls)
+                                        (slice* l start ls))
+                            c0        (max 0 (- start ls))
+                            c1        (min cs (- end ls))
+                            mid-chunk (when (< c0 c1)
+                                        (subvec chunk c0 c1))
+                            right     (when (> end rs)
+                                        (slice* r 0 (- end rs)))]
+                        (slice-3 left mid-chunk right))))))))]
+    (-> (slice* root start end)
+      ensure-left-fringe
+      ensure-right-fringe)))
+
+(defn ensure-split-parts
+  "Restore CSI on both halves of a split. The left half may have an
+  undersized right fringe; the right half may have an undersized left
+  fringe."
+  [[l r]]
+  [(ensure-right-fringe l)
+   (ensure-left-fringe r)])
+
+(defn rope-splice-root
+  "Replace [start, end) in root with mid-root, where all arguments are rope
+  roots. Uses raw positional splits and repairs only the fringes that remain
+  exposed in the final result."
+  [root ^long start ^long end mid-root]
+  (let [[l r]  (rope-split-at root start)
+        [_ rr] (rope-split-at r (- end start))]
+    (cond
+      (leaf? mid-root)
+      (cond
+        (leaf? l)  (ensure-left-fringe rr)
+        (leaf? rr) (ensure-right-fringe l)
+        :else      (rope-concat l rr))
+
+      (leaf? l)
+      (if (leaf? rr)
+        mid-root
+        (rope-concat mid-root rr))
+
+      :else
+      (let [left+mid (rope-concat l mid-root)]
+        (if (leaf? rr)
+          left+mid
+          (rope-concat left+mid rr))))))
+
+(defn rope-insert-root
+  "Insert mid-root at start in root."
+  [root ^long start mid-root]
+  (rope-splice-root root start start mid-root))
+
+(defn rope-remove-root
+  "Remove [start, end) from root."
+  [root ^long start ^long end]
+  (rope-splice-root root start end nil))
+
+(defn rope-peek-right
+  [root]
+  (when-not (leaf? root)
+    (let [chunk (node-chunk (tree/node-greatest root))]
+      (peek chunk))))
+
+(defn rope-pop-right
+  [root]
+  (if (leaf? root)
+    (throw (IllegalStateException. "Can't pop empty vector"))
+    (let [create rope-node-create]
+      (letfn [(pop* [n]
+                (let [ck (-k n)
+                      l  (-l n)
+                      r  (-r n)]
+                  (if (leaf? r)
+                    (if (> (.count ^clojure.lang.Counted ck) 1)
+                      (create (pop ck) nil l r)
+                      l)
+                    (tree/node-stitch ck nil l (pop* r) create))))]
+        (pop* root)))))
+
+(defn rope-conj-right
+  [root x]
+  (if (leaf? root)
+    (chunk-node [x])
+    (let [create rope-node-create]
+      (letfn [(conj* [n]
+                (let [ck (-k n)
+                      l  (-l n)
+                      r  (-r n)]
+                  (if (leaf? r)
+                    (if (< (.count ^clojure.lang.Counted ck) +target-chunk-size+)
+                      (create (conj ck x) nil l r)
+                      (tree/node-stitch ck nil l (chunk-node [x]) create))
+                    (tree/node-stitch ck nil l (conj* r) create))))]
+        (conj* root)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Traversal
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn rope-chunks-seq
+  [root]
+  (when-not (leaf? root)
+    (tree/node-key-seq root (tree/node-size root))))
+
+(defn rope-chunks-rseq
+  [root]
+  (when-not (leaf? root)
+    (tree/node-key-seq-reverse root (tree/node-size root))))
+
+(defn- seq-equiv
+  "Element-wise sequential equivalence."
+  [s1 o]
+  (if-not (or (instance? clojure.lang.Sequential o)
+              (instance? java.util.List o))
+    false
+    (loop [s1 (seq s1) s2 (seq o)]
+      (cond
+        (nil? s1) (nil? s2)
+        (nil? s2) false
+        (not (Util/equiv (first s1) (first s2))) false
+        :else (recur (next s1) (next s2))))))
+
+(deftype RopeSeq [enum chunk ^long i cnt _meta]
+  clojure.lang.ISeq
+  (first [_]
+    (.nth ^clojure.lang.Indexed chunk (unchecked-int i)))
+  (next [_]
+    (let [next-cnt (when cnt (unchecked-dec-int cnt))
+          next-i   (unchecked-inc i)]
+      (if (< next-i (count chunk))
+        (RopeSeq. enum chunk next-i next-cnt nil)
+        (when-let [e (tree/node-enum-rest enum)]
+          (let [chunk' (-k (tree/node-enum-first e))]
+            (RopeSeq. e chunk' 0 next-cnt nil))))))
+  (more [this]
+    (or (.next this) ()))
+  (cons [this o]
+    (clojure.lang.Cons. o this))
+
+  clojure.lang.Seqable
+  (seq [this] this)
+
+  clojure.lang.Sequential
+
+  java.lang.Iterable
+  (iterator [this]
+    (SeqIterator. this))
+
+  clojure.lang.Counted
+  (count [_]
+    (or cnt
+        (loop [e enum
+               chunk chunk
+               i i
+               n 0]
+          (let [n (+ n (- (count chunk) i))]
+            (if-let [e' (tree/node-enum-rest e)]
+              (let [chunk' (-k (tree/node-enum-first e'))]
+                (recur e' chunk' 0 n))
+              n)))))
+
+  clojure.lang.IReduceInit
+  (reduce [_ f init]
+    (loop [e enum
+           chunk chunk
+           i i
+           acc init]
+      (let [acc (loop [idx i
+                       acc acc]
+                  (if (< idx (count chunk))
+                    (let [ret (f acc (.nth ^clojure.lang.Indexed chunk (unchecked-int idx)))]
+                      (if (reduced? ret)
+                        ret
+                        (recur (unchecked-inc idx) ret)))
+                    acc))]
+        (if (reduced? acc)
+          @acc
+          (if-let [e' (tree/node-enum-rest e)]
+            (let [chunk' (-k (tree/node-enum-first e'))]
+              (recur e' chunk' 0 acc))
+            acc)))))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (if enum
+      (let [acc (.nth ^clojure.lang.Indexed chunk (unchecked-int i))
+            next-i (unchecked-inc i)]
+        (if (< next-i (count chunk))
+          (.reduce ^clojure.lang.IReduceInit
+            (RopeSeq. enum chunk next-i nil nil) f acc)
+          (if-let [e' (tree/node-enum-rest enum)]
+            (let [chunk' (-k (tree/node-enum-first e'))]
+              (.reduce ^clojure.lang.IReduceInit
+                (RopeSeq. e' chunk' 0 nil nil) f acc))
+            acc)))
+      (f)))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/hashOrdered this))
+
+  clojure.lang.IPersistentCollection
+  (empty [_] ())
+  (equiv [this o]
+    (seq-equiv this o))
+
+  Object
+  (hashCode [this]
+    (Util/hash this))
+  (equals [this o]
+    (Util/equals this o))
+
+  clojure.lang.IMeta
+  (meta [_] _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (RopeSeq. enum chunk i cnt m)))
+
+(deftype RopeSeqReverse [enum chunk ^long i cnt _meta]
+  clojure.lang.ISeq
+  (first [_]
+    (.nth ^clojure.lang.Indexed chunk (unchecked-int i)))
+  (next [_]
+    (let [next-cnt (when cnt (unchecked-dec-int cnt))]
+      (if (pos? i)
+        (RopeSeqReverse. enum chunk (unchecked-dec i) next-cnt nil)
+        (when-let [e (tree/node-enum-prior enum)]
+          (let [chunk' (-k (tree/node-enum-first e))]
+            (RopeSeqReverse. e chunk' (dec (count chunk')) next-cnt nil))))))
+  (more [this]
+    (or (.next this) ()))
+  (cons [this o]
+    (clojure.lang.Cons. o this))
+
+  clojure.lang.Seqable
+  (seq [this] this)
+
+  clojure.lang.Sequential
+
+  java.lang.Iterable
+  (iterator [this]
+    (SeqIterator. this))
+
+  clojure.lang.Counted
+  (count [_]
+    (or cnt
+        (loop [e enum
+               chunk chunk
+               i i
+               n 0]
+          (let [n (+ n (inc i))]
+            (if-let [e' (tree/node-enum-prior e)]
+              (let [chunk' (-k (tree/node-enum-first e'))]
+                (recur e' chunk' (dec (count chunk')) n))
+              n)))))
+
+  clojure.lang.IReduceInit
+  (reduce [_ f init]
+    (loop [e enum
+           chunk chunk
+           i i
+           acc init]
+      (let [acc (loop [idx i
+                       acc acc]
+                  (if (neg? idx)
+                    acc
+                    (let [ret (f acc (.nth ^clojure.lang.Indexed chunk (unchecked-int idx)))]
+                      (if (reduced? ret)
+                        ret
+                        (recur (unchecked-dec idx) ret)))))]
+        (if (reduced? acc)
+          @acc
+          (if-let [e' (tree/node-enum-prior e)]
+            (let [chunk' (-k (tree/node-enum-first e'))]
+              (recur e' chunk' (dec (count chunk')) acc))
+            acc)))))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (if enum
+      (let [acc (.nth ^clojure.lang.Indexed chunk (unchecked-int i))]
+        (if (pos? i)
+          (.reduce ^clojure.lang.IReduceInit
+            (RopeSeqReverse. enum chunk (unchecked-dec i) nil nil) f acc)
+          (if-let [e' (tree/node-enum-prior enum)]
+            (let [chunk' (-k (tree/node-enum-first e'))]
+              (.reduce ^clojure.lang.IReduceInit
+                (RopeSeqReverse. e' chunk' (dec (count chunk')) nil nil) f acc))
+            acc)))
+      (f)))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/hashOrdered this))
+
+  clojure.lang.IPersistentCollection
+  (empty [_] ())
+  (equiv [this o]
+    (seq-equiv this o))
+
+  Object
+  (hashCode [this]
+    (Util/hash this))
+  (equals [this o]
+    (Util/equals this o))
+
+  clojure.lang.IMeta
+  (meta [_] _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (RopeSeqReverse. enum chunk i cnt m)))
+
+(defn rope-seq
+  [root]
+  (when-let [enum (tree/node-enumerator root)]
+    (let [chunk (-k (tree/node-enum-first enum))]
+      (RopeSeq. enum chunk 0 (rope-size root) nil))))
+
+(defn rope-rseq
+  [root]
+  (when-let [enum (tree/node-enumerator-reverse root)]
+    (let [chunk (-k (tree/node-enum-first enum))]
+      (RopeSeqReverse. enum chunk (dec (count chunk)) (rope-size root) nil))))
+
+(defn rope-chunks-reduce
+  ([f init root]
+   (if (leaf? root)
+     init
+     (tree/node-reduce-keys f init root)))
+  ([f root]
+   (if (leaf? root)
+     (f)
+     (tree/node-reduce-keys f root))))
+
+(defn- reduce-chunk-indexed
+  "Fallback reduce for SubVector and other non-IReduceInit chunks."
+  [f acc chunk]
+  (let [^clojure.lang.Indexed chunk chunk
+        n (.count ^clojure.lang.Counted chunk)]
+    (loop [i (int 0) acc acc]
+      (if (< i n)
+        (let [ret (f acc (.nth chunk i))]
+          (if (reduced? ret)
+            ret
+            (recur (unchecked-inc-int i) ret)))
+        acc))))
+
+(defn rope-reduce
+  "Direct in-order tree walk: left subtree, chunk, right subtree.
+  Bypasses the enumerator infrastructure to eliminate EnumFrame allocation
+  and per-chunk lambda overhead. The right-subtree continuation uses recur
+  for zero stack growth on that branch; left-subtree recursion depth is
+  bounded by tree height (O(log n)).
+
+  For IReduceInit chunks (PersistentVector), delegates to the vector's
+  native reduce for tight array iteration. A single volatile + wrapper
+  closure is allocated once per reduce call (not per chunk) to detect
+  early termination from reduced."
+  ([f init root]
+   (if (leaf? root)
+     init
+     (let [stopped (volatile! false)
+           wf      (fn [acc x]
+                     (let [ret (f acc x)]
+                       (if (reduced? ret)
+                         (do (vreset! stopped true) (reduced @ret))
+                         ret)))]
+       (letfn [(reduce-chunk [acc chunk]
+                 (if (instance? clojure.lang.IReduceInit chunk)
+                   (let [result (.reduce ^clojure.lang.IReduceInit chunk wf acc)]
+                     (if @stopped (reduced result) result))
+                   (reduce-chunk-indexed f acc chunk)))
+               (walk [acc n]
+                 (if (leaf? n)
+                   acc
+                   (let [acc (walk acc (-l n))]
+                     (if (reduced? acc)
+                       acc
+                       (let [acc (reduce-chunk acc (-k n))]
+                         (if (reduced? acc)
+                           acc
+                           (recur acc (-r n))))))))]
+         (let [result (walk init root)]
+           (if (reduced? result) @result result))))))
+  ;; 1-arity duplicates the walk/reduce-chunk letfn because both arities
+  ;; close over the same volatile + wrapper; factoring it out would require
+  ;; passing them as arguments through the recursive walk for no readability gain.
+  ([f root]
+   (if (leaf? root)
+     (f)
+     (let [stopped (volatile! false)
+           wf      (fn [acc x]
+                     (let [ret (f acc x)]
+                       (if (reduced? ret)
+                         (do (vreset! stopped true) (reduced @ret))
+                         ret)))]
+       (letfn [(reduce-chunk [acc chunk]
+                 (if (instance? clojure.lang.IReduceInit chunk)
+                   (let [result (.reduce ^clojure.lang.IReduceInit chunk wf acc)]
+                     (if @stopped (reduced result) result))
+                   (reduce-chunk-indexed f acc chunk)))
+               (walk [acc n]
+                 (if (leaf? n)
+                   acc
+                   (let [acc (walk acc (-l n))]
+                     (if (reduced? acc)
+                       acc
+                       (let [acc (reduce-chunk acc (-k n))]
+                         (if (reduced? acc)
+                           acc
+                           (recur acc (-r n))))))))]
+         ;; Bootstrap: first element as init, then reduce the rest
+         (let [least  (tree/node-least root)
+               chunk0 (-k least)
+               init   (.nth ^clojure.lang.Indexed chunk0 0)
+               acc0   (reduce-chunk init
+                        (subvec chunk0 1 (.count ^clojure.lang.Counted chunk0)))]
+           (if (reduced? acc0)
+             @acc0
+             (let [rest-root (tree/node-remove-least root rope-node-create)
+                   result    (walk acc0 rest-root)]
+               (if (reduced? result) @result result)))))))))
+
+(defn rope-fold
+  "Parallel fold over the rope's existing tree shape.
+
+  Unlike a split-based fold, this does not rebuild intermediate half-ropes.
+  It recursively folds left subtree, current chunk, and right subtree in
+  left-to-right order, using subtree sizes to decide when to stop splitting."
+  [root ^long n combinef reducef]
+  (letfn [(reduce-chunk [acc chunk]
+            (if (instance? clojure.lang.IReduceInit chunk)
+              (.reduce ^clojure.lang.IReduceInit chunk reducef acc)
+              (reduce-chunk-indexed reducef acc chunk)))
+          (fold-node [node]
+            (cond
+              (leaf? node)
+              (combinef)
+
+              (<= (long (-v node)) n)
+              (letfn [(walk [acc n]
+                        (if (leaf? n)
+                          acc
+                          (let [acc (walk acc (-l n))
+                                acc (reduce-chunk acc (-k n))]
+                            (recur acc (-r n)))))]
+                (walk (combinef) node))
+
+              :else
+              (let [l      (-l node)
+                    chunk  (-k node)
+                    r      (-r node)
+                    chunkv (reduce-chunk (combinef) chunk)]
+                (par/fork-join
+                  [lv (fold-node l) rv (fold-node r)]
+                  (combinef (combinef lv chunkv) rv)))))]
+    (if (par/in-fork-join-pool?)
+      (fold-node root)
+      (par/invoke-root #(fold-node root)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Materialization
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn rope->str
+  "Efficient rope-to-string via StringBuilder. Appends each chunk's
+  elements directly, avoiding lazy seq overhead."
+  ^String [root]
+  (if (leaf? root)
+    ""
+    (let [sb (StringBuilder. (int (rope-size root)))]
+      (letfn [(walk [n]
+                (when-not (leaf? n)
+                  (walk (-l n))
+                  (let [chunk (-k n)]
+                    (dotimes [i (count chunk)]
+                      (.append sb (nth chunk i))))
+                  (walk (-r n))))]
+        (walk root))
+      (.toString sb))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Invariant Checking
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn invariant-valid?
+  "Check that a rope root satisfies the Chunk Size Invariant:
+  - every chunk has size in [1, target]
+  - every chunk except the rightmost has size >= min
+  Returns true if CSI holds, false otherwise."
+  [root]
+  (if (leaf? root)
+    true
+    (let [chunks (root->chunks root)
+          sizes  (mapv count chunks)]
+      (and
+        (every? pos? sizes)
+        (every? #(<= % +target-chunk-size+) sizes)
+        (every? #(>= % +min-chunk-size+) (butlast sizes))))))
diff --git a/src/ordered_collections/kernel/tree.clj b/src/ordered_collections/kernel/tree.clj
new file mode 100644
index 0000000..d6bb4e7
--- /dev/null
+++ b/src/ordered_collections/kernel/tree.clj
@@ -0,0 +1,1986 @@
+(ns ordered-collections.kernel.tree
+  (:require [clojure.core.reducers                      :as r]
+            [ordered-collections.parallel      :as parallel]
+            [ordered-collections.kernel.interval :as interval]
+            [ordered-collections.kernel.node     :as node
+             :refer [leaf? leaf -k -v -l -r -x -z -kv]]
+            [ordered-collections.kernel.order    :as order])
+  (:import  [clojure.lang ASeq MapEntry RT ISeq Seqable Sequential IPersistentCollection]
+            [java.util Comparator]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Weight Balanced Functional Binary Interval Tree (Hirai-Yamamoto Tree)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; This is an implementation of a weight-balanced binary interval-tree data
+;; structure based on the following references:
+;;
+;; --  Adams (1992)
+;;     'Implementing Sets Efficiently in a Functional Language'
+;;     Technical Report CSTR 92-10, University of Southampton.
+;;     <http://groups.csail.mit.edu/mac/users/adams/BB/92-10.ps>
+;;
+;; --  Hirai and Yamamoto (2011)
+;;     'Balancing Weight-Balanced Trees'
+;;     Journal of Functional Programming / 21 (3):
+;;     Pages 287-307
+;;     <https://yoichihirai.com/bst.pdf>
+;;
+;; --  Oleg Kiselyov
+;;     'Towards the best collection API, A design of the overall optimal
+;;     collection traversal interface'
+;;     <https://okmij.org/ftp/papers/LL3-collections-enumerators.txt>
+;;
+;; --  Nievergelt and Reingold (1972)
+;;     'Binary Search Trees of Bounded Balance'
+;;     STOC '72 Proceedings
+;;     4th Annual ACM symposium on Theory of Computing
+;;     Pages 137-142
+;;     <https://dl.acm.org/doi/abs/10.1145/800152.804906>
+;;
+;; --  Driscoll, Sarnak, Sleator, and Tarjan (1989)
+;;     'Making Data Structures Persistent'
+;;     Journal of Computer and System Sciences Volume 38 Issue 1, February 1989
+;;     18th Annual ACM Symposium on Theory of Computing
+;;     Pages 86-124
+;;     <https://www.sciencedirect.com/science/article/pii/0022000089900342>
+;;
+;; --  MIT Scheme weight balanced tree as reimplemented by Yoichi Hirai
+;;     and Kazuhiko Yamamoto using the revised non-variant algorithm recommended
+;;     integer balance parameters from (Hirai/Yamomoto 2011).
+;;     <https://www.cambridge.org/core/journals/journal-of-functional-programming/article/
+;;     balancing-weightbalanced-trees/7281C4DE7E56B74F2D13F06E31DCBC5B>
+;;
+;; --  Wikipedia
+;;     'Interval Tree'
+;;     <https://en.wikipedia.org/wiki/Interval_tree>
+;;
+;; --  Wikipedia
+;;     'Weight Balanced Tree'
+;;     <https://en.wikipedia.org/wiki/Weight-balanced_tree>
+;;
+;; --  Andrew Baine, Rahul Jaine (2007)
+;;     'Purely Functional Data Structures in Common Lisp'
+;;     Google Summer of Code 2007
+;;     <https://common-lisp.net/project/funds/funds.pdf>
+;;     <https://developers.google.com/open-source/gsoc/2007/>
+;;
+;; -- Scott L. Burson
+;;     'Functional Set-Theoretic Collections for Common Lisp'
+;;     <https://common-lisp.net/project/fset/Site/index.html>
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Weight Balancing Constants
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def ^{:const true
+       :doc   "The primary balancing rotation coefficient that is used for the
+              determination whether two subtrees of a node are in balance or
+              require adjustment by means of a rotation operation.  The specific
+              rotation to be performed is determined by `+gamma+`."}
+  +delta+ 3)
+
+(def ^{:const true
+       :doc   "The secondary balancing rotation coefficient that is used for the
+              determination of whether a single or double rotation operation should
+              occur, once it has been decided based on `+delta+` that a rotation is
+              indeed required."}
+  +gamma+ 2)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Node Destructuring
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmacro kvlr
+  "destructure node n: key value left right. This is the principal destructuring macro
+  for operating on regions of trees"
+  [[ksym vsym lsym rsym] n & body]
+  `(let [n# ~n
+         ~ksym (-k n#) ~vsym (-v n#)
+         ~lsym (-l n#) ~rsym (-r n#)]
+     ~@body))
+
+(defmacro lr [[lsym rsym] n & body]
+  `(let [n# ~n ~lsym (-l n#) ~rsym (-r n#)]
+     ~@body))
+
+
+(defn maybe-z [n]
+  (when-not (leaf? n) (-z n)))
+
+(def ^:private node-accessor {:k -k :v -v :kv -kv nil identity})
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Balance Metrics
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn node-size
+  "returns the balance metric of the tree rooted at n."
+  ^long [n]
+  (if (leaf? n) 0 (-x n)))
+
+(definline node-weight
+  "Returns node weight for rotation calculations using the 'revised non-variant
+   algorithm' for weight balanced binary trees. Weight = size + 1."
+  [n]
+  `(let [n# ~n]
+     (unchecked-inc (if (leaf? n#) 0 (long (-x n#))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Node Builders (t-join)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; `*compare*` and `*t-join*` are the core representation hooks for the
+;; tree algebra. Dynamic binding lets one split/join/search implementation serve
+;; many concrete node families: generic nodes, primitive-key nodes, interval
+;; nodes, segment/augmented nodes, and future variants with different storage
+;; or augmentation strategy. That is the basis of the library's open
+;; representational polymorphism: collection constructors choose a comparator
+;; and node constructor, then the shared tree algorithms operate uniformly over
+;; that representation.
+
+(defn node-create-weight-balanced
+  "Join left and right weight-balanced subtrees at root k/v.
+  Assumes all keys in l < k < all keys in r."
+  [k v l r]
+  (node/->SimpleNode k v l r (+ 1 (node-size l) (node-size r))))
+
+(defn node-create-weight-balanced-long
+  "Join left and right weight-balanced subtrees at primitive long root k/v.
+  Specialized for Long keys - avoids boxing overhead.
+  Assumes all keys in l < k < all keys in r."
+  [k v l r]
+  (node/->LongKeyNode (long k) v l r (+ 1 (node-size l) (node-size r))))
+
+(defn node-create-weight-balanced-double
+  "Join left and right weight-balanced subtrees at primitive double root k/v.
+  Specialized for Double keys - avoids boxing overhead.
+  Assumes all keys in l < k < all keys in r."
+  [k v l r]
+  (node/->DoubleKeyNode (double k) v l r (+ 1 (node-size l) (node-size r))))
+
+(defn node-create-weight-balanced-interval
+  "Join left and right weight-balanced interval subtrees at root k/v.
+  Assumes all keys in l < k < all keys in r."
+  [i v l r]
+  (node/->IntervalNode i v l r (+ 1 (node-size l) (node-size r))
+     (order/max (interval/b i) (maybe-z l) (maybe-z r))))
+
+(def ^:dynamic *t-join* node-create-weight-balanced)
+
+(defn node-create
+  "Join left and right subtrees at root k/v.
+  Assumes all keys in l < k < all keys in r."
+  [k v l r]
+  (*t-join* k v l r))
+
+(defn node-singleton
+  "Create and return a newly allocated, balanced tree
+  containing a single association, that of key K with value V."
+  [k v]
+  (node-create k v (leaf) (leaf)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Node Enumerators: the fundamental traversal algorithm
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Enumerators provide efficient partial (lazy) in-order traversal of tree
+;; structure without materializing the entire sequence upfront. They work by
+;; decomposing the tree into a "left spine" — a linked list of frames, each
+;; holding a node and its unvisited subtree.
+;;
+;; CONCEPT: Left Spine Decomposition
+;;
+;; Given this tree:
+;;
+;;                    ,---,
+;;                    | 4 |
+;;                    :---:
+;;                   :     :
+;;              ,---:       :---,
+;;              | 2 |       | 6 |
+;;              :---:       :---:
+;;             :     :     :     :
+;;         ,--:   :--,  ,--:   :--,
+;;         |1 |   |3 |  |5 |   |7 |
+;;         '--'   '--'  '--'   '--'
+;;
+;; The forward enumerator walks down the LEFT spine, building a chain of
+;; EnumFrames. Each frame saves (node, right-subtree, next-frame):
+;;
+;;     node-enumerator(4)
+;;
+;;     [1 | nil | next] -> [2 | subtree 3 | next] -> [4 | subtree 6 | nil]
+;;
+;; The head of the chain is the current element. Each frame is:
+;;   [node | saved-right-subtree | next-frame]
+;;
+;; TRAVERSAL:
+;;
+;;   1. node-enum-first returns the current node (head of spine)
+;;
+;;   2. node-enum-rest advances by:
+;;      - Taking the saved right-subtree
+;;      - Recursively building a new left spine from it
+;;      - Continuing with the next frame
+;;
+;;      After visiting node 1:
+;;        subtree=nil, next=Frame(2,...)
+;;        → returns Frame(2,...) directly (no subtree to enumerate)
+;;
+;;      After visiting node 2:
+;;        subtree=3, next=Frame(4,...)
+;;        → enumerate the left spine of subtree 3 and link it to Frame(4,...)
+;;
+;;          before: [2 | subtree 3 | next -> [4 | subtree 6 | nil]]
+;;          after:  [3 | nil      | next -> [4 | subtree 6 | nil]]
+;;
+;; This produces the in-order sequence: 1, 2, 3, 4, 5, 6, 7
+;;
+;; The reverse enumerator (node-enumerator-reverse) works symmetrically,
+;; walking down the RIGHT spine and saving left subtrees.
+;;
+;; EFFICIENCY:
+;;
+;; - O(1) to get current node
+;; - O(log n) amortized per advance (each node visited once across full traversal)
+;; - O(log n) space (depth of spine = tree height)
+;; - Lazy: only materializes nodes as needed
+;;
+;; EnumFrame is a simple deftype triple that avoids the allocation overhead
+;; of persistent lists (1 object vs 3 cons cells per frame).
+
+(deftype EnumFrame [node subtree next])
+
+(defn node-enumerator
+  "Efficient mechanism to accomplish partial enumeration of
+   tree-structure into a seq representation without incurring the
+   overhead of operating over the entire tree. Used internally for
+   implementation of higher-level collection api routines.
+
+   Returns an EnumFrame representing the leftmost spine of the tree,
+   where each frame holds (current-node, right-subtree, next-frame)."
+  ([n] (node-enumerator n nil))
+  ([n enum]
+   (if (leaf? n)
+     enum
+     (recur (-l n) (EnumFrame. n (-r n) enum)))))
+
+(defn node-enumerator-reverse
+  "Reverse enumerator: builds rightmost spine where each frame holds
+   (current-node, left-subtree, next-frame)."
+  ([n] (node-enumerator-reverse n nil))
+  ([n enum]
+   (if (leaf? n)
+     enum
+     (recur (-r n) (EnumFrame. n (-l n) enum)))))
+
+(defn node-enum-first
+  "Return the current node from an enumerator frame."
+  [^EnumFrame enum]
+  (.-node enum))
+
+(defn node-enum-rest
+  "Advance forward enumerator to the next node."
+  [enum]
+  (when (some? enum)
+    (let [^EnumFrame ef enum
+          subtree (.-subtree ef)
+          next    (.-next ef)]
+      (when-not (and (nil? subtree) (nil? next))
+        (node-enumerator subtree next)))))
+
+(defn node-enum-prior
+  "Advance reverse enumerator to the next (prior) node."
+  [enum]
+  (when (some? enum)
+    (let [^EnumFrame ef enum
+          subtree (.-subtree ef)
+          next    (.-next ef)]
+      (when-not (and (nil? subtree) (nil? next))
+        (node-enumerator-reverse subtree next)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Tree Rotations (Weight Balanced)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; macros because they are directly in the hot path.
+
+(defmacro rotate-single-left
+  "Single left rotation. Move Y (the left subtree of the right subtree of A)
+  into the left subtree. Required when: weight(X) < δ × weight(B) and
+  weight(Y) < γ × weight(Z).
+
+                ,---,                                  ,---,
+                | A |                                  | B |
+                :---:                                  :---:
+               :     :                                :     :
+          ,---:       :---,                      ,---:       :---,
+          | X |       | B |           =>         | A |       | Z |
+          '---'       :---:                      :---:       '---'
+                 ,---:     :---,            ,---:     :---,
+                 | Y |     | Z |            | X |     | Y |
+                 '---'     '---'            '---'     '---'
+  "
+  [create ak av x b]
+  `(let [b# ~b
+         bk# (-k b#) bv# (-v b#) y# (-l b#) z# (-r b#)]
+     (~create bk# bv# (~create ~ak ~av ~x y#) z#)))
+
+(defmacro rotate-double-left
+  "Double left rotation. Move Y1 (the left subtree of B, which is the left
+  subtree of C, which is the right subtree of A) into the left subtree.
+  Required when: weight(X) < δ × weight(C) and weight(Y) >= γ × weight(Z).
+
+                ,---,                                    ,---,
+                | A |                                    | B |
+             ___:---:___                             ____:---:____
+        ,---:           :---,                   ,---:             :---,
+        | X |           | C |                   | A |             | C |
+        '---'           :---:         =>        :---:             :---:
+                   ,---:     :---,         ,---:     :---,   ,---:     :---,
+                   | B |     | Z |         | X |     | y1|   | y2|     | Z |
+                   :---:     '---'         '---'     '---'   '---'     '---'
+              ,---:     :---,
+              | y1|     | y2|
+              '---'     '---'
+  "
+  [create ak av x c]
+  `(let [c# ~c
+         ck# (-k c#) cv# (-v c#) b# (-l c#) z# (-r c#)
+         bk# (-k b#) bv# (-v b#) y1# (-l b#) y2# (-r b#)]
+     (~create bk# bv# (~create ~ak ~av ~x y1#) (~create ck# cv# y2# z#))))
+
+(defmacro rotate-single-right
+  "Single right rotation. Move Y (the right subtree of the left subtree of B)
+  into the right subtree. Required when: weight(Z) < δ × weight(A) and
+  weight(Y) < γ × weight(X).
+
+                ,---,                                  ,---,
+                | B |                                  | A |
+                :---:                                  :---:
+               :     :                                :     :
+          ,---:       :---,                      ,---:       :---,
+          | A |       | Z |          =>          | X |       | B |
+          :---:       '---'                      '---'       :---:
+     ,---:     :---,                                    ,---:     :---,
+     | X |     | Y |                                    | Y |     | Z |
+     '---'     '---'                                    '---'     '---'
+  "
+  [create bk bv a z]
+  `(let [a# ~a
+         ak# (-k a#) av# (-v a#) x# (-l a#) y# (-r a#)]
+     (~create ak# av# x# (~create ~bk ~bv y# ~z))))
+
+(defmacro rotate-double-right
+  "Double right rotation. Move Y2 (the right subtree of B, which is the right
+  subtree of A, which is the left subtree of C) into the right subtree.
+  Required when: weight(Z) < δ × weight(A) and weight(Y) >= γ × weight(X).
+
+                ,---,                                    ,---,
+                | C |                                    | B |
+             ___:---:___                             ____:---:____
+        ,---:           :---,                   ,---:             :---,
+        | A |           | Z |                   | A |             | C |
+        :---:           '---'        =>         :---:             :---:
+   ,---:     :---,                         ,---:     :---,   ,---:     :---,
+   | X |     | B |                         | X |     | y1|   | y2|     | Z |
+   '---'     :---:                         '---'     '---'   '---'     '---'
+        ,---:     :---,
+        | y1|     | y2|
+        '---'     '---'
+  "
+  [create ck cv a z]
+  `(let [a# ~a
+         ak# (-k a#) av# (-v a#) x# (-l a#) b# (-r a#)
+         bk# (-k b#) bv# (-v b#) y1# (-l b#) y2# (-r b#)]
+     (~create bk# bv# (~create ak# av# x# y1#) (~create ~ck ~cv y2# ~z))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Stitch - the fundamental balancing constructor
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn node-stitch
+  "Join left and right subtrees at root k/v, performing a single or double
+  rotation to restore weight balance if needed.
+
+  This is the tree's fundamental balancing constructor. It assumes all keys
+  in `l` are less than `k`, all keys in `r` are greater than `k`, and that
+  at most one single or double rotation is needed to restore balance.
+
+  The 5-arity form takes an explicit node constructor as its final argument
+  and is used in hot internal paths to avoid dynamic-var indirection. The
+  4-arity form uses the current `*t-join*` binding."
+  ([k v l r]
+   (node-stitch k v l r *t-join*))
+  ([k v l r create]
+   (let [lw (node-weight l)
+         rw (node-weight r)]
+     (cond
+       ;; Right-heavy: rotate left
+       (> rw (* +delta+ lw))
+       (let [rl  (-l r)
+             rlw (node-weight rl)
+             rrw (node-weight (-r r))]
+         (if (< rlw (* +gamma+ rrw))
+           (rotate-single-left create k v l r)
+           (rotate-double-left create k v l r)))
+
+       ;; Left-heavy: rotate right
+       (> lw (* +delta+ rw))
+       (let [lr  (-r l)
+             llw (node-weight (-l l))
+             lrw (node-weight lr)]
+         (if (< lrw (* +gamma+ llw))
+           (rotate-single-right create k v l r)
+           (rotate-double-right create k v l r)))
+
+       ;; Balanced
+       :else
+       (create k v l r)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fundamental Tree Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn node-add
+  "Insert a new key/value into the tree rooted at n."
+  ([n k]
+   (node-add n k k))
+  ([n k v]
+   (node-add n k v order/*compare* *t-join*))
+  ([n k v ^Comparator cmp create]
+   (letfn [(add [n]
+             (if (leaf? n)
+               (create k v (leaf) (leaf))
+               (kvlr [key val l r] n
+                 (let [c (.compare cmp k key)]
+                   (cond
+                     (zero? c) (create key v l r)
+                     (neg? c)  (node-stitch key val (add l) r create)
+                     :else     (node-stitch key val l (add r) create))))))]
+     (add n))))
+
+(defn node-add-if-absent
+  "Insert key/value only if key doesn't exist. Returns new tree or nil if key exists.
+   Single traversal - more efficient than contains? + add for assocEx."
+  ([n k v ^Comparator cmp create]
+   (letfn [(add [n]
+             (if (leaf? n)
+               (create k v (leaf) (leaf))
+               (kvlr [key val l r] n
+                 (let [c (.compare cmp k key)]
+                   (cond
+                     (zero? c) nil  ; key exists, signal failure
+                     (neg? c)  (when-let [new-l (add l)]
+                                 (node-stitch key val new-l r create))
+                     :else     (when-let [new-r (add r)]
+                                 (node-stitch key val l new-r create)))))))]
+     (add n))))
+
+(defn node-concat3
+  "Join two trees, the left rooted at l, and the right at r,
+  with a new key/value, performing rotation operations on the resulting
+  trees and subtrees. Assumes all keys in l are smaller than all keys in
+  r, and the relative balance of l and r is such that no more than one
+  rotation operation will be required to balance the resulting tree."
+  ([k v l r]
+   (node-concat3 k v l r order/*compare* *t-join*))
+  ([k v l r ^Comparator cmp create]
+   (letfn [(add [n]
+             (if (leaf? n)
+               (create k v (leaf) (leaf))
+               (kvlr [key val l r] n
+                 (let [c (.compare cmp k key)]
+                   (cond
+                     (zero? c) (create key v l r)
+                     (neg? c)  (node-stitch key val (add l) r create)
+                     :else     (node-stitch key val l (add r) create))))))
+           (cat3 [k v l r]
+             (cond
+               (leaf? l) (add r)
+               (leaf? r) (add l)
+               true      (let [lw (node-weight l)
+                               rw (node-weight r)]
+                           (cond
+                             (< (* +delta+ lw) rw) (kvlr [k2 v2 l2 r2] r
+                                                     (node-stitch k2 v2
+                                                       (cat3 k v l l2) r2 create))
+                             (< (* +delta+ rw) lw) (kvlr [k1 v1 l1 r1] l
+                                                     (node-stitch k1 v1 l1
+                                                       (cat3 k v r1 r) create))
+                             true                  (create k v l r)))))]
+     (cat3 k v l r))))
+
+(defn node-least-kv
+  "Return [k v] for the minimum key of the tree rooted at n."
+  [n]
+  (cond
+    (leaf? n)      (throw (ex-info "least: empty tree" {:node n}))
+    (leaf? (-l n)) [(-k n) (-v n)]
+    :else          (recur (-l n))))
+
+(defn node-least
+  "Return the node containing the minimum key of the tree rooted at n."
+  [n]
+  (cond
+    (leaf? n)      (throw (ex-info "least: empty tree" {:node n}))
+    (leaf? (-l n)) n
+    :else          (recur (-l n))))
+
+(defn node-greatest-kv
+  "Return [k v] for the maximum key of the tree rooted at n."
+  [n]
+  (cond
+    (leaf? n)      (throw (ex-info "greatest: empty tree" {:node n}))
+    (leaf? (-r n)) [(-k n) (-v n)]
+    :else          (recur (-r n))))
+
+(defn node-greatest
+  "Return the node containing the maximum key of the tree rooted at n."
+  [n]
+  (cond
+    (leaf? n)      (throw (ex-info "greatest: empty tree" {:node n}))
+    (leaf? (-r n)) n
+    :else          (recur (-r n))))
+
+(defn node-remove-least
+  "Return a tree the same as the one rooted at n, with the node
+  containing the minimum key removed. See node-least."
+  ([n]
+   (node-remove-least n *t-join*))
+  ([n create]
+   (letfn [(rm-least [n]
+             (cond
+               (leaf? n)      (throw (ex-info "remove-least: empty tree" {:node n}))
+               (leaf? (-l n)) (-r n)
+               :else          (node-stitch (-k n) (-v n)
+                                (rm-least (-l n)) (-r n) create)))]
+     (rm-least n))))
+
+(defn node-remove-greatest
+  "Return a tree the same as the one rooted at n, with the node
+  containing the maximum key removed. See node-greatest."
+  [n]
+  (let [create *t-join*]
+    (letfn [(rm-greatest [n]
+              (cond
+                (leaf? n)      (throw (ex-info "remove-greatest: empty tree" {:node n}))
+                (leaf? (-r n)) (-l n)
+                :else          (node-stitch (-k n) (-v n) (-l n)
+                                 (rm-greatest (-r n)) create)))]
+      (rm-greatest n))))
+
+(defn node-concat2
+  "Join two trees, the left rooted at l, and the right at r,
+  performing a single balancing operation on the resulting tree, if
+  needed. Assumes all keys in l are smaller than all keys in r, and
+  the relative balance of l and r is such that no more than one rotation
+  operation will be required to balance the resulting tree."
+  ([l r]
+   (node-concat2 l r *t-join*))
+  ([l r create]
+   (cond
+     (leaf? l) r
+     (leaf? r) l
+     :else     (let [[k v] (node-least-kv r)]
+                 (node-stitch k v l (node-remove-least r create) create)))))
+
+(defn node-remove
+  "remove the node whose key is equal to k, if present."
+  ([n k]
+   (node-remove n k order/*compare* *t-join*))
+  ([n k ^Comparator cmp create]
+   (letfn [(rm [n]
+             (if (leaf? n)
+               (leaf)
+               (kvlr [key val l r] n
+                 (let [c (.compare cmp k key)]
+                   (cond
+                     (zero? c) (node-concat2 l r create)
+                     (neg? c)  (node-stitch key val (rm l) r create)
+                     :else     (node-stitch key val l (rm r) create))))))]
+     (rm n))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Lookup
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; These are the hottest paths in the library. Every lookup, contains?, and get
+;; operation flows through here. Optimizations applied:
+;;
+;; 1. Use definline for zero-overhead accessor calls
+;; 2. Avoid dynamic var lookup - always pass comparator explicitly
+;; 3. Minimize branching in the loop
+;; 4. Type hints to avoid reflection
+;; 5. Primitive specializations for Long keys bypass Comparator entirely
+;;
+;; PERFORMANCE NOTE: The 3-arity versions with explicit ^Comparator are the
+;; fast path. The 2-arity versions that use order/*compare* have ~200ns
+;; overhead per call from dynamic binding lookup.
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Primitive-specialized lookup for Long keys.
+;; Bypasses Comparator dispatch entirely by using Long/compare directly.
+;; This is ~30% faster than going through the Comparator interface.
+
+(defn node-contains-long?
+  "Primitive-specialized membership check for Long keys.
+
+  Use this when the caller only needs a boolean presence test. It avoids both
+  Comparator dispatch and the broader node-returning contract of `node-find-long`."
+  [n ^long k]
+  (loop [n n]
+    (if (leaf? n)
+      false
+      (let [nk (long (-k n))
+            c (Long/compare k nk)]
+        (if (zero? c) true (recur (if (neg? c) (-l n) (-r n))))))))
+
+(defn node-find-long
+  "Primitive-specialized node lookup for Long keys.
+
+  Use this when the caller needs the matching node rather than just a boolean.
+  Kept separate from `node-contains-long?` so membership-only call sites can stay
+  on the minimal boolean path."
+  ([n ^long k]
+   (node-find-long n k nil))
+  ([n ^long k not-found]
+   (loop [n n]
+     (if (leaf? n)
+       not-found
+       (let [nk (long (-k n))
+             c (Long/compare k nk)]
+         (if (zero? c) n (recur (if (neg? c) (-l n) (-r n)))))))))
+
+(defn node-find-val-long
+  "Primitive-specialized value lookup for Long keys.
+
+  Use this when the caller needs only the associated value (or `not-found`),
+  without materializing the broader node-returning path."
+  [n ^long k not-found]
+  (loop [n n]
+    (if (leaf? n)
+      not-found
+      (let [nk (long (-k n))
+            c (Long/compare k nk)]
+        (if (zero? c) (-v n) (recur (if (neg? c) (-l n) (-r n))))))))
+
+;; String-specialized lookup functions.
+;; Uses String.compareTo directly, avoiding Comparator dispatch.
+
+(defn node-contains-string?
+  "String-specialized membership check.
+
+  Use this when the caller only needs presence/absence. It uses
+  `String.compareTo` directly and avoids the broader node-returning contract of
+  `node-find-string`."
+  [n ^String k]
+  (loop [n n]
+    (if (leaf? n)
+      false
+      (let [c (.compareTo k ^String (-k n))]
+        (if (zero? c) true (recur (if (neg? c) (-l n) (-r n))))))))
+
+(defn node-find-string
+  "String-specialized node lookup.
+
+  Use this when the caller needs the matching node rather than just a boolean.
+  Kept separate from `node-contains-string?` so membership-only call sites can
+  stay on the minimal boolean path."
+  ([n ^String k]
+   (node-find-string n k nil))
+  ([n ^String k not-found]
+   (loop [n n]
+     (if (leaf? n)
+       not-found
+       (let [c (.compareTo k ^String (-k n))]
+         (if (zero? c) n (recur (if (neg? c) (-l n) (-r n)))))))))
+
+(defn node-find-val-string
+  "String-specialized value lookup.
+
+  Use this when the caller needs only the associated value (or `not-found`),
+  without materializing the broader node-returning path."
+  [n ^String k not-found]
+  (loop [n n]
+    (if (leaf? n)
+      not-found
+      (let [c (.compareTo k ^String (-k n))]
+        (if (zero? c) (-v n) (recur (if (neg? c) (-l n) (-r n))))))))
+
+(defn node-find
+  "find a node in n whose key = k.
+   Returns a node implementing INode, or `not-found` when absent.
+
+   Arity notes:
+   - `(node-find n k)` uses the current dynamic comparator
+   - `(node-find n k cmp)` uses an explicit comparator
+   - `(node-find n k not-found cmp)` uses both an explicit fallback and comparator"
+  ([n k]
+   (node-find n k nil order/*compare*))
+  ([n k ^Comparator cmp]
+   (node-find n k nil cmp))
+  ([n k not-found ^Comparator cmp]
+   (loop [n n]
+     (if (leaf? n)
+       not-found
+       (let [c (.compare cmp k (-k n))]
+         (if (zero? c) n (recur (if (neg? c) (-l n) (-r n)))))))))
+
+(defn node-find-val
+  "Find value for key k in tree. Returns the value or not-found."
+  ([n k not-found]
+   (node-find-val n k not-found order/*compare*))
+  ([n k not-found ^Comparator cmp]
+   (loop [n n]
+     (if (leaf? n)
+       not-found
+       (let [c (.compare cmp k (-k n))]
+         (if (zero? c) (-v n) (recur (if (neg? c) (-l n) (-r n)))))))))
+
+(defn node-contains?
+  "Check if key k exists in tree."
+  ([n k]
+   (node-contains? n k order/*compare*))
+  ([n k ^Comparator cmp]
+   (loop [n n]
+     (if (leaf? n)
+       false
+       (let [c (.compare cmp k (-k n))]
+         (if (zero? c) true (recur (if (neg? c) (-l n) (-r n)))))))))
+
+(defn node-find-nearest
+  "Find the nearest k according to relation expressed by :< or :>"
+  [n k & [gt-or-lt]]
+  (let [gt-or-lt (or gt-or-lt :<)
+        ^Comparator cmp-fn order/*compare*
+        [cmp fwd rev] (case gt-or-lt
+                        :< [(fn [x y] (neg? (.compare cmp-fn x y))) -l -r]
+                        :> [(fn [x y] (pos? (.compare cmp-fn x y))) -r -l])]
+    (loop [this n best nil]
+      (cond
+        (leaf? this)      best
+        (cmp k (-k this)) (recur (fwd this) best)
+        true              (recur (rev this) this)))))
+
+(defn node-predecessor
+  "Find the predecessor of key k (greatest element strictly less than k).
+   Returns the node, or nil if no predecessor exists.
+   O(log n) - single traversal that tracks the last right turn."
+  [n k]
+  (let [^Comparator cmp order/*compare*]
+    (loop [n n
+           predecessor nil]
+      (if (leaf? n)
+        predecessor
+        (let [c (.compare cmp k (-k n))]
+          (cond
+            ;; k < current: go left, predecessor unchanged
+            (neg? c) (recur (-l n) predecessor)
+            ;; k > current: current is potential predecessor, go right
+            (pos? c) (recur (-r n) n)
+            ;; k = current: predecessor is max of left subtree, if any
+            :else (if (leaf? (-l n))
+                    predecessor
+                    (node-greatest (-l n)))))))))
+
+(defn node-successor
+  "Find the successor of key k (least element strictly greater than k).
+   Returns the node, or nil if no successor exists.
+   O(log n) - single traversal that tracks the last left turn."
+  [n k]
+  (let [^Comparator cmp order/*compare*]
+    (loop [n n
+           successor nil]
+      (if (leaf? n)
+        successor
+        (let [c (.compare cmp k (-k n))]
+          (cond
+            ;; k > current: go right, successor unchanged
+            (pos? c) (recur (-r n) successor)
+            ;; k < current: current is potential successor, go left
+            (neg? c) (recur (-l n) n)
+            ;; k = current: successor is min of right subtree, if any
+            :else (if (leaf? (-r n))
+                    successor
+                    (node-least (-r n)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Tree Augmentation and Search
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; AUGMENTED INTERVAL TREE
+;;
+;; An interval tree stores intervals [a,b] and supports efficient queries for
+;; all intervals that overlap a given point or interval. The key insight is
+;; the -z augmentation: each node stores the MAXIMUM ENDPOINT of all intervals
+;; in its subtree.
+;;
+;; NODE STRUCTURE (IntervalNode):
+;;
+;;   -k : interval [a,b] — the key, sorted by start point 'a'
+;;   -v : associated value
+;;   -l : left subtree  (intervals with smaller start points)
+;;   -r : right subtree (intervals with larger start points)
+;;   -x : subtree size (for weight balancing)
+;;   -z : MAX endpoint 'b' across this node and all descendants
+;;
+;; EXAMPLE: Intervals [1,5], [3,8], [6,7], [4,9], [2,3]
+;;
+;; Sorted by start point and built into a balanced tree:
+;;
+;;                          ┌─────────────────┐
+;;                          │ key: [3,8]      │
+;;                          │ z: 9  ←─────────────── max(8, 5, 9) from subtree
+;;                          └────────┬────────┘
+;;                      ┌────────────┴────────────┐
+;;              ┌───────┴───────┐         ┌───────┴───────┐
+;;              │ key: [1,5]    │         │ key: [6,7]    │
+;;              │ z: 5          │         │ z: 9          │
+;;              └───────┬───────┘         └───────┬───────┘
+;;                      │                 ┌───────┴───────┐
+;;              ┌───────┴───────┐         │ key: [4,9]    │
+;;              │ key: [2,3]    │         │ z: 9          │
+;;              │ z: 3          │         └───────────────┘
+;;              └───────────────┘
+;;
+;; SEARCH ALGORITHM (finding intervals that overlap query interval Q=[qa,qb]):
+;;
+;; Two intervals [a,b] and [qa,qb] overlap iff: a <= qb AND qa <= b
+;;
+;; The -z augmentation enables PRUNING:
+;;
+;;   1. PRUNE LEFT SUBTREE: If qa > left.-z, no interval in the left subtree
+;;      can overlap Q (all endpoints are too small).
+;;
+;;   2. PRUNE RIGHT SUBTREE: If qb < node.key.a, no interval in the right
+;;      subtree can overlap Q (all start points are too large).
+;;
+;; SEARCH WALKTHROUGH: Query Q=[5,6] on the tree above
+;;
+;;   At [3,8]: z=9
+;;     • Right subtree: qb=6 >= key.a=3? Yes → search right
+;;     • Check [3,8]: overlaps [5,6]? 3<=6 ∧ 5<=8 → YES, collect it
+;;     • Left subtree: qa=5 <= left.z=5? Yes → search left
+;;
+;;   At [6,7]: z=9
+;;     • Right subtree: qb=6 >= key.a=6? Yes → search right
+;;     • Check [6,7]: overlaps [5,6]? 6<=6 ∧ 5<=7 → YES, collect it
+;;     • Left subtree: (has child [4,9])
+;;
+;;   At [4,9]: z=9
+;;     • Check [4,9]: overlaps [5,6]? 4<=6 ∧ 5<=9 → YES, collect it
+;;
+;;   At [1,5]: z=5
+;;     • Right subtree: none
+;;     • Check [1,5]: overlaps [5,6]? 1<=6 ∧ 5<=5 → YES, collect it
+;;     • Left subtree: qa=5 <= left.z=3? No → PRUNE (skip [2,3])
+;;
+;; Result: [[3,8], [6,7], [4,9], [1,5]] — found 4 overlapping intervals,
+;;         pruned [2,3] without examining it.
+;;
+;; COMPLEXITY: O(k + log n) where k = number of overlapping intervals.
+;; The -z augmentation ensures we only visit nodes that could contain matches.
+
+(defn- node-find-interval-fn [i pred]
+  (let [i      (interval/ordered-pair i)
+        result (volatile! nil)
+        accum  (if pred
+                 (fn [n] (vswap! result #(if (or (nil? %) (pred n %)) n %)))
+                 (fn [n] (vswap! result conj n)))]
+    (fn [n]
+      (letfn [(srch [this]
+                (when-not (leaf? this)
+                  ;; Search right if query endpoint >= node's start point
+                  (when (order/compare>= (interval/b i) (-> this -k interval/a))
+                    (-> this -r srch))
+                  ;; Check current node for intersection
+                  (when (interval/intersects? i (-k this))
+                    (accum this))
+                  ;; Search left only if query start <= max endpoint in left subtree
+                  (when (and (not (leaf? (-l this)))
+                             (order/compare<= (interval/a i) (-> this -l -z)))
+                    (-> this -l srch))))]
+        (srch n)
+        @result))))
+
+(defn node-find-intervals [n i]
+  ((node-find-interval-fn i nil) n))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Iteration - `node-run!` et al. for eager side-effecting walks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn node-run!
+  "Eagerly apply f to each node of the tree rooted at n, from least to greatest."
+  [n f]
+  (when-not (leaf? n)
+    (lr [l r] n
+      (node-run! l f)
+      (f n)
+      (node-run! r f))))
+
+(defn node-run-kv!
+  "Eagerly apply f to each key/value pair in the tree rooted at n, from least to greatest."
+  [n f]
+  (when-not (leaf? n)
+    (lr [l r] n
+      (node-run-kv! l f)
+      (f (-k n) (-v n))
+      (node-run-kv! r f))))
+
+(defn node-run-reverse!
+  "Eagerly apply f to each node of the tree rooted at n, from greatest to least."
+  [n f]
+  (when-not (leaf? n)
+    (lr [l r] n
+      (node-run-reverse! r f)
+      (f n)
+      (node-run-reverse! l f))))
+
+(defn node-run-kv-reverse!
+  "Eagerly apply f to each key/value pair in the tree rooted at n, from greatest to least."
+  [n f]
+  (when-not (leaf? n)
+    (lr [l r] n
+      (node-run-kv-reverse! r f)
+      (f (-k n) (-v n))
+      (node-run-kv-reverse! l f))))
+
+(defmacro ^:private enum-count
+  [enum next-fn]
+  `(loop [e# ~enum n# 0]
+     (if e#
+       (recur (~next-fn e#) (unchecked-inc-int n#))
+       n#)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Reduction
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Reduction is layered on top of enumerators.
+;;
+;; There are two distinct reduction shapes:
+;;
+;; 1. Unary reduction over a projected node value
+;;    `(f acc x)`
+;;    Used for:
+;;      - nodes
+;;      - keys
+;;      - entries
+;;    These share one implementation strategy:
+;;      - direction is chosen by the enumerator step (`node-enum-rest` or
+;;        `node-enum-prior`)
+;;      - projection is chosen by a small function (`identity`, `-k`,
+;;        `node-entry`)
+;;
+;; 2. Key/value reduction
+;;    `(f acc k v)`
+;;    This stays separate because it has no natural seeded 2-arity form, and
+;;    forcing it through the unary projection layer would add avoidable packing.
+;;
+;; All reducers support `reduced` short-circuiting. The unary reducers share
+;; the seeded and explicit-init enumerator kernels below.
+
+(declare node-add node-nth node-split)
+
+(defmacro ^:private enum-reduce-init
+  "Shared enumerator reduction kernel for explicit initial values."
+  [enum next-fn acc-sym init-expr node-sym step-expr]
+  `(loop [e# ~enum ~acc-sym ~init-expr]
+     (if (nil? e#)
+       ~acc-sym
+       (let [~node-sym (node-enum-first e#)
+             ret# ~step-expr]
+         (if (reduced? ret#)
+           @ret#
+           (recur (~next-fn e#) ret#))))))
+
+(defmacro ^:private enum-reduce-first
+  "Shared enumerator reduction kernel for the 1-arity IReduce case, where the
+   first element seeds the accumulator and empty enumerations call (f)."
+  [enum-expr next-fn acc-sym node-sym seed-expr step-expr empty-expr]
+  `(if-let [e0# ~enum-expr]
+     (let [~node-sym (node-enum-first e0#)]
+       (loop [e# (~next-fn e0#) ~acc-sym ~seed-expr]
+         (if (nil? e#)
+           ~acc-sym
+           (let [~node-sym (node-enum-first e#)
+             ret# ~step-expr]
+             (if (reduced? ret#)
+               @ret#
+               (recur (~next-fn e#) ret#))))))
+     ~empty-expr))
+
+(defn- make-unary-reducer
+  "Build a reducer over nodes traversed by `enum-fn` / `next-fn`, projecting
+   each visited node through `project` before calling `f`."
+  [enum-fn next-fn project]
+  (fn
+    ([f init root]
+     (enum-reduce-init (enum-fn root) next-fn acc init n
+       (f acc (project n))))
+    ([f root]
+     (enum-reduce-first (enum-fn root) next-fn acc n (project n)
+       (f acc (project n))
+       (f)))))
+
+(defn- node-entry [n]
+  (clojure.lang.MapEntry. (-k n) (-v n)))
+
+(def node-reduce
+  (make-unary-reducer node-enumerator node-enum-rest identity))
+
+(def node-reduce-right
+  (make-unary-reducer node-enumerator-reverse node-enum-prior identity))
+
+(def node-reduce-keys
+  (make-unary-reducer node-enumerator node-enum-rest -k))
+
+(def node-reduce-keys-right
+  (make-unary-reducer node-enumerator-reverse node-enum-prior -k))
+
+(def node-reduce-entries
+  (make-unary-reducer node-enumerator node-enum-rest node-entry))
+
+(def node-reduce-entries-right
+  (make-unary-reducer node-enumerator-reverse node-enum-prior node-entry))
+
+(defn node-reduce-kv
+  "Reduce tree key/value pairs from least to greatest via (f acc k v).
+   Supports early termination via clojure.core/reduced."
+  [f init root]
+  (letfn [(reduce-node [acc n]
+            (cond
+              (leaf? n) acc
+              (reduced? acc) acc
+              :else
+              (lr [l r] n
+                (let [acc (reduce-node acc l)]
+                  (if (reduced? acc)
+                    acc
+                    (let [acc (f acc (-k n) (-v n))]
+                      (if (reduced? acc)
+                        acc
+                        (reduce-node acc r))))))))]
+    (let [result (reduce-node init root)]
+      (if (reduced? result) @result result))))
+
+(defn node-reduce-kv-right
+  "Reduce tree key/value pairs from greatest to least via (f acc k v).
+   Supports early termination via clojure.core/reduced."
+  [f init root]
+  (letfn [(reduce-node [acc n]
+            (cond
+              (leaf? n) acc
+              (reduced? acc) acc
+              :else
+              (lr [l r] n
+                (let [acc (reduce-node acc r)]
+                  (if (reduced? acc)
+                    acc
+                    (let [acc (f acc (-k n) (-v n))]
+                      (if (reduced? acc)
+                        acc
+                        (reduce-node acc l))))))))]
+    (let [result (reduce-node init root)]
+      (if (reduced? result) @result result))))
+
+(defn node-chunks
+  "Partition tree `n` into roughly equal subtrees of about `chunk-size`
+  elements."
+  [^long chunk-size n]
+  (let [sz         (node-size n)
+        num-chunks (max 2 (quot sz chunk-size))]
+    (loop [i         1
+           remaining n
+           result    []]
+      (if (or (= i num-chunks) (leaf? remaining))
+        (conj result remaining)
+        (let [pos       (long (* sz (/ (double i) num-chunks)))
+              split-key (-k (node-nth n pos))
+              [lt present gt] (node-split remaining split-key)
+              gt (if present
+                   (node-add gt (first present) (second present))
+                   gt)]
+          (recur (inc i) gt (conj result lt)))))))
+
+(defn node-fold
+  "Parallel fold to support clojure.core.reducers/CollFold.
+
+   Splits the tree into chunks, then folds them in parallel via r/fold.
+   Splitting is done eagerly in the caller's thread (where dynamic bindings
+   are available); each chunk's sequential reduce uses node-reduce which
+   needs no bindings."
+  [^long chunk-size n combinef reducef]
+  {:pre [(pos? chunk-size)]}
+  (let [sz (node-size n)]
+    (if (<= sz chunk-size)
+      (node-reduce reducef (combinef) n)
+      (let [subtrees    (node-chunks chunk-size n)
+            rf (fn [_ ^long idx]
+                 (node-reduce reducef (combinef) (nth subtrees idx)))]
+        (r/fold 1 combinef rf (vec (range (count subtrees))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Tree Health
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn node-healthy?
+  "verify node `n` and all descendants satisfy the node-invariants
+  of a weight-balanced binary tree."
+  [n]
+  (if (leaf? n)
+    true
+    (lr [l r] n
+      (let [lw (node-weight l)
+            rw (node-weight r)]
+        (and
+          (<= (max lw rw) (* +delta+ (min lw rw)))
+          (node-healthy? l)
+          (node-healthy? r))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Tree Splitting (Logarithmic Time)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; SPLIT OPERATION
+;;
+;; `node-split` decomposes a tree at a pivot key k into three parts:
+;;   (L, present, R)
+;;
+;; Where:
+;;   L       = tree of all elements < k
+;;   present = nil if k not found, or (k v) if found
+;;   R       = tree of all elements > k
+;;
+;;
+;; COMPLEXITY: O(log n) — each recursive call descends one level
+;;
+;; WHY IT MATTERS: Split is the foundation for efficient set operations.
+;; Instead of element-by-element insertion (O(n log n)), we can implement
+;; union, intersection, and difference in O(n) time using divide-and-conquer.
+
+(defn- node-split-lesser*
+  [n k ^Comparator cmp create]
+  (loop [n n]
+    (if (leaf? n)
+      n
+      (kvlr [kn vn ln rn] n
+        (let [c (.compare cmp k kn)]
+          (cond
+            (zero? c) ln
+            (neg? c)  (recur ln)
+            :else     (node-concat3 kn vn ln (node-split-lesser* rn k cmp create) cmp create)))))))
+
+(defn node-split-lesser
+  "return a tree of all nodes whose key is less than k (Logarithmic time)."
+  [n k]
+  (node-split-lesser* n k order/*compare* *t-join*))
+
+(defn- node-split-greater*
+  [n k ^Comparator cmp create]
+  (loop [n n]
+    (if (leaf? n)
+      n
+      (kvlr [kn vn ln rn] n
+        (let [c (.compare cmp k kn)]
+          (cond
+            (zero? c) rn
+            (neg? c)  (node-concat3 kn vn (node-split-greater* ln k cmp create) rn cmp create)
+            :else     (recur rn)))))))
+
+(defn node-split-greater
+  "return a tree of all nodes whose key is greater than k (Logarithmic time)."
+  [n k]
+  (node-split-greater* n k order/*compare* *t-join*))
+
+(defn- node-split*
+  [n k ^Comparator cmp create]
+  (letfn [(split [n]
+            (if (leaf? n)
+              [nil nil nil]
+              (kvlr [ak v l r] n
+                (let [c (.compare cmp k ak)]
+                  (cond
+                    (zero? c) [l (list k v) r]
+                    (neg? c)  (let [[ll pres rl] (split l)]
+                                [ll pres (node-concat3 ak v rl r cmp create)])
+                    :else     (let [[lr pres rr] (split r)]
+                                [(node-concat3 ak v l lr cmp create) pres rr]))))))]
+    (split n)))
+
+(defn node-split
+  "returns a triple (l present r) where: l is the set of elements of
+  n that are < k, r is the set of elements of n that are > k, present
+  is false if n contains no element equal to k, or (k v) if n contains
+  an element with key equal to k."
+  [n k]
+  (node-split* n k order/*compare* *t-join*))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Tree Comparator (Worst-Case Linear Time)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn node-compare
+  "return 3-way comparison of the trees n1 and n2 using an accessor
+  to compare specific node consitituent values: :k, :v, :kv, or any
+  user-specifed function.  Default, when not specified, to the
+  entire node structure. return-value semantics:
+   -1  -> n1 is LESS-THAN    n2
+    0  -> n1 is EQUAL-TO     n2
+   +1  -> n1 is GREATER-THAN n2"
+  [accessor n1 n2]
+  (let [acc-fn (cond-> accessor
+                 (not (fn? accessor)) node-accessor)
+        ^Comparator cmp order/*compare*]
+    (loop [e1 (node-enumerator n1 nil)
+           e2 (node-enumerator n2 nil)]
+      (cond
+        (and (nil? e1) (nil? e2))  0
+        (nil? e1)                  -1
+        (nil? e2)                   1
+        :else
+        (let [^EnumFrame ef1 e1
+              ^EnumFrame ef2 e2
+              x1   (.-node ef1)
+              x2   (.-node ef2)
+              val1 (acc-fn x1)
+              val2 (acc-fn x2)
+              c    (.compare cmp val1 val2)]
+          (if-not (zero? c)
+            c
+            (recur (node-enumerator (.-subtree ef1) (.-next ef1))
+                   (node-enumerator (.-subtree ef2) (.-next ef2)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fundamental Set Operations (Worst-Case Linear Time)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; SET OPERATIONS VIA DIVIDE-AND-CONQUER
+;;
+;; Union, intersection, and difference are implemented using a powerful
+;; divide-and-conquer strategy based on `node-split`. This achieves O(m+n)
+;; time complexity instead of the naive O(m log n) element-by-element approach.
+;;
+;; THE PATTERN (using union as example):
+;;
+;;   union(T1, T2):
+;;     if T1 is empty: return T2
+;;     if T2 is empty: return T1
+;;
+;;     Pick the root of T2: key=k, left=L2, right=R2
+;;     Split T1 at k:       (L1, _, R1) = split(T1, k)
+;;
+;;     Recursively:
+;;       left-result  = union(L1, L2)    ← elements < k from both trees
+;;       right-result = union(R1, R2)    ← elements > k from both trees
+;;
+;;     Combine: concat3(k, v, left-result, right-result)
+;;
+;; VISUAL: union of {1,3,5} and {2,3,4}
+;;
+;;         T1              T2
+;;        ,---,           ,---,
+;;        | 3 |           | 3 |
+;;        :---:           :---:
+;;       :     :         :     :
+;;    ,-:       :-,   ,-:       :-,
+;;    |1 |     |5 |   |2 |     |4 |
+;;    '--'     '--'   '--'     '--'
+;;
+;;   Step 1: Split T1 at T2's root (3)
+;;           L1={1}, present=(3,v), R1={5}
+;;
+;;   Step 2: Recurse
+;;           union({1}, {2}) → {1,2}
+;;           union({5}, {4}) → {4,5}
+;;
+;;   Step 3: Combine
+;;           concat3(3, v, {1,2}, {4,5}) → {1,2,3,4,5}
+;;
+;;
+;; INTERSECTION works similarly but only keeps k if present in BOTH trees:
+;;
+;;   intersection(T1, T2):
+;;     Split T1 at T2's root k: (L1, present, R1)
+;;     If present:  concat3(k, v, intersect(L1,L2), intersect(R1,R2))
+;;     If absent:   concat2(intersect(L1,L2), intersect(R1,R2))
+;;                           └─ no middle element to join with
+;;
+;; DIFFERENCE removes elements of T2 from T1:
+;;
+;;   difference(T1, T2):
+;;     Split T1 at T2's root k: (L1, _, R1)
+;;     concat2(difference(L1,L2), difference(R1,R2))
+;;             └─ always concat2, never include k (it's in T2)
+;;
+;; WHY O(m+n)?
+;;
+;; Each node from both trees is visited exactly once. The split and concat3
+;; operations are O(log n), but the total work across all recursive calls
+;; telescopes to O(m+n) because:
+;;   - Each split divides T1 into disjoint parts
+;;   - Each element participates in only O(1) concat3 operations
+;;
+;; This is the "Adams' algorithm" from the 1992 paper, refined by many others.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Explicit-Argument Algebra Hot Paths
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; The public tree algebra functions are intentionally dynamic-var friendly,
+;; but the recursive set/map kernels are hot enough that repeated lookups of
+;; `order/*compare*` and `*t-join*` are measurable overhead. These private
+;; variants thread the comparator and node constructor explicitly so the caller
+;; can capture them once and reuse them through the whole recursion. This keeps
+;; the extensible dynamic-binding architecture at the public boundary while
+;; avoiding paying for it at every recursive step in the hottest paths.
+
+(defn- node-set-union*
+  [n1 n2 ^Comparator cmp create]
+  (cond
+    (leaf? n1) n2
+    (leaf? n2) n1
+    :else      (kvlr [ak av l r] n2
+                 (let [[l1 _ r1] (node-split* n1 ak cmp create)]
+                   (node-concat3 ak av
+                                  (node-set-union* l1 l cmp create)
+                                  (node-set-union* r1 r cmp create)
+                                  cmp create)))))
+
+(defn- node-set-intersection*
+  [n1 n2 ^Comparator cmp create]
+  (cond
+    (leaf? n1) (leaf)
+    (leaf? n2) (leaf)
+    :else      (kvlr [ak av l r] n2
+                 (let [[l1 x r1] (node-split* n1 ak cmp create)]
+                   (if x
+                     (node-concat3 ak av
+                                    (node-set-intersection* l1 l cmp create)
+                                    (node-set-intersection* r1 r cmp create)
+                                    cmp create)
+                     (node-concat2 (node-set-intersection* l1 l cmp create)
+                                    (node-set-intersection* r1 r cmp create)
+                                    create))))))
+
+(defn- node-set-difference*
+  [n1 n2 ^Comparator cmp create]
+  (cond
+    (leaf? n1) (leaf)
+    (leaf? n2) n1
+    :else      (kvlr [ak _ l r] n2
+                 (let [[l1 _ r1] (node-split* n1 ak cmp create)]
+                   (node-concat2 (node-set-difference* l1 l cmp create)
+                                  (node-set-difference* r1 r cmp create)
+                                  create)))))
+
+(defn- node-map-merge*
+  [n1 n2 merge-fn ^Comparator cmp create]
+  (cond
+    (leaf? n1) n2
+    (leaf? n2) n1
+    :else      (kvlr [ak av l r] n2
+                 (let [[l1 x r1] (node-split* n1 ak cmp create)
+                       val       (if x
+                                   (merge-fn ak av (second x))
+                                   av)]
+                   (node-concat3 ak val
+                                  (node-map-merge* l1 l merge-fn cmp create)
+                                  (node-map-merge* r1 r merge-fn cmp create)
+                                  cmp create)))))
+
+(defn node-set-union
+  "set union"
+  [n1 n2]
+  (node-set-union* n1 n2 order/*compare* *t-join*))
+
+(defn node-set-intersection
+  "set intersection"
+  [n1 n2]
+  (node-set-intersection* n1 n2 order/*compare* *t-join*))
+
+(defn node-set-difference
+  "set difference"
+  [n1 n2]
+  (node-set-difference* n1 n2 order/*compare* *t-join*))
+
+(defn node-subset?
+  "return true if `sub` is a subset of `super`"
+  [super sub]
+  (let [^Comparator cmp order/*compare*]
+    (letfn [(subset? [n1 n2]
+              (cond
+                (leaf? n1) true
+                (leaf? n2) false
+                :else
+                (and
+                  (<= (node-size n1) (node-size n2))
+                  (kvlr [k1 _ l1 r1] n1
+                    (kvlr [k2 _ l2 r2] n2
+                      (let [c (.compare cmp k1 k2)]
+                        (cond
+                          (zero? c) (and (subset? l1 l2) (subset? r1 r2))
+                          (neg? c)  (and (subset? l1 l2) (node-find n2 k1 cmp) (subset? r1 n2))
+                          :else     (and (subset? r1 r2) (node-find n2 k1 cmp) (subset? l1 n2)))))))))]
+      (or (leaf? sub) (boolean (subset? sub super))))))
+
+(defn node-disjoint?
+  "Return true if the two trees share no elements.
+   Short-circuits on the first common element found.
+   Complexity: O(m log(n/m + 1)) where m <= n."
+  [n1 n2]
+  (cond
+    (leaf? n1) true
+    (leaf? n2) true
+    :else
+    (kvlr [k _ l r] n1
+      (let [[bl present br] (node-split n2 k)]
+        (if present
+          false
+          (and (node-disjoint? l bl)
+               (node-disjoint? r br)))))))
+
+(def node-set-compare (partial node-compare :k))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Parallel Set Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; These implementations use Java's ForkJoinPool for efficient work-stealing
+;; parallelism. The algorithms are based on:
+;;
+;;   Blelloch, Ferizovic, Sun (2016, 2022)
+;;   "Just Join for Parallel Ordered Sets" / "Joinable Parallel Balanced Binary Trees"
+;;   SPAA '16, TOPC '22
+;;
+;; Key insight: All set operations reduce to split + recursive operation + join.
+;; The divide-and-conquer structure naturally maps to fork-join parallelism.
+;;
+;; Performance characteristics:
+;;   - Work: O(m log(n/m + 1)) where m <= n
+;;   - Span: O(log^2 n) - polylogarithmic, enabling high parallelism
+;;   - Scalability: Linear speedup up to O(n/log^2 n) processors
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Root-entry thresholds for the parallel path. These are operation-specific
+;; because the current benchmark data does not support one universal crossover:
+;; comparator cost and result reconstruction differ enough between union,
+;; intersection, difference, and merge that a single conservative threshold
+;; would leave many practical wins on the table.
+
+(def ^:const ^long +parallel-union-root-threshold+ 131072)
+(def ^:const ^long +parallel-intersection-root-threshold+ 65536)
+(def ^:const ^long +parallel-difference-root-threshold+ 131072)
+(def ^:const ^long +parallel-merge-root-threshold+ 65536)
+
+;; Recursive re-fork thresholds, again kept operation-specific. Once we have
+;; paid the top-level entry cost and the spawn guard has filtered out lopsided
+;; subproblems, the benchmark evidence supports lower cutoffs than a single
+;; conservative recursive threshold.
+
+(def ^:const ^long +parallel-union-recursive-threshold+ 65536)
+(def ^:const ^long +parallel-intersection-recursive-threshold+ 65536)
+(def ^:const ^long +parallel-difference-recursive-threshold+ 65536)
+(def ^:const ^long +parallel-merge-recursive-threshold+ 65536)
+
+;; Once we are in the parallel path, only fork a recursive split when both
+;; branches are substantive enough to amortize task overhead. This keeps the
+;; recursive kernels from spawning on highly lopsided splits, where a single
+;; large branch can still recurse and find better-shaped parallel work deeper
+;; in the tree.
+
+(def ^:const ^long +parallel-min-branch+ 65536)
+
+;; Secondary threshold for very small subtrees where even sequential
+;; divide-and-conquer has overhead. Use direct linear merge instead.
+
+(def ^:const ^long +sequential-cutoff+ 64)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Parallel Spawn Heuristics
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; The top-level threshold decides whether an operation enters the ForkJoin
+;; regime at all. Once there, each recursive split still needs a local spawn
+;; decision: balanced subproblems benefit from forking, but lopsided splits
+;; often do better by continuing in one worker and letting the larger branch
+;; find parallelism lower in the tree.
+
+(defn- parallel-spawn-side
+  [^long left-total ^long right-total]
+  (let [smaller (min left-total right-total)]
+    (when (>= smaller +parallel-min-branch+)
+      (if (>= left-total right-total)
+        :left
+        :right))))
+
+(defn- parallel-recursive?
+  [^long total ^long threshold]
+  (>= total threshold))
+
+(defn- node-set-union-parallel*
+  [n1 n2 ^Comparator cmp create recursive-threshold]
+  (cond
+    (leaf? n1) n2
+    (leaf? n2) n1
+    :else
+    (let [total (+ (node-size n1) (node-size n2))]
+      (kvlr [ak av l r] n2
+        (let [[l1 _ r1] (node-split* n1 ak cmp create)
+              left-total (+ (node-size l1) (node-size l))
+              right-total (+ (node-size r1) (node-size r))
+              spawn-side (parallel-spawn-side left-total right-total)]
+          (if-not (parallel-recursive? total recursive-threshold)
+            (node-concat3 ak av
+                           (node-set-union* l1 l cmp create)
+                           (node-set-union* r1 r cmp create)
+                           cmp create)
+            (case spawn-side
+              :left
+              (parallel/fork-join [left-result (node-set-union-parallel* l1 l cmp create recursive-threshold)
+                                   right-result (node-set-union-parallel* r1 r cmp create recursive-threshold)]
+                (node-concat3 ak av left-result right-result cmp create))
+
+              :right
+              (parallel/fork-join [right-result (node-set-union-parallel* r1 r cmp create recursive-threshold)
+                                   left-result (node-set-union-parallel* l1 l cmp create recursive-threshold)]
+                (node-concat3 ak av left-result right-result cmp create))
+
+              (node-concat3 ak av
+                             (node-set-union-parallel* l1 l cmp create recursive-threshold)
+                             (node-set-union-parallel* r1 r cmp create recursive-threshold)
+                             cmp create))))))))
+
+(defn- node-set-intersection-parallel*
+  [n1 n2 ^Comparator cmp create recursive-threshold]
+  (cond
+    (leaf? n1) (leaf)
+    (leaf? n2) (leaf)
+    :else
+    (let [total (+ (node-size n1) (node-size n2))]
+      (kvlr [ak av l r] n2
+        (let [[l1 x r1] (node-split* n1 ak cmp create)
+              left-total (+ (node-size l1) (node-size l))
+              right-total (+ (node-size r1) (node-size r))
+              spawn-side (parallel-spawn-side left-total right-total)]
+          (if-not (parallel-recursive? total recursive-threshold)
+            (if x
+              (node-concat3 ak av
+                             (node-set-intersection* l1 l cmp create)
+                             (node-set-intersection* r1 r cmp create)
+                             cmp create)
+              (node-concat2 (node-set-intersection* l1 l cmp create)
+                             (node-set-intersection* r1 r cmp create)
+                             create))
+            (case spawn-side
+              :left
+              (parallel/fork-join [left-result (node-set-intersection-parallel* l1 l cmp create recursive-threshold)
+                                   right-result (node-set-intersection-parallel* r1 r cmp create recursive-threshold)]
+                (if x
+                  (node-concat3 ak av left-result right-result cmp create)
+                  (node-concat2 left-result right-result create)))
+
+              :right
+              (parallel/fork-join [right-result (node-set-intersection-parallel* r1 r cmp create recursive-threshold)
+                                   left-result (node-set-intersection-parallel* l1 l cmp create recursive-threshold)]
+                (if x
+                  (node-concat3 ak av left-result right-result cmp create)
+                  (node-concat2 left-result right-result create)))
+
+              (let [left-result (node-set-intersection-parallel* l1 l cmp create recursive-threshold)
+                    right-result (node-set-intersection-parallel* r1 r cmp create recursive-threshold)]
+                (if x
+                  (node-concat3 ak av left-result right-result cmp create)
+                  (node-concat2 left-result right-result create))))))))))
+
+(defn- node-set-difference-parallel*
+  [n1 n2 ^Comparator cmp create recursive-threshold]
+  (cond
+    (leaf? n1) (leaf)
+    (leaf? n2) n1
+    :else
+    (let [total (+ (node-size n1) (node-size n2))]
+      (kvlr [ak _ l r] n2
+        (let [[l1 _ r1] (node-split* n1 ak cmp create)
+              left-total (+ (node-size l1) (node-size l))
+              right-total (+ (node-size r1) (node-size r))
+              spawn-side (parallel-spawn-side left-total right-total)]
+          (if-not (parallel-recursive? total recursive-threshold)
+            (node-concat2 (node-set-difference* l1 l cmp create)
+                           (node-set-difference* r1 r cmp create)
+                           create)
+            (case spawn-side
+              :left
+              (parallel/fork-join [left-result (node-set-difference-parallel* l1 l cmp create recursive-threshold)
+                                   right-result (node-set-difference-parallel* r1 r cmp create recursive-threshold)]
+                (node-concat2 left-result right-result create))
+
+              :right
+              (parallel/fork-join [right-result (node-set-difference-parallel* r1 r cmp create recursive-threshold)
+                                   left-result (node-set-difference-parallel* l1 l cmp create recursive-threshold)]
+                (node-concat2 left-result right-result create))
+
+              (node-concat2 (node-set-difference-parallel* l1 l cmp create recursive-threshold)
+                             (node-set-difference-parallel* r1 r cmp create recursive-threshold)
+                             create))))))))
+
+(defn- node-map-merge-parallel*
+  [n1 n2 merge-fn ^Comparator cmp create recursive-threshold]
+  (cond
+    (leaf? n1) n2
+    (leaf? n2) n1
+    :else
+    (let [total (+ (node-size n1) (node-size n2))]
+      (kvlr [ak av l r] n2
+        (let [[l1 x r1] (node-split* n1 ak cmp create)
+              val (if x (merge-fn ak av (second x)) av)
+              left-total (+ (node-size l1) (node-size l))
+              right-total (+ (node-size r1) (node-size r))
+              spawn-side (parallel-spawn-side left-total right-total)]
+          (if-not (parallel-recursive? total recursive-threshold)
+            (node-concat3 ak val
+                           (node-map-merge* l1 l merge-fn cmp create)
+                           (node-map-merge* r1 r merge-fn cmp create)
+                           cmp create)
+            (case spawn-side
+              :left
+              (parallel/fork-join [left-result (node-map-merge-parallel* l1 l merge-fn cmp create recursive-threshold)
+                                   right-result (node-map-merge-parallel* r1 r merge-fn cmp create recursive-threshold)]
+                (node-concat3 ak val left-result right-result cmp create))
+
+              :right
+              (parallel/fork-join [right-result (node-map-merge-parallel* r1 r merge-fn cmp create recursive-threshold)
+                                   left-result (node-map-merge-parallel* l1 l merge-fn cmp create recursive-threshold)]
+                (node-concat3 ak val left-result right-result cmp create))
+
+              (node-concat3 ak val
+                             (node-map-merge-parallel* l1 l merge-fn cmp create recursive-threshold)
+                             (node-map-merge-parallel* r1 r merge-fn cmp create recursive-threshold)
+                             cmp create))))))))
+
+(defn node-set-union-parallel
+  "Parallel set union using ForkJoinPool.
+
+   Algorithm: Adams' divide-and-conquer with work-stealing parallelism.
+   1. Split T1 at T2's root key
+   2. Recursively union (T1.left, T2.left) and (T1.right, T2.right) in parallel
+   3. Join results at T2's root
+
+   Complexity:
+     Work: O(m + n)
+     Span: O(log^2 n)
+     Speedup: Near-linear up to ~16 cores for large trees"
+  [n1 n2]
+  (let [cmp order/*compare*
+        join *t-join*]
+    (if (parallel/in-fork-join-pool?)
+      (node-set-union-parallel* n1 n2 cmp join +parallel-union-recursive-threshold+)
+      (parallel/invoke-root
+        #(node-set-union-parallel* n1 n2 cmp join +parallel-union-recursive-threshold+)))))
+
+(defn node-set-intersection-parallel
+  "Parallel set intersection using ForkJoinPool.
+
+   Algorithm: Split T1 at T2's root, recursively intersect subtrees,
+   include root only if present in both trees.
+
+   Complexity: Same as union - O(m+n) work, O(log^2 n) span."
+  [n1 n2]
+  (let [cmp order/*compare*
+        join *t-join*]
+    (if (parallel/in-fork-join-pool?)
+      (node-set-intersection-parallel* n1 n2 cmp join +parallel-intersection-recursive-threshold+)
+      (parallel/invoke-root
+        #(node-set-intersection-parallel* n1 n2 cmp join +parallel-intersection-recursive-threshold+)))))
+
+(defn node-set-difference-parallel
+  "Parallel set difference using ForkJoinPool.
+
+   Algorithm: Split T1 at T2's root, recursively compute difference,
+   never include T2's root (since we're computing T1 - T2).
+
+   Complexity: Same as union - O(m+n) work, O(log^2 n) span."
+  [n1 n2]
+  (let [cmp order/*compare*
+        join *t-join*]
+    (if (parallel/in-fork-join-pool?)
+      (node-set-difference-parallel* n1 n2 cmp join +parallel-difference-recursive-threshold+)
+      (parallel/invoke-root
+        #(node-set-difference-parallel* n1 n2 cmp join +parallel-difference-recursive-threshold+)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fundamental Map Operations (Worst-Case Linear Time)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; TODO: adjust this
+
+(defn node-map-merge
+  "Merge two maps in worst case linear time."
+  [n1 n2 merge-fn]
+  (node-map-merge* n1 n2 merge-fn order/*compare* *t-join*))
+
+(defn node-map-merge-parallel
+  "Parallel map merge using ForkJoinPool.
+
+   Algorithm: Split T1 at T2's root key, recursively merge subtrees,
+   resolve collisions with merge-fn. Fork-join parallelism for large trees."
+  [n1 n2 merge-fn]
+  (let [cmp order/*compare*
+        join *t-join*]
+    (if (parallel/in-fork-join-pool?)
+      (node-map-merge-parallel* n1 n2 merge-fn cmp join +parallel-merge-recursive-threshold+)
+      (parallel/invoke-root
+        #(node-map-merge-parallel* n1 n2 merge-fn cmp join +parallel-merge-recursive-threshold+)))))
+
+(defn node-map-compare
+  "Compare two map trees element-by-element. Keys are compared using
+   the bound *compare* comparator; on key equality, values are compared
+   using clojure.lang.Util/compare to handle arbitrary value types."
+  [n1 n2]
+  (let [^java.util.Comparator cmp order/*compare*]
+    (loop [e1 (node-enumerator n1 nil)
+           e2 (node-enumerator n2 nil)]
+      (cond
+        (and (nil? e1) (nil? e2))  0
+        (nil? e1)                  -1
+        (nil? e2)                   1
+        :else
+        (let [^EnumFrame ef1 e1
+              ^EnumFrame ef2 e2
+              x1 (.-node ef1)
+              x2 (.-node ef2)
+              kc (.compare cmp (-k x1) (-k x2))]
+          (if-not (zero? kc)
+            kc
+            (let [vc (clojure.lang.Util/compare (-v x1) (-v x2))]
+              (if-not (zero? vc)
+                vc
+                (recur (node-enumerator (.-subtree ef1) (.-next ef1))
+                       (node-enumerator (.-subtree ef2) (.-next ef2)))))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fundamental Vector Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn node-nth
+  "Return nth node from the beginning of the ordered tree rooted at n.
+   (Logarithmic Time)"
+  [n ^long index]
+  (letfn [(srch [n ^long index]
+            (lr [l r] n
+              (let [lsize (node-size l)]
+                (cond
+                  (< index lsize) (recur l index)
+                  (> index lsize) (recur r (- index (inc lsize)))
+                  :else           n))))]
+    (if-not (and (<= 0 index) (< index (node-size n)))
+      (throw (ex-info "index out of range" {:i index :max (node-size n)}))
+      (srch n (long index)))))
+
+(defn node-rank
+  "Return the rank (sequential position) of a given KEY within the
+  ordered tree rooted at n. (Logarithmic Time)"
+  ([n k]
+   (node-rank n k order/*compare*))
+  ([n k ^Comparator cmp]
+   (loop [n n k k rank (long 0)]
+     (if (leaf? n)
+       nil
+       (let [c (.compare cmp k (-k n))]
+         (cond
+           (zero? c) (+ rank (node-size (-l n)))
+           (neg? c)  (recur (-l n) k rank)
+           :else     (recur (-r n) k (+ 1 rank (node-size (-l n))))))))))
+
+;; MAYBE: other splits? <= < > ?
+
+(defn node-split-nth
+  "return a tree of all nodes whose position is >= i. (Logarithmic Time)"
+  [n ^long i]
+  (if-not (pos? i)
+    n
+    (->> i dec (node-nth n) -k (node-split-greater n))))
+
+(defn node-vec
+  "Eagerly return a vector of all nodes in tree rooted at n in
+  the specified order, optionally using an accessor to extract
+  specific node consitituent values: :k, :v, :kv, or any
+  user-specifed function.  Default, when not specified, to the
+  entire node structure."
+  [n & {:keys [accessor reverse?]}]
+  (let [acc   (transient [])
+        fold  (if reverse? node-reduce-right node-reduce)
+        nval  (cond-> accessor
+                (not (fn? accessor)) node-accessor)]
+    (fold #(conj! %1 (nval %2)) acc n)
+    (persistent! acc)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Lazy Seq
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- node-seq-fn [dir]
+  (let [next-fn (case dir
+                  :< node-enum-rest
+                  :> node-enum-prior)]
+    (fn seq-fn [enum]
+      (lazy-seq
+        (when-not (nil? enum)
+          (cons (node-enum-first enum)
+                (seq-fn (next-fn enum))))))))
+
+(defn node-seq
+  "Return a (lazy) seq of nodes in tree rooted at n in the order they occur.
+   (Logarithmic Time)"
+  [n]
+  ((node-seq-fn :<) (node-enumerator n)))
+
+(defn node-seq-reverse
+  "Return a (lazy) seq of nodes in tree rooted at n in reverse order."
+  [n]
+  ((node-seq-fn :>) (node-enumerator-reverse n)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Efficient Direct Seq
+;;
+;; The tree already supports ordinary lazy iteration via `node-seq`,
+;; `node-seq-reverse`, `seq`, `rseq`, `subseq`, and friends. These direct seq
+;; types preserve normal seq behavior while avoiding the extra allocation and
+;; wrapper overhead.
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- seq-equiv
+  "Compare two sequences for equivalence, element by element."
+  [s1 o]
+  (if-not (or (instance? clojure.lang.Sequential o) (instance? java.util.List o))
+    false
+    (loop [s1 (seq s1) s2 (seq o)]
+      (cond
+        (nil? s1) (nil? s2)
+        (nil? s2) false
+        (not (clojure.lang.Util/equiv (first s1) (first s2))) false
+        :else (recur (next s1) (next s2))))))
+
+(defmacro ^:private def-projected-seq-type [name next-fn project ctor]
+  (let [enum-sym 'enum
+        cnt-sym 'cnt
+        meta-sym '_meta
+        acc-sym 'acc
+        n-sym 'n
+        f-sym 'f
+        init-sym 'init
+        m-sym 'm]
+    `(deftype ~name [~enum-sym ~cnt-sym ~meta-sym]
+       clojure.lang.ISeq
+       (first [_]
+         (~project (node-enum-first ~enum-sym)))
+       (next [_]
+         (when-let [e# (~next-fn ~enum-sym)]
+           (~ctor e# (when ~cnt-sym (unchecked-dec-int ~cnt-sym)) nil)))
+       (more [this#]
+         (or (.next this#) ()))
+       (cons [this# o#]
+         (clojure.lang.Cons. o# this#))
+
+       clojure.lang.Seqable
+       (seq [this#] this#)
+
+       clojure.lang.Sequential
+
+       java.lang.Iterable
+       (iterator [this#]
+         (clojure.lang.SeqIterator. this#))
+
+       clojure.lang.Counted
+       (count [_]
+         (if ~cnt-sym ~cnt-sym (enum-count ~enum-sym ~next-fn)))
+
+       clojure.lang.IReduceInit
+       (reduce [_ ~f-sym ~init-sym]
+         (enum-reduce-init ~enum-sym ~next-fn ~acc-sym ~init-sym ~n-sym
+                           (~f-sym ~acc-sym (~project ~n-sym))))
+
+       clojure.lang.IReduce
+       (reduce [_ ~f-sym]
+         (enum-reduce-first ~enum-sym ~next-fn ~acc-sym ~n-sym (~project ~n-sym)
+                            (~f-sym ~acc-sym (~project ~n-sym))
+                            (~f-sym)))
+
+       clojure.lang.IHashEq
+       (hasheq [this#]
+         (clojure.lang.Murmur3/hashOrdered this#))
+
+       clojure.lang.IPersistentCollection
+       (empty [_] ())
+       (equiv [this# o#]
+         (seq-equiv this# o#))
+
+       java.lang.Object
+       (hashCode [this#]
+         (clojure.lang.Util/hash this#))
+       (equals [this# o#]
+         (clojure.lang.Util/equals this# o#))
+
+       clojure.lang.IMeta
+       (meta [_] ~meta-sym)
+
+       clojure.lang.IObj
+       (withMeta [_ ~m-sym]
+         (~ctor ~enum-sym ~cnt-sym ~m-sym)))))
+
+(def-projected-seq-type KeySeq   node-enum-rest -k KeySeq.)
+(def-projected-seq-type EntrySeq node-enum-rest -kv EntrySeq.)
+
+(defn node-key-seq
+  "Return an efficient seq of keys from tree rooted at n."
+  ([n] (node-key-seq n nil))
+  ([n cnt]
+   (when-let [e (node-enumerator n)]
+     (KeySeq. e cnt nil))))
+
+(defn node-entry-seq
+  "Return an efficient seq of map entries from tree rooted at n."
+  ([n] (node-entry-seq n nil))
+  ([n cnt]
+   (when-let [e (node-enumerator n)]
+     (EntrySeq. e cnt nil))))
+
+(def-projected-seq-type KeySeqReverse node-enum-prior -k KeySeqReverse.)
+(def-projected-seq-type EntrySeqReverse node-enum-prior -kv EntrySeqReverse.)
+
+(defn node-key-seq-reverse
+  "Return an efficient reverse seq of keys from tree rooted at n."
+  ([n] (node-key-seq-reverse n nil))
+  ([n cnt]
+   (when-let [e (node-enumerator-reverse n)]
+     (KeySeqReverse. e cnt nil))))
+
+(defn node-entry-seq-reverse
+  "Return an efficient reverse seq of map entries from tree rooted at n."
+  ([n] (node-entry-seq-reverse n nil))
+  ([n cnt]
+   (when-let [e (node-enumerator-reverse n)]
+     (EntrySeqReverse. e cnt nil))))
+
+(defn node-subseq
+  "Return a seq of nodes for the slice of the tree from position
+  `from` to `to` (inclusive)."
+  ([n from]
+   (node-subseq n from (dec (node-size n))))
+  ([n ^long from ^long to]
+   (let [cnt (inc (- to from))]
+     (cond
+       (leaf? n)        nil
+       (not (pos? cnt)) nil
+       true (->> from (node-split-nth n) node-seq (take cnt))))))
diff --git a/src/ordered_collections/parallel.clj b/src/ordered_collections/parallel.clj
new file mode 100644
index 0000000..e69496d
--- /dev/null
+++ b/src/ordered_collections/parallel.clj
@@ -0,0 +1,54 @@
+(ns ordered-collections.parallel
+  "Minimal fork-join helpers for CPU-bound tree recursion.
+
+   The small set of primitives needed by the tree algorithms:
+
+   - enter the common pool once at the root
+   - fork one recursive branch
+   - compute the other branch inline
+   - join and combine"
+  (:import [java.util.concurrent ForkJoinPool ForkJoinTask RecursiveTask]))
+
+(def ^ForkJoinPool common-fork-join-pool
+  "Shared ForkJoinPool used by collection parallel operations."
+  (ForkJoinPool/commonPool))
+
+(defn in-fork-join-pool?
+  []
+  (ForkJoinTask/inForkJoinPool))
+
+(defn ^RecursiveTask recursive-task
+  "Create a RecursiveTask from a nullary thunk.
+
+   This avoids the extra Callable -> ForkJoinTask adaptation layer used by
+   ForkJoinTask/adapt while keeping task construction generic."
+  [f]
+  (proxy [RecursiveTask] []
+    (compute []
+      (f))))
+
+(defn invoke-root
+  "Run thunk in the common pool and return its result.
+
+   This is the outer entry point into fork-join execution. Recursive work
+   below that point should use `fork-join`"
+  [f]
+  (.invoke common-fork-join-pool ^ForkJoinTask (recursive-task f)))
+
+(defmacro fork-join
+  "Fork left-expr as a RecursiveTask, compute right-expr inline, then join.
+
+   This left-fork/right-inline shape matches the intended recursive
+   divide-and-conquer usage: keep one branch local, make the other branch
+   stealable by ForkJoinPool worker threads, then combine the results.
+
+   ForkJoin worker threads do not propagate Clojure dynamic bindings.
+   Forked bodies must therefore rely only on explicit arguments
+   captured at the parallel entry point, not on dynamic vars such as
+   `order/*compare*` or `tree/*t-join*`."
+  [[left-sym left-expr right-sym right-expr] combine-expr]
+  `(let [left-task# (recursive-task (fn [] ~left-expr))
+         _# (.fork ^ForkJoinTask left-task#)
+         ~right-sym ~right-expr
+         ~left-sym (.join ^ForkJoinTask left-task#)]
+     ~combine-expr))
diff --git a/src/ordered_collections/protocol.clj b/src/ordered_collections/protocol.clj
new file mode 100644
index 0000000..7418177
--- /dev/null
+++ b/src/ordered_collections/protocol.clj
@@ -0,0 +1,190 @@
+(ns ordered-collections.protocol
+  (:refer-clojure :exclude [split-at subrange]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Set Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PExtensibleSet
+  "Protocol for set algebra operations.
+
+   Provides the standard set-theoretic operations: union, intersection,
+   difference, and subset/superset predicates. Operations return sets
+   preserving the type of the receiver."
+  (intersection [this that]
+    "Return the set of elements present in both this and that.")
+  (union [this that]
+    "Return the set of elements present in either this or that.")
+  (difference [this that]
+    "Return the set of elements in this but not in that.")
+  (subset? [this that]
+    "Return true if every element of this is also in that.")
+  (superset? [this that]
+    "Return true if every element of that is also in this.")
+  (disjoint? [this that]
+    "Return true if this and that share no elements."))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Exclusive Association Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PExclusiveAssoc
+  "Protocol for exclusive association (insert only, no update)."
+  (assoc-new [m k v]
+    "Associate k with v only if k is not already present.
+    Returns the new collection with the key added, or the original
+    collection unchanged if the key already exists."))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ranked Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PRanked
+  "Protocol for collections supporting rank-based operations."
+  (rank-of [coll x]
+    "Return the 0-based index of element x in sorted order, or -1 if not present.")
+  (slice [coll start end]
+    "Return a seq of elements from index start (inclusive) to end (exclusive).")
+  (median [coll]
+    "Return the median element. For even-sized collections, returns the lower median.")
+  (percentile [coll pct]
+    "Return the element at the given percentile (0-100)."))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Nearest Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PNearest
+  "Protocol for finding nearest elements and ranges relative to a key."
+  (nearest [coll test k]
+    "Find the nearest element satisfying test relative to k.
+    Tests: :< (predecessor), :<= (floor), :>= (ceiling), :> (successor).
+    Returns element (for sets) or [key value] (for maps), or nil if none.")
+  (subrange [coll test k]
+    "Return subcollection of elements satisfying test relative to k.
+    Tests: :< :<= :>= :>"))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Splittable Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PSplittable
+  "Protocol for collections supporting efficient split operations.
+  Compatible with clojure.data.avl split operations."
+  (split-key [coll k]
+    "Split collection at key k, returning [left entry right].
+    - left: collection of elements less than k
+    - entry: the element/entry at k, or nil if not present
+    - right: collection of elements greater than k")
+  (split-at [coll i]
+    "Split collection at index i, returning [left right].
+    - left: collection of the first i elements (indices 0 to i-1)
+    - right: collection of remaining elements (indices i to n-1)"))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Range Aggregate Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PRangeAggregate
+  "Protocol for range aggregate queries over associative operations."
+  (aggregate-range [coll lo hi]
+    "Return aggregate over index range [lo, hi] inclusive.")
+  (aggregate [coll]
+    "Return aggregate over entire collection.")
+  (update-val [coll k v]
+    "Update value at index k, returning new collection.")
+  (update-fn [coll k f]
+    "Update value at index k by applying f, returning new collection."))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Collection Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PIntervalCollection
+  "Protocol for interval-based collections supporting overlap queries."
+  (overlapping [coll interval] "Return all intervals overlapping the given point or interval."))
+
+(defprotocol PSpan
+  "Protocol for collections that cover a contiguous range."
+  (span [coll] "Return [min max] covering all elements, or nil if empty."))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Range Map Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PRangeMap
+  "Protocol for range map operations (non-overlapping ranges to values)."
+  (ranges          [rm]           "Return seq of [[lo hi] value] entries.")
+  (get-entry       [rm point]     "Return [[lo hi] value] containing point, or nil.")
+  (assoc-coalescing [rm rng val]  "Insert range [lo hi), merging adjacent same-value ranges.")
+  (range-remove    [rm rng]       "Remove all mappings in [lo, hi) range.")
+  (gaps            [rm]           "Return seq of [lo hi] gaps between ranges."))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Multiset Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PMultiset
+  "Protocol for multiset (bag) operations."
+  (multiplicity       [ms k]   "Return count of element k.")
+  (disj-one           [ms k]   "Remove one occurrence of k.")
+  (disj-all           [ms k]   "Remove all occurrences of k.")
+  (distinct-elements  [ms]     "Return set of distinct elements.")
+  (element-frequencies [ms]    "Return map of element -> count."))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Priority Queue Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PPriorityQueue
+  "Protocol for priority queue operations.
+  Elements are [priority value] pairs. Queue order is determined by the
+  configured priority comparator."
+  (push     [pq priority value] "Add element with given priority.")
+  (push-all [pq pairs]          "Add multiple [priority value] pairs.")
+  (peek-min [pq]                "Return first [priority value] in queue order, or nil.")
+  (peek-min-val [pq]            "Return just the value of the first element, or nil.")
+  (pop-min  [pq]                "Remove first element. Returns queue unchanged if empty.")
+  (peek-max [pq]                "Return last [priority value] in queue order, or nil.")
+  (peek-max-val [pq]            "Return just the value of the last element, or nil.")
+  (pop-max  [pq]                "Remove last element. Returns queue unchanged if empty."))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fuzzy Collection Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PFuzzy
+  "Protocol for fuzzy/nearest-neighbor collections."
+  (nearest-with-distance [coll query]
+    "Find nearest element/entry with distance.
+    Returns [element distance] for sets, [key value distance] for maps.")
+  (exact-contains? [coll k]
+    "Check if collection contains exactly k (no fuzzy matching).")
+  (exact-get [coll k] [coll k not-found]
+    "Get value for exactly k (maps only, no fuzzy matching)."))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Rope Protocol
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol PRope
+  "Protocol for persistent rope operations — structural editing of
+  indexed sequences in O(log n)."
+  (rope-cat [r1 r2]
+    "Structural rope-to-rope concatenation. O(log n).")
+  (rope-split [r i]
+    "Split rope at index i, returning [left right]. O(log n).")
+  (rope-sub [r start end]
+    "Extract subrange [start, end) as a new rope. O(log n).")
+  (rope-insert [r i coll]
+    "Insert elements from coll at index i. O(log n).")
+  (rope-remove [r start end]
+    "Remove range [start, end). O(log n).")
+  (rope-splice [r start end coll]
+    "Replace range [start, end) with elements from coll. O(log n).")
+  (rope-chunks [r]
+    "Return a seq of the rope's internal chunk vectors.")
+  (rope-str [r]
+    "Efficiently convert a rope of characters/strings to a String."))
diff --git a/src/ordered_collections/readers.clj b/src/ordered_collections/readers.clj
new file mode 100644
index 0000000..aaca481
--- /dev/null
+++ b/src/ordered_collections/readers.clj
@@ -0,0 +1,31 @@
+(ns ordered-collections.readers
+  "Tagged literal reader functions for EDN round-tripping.
+
+   These functions are referenced by data_readers.clj and are called by
+   the Clojure reader when it encounters tagged literals like #ordered/set.
+
+   For use with clojure.edn/read-string, pass `readers` as the :readers option."
+  (:require [ordered-collections.core :as oc]))
+
+(def ordered-set      oc/ordered-set)
+(def ordered-map      oc/ordered-map)
+(def interval-set     oc/interval-set)
+(def interval-map     oc/interval-map)
+(def range-map        oc/range-map)
+(def priority-queue   oc/priority-queue)
+(def ordered-multiset oc/ordered-multiset)
+(def rope             oc/rope)
+
+(def readers
+  "Map of tag symbols to reader functions.
+   Pass to clojure.edn/read-string as the :readers option:
+
+     (clojure.edn/read-string {:readers readers} s)"
+  {'ordered/set            ordered-set
+   'ordered/map            ordered-map
+   'ordered/interval-set   interval-set
+   'ordered/interval-map   interval-map
+   'ordered/range-map      range-map
+   'ordered/priority-queue priority-queue
+   'ordered/multiset       ordered-multiset
+   'ordered/rope           rope})
diff --git a/src/ordered_collections/types/fuzzy_map.clj b/src/ordered_collections/types/fuzzy_map.clj
new file mode 100644
index 0000000..409e780
--- /dev/null
+++ b/src/ordered_collections/types/fuzzy_map.clj
@@ -0,0 +1,379 @@
+(ns ordered-collections.types.fuzzy-map
+  "A map that returns the value associated with the closest key.
+
+   When looking up a key, returns the value for the key in the map that is
+   closest to the query. For numeric keys, distance is |query - key|.
+
+   Tie-breaking: When two keys are equidistant, use :< to prefer the
+   smaller key, or :> to prefer the larger key."
+  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
+            [ordered-collections.types.fuzzy-set :as fuzzy]
+            [ordered-collections.types.shared :refer [with-compare]]
+            [ordered-collections.kernel.node     :as node]
+            [ordered-collections.kernel.order    :as order]
+            [ordered-collections.protocol      :as proto :refer [PRanked]]
+            [ordered-collections.kernel.root]
+            [ordered-collections.kernel.tree     :as tree])
+  (:import  [clojure.lang                RT Murmur3 MapEntry]
+            [ordered_collections.protocol PFuzzy]
+            [ordered_collections.kernel.root     INodeCollection
+                                         IBalancedCollection
+                                         IOrderedCollection]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Nearest Lookup for Maps
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn find-nearest-entry
+  "Find the entry with key nearest to query in the tree.
+
+   Parameters:
+   - root: the tree root
+   - query: the key to find nearest to
+   - cmp: comparator for ordering
+   - distance-fn: (fn [a b] -> number) returns distance between keys
+   - tiebreak: :< (prefer smaller) or :> (prefer larger) when equidistant
+
+   Returns [key value] for the nearest entry, or nil if tree is empty."
+  [root query ^java.util.Comparator cmp distance-fn tiebreak]
+  (if (node/leaf? root)
+    nil
+    (binding [order/*compare* cmp]
+      (let [;; Split tree at query point
+            [lt present gt] (tree/node-split root query)
+            ;; Get floor (greatest key <= query)
+            floor-node (if present
+                         present
+                         (when-not (node/leaf? lt)
+                           (tree/node-greatest lt)))
+            ;; Get ceiling (least key >= query)
+            ceiling-node (if present
+                           present
+                           (when-not (node/leaf? gt)
+                             (tree/node-least gt)))]
+        (cond
+          ;; Query key exists exactly
+          present
+          [(first present) (second present)]
+
+          ;; Only floor exists
+          (and floor-node (nil? ceiling-node))
+          [(node/-k floor-node) (node/-v floor-node)]
+
+          ;; Only ceiling exists
+          (and ceiling-node (nil? floor-node))
+          [(node/-k ceiling-node) (node/-v ceiling-node)]
+
+          ;; Both exist - compare distances
+          (and floor-node ceiling-node)
+          (let [floor-key (node/-k floor-node)
+                ceiling-key (node/-k ceiling-node)
+                floor-dist (distance-fn query floor-key)
+                ceiling-dist (distance-fn query ceiling-key)]
+            (cond
+              (< floor-dist ceiling-dist) [floor-key (node/-v floor-node)]
+              (> floor-dist ceiling-dist) [ceiling-key (node/-v ceiling-node)]
+              ;; Equal distance - use tiebreaker
+              (= tiebreak :<) [floor-key (node/-v floor-node)]
+              :else [ceiling-key (node/-v ceiling-node)]))
+
+          ;; Empty tree
+          :else nil)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; FuzzyMap Type
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields: root, cmp, distance-fn, tiebreak, _meta — same as FuzzySet.
+;;
+;; ILookup/IFn return the value for the nearest key. Seq/reduce/nth
+;; return MapEntry. Implements IKVReduce for reduce-kv. exact-get and
+;; exact-contains? bypass fuzzy matching for precise key access.
+
+(deftype FuzzyMap [root cmp distance-fn tiebreak _meta]
+
+  java.io.Serializable
+
+  INodeCollection
+  (getAllocator [_]
+    tree/node-create-weight-balanced)
+  (getRoot [_]
+    root)
+
+  IOrderedCollection
+  (getCmp [_]
+    cmp)
+  (isCompatible [_ o]
+    (and (instance? FuzzyMap o)
+         (= cmp (.getCmp ^FuzzyMap o))
+         (= distance-fn (.-distance-fn ^FuzzyMap o))
+         (= tiebreak (.-tiebreak ^FuzzyMap o))))
+  (isSimilar [_ o]
+    (map? o))
+
+  IBalancedCollection
+  (getStitch [_]
+    tree/node-stitch)
+
+  clojure.lang.IMeta
+  (meta [_]
+    _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (new FuzzyMap root cmp distance-fn tiebreak m))
+
+  clojure.lang.Indexed
+  (nth [_ i]
+    (node/-kv (tree/node-nth root i)))
+  (nth [_ i not-found]
+    (if (and (>= i 0) (< i (tree/node-size root)))
+      (node/-kv (tree/node-nth root i))
+      not-found))
+
+  clojure.lang.MapEquivalence
+
+  clojure.lang.Seqable
+  (seq [_]
+    (tree/node-entry-seq root (tree/node-size root)))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (tree/node-entry-seq-reverse root (tree/node-size root)))
+
+  clojure.lang.ILookup
+  ;; Fuzzy lookup - returns the value for the nearest key
+  (valAt [this query not-found]
+    (if (node/leaf? root)
+      not-found
+      (if-let [[_ v] (find-nearest-entry root query cmp distance-fn tiebreak)]
+        v
+        not-found)))
+  (valAt [this query]
+    (.valAt this query nil))
+
+  clojure.lang.IFn
+  (invoke [this query not-found]
+    (.valAt this query not-found))
+  (invoke [this query]
+    (.valAt this query))
+  (applyTo [this args]
+    (let [n (RT/boundedLength args 2)]
+      (case n
+        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
+        1 (.invoke this (first args))
+        2 (.invoke this (first args) (second args))
+        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
+
+  java.lang.Comparable
+  (compareTo [this o]
+    (with-compare this
+      (cond
+        (identical? this o) 0
+        (.isCompatible this o) (tree/node-map-compare root (.getRoot ^FuzzyMap o))
+        (.isSimilar this o) (.compareTo ^Comparable (into (empty o) this) o)
+        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
+
+  java.util.Map
+  (size [_]
+    (tree/node-size root))
+  (isEmpty [_]
+    (node/leaf? root))
+  (containsValue [this v]
+    (with-compare this
+      (boolean
+        (tree/node-reduce
+          (fn [_ n] (when (= v (node/-v n)) (reduced true)))
+          nil root))))
+  (get [this k]
+    (.valAt this k))
+  (put [_ _ _]
+    (throw (UnsupportedOperationException.)))
+  (remove [_ _]
+    (throw (UnsupportedOperationException.)))
+  (putAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (clear [_]
+    (throw (UnsupportedOperationException.)))
+  (keySet [this]
+    (with-compare this
+      (set (map node/-k (tree/node-seq root)))))
+  (values [this]
+    (with-compare this
+      (map node/-v (tree/node-seq root))))
+  (entrySet [this]
+    (with-compare this
+      (set (map node/-kv (tree/node-seq root)))))
+
+  java.util.SortedMap
+  (comparator [_]
+    cmp)
+  (firstKey [this]
+    (with-compare this
+      (first (tree/node-least-kv root))))
+  (lastKey [this]
+    (with-compare this
+      (first (tree/node-greatest-kv root))))
+  (headMap [this k]
+    (with-compare this
+      (new FuzzyMap (tree/node-split-lesser root k) cmp distance-fn tiebreak _meta)))
+  (tailMap [this k]
+    (with-compare this
+      (let [[_ present gt] (tree/node-split root k)]
+        (if present
+          (new FuzzyMap (tree/node-add gt (first present) (second present)) cmp distance-fn tiebreak _meta)
+          (new FuzzyMap gt cmp distance-fn tiebreak _meta)))))
+  (subMap [this from to]
+    (with-compare this
+      (let [[_ from-present from-gt] (tree/node-split root from)
+            from-tree (if from-present
+                        (tree/node-add from-gt (first from-present) (second from-present))
+                        from-gt)
+            to-tree (tree/node-split-lesser root to)
+            result (tree/node-set-intersection from-tree to-tree)]
+        (new FuzzyMap result cmp distance-fn tiebreak _meta))))
+
+  clojure.lang.Sorted
+  (entryKey [_ entry]
+    (key entry))
+  (seq [_ ascending]
+    (if ascending
+      (tree/node-entry-seq root)
+      (tree/node-entry-seq-reverse root)))
+  (seqFrom [this k ascending]
+    (with-compare this
+      (let [[lt present gt] (tree/node-split root k)]
+        (if ascending
+          (if present
+            (cons (MapEntry. (first present) (second present))
+                  (tree/node-entry-seq gt))
+            (tree/node-entry-seq gt))
+          (if present
+            (cons (MapEntry. (first present) (second present))
+                  (tree/node-entry-seq-reverse lt))
+            (tree/node-entry-seq-reverse lt))))))
+
+  clojure.lang.Associative
+  (containsKey [this k]
+    (tree/node-contains? root k cmp))
+  (entryAt [this k]
+    (some-> root (tree/node-find k cmp) node/-kv))
+  (assoc [this k v]
+    (new FuzzyMap (tree/node-add root k v cmp tree/node-create-weight-balanced) cmp distance-fn tiebreak _meta))
+
+  clojure.lang.IPersistentCollection
+  (count [_]
+    (tree/node-size root))
+  (cons [this entry]
+    (if (map? entry)
+      (reduce (fn [m [k v]] (assoc m k v)) this (seq entry))
+      (.assoc this (first entry) (second entry))))
+  (empty [_]
+    (new FuzzyMap (node/leaf) cmp distance-fn tiebreak _meta))
+  (equiv [this o]
+    (with-compare this
+      (cond
+        (identical? this o) true
+        (not (instance? clojure.lang.Counted o)) false
+        (not= (tree/node-size root) (.count ^clojure.lang.Counted o)) false
+        (.isCompatible this o) (zero? (tree/node-map-compare root (.getRoot ^FuzzyMap o)))
+        (.isSimilar this o) (every? (fn [e] (= (val e) (get o (key e) ::not-found))) this)
+        :else false)))
+
+  clojure.lang.IPersistentMap
+  (assocEx [this k v]
+    (if (.containsKey this k)
+      (throw (Exception. "Key already present"))
+      (.assoc this k v)))
+  (without [this k]
+    (new FuzzyMap (tree/node-remove root k cmp tree/node-create-weight-balanced) cmp distance-fn tiebreak _meta))
+
+  Object
+  (toString [this]
+    (pr-str this))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    ;; Must match APersistentMap: sum of hasheq(MapEntry) for each entry, then mixCollHash
+    (Murmur3/mixCollHash
+      (unchecked-int
+        (tree/node-reduce
+          (fn [^long acc n]
+            (unchecked-add acc (long (clojure.lang.Util/hasheq
+                                       (clojure.lang.MapEntry. (node/-k n) (node/-v n))))))
+          (long 0)
+          root))
+      (tree/node-size root)))
+
+  clojure.lang.IReduceInit
+  (reduce [this f init]
+    (tree/node-reduce-entries f init root))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (tree/node-reduce-entries f root))
+
+  clojure.core.protocols/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^clojure.lang.IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^clojure.lang.IReduceInit this f init))
+
+  clojure.lang.IKVReduce
+  (kvreduce [this f init]
+    (tree/node-reduce-kv f init root))
+
+  clojure.core.reducers.CollFold
+  (coll-fold [this n combinef reducef]
+    (with-compare this
+      (tree/node-fold n root combinef
+        (fn [acc node] (reducef acc (node/-kv node))))))
+
+  PRanked
+  (rank-of [_ k]
+    (or (tree/node-rank root k cmp) -1))
+  (slice [_ start end]
+    (let [n (tree/node-size root)
+          start (max 0 (long start))
+          end (min n (long end))]
+      (when (< start end)
+        (binding [order/*compare* cmp]
+          (map (fn [node] (MapEntry. (node/-k node) (node/-v node)))
+               (tree/node-subseq root start (dec end)))))))
+  (median [_]
+    (let [n (tree/node-size root)]
+      (when (pos? n)
+        (let [node (tree/node-nth root (quot (dec n) 2))]
+          (MapEntry. (node/-k node) (node/-v node))))))
+  (percentile [_ pct]
+    (let [n (tree/node-size root)]
+      (when (pos? n)
+        (let [idx (min (dec n) (long (* (/ (double pct) 100.0) n)))
+              node (tree/node-nth root idx)]
+          (MapEntry. (node/-k node) (node/-v node))))))
+
+  PFuzzy
+  (nearest-with-distance [this query]
+    (when-not (node/leaf? root)
+      (when-let [[k v] (find-nearest-entry root query cmp distance-fn tiebreak)]
+        [k v (distance-fn query k)])))
+  (exact-contains? [_ k]
+    (if (tree/node-find root k cmp) true false))
+  (exact-get [_ k]
+    (if-let [n (tree/node-find root k cmp)]
+      (node/-v n)
+      nil))
+  (exact-get [_ k not-found]
+    (if-let [n (tree/node-find root k cmp)]
+      (node/-v n)
+      not-found)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method FuzzyMap [m ^java.io.Writer w]
+  (.write w "#<FuzzyMap ")
+  (print-method (into {} (seq m)) w)
+  (.write w ">"))
diff --git a/src/ordered_collections/types/fuzzy_set.clj b/src/ordered_collections/types/fuzzy_set.clj
new file mode 100644
index 0000000..8b7dcd4
--- /dev/null
+++ b/src/ordered_collections/types/fuzzy_set.clj
@@ -0,0 +1,420 @@
+(ns ordered-collections.types.fuzzy-set
+  "A set that returns the closest element to a query.
+
+   When looking up a value, returns the element in the set that is closest
+   to the query. For numeric keys, distance is |query - element|.
+
+   Tie-breaking: When two elements are equidistant, use :< to prefer the
+   smaller element, or :> to prefer the larger element."
+  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
+            [ordered-collections.types.shared :refer [with-compare]]
+            [ordered-collections.kernel.node     :as node]
+            [ordered-collections.kernel.order    :as order]
+            [ordered-collections.protocol      :as proto :refer [PRanked PNearest PSplittable]]
+            [ordered-collections.kernel.root]
+            [ordered-collections.kernel.tree     :as tree])
+  (:import  [clojure.lang                RT Murmur3]
+            [ordered_collections.protocol PFuzzy]
+            [ordered_collections.kernel.root     INodeCollection
+                                         IBalancedCollection
+                                         IOrderedCollection]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Distance Functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn numeric-distance
+  "Default distance function for numeric types."
+  ^double [^Number a ^Number b]
+  (Math/abs (- (.doubleValue a) (.doubleValue b))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Nearest Lookup
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn find-nearest
+  "Find the nearest element to query in the tree.
+
+   Parameters:
+   - root: the tree root
+   - query: the value to find nearest to
+   - cmp: comparator for ordering
+   - distance-fn: (fn [a b] -> number) returns distance between elements
+   - tiebreak: :< (prefer smaller) or :> (prefer larger) when equidistant
+
+   Returns the nearest element, or nil if tree is empty."
+  [root query ^java.util.Comparator cmp distance-fn tiebreak]
+  (if (node/leaf? root)
+    nil
+    (binding [order/*compare* cmp]
+      (let [;; Split tree at query point
+            [lt present gt] (tree/node-split root query)
+            ;; Get floor (greatest element <= query)
+            floor-node (if present
+                         query
+                         (when-not (node/leaf? lt)
+                           (node/-k (tree/node-greatest lt))))
+            ;; Get ceiling (least element >= query)
+            ceiling-node (if present
+                           query
+                           (when-not (node/leaf? gt)
+                             (node/-k (tree/node-least gt))))]
+        (cond
+          ;; Query exists exactly
+          present query
+
+          ;; Only floor exists
+          (and floor-node (nil? ceiling-node))
+          floor-node
+
+          ;; Only ceiling exists
+          (and ceiling-node (nil? floor-node))
+          ceiling-node
+
+          ;; Both exist - compare distances
+          (and floor-node ceiling-node)
+          (let [floor-dist (distance-fn query floor-node)
+                ceiling-dist (distance-fn query ceiling-node)]
+            (cond
+              (< floor-dist ceiling-dist) floor-node
+              (> floor-dist ceiling-dist) ceiling-node
+              ;; Equal distance - use tiebreaker
+              (= tiebreak :<) floor-node
+              :else ceiling-node))
+
+          ;; Empty tree
+          :else nil)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; FuzzySet Type
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields:
+;;   root        — ordered set tree (k = v = element)
+;;   cmp         — element comparator
+;;   distance-fn — (fn [query element] -> number), default numeric |a - b|
+;;   tiebreak    — :< (prefer smaller) or :> (prefer larger) when equidistant
+;;   _meta       — metadata map
+;;
+;; Lookup splits the tree at the query point, compares distances to floor
+;; and ceiling, and returns the nearest. ILookup/IFn return the nearest
+;; element, not a membership test.
+
+(deftype FuzzySet [root cmp distance-fn tiebreak _meta]
+
+  java.io.Serializable
+
+  INodeCollection
+  (getAllocator [_]
+    tree/node-create-weight-balanced)
+  (getRoot [_]
+    root)
+
+  IOrderedCollection
+  (getCmp [_]
+    cmp)
+  (isCompatible [_ o]
+    (and (instance? FuzzySet o)
+         (= cmp (.getCmp ^FuzzySet o))
+         (= distance-fn (.-distance-fn ^FuzzySet o))
+         (= tiebreak (.-tiebreak ^FuzzySet o))))
+  (isSimilar [_ o]
+    (set? o))
+
+  IBalancedCollection
+  (getStitch [_]
+    tree/node-stitch)
+
+  clojure.lang.IMeta
+  (meta [_]
+    _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (new FuzzySet root cmp distance-fn tiebreak m))
+
+  clojure.lang.Indexed
+  (nth [_ i]
+    (node/-k (tree/node-nth root i)))
+  (nth [_ i not-found]
+    (if (and (>= i 0) (< i (tree/node-size root)))
+      (node/-k (tree/node-nth root i))
+      not-found))
+
+  clojure.lang.Seqable
+  (seq [_]
+    (tree/node-key-seq root (tree/node-size root)))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (tree/node-key-seq-reverse root (tree/node-size root)))
+
+  clojure.lang.ILookup
+  ;; Fuzzy lookup - returns the nearest element
+  (valAt [this query not-found]
+    (if (node/leaf? root)
+      not-found
+      (if-let [nearest (find-nearest root query cmp distance-fn tiebreak)]
+        nearest
+        not-found)))
+  (valAt [this query]
+    (.valAt this query nil))
+
+  clojure.lang.IFn
+  (invoke [this query not-found]
+    (.valAt this query not-found))
+  (invoke [this query]
+    (.valAt this query))
+  (applyTo [this args]
+    (let [n (RT/boundedLength args 2)]
+      (case n
+        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
+        1 (.invoke this (first args))
+        2 (.invoke this (first args) (second args))
+        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
+
+  java.util.Collection
+  (toArray [this]
+    (with-compare this
+      (object-array (tree/node-vec root :accessor :k))))
+  (isEmpty [_]
+    (node/leaf? root))
+  (add [_ _]
+    (throw (UnsupportedOperationException.)))
+  (addAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (removeAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (retainAll [_ _]
+    (throw (UnsupportedOperationException.)))
+
+  java.util.List
+  (indexOf [_ x]
+    (or (tree/node-rank root x cmp) -1))
+  (lastIndexOf [this x]
+    (.indexOf this x))
+
+  java.util.Set
+  (size [_]
+    (tree/node-size root))
+  (iterator [this]
+    (clojure.lang.SeqIterator. (seq this)))
+  (containsAll [this s]
+    (with-compare this
+      (every? #(.contains this %) s)))
+
+  java.lang.Comparable
+  (compareTo [this o]
+    (with-compare this
+      (cond
+        (identical? this o) 0
+        (.isCompatible this o) (tree/node-set-compare root (.getRoot ^FuzzySet o))
+        true (throw (ex-info "unsupported comparison" {:this this :o o})))))
+
+  java.util.SortedSet
+  (comparator [_]
+    cmp)
+  (first [this]
+    (with-compare this
+      (first (tree/node-least-kv root))))
+  (last [this]
+    (with-compare this
+      (first (tree/node-greatest-kv root))))
+  (headSet [this x]
+    (with-compare this
+      (new FuzzySet (tree/node-split-lesser root x) cmp distance-fn tiebreak _meta)))
+  (tailSet [this x]
+    (with-compare this
+      (let [[_ present gt] (tree/node-split root x)]
+        (if present
+          (new FuzzySet (tree/node-add gt (first present) (first present)) cmp distance-fn tiebreak _meta)
+          (new FuzzySet gt cmp distance-fn tiebreak _meta)))))
+  (subSet [this from to]
+    (with-compare this
+      (let [[_ from-present from-gt] (tree/node-split root from)
+            from-tree (if from-present
+                        (tree/node-add from-gt (first from-present) (first from-present))
+                        from-gt)
+            to-tree (tree/node-split-lesser root to)
+            result  (tree/node-set-intersection from-tree to-tree)]
+        (new FuzzySet result cmp distance-fn tiebreak _meta))))
+
+  java.util.NavigableSet
+  (ceiling [this x]
+    (with-compare this
+      (let [[_ x' r] (tree/node-split root x)]
+        (if (some? x')
+          (first x')
+          (when-not (node/leaf? r)
+            (first (tree/node-least-kv r)))))))
+  (floor [this x]
+    (with-compare this
+      (let [[l x' _] (tree/node-split root x)]
+        (if (some? x')
+          (first x')
+          (when-not (node/leaf? l)
+            (first (tree/node-greatest-kv l)))))))
+
+  clojure.lang.Sorted
+  (entryKey [_ entry]
+    entry)
+  (seq [_ ascending]
+    (if ascending
+      (tree/node-key-seq root)
+      (tree/node-key-seq-reverse root)))
+  (seqFrom [this k ascending]
+    (with-compare this
+      (let [[lt present gt] (tree/node-split root k)]
+        (if ascending
+          (if present
+            (cons (first present) (tree/node-key-seq gt))
+            (tree/node-key-seq gt))
+          (if present
+            (cons (first present) (tree/node-key-seq-reverse lt))
+            (tree/node-key-seq-reverse lt))))))
+
+  clojure.lang.IPersistentSet
+  (equiv [this o]
+    (with-compare this
+      (cond
+        (identical? this o) true
+        (not (instance? clojure.lang.Counted o)) false
+        (not= (tree/node-size root) (.count ^clojure.lang.Counted o)) false
+        (.isCompatible this o) (zero? (tree/node-set-compare root (.getRoot ^FuzzySet o)))
+        (.isSimilar this o) (every? #(contains? o %) this)
+        :else false)))
+  (count [_]
+    (tree/node-size root))
+  (empty [_]
+    (new FuzzySet (node/leaf) cmp distance-fn tiebreak _meta))
+  (contains [this k]
+    (tree/node-contains? root k cmp))
+  (disjoin [this k]
+    (new FuzzySet (tree/node-remove root k cmp tree/node-create-weight-balanced) cmp distance-fn tiebreak _meta))
+  (cons [this k]
+    (new FuzzySet (tree/node-add root k k cmp tree/node-create-weight-balanced) cmp distance-fn tiebreak _meta))
+
+  Object
+  (toString [this]
+    (pr-str this))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    ;; Must match APersistentSet: sum of hasheq(element), then mixCollHash
+    (Murmur3/mixCollHash
+      (unchecked-int
+        (tree/node-reduce
+          (fn [^long acc n]
+            (unchecked-add acc (long (clojure.lang.Util/hasheq (node/-k n)))))
+          (long 0)
+          root))
+      (tree/node-size root)))
+
+  clojure.lang.IReduceInit
+  (reduce [this f init]
+    (tree/node-reduce-keys f init root))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (tree/node-reduce-keys f root))
+
+  clojure.core.protocols/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^clojure.lang.IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^clojure.lang.IReduceInit this f init))
+
+  clojure.core.reducers.CollFold
+  (coll-fold [this n combinef reducef]
+    (with-compare this
+      (tree/node-fold n root combinef
+        (fn [acc node] (reducef acc (node/-k node))))))
+
+  PNearest
+  (nearest [this test k]
+    (with-compare this
+      (case test
+        :< (when-let [n (tree/node-predecessor root k)]
+             (node/-k n))
+        :<= (when-let [n (tree/node-find-nearest root k :<)]
+              (node/-k n))
+        :> (when-let [n (tree/node-successor root k)]
+             (node/-k n))
+        :>= (when-let [n (tree/node-find-nearest root k :>)]
+              (node/-k n))
+        (throw (ex-info "nearest test must be :<, :<=, :>, or :>=" {:test test})))))
+  (subrange [this test k]
+    (with-compare this
+      (let [result-root (case test
+                          (:< :<=) (tree/node-split-lesser root k)
+                          (:> :>=) (tree/node-split-greater root k)
+                          (throw (ex-info "subrange test must be :<, :<=, :>, or :>=" {:test test})))
+            result-root (case test
+                          (:<= :>=) (if-let [n (tree/node-find root k)]
+                                      (tree/node-add result-root (node/-k n) (node/-v n))
+                                      result-root)
+                          result-root)]
+        (new FuzzySet result-root cmp distance-fn tiebreak _meta))))
+
+  PRanked
+  (rank-of [_ x]
+    (or (tree/node-rank root x cmp) -1))
+  (slice [_ start end]
+    (let [n (tree/node-size root)
+          start (max 0 (long start))
+          end (min n (long end))]
+      (when (< start end)
+        (binding [order/*compare* cmp]
+          (map node/-k (tree/node-subseq root start (dec end)))))))
+  (median [_]
+    (let [n (tree/node-size root)]
+      (when (pos? n)
+        (node/-k (tree/node-nth root (quot (dec n) 2))))))
+  (percentile [_ pct]
+    (let [n (tree/node-size root)]
+      (when (pos? n)
+        (let [idx (min (dec n) (long (* (/ (double pct) 100.0) n)))]
+          (node/-k (tree/node-nth root idx))))))
+
+  PSplittable
+  (split-key [this k]
+    (with-compare this
+      (let [[l present r] (tree/node-split root k)
+            entry (when present (first present))]
+        [(new FuzzySet l cmp distance-fn tiebreak _meta)
+         entry
+         (new FuzzySet r cmp distance-fn tiebreak _meta)])))
+  (split-at [this i]
+    (with-compare this
+      (let [n (tree/node-size root)]
+        (cond
+          (<= i 0) [(.empty this) this]
+          (>= i n) [this (.empty this)]
+          :else
+          (let [left-root  (tree/node-split-lesser root (node/-k (tree/node-nth root i)))
+                right-root (tree/node-split-nth root i)]
+            [(new FuzzySet left-root cmp distance-fn tiebreak _meta)
+             (new FuzzySet right-root cmp distance-fn tiebreak _meta)])))))
+
+  PFuzzy
+  (nearest-with-distance [this query]
+    (when-not (node/leaf? root)
+      (let [nearest-elem (.valAt this query)]
+        (when nearest-elem
+          [nearest-elem (distance-fn query nearest-elem)]))))
+  (exact-contains? [_ k]
+    (if (tree/node-find root k cmp) true false))
+  (exact-get [_ k]
+    (throw (UnsupportedOperationException. "exact-get not supported for FuzzySet")))
+  (exact-get [_ k not-found]
+    (throw (UnsupportedOperationException. "exact-get not supported for FuzzySet"))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method FuzzySet [s ^java.io.Writer w]
+  (.write w "#<FuzzySet ")
+  (print-method (vec (seq s)) w)
+  (.write w ">"))
diff --git a/src/ordered_collections/types/interop.clj b/src/ordered_collections/types/interop.clj
new file mode 100644
index 0000000..3c69bc0
--- /dev/null
+++ b/src/ordered_collections/types/interop.clj
@@ -0,0 +1,168 @@
+(ns ordered-collections.types.interop
+  "Protocol extensions for interoperability with standard Clojure collections.
+
+   Extends ordered-collections protocols to:
+   - PersistentHashSet
+   - PersistentTreeSet
+   - PersistentTreeMap
+
+   This allows protocol functions like union, intersection, nearest, etc.
+   to work with standard Clojure sorted collections."
+  (:require [clojure.set :as set]
+            [ordered-collections.protocol :as proto]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PExtensibleSet - Set algebra operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(extend-type clojure.lang.PersistentHashSet
+  proto/PExtensibleSet
+  (intersection [this that]
+    (set/intersection this that))
+  (union [this that]
+    (set/union this that))
+  (difference [this that]
+    (set/difference this that))
+  (subset? [this that]
+    (set/subset? this that))
+  (superset? [this that]
+    (set/subset? that this))
+  (disjoint? [this that]
+    (empty? (set/intersection this that))))
+
+(extend-type clojure.lang.PersistentTreeSet
+  proto/PExtensibleSet
+  (intersection [this that]
+    (set/intersection this that))
+  (union [this that]
+    (set/union this that))
+  (difference [this that]
+    (set/difference this that))
+  (subset? [this that]
+    (set/subset? this that))
+  (superset? [this that]
+    (set/subset? that this))
+  (disjoint? [this that]
+    (empty? (set/intersection this that))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PNearest - Floor/ceiling/predecessor/successor operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(extend-type clojure.lang.PersistentTreeSet
+  proto/PNearest
+  (nearest [this test k]
+    (case test
+      :<  (first (rsubseq this < k))
+      :<= (first (rsubseq this <= k))
+      :>  (first (subseq this > k))
+      :>= (first (subseq this >= k))
+      (throw (ex-info "nearest test must be :<, :<=, :>, or :>=" {:test test}))))
+  (subrange [this test k]
+    (into (empty this)
+          (case test
+            :<  (subseq this < k)
+            :<= (subseq this <= k)
+            :>  (subseq this > k)
+            :>= (subseq this >= k)
+            (throw (ex-info "subrange test must be :<, :<=, :>, or :>=" {:test test}))))))
+
+(extend-type clojure.lang.PersistentTreeMap
+  proto/PNearest
+  (nearest [this test k]
+    (when-let [entry (case test
+                       :<  (first (rsubseq this < k))
+                       :<= (first (rsubseq this <= k))
+                       :>  (first (subseq this > k))
+                       :>= (first (subseq this >= k))
+                       (throw (ex-info "nearest test must be :<, :<=, :>, or :>=" {:test test})))]
+      [(key entry) (val entry)]))
+  (subrange [this test k]
+    (into (empty this)
+          (case test
+            :<  (subseq this < k)
+            :<= (subseq this <= k)
+            :>  (subseq this > k)
+            :>= (subseq this >= k)
+            (throw (ex-info "subrange test must be :<, :<=, :>, or :>=" {:test test}))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PRanked - Index-based operations (O(n) for standard sorted collections)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Note: These are O(n) implementations since PersistentTreeSet/Map don't
+;; maintain subtree sizes. For performance-critical code, use ordered-set/map.
+
+(extend-type clojure.lang.PersistentTreeSet
+  proto/PRanked
+  (rank-of [this x]
+    (if (contains? this x)
+      (count (subseq this < x))
+      -1))
+  (slice [this start end]
+    (let [s (seq this)]
+      (when s
+        (->> s (drop start) (take (- end start))))))
+  (median [this]
+    (let [n (count this)]
+      (when (pos? n)
+        (nth (seq this) (quot (dec n) 2)))))
+  (percentile [this pct]
+    (let [n (count this)]
+      (when (pos? n)
+        (let [idx (min (dec n) (long (* (/ (double pct) 100.0) n)))]
+          (nth (seq this) idx))))))
+
+(extend-type clojure.lang.PersistentTreeMap
+  proto/PRanked
+  (rank-of [this k]
+    (if (contains? this k)
+      (count (subseq this < k))
+      -1))
+  (slice [this start end]
+    (let [s (seq this)]
+      (when s
+        (->> s (drop start) (take (- end start))))))
+  (median [this]
+    (let [n (count this)]
+      (when (pos? n)
+        (nth (seq this) (quot (dec n) 2)))))
+  (percentile [this pct]
+    (let [n (count this)]
+      (when (pos? n)
+        (let [idx (min (dec n) (long (* (/ (double pct) 100.0) n)))]
+          (nth (seq this) idx))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PSplittable - Split operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(extend-type clojure.lang.PersistentTreeSet
+  proto/PSplittable
+  (split-key [this k]
+    (let [left  (into (empty this) (subseq this < k))
+          entry (when (contains? this k) k)
+          right (into (empty this) (subseq this > k))]
+      [left entry right]))
+  (split-at [this i]
+    (let [s (seq this)
+          left  (into (empty this) (take i s))
+          right (into (empty this) (drop i s))]
+      [left right])))
+
+(extend-type clojure.lang.PersistentTreeMap
+  proto/PSplittable
+  (split-key [this k]
+    (let [left  (into (empty this) (subseq this < k))
+          entry (when (contains? this k) [(find this k)])
+          right (into (empty this) (subseq this > k))]
+      [left (when entry [(key (first entry)) (val (first entry))]) right]))
+  (split-at [this i]
+    (let [s (seq this)
+          left  (into (empty this) (take i s))
+          right (into (empty this) (drop i s))]
+      [left right])))
diff --git a/src/ordered_collections/types/interval_map.clj b/src/ordered_collections/types/interval_map.clj
new file mode 100644
index 0000000..3002107
--- /dev/null
+++ b/src/ordered_collections/types/interval_map.clj
@@ -0,0 +1,246 @@
+(ns ordered-collections.types.interval-map
+  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
+            [ordered-collections.types.shared :refer [with-tree-env]
+             :rename {with-tree-env with-interval-map}]
+            [ordered-collections.kernel.interval :as interval]
+            [ordered-collections.kernel.node     :as node]
+            [ordered-collections.protocol      :as proto]
+            [ordered-collections.kernel.root]
+            [ordered-collections.kernel.order    :as order]
+            [ordered-collections.kernel.tree     :as tree])
+  (:import  [clojure.lang                RT MapEntry Murmur3]
+            [ordered_collections.protocol PIntervalCollection PSpan]
+            [ordered_collections.kernel.root     INodeCollection
+                                         IBalancedCollection
+                                         IOrderedCollection
+                                         IIntervalCollection]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields: root, cmp, alloc, stitch, _meta — same as IntervalSet.
+;;
+;; ILookup/IFn return values for overlapping intervals (not the
+;; intervals themselves). Seq/reduce/nth return MapEntry of [interval value].
+;; Like IntervalSet, requires with-tree-env for augmented node construction.
+
+(deftype IntervalMap [root cmp alloc stitch _meta]
+
+  java.io.Serializable
+
+  INodeCollection
+  (getAllocator [_]
+    alloc)
+  (getRoot [_]
+    root)
+
+  IOrderedCollection
+  (getCmp [_]
+    cmp)
+  (isCompatible [_ o]
+    (and (instance? IntervalMap o) (= cmp (.getCmp ^IOrderedCollection o)) (= stitch (.getStitch ^IBalancedCollection o))))
+  (isSimilar [_ o]
+    (map? o))
+
+  IBalancedCollection
+  (getStitch [_]
+    stitch)
+
+  IIntervalCollection
+
+  PIntervalCollection
+  (overlapping [this interval]
+    (with-interval-map this
+      (when-let [found (seq (tree/node-find-intervals root interval))]
+        (map node/-kv found))))
+
+  PSpan
+  (span [this]
+    (when-not (node/leaf? root)
+      [(first (node/-k (tree/node-least root))) (node/-z root)]))
+
+  clojure.lang.IMeta
+  (meta [_]
+    _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (IntervalMap. root cmp alloc stitch m))
+
+  clojure.lang.Indexed
+  (nth [_ i]
+    (node/-kv (tree/node-nth root i)))
+  (nth [_ i not-found]
+    (if (and (>= i 0) (< i (tree/node-size root)))
+      (node/-kv (tree/node-nth root i))
+      not-found))
+
+  clojure.lang.MapEquivalence
+
+  clojure.lang.Seqable
+  (seq [_]
+    (tree/node-entry-seq root (tree/node-size root)))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (tree/node-entry-seq-reverse root (tree/node-size root)))
+
+  clojure.lang.ILookup
+  (valAt [this k not-found]
+    (with-interval-map this
+      (if-let [found (seq (tree/node-find-intervals root k))]
+        (map node/-v found)
+        not-found)))
+  (valAt [this k]
+    (.valAt this k nil))
+
+  clojure.lang.IFn
+  (invoke [this k not-found]
+    (.valAt this k not-found))
+  (invoke [this k]
+    (.valAt this k))
+  (applyTo [this args]
+    (let [n (RT/boundedLength args 2)]
+      (case n
+        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
+        1 (.invoke this (first args))
+        2 (.invoke this (first args) (second args))
+        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
+
+  java.lang.Comparable
+  (compareTo [this o]
+    (with-interval-map this
+      (cond
+        (identical? this o) 0
+        (.isCompatible this o) (tree/node-map-compare root (.getRoot ^INodeCollection o))
+        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
+
+  clojure.lang.Counted
+  (count [this]
+    (tree/node-size root))
+
+  clojure.lang.Associative
+  (containsKey [this k]
+    (with-interval-map this
+      (not (empty? (tree/node-find-intervals root k)))))
+  (entryAt [this k]
+    (with-interval-map this
+      (when-let [found (seq (tree/node-find-intervals root k))]
+        (node/-kv (first found)))))
+  (assoc [this k v]
+    (IntervalMap. (tree/node-add root (interval/ordered-pair k) v cmp alloc) cmp alloc stitch _meta))
+  (empty [this]
+    (IntervalMap. (node/leaf) cmp alloc stitch _meta))
+
+  java.util.Map
+  (get [this k]
+    (.valAt this k))
+  (isEmpty [_]
+    (node/leaf? root))
+  (size [_]
+    (tree/node-size root))
+  (keySet [this]
+    (with-interval-map this
+      (set (tree/node-vec root :accessor :k))))
+  (put [_ _ _]
+    (throw (UnsupportedOperationException.)))
+  (putAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (clear [_]
+    (throw (UnsupportedOperationException.)))
+  (values [this]
+    (with-interval-map this
+      (tree/node-vec root :accessor :v)))
+  (entrySet [this]
+    (with-interval-map this
+      (set (tree/node-vec root :accessor :kv))))
+  (iterator [this]
+    (clojure.lang.SeqIterator. (seq this)))
+
+  clojure.lang.IPersistentCollection
+  (equiv [this o]
+    (with-interval-map this
+      (cond
+        (identical? this o) true
+        (not (instance? clojure.lang.Counted o)) false
+        (.isCompatible this o) (and (= (.count this) (.count ^clojure.lang.Counted o))
+                                    (zero? (tree/node-map-compare root (.getRoot ^INodeCollection o))))
+        :else false)))
+
+  (cons [this o]
+    (.assoc this (nth o 0) (nth o 1)))
+
+  clojure.lang.IReduceInit
+  (reduce [this f init]
+    (tree/node-reduce-entries f init root))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (tree/node-reduce-entries f root))
+
+  clojure.core.protocols/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^clojure.lang.IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^clojure.lang.IReduceInit this f init))
+
+  clojure.lang.IKVReduce
+  (kvreduce [this f init]
+    (tree/node-reduce-kv f init root))
+
+  Object
+  (toString [this]
+    (pr-str this))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/mixCollHash
+      (unchecked-int
+        (tree/node-reduce
+          (fn [^long acc n]
+            (unchecked-add acc (long (clojure.lang.Util/hasheq
+                                       (clojure.lang.MapEntry. (node/-k n) (node/-v n))))))
+          (long 0)
+          root))
+      (tree/node-size root)))
+
+  clojure.core.reducers.CollFold
+  (coll-fold [this n combinef reducef]
+    (with-interval-map this
+      (tree/node-fold n root combinef
+        (fn [acc node] (reducef acc (node/-kv node))))))
+
+  clojure.lang.IPersistentMap
+  (assocEx [this k v]
+    (if (contains? this k)
+      (throw (RuntimeException. "Key or value already present"))
+      (assoc this k v)))
+  (without [this k]
+    (IntervalMap. (tree/node-remove root (interval/ordered-pair k) cmp alloc) cmp alloc stitch _meta)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method IntervalMap [^IntervalMap m ^java.io.Writer w]
+  (if (order/default-comparator? (.getCmp ^IOrderedCollection m))
+    (do (.write w "#ordered/interval-map [")
+        (let [s (seq m)]
+          (when s
+            (let [[k v] (first s)]
+              (print-method [(vec k) v] w))
+            (doseq [[k v] (rest s)]
+              (.write w " ")
+              (print-method [(vec k) v] w))))
+        (.write w "]"))
+    (do (.write w "#<IntervalMap {")
+        (let [s (seq m)]
+          (when s
+            (let [[k v] (first s)]
+              (print-method k w) (.write w " ") (print-method v w))
+            (doseq [[k v] (rest s)]
+              (.write w ", ")
+              (print-method k w) (.write w " ") (print-method v w))))
+        (.write w "}>"))))
diff --git a/src/ordered_collections/types/interval_set.clj b/src/ordered_collections/types/interval_set.clj
new file mode 100644
index 0000000..9d96715
--- /dev/null
+++ b/src/ordered_collections/types/interval_set.clj
@@ -0,0 +1,309 @@
+(ns ordered-collections.types.interval-set
+  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
+            [clojure.set]
+            [ordered-collections.types.shared :refer [with-tree-env]
+             :rename {with-tree-env with-interval-set}]
+            [ordered-collections.kernel.interval :as interval]
+            [ordered-collections.kernel.node     :as node]
+            [ordered-collections.kernel.order    :as order]
+            [ordered-collections.protocol      :as proto]
+            [ordered-collections.kernel.root]
+            [ordered-collections.kernel.tree     :as tree])
+  (:import  [clojure.lang                RT Murmur3]
+            [ordered_collections.protocol PExtensibleSet PIntervalCollection PSpan]
+            [ordered_collections.kernel.root     INodeCollection
+                                         IBalancedCollection
+                                         IOrderedCollection
+                                         IIntervalCollection]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Set
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields: root, cmp, alloc, stitch, _meta — same shape as OrderedSet.
+;;
+;; Requires with-tree-env (binds both *compare* and *t-join*) because
+;; IntervalNode propagates max-endpoint augmentation (-z) during node
+;; construction. ILookup/IFn return overlapping intervals, not a boolean
+;; membership test. isSimilar returns false — no cross-type fallback to
+;; clojure.set since interval semantics differ from flat set algebra.
+
+(deftype IntervalSet [root cmp alloc stitch _meta]
+
+  java.io.Serializable
+
+  INodeCollection
+  (getAllocator [_]
+    alloc)
+  (getRoot [_]
+    root)
+
+  IOrderedCollection
+  (getCmp [_]
+    cmp)
+  (isCompatible [_ o]
+    (and (instance? IntervalSet o) (= cmp (.getCmp ^IOrderedCollection o))))
+  (isSimilar [_ _]
+    false)
+
+  IBalancedCollection
+  (getStitch [_]
+    stitch)
+
+  IIntervalCollection
+
+  PIntervalCollection
+  (overlapping [this interval]
+    (with-interval-set this
+      (when-let [found (seq (tree/node-find-intervals root interval))]
+        (map node/-k found))))
+
+  PSpan
+  (span [this]
+    (when-not (node/leaf? root)
+      [(first (node/-k (tree/node-least root))) (node/-z root)]))
+
+  PExtensibleSet
+  (intersection [this that]
+    (with-interval-set this
+      (cond
+        (identical? this that)    this
+        (.isCompatible this that)
+        (let [that-root (.getRoot ^INodeCollection that)
+              use-parallel? (>= (+ (tree/node-size root) (tree/node-size that-root))
+                                tree/+parallel-intersection-root-threshold+)]
+          (IntervalSet.
+           (if use-parallel?
+             (tree/node-set-intersection-parallel root that-root)
+             (tree/node-set-intersection root that-root))
+           cmp alloc stitch _meta))
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+  (union [this that]
+    (with-interval-set this
+      (cond
+        (identical? this that)    this
+        (.isCompatible this that)
+        (let [that-root (.getRoot ^INodeCollection that)
+              use-parallel? (>= (+ (tree/node-size root) (tree/node-size that-root))
+                                tree/+parallel-union-root-threshold+)]
+          (IntervalSet.
+           (if use-parallel?
+             (tree/node-set-union-parallel root that-root)
+             (tree/node-set-union root that-root))
+           cmp alloc stitch _meta))
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+  (difference [this that]
+    (with-interval-set this
+      (cond
+        (identical? this that)    (.empty this)
+        (.isCompatible this that)
+        (let [that-root (.getRoot ^INodeCollection that)
+              use-parallel? (>= (+ (tree/node-size root) (tree/node-size that-root))
+                                tree/+parallel-difference-root-threshold+)]
+          (IntervalSet.
+           (if use-parallel?
+             (tree/node-set-difference-parallel root that-root)
+             (tree/node-set-difference root that-root))
+           cmp alloc stitch _meta))
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+  (subset? [this that]
+    (with-interval-set this
+      (cond
+        (identical? this that)    true
+        (.isCompatible this that) (tree/node-subset? (.getRoot ^INodeCollection that) root) ;; Grr. reverse args of tree/subset
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+  (superset? [this that]
+    (with-interval-set this
+      (cond
+        (identical? this that)    true
+        (.isCompatible this that) (tree/node-subset? root (.getRoot ^INodeCollection that))
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+  (disjoint? [this that]
+    (with-interval-set this
+      (cond
+        (identical? this that)    (zero? (tree/node-size root))
+        (.isCompatible this that) (tree/node-disjoint? root (.getRoot ^INodeCollection that))
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+
+  clojure.lang.IMeta
+  (meta [_]
+    _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (IntervalSet. root cmp alloc stitch m))
+
+  clojure.lang.Indexed
+  (nth [_ i]
+    (node/-k (tree/node-nth root i)))
+  (nth [_ i not-found]
+    (if (and (>= i 0) (< i (tree/node-size root)))
+      (node/-k (tree/node-nth root i))
+      not-found))
+
+  clojure.lang.Seqable
+  (seq [_]
+    (tree/node-key-seq root (tree/node-size root)))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (tree/node-key-seq-reverse root (tree/node-size root)))
+
+  clojure.lang.ILookup
+  (valAt [this k not-found]
+    (with-interval-set this
+      (if-let [found (seq (tree/node-find-intervals root k))]
+        (map node/-k found)
+        not-found)))
+  (valAt [this k]
+    (.valAt this k nil))
+
+  clojure.lang.IFn
+  (invoke [this k not-found]
+    (.valAt this k not-found))
+  (invoke [this k]
+    (.valAt this k))
+  (applyTo [this args]
+    (let [n (RT/boundedLength args 2)]
+      (case n
+        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
+        1 (.invoke this (first args))
+        2 (.invoke this (first args) (second args))
+        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
+
+  java.lang.Comparable
+  (compareTo [this o]
+    (with-interval-set this
+      (cond
+        (identical? this o)   0
+        (.isCompatible this o) (tree/node-set-compare root (.getRoot ^INodeCollection o))
+        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
+
+  java.util.Collection
+  (toArray [this]
+    (with-interval-set this
+      (object-array (tree/node-vec root :accessor :k)))) ; better constructor not a priority
+  (isEmpty [_]
+    (node/leaf? root))
+  (add [_ _]
+    (throw (UnsupportedOperationException.)))
+  (addAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (removeAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (retainAll [_ _]
+    (throw (UnsupportedOperationException.)))
+
+  java.util.Set
+  (size [_]
+    (tree/node-size root))
+  (iterator [this]
+    (clojure.lang.SeqIterator. (seq this)))
+  (containsAll [this s]
+    ;; Checks if all intervals in s exist as exact intervals in this set.
+    ;; Does NOT check coverage (use interval queries for that).
+    (with-interval-set this
+      (cond
+        (identical? this s)    true
+        (coll? s) (every? #(.contains this %) s)
+        true      (throw (ex-info "unsupported comparison: " {:this this :s s})))))
+
+  java.util.SortedSet
+  (comparator [_]
+    cmp)
+  (first [this]
+    (with-interval-set this
+      (first (tree/node-least-kv root))))
+  (last [this]
+    (with-interval-set this
+      (first (tree/node-greatest-kv root))))
+  (headSet [this x]
+    (with-interval-set this
+      (IntervalSet. (tree/node-split-lesser root (interval/ordered-pair x)) cmp alloc stitch _meta)))
+  (tailSet [this x]
+    (with-interval-set this
+      (let [k (interval/ordered-pair x)
+            [_ present gt] (tree/node-split root k)]
+        (if present
+          (IntervalSet. (tree/node-add gt (first present) (first present) cmp alloc) cmp alloc stitch _meta)
+          (IntervalSet. gt cmp alloc stitch _meta)))))
+  (subSet [this from to]
+    (with-interval-set this
+      (let [from-k (interval/ordered-pair from)
+            to-k (interval/ordered-pair to)
+            [_ from-present from-gt] (tree/node-split root from-k)
+            from-tree (if from-present
+                        (tree/node-add from-gt (first from-present) (first from-present) cmp alloc)
+                        from-gt)
+            to-tree (tree/node-split-lesser root to-k)
+            result (tree/node-set-intersection from-tree to-tree)]
+        (IntervalSet. result cmp alloc stitch _meta))))
+
+  clojure.lang.IPersistentSet
+  (equiv [this o]
+    (with-interval-set this
+      (cond
+        (identical? this o) true
+        (not (instance? clojure.lang.Counted o)) false
+        (.isCompatible this o) (and (= (.count this) (.count ^clojure.lang.Counted o))
+                                    (zero? (tree/node-set-compare root (.getRoot ^INodeCollection o))))
+        :else false)))
+  (count [_]
+    (tree/node-size root))
+  (empty [_]
+    (IntervalSet. (node/leaf) cmp alloc stitch _meta))
+  (contains [this k]
+    (with-interval-set this
+      (some? (seq (tree/node-find-intervals root (interval/ordered-pair k))))))
+  (disjoin [this k]
+    (IntervalSet. (tree/node-remove root (interval/ordered-pair k) cmp alloc) cmp alloc stitch _meta))
+  (cons [this k]
+    (IntervalSet. (tree/node-add root (interval/ordered-pair k) (interval/ordered-pair k) cmp alloc) cmp alloc stitch _meta))
+
+  clojure.lang.IReduceInit
+  (reduce [this f init]
+    (tree/node-reduce-keys f init root))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (tree/node-reduce-keys f root))
+
+  clojure.core.protocols/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^clojure.lang.IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^clojure.lang.IReduceInit this f init))
+
+  Object
+  (toString [this]
+    (pr-str this))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/mixCollHash
+      (unchecked-int
+        (tree/node-reduce
+          (fn [^long acc n]
+            (unchecked-add acc (long (clojure.lang.Util/hasheq (node/-k n)))))
+          (long 0)
+          root))
+      (tree/node-size root)))
+
+  clojure.core.reducers.CollFold
+  (coll-fold [this n combinef reducef]
+    (with-interval-set this
+      (tree/node-fold n root combinef
+        (fn [acc node] (reducef acc (node/-k node)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method IntervalSet [^IntervalSet s ^java.io.Writer w]
+  (if (order/default-comparator? (.getCmp ^IOrderedCollection s))
+    (do (.write w "#ordered/interval-set ")
+        (print-method (vec s) w))
+    (do (.write w "#<IntervalSet ")
+        (print-method (vec s) w)
+        (.write w ">"))))
diff --git a/src/ordered_collections/types/ordered_map.clj b/src/ordered_collections/types/ordered_map.clj
new file mode 100644
index 0000000..2b907ad
--- /dev/null
+++ b/src/ordered_collections/types/ordered_map.clj
@@ -0,0 +1,415 @@
+(ns ordered-collections.types.ordered-map
+  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
+            [ordered-collections.types.shared :refer [with-compare]]
+            [ordered-collections.kernel.node     :as node]
+            [ordered-collections.kernel.order    :as order]
+            [ordered-collections.protocol      :as proto]
+            [ordered-collections.kernel.root]
+            [ordered-collections.kernel.tree     :as tree])
+  (:import  [clojure.lang                RT Murmur3]
+            [ordered_collections.protocol PNearest PRanked PSplittable PExclusiveAssoc]
+            [ordered_collections.kernel.root     INodeCollection
+                                         IBalancedCollection
+                                         IOrderedCollection]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields: root, cmp, alloc, stitch, _meta — same layout as OrderedSet.
+;;
+;; Lookup returns values (not nodes). Seq/reduce/nth return MapEntry.
+;; Implements IKVReduce for reduce-kv. The ordered-merge-with function
+;; (defined after the deftype) uses tree-level parallel merge for
+;; compatible maps, sequential assoc fallback otherwise.
+
+(deftype OrderedMap [root cmp alloc stitch _meta]
+
+  java.io.Serializable  ;; marker interface for serialization
+
+  INodeCollection
+  (getAllocator [_]
+    alloc)
+  (getRoot [_]
+    root)
+
+  IOrderedCollection
+  (getCmp [_]
+    cmp)
+  (isCompatible [_ o]
+    (and (instance? OrderedMap o)
+         (= cmp (.getCmp ^IOrderedCollection o))
+         (= stitch (.getStitch ^IBalancedCollection o))))
+  (isSimilar [_ o]
+    (map? o))
+
+  IBalancedCollection
+  (getStitch [_]
+    stitch)
+
+  clojure.lang.IMeta
+  (meta [_]
+    _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (OrderedMap. root cmp alloc stitch m))
+
+  clojure.lang.Indexed
+  (nth [_ i]
+    ;; nth doesn't need comparator - only uses subtree sizes
+    (node/-kv (tree/node-nth root i)))
+  (nth [_ i not-found]
+    (if (and (>= i 0) (< i (tree/node-size root)))
+      (node/-kv (tree/node-nth root i))
+      not-found))
+
+  clojure.lang.MapEquivalence
+
+  clojure.lang.Seqable
+  (seq [_]
+    (tree/node-entry-seq root (tree/node-size root)))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (tree/node-entry-seq-reverse root (tree/node-size root)))
+
+  clojure.lang.ILookup
+  (valAt [this k not-found]
+    ;; Fast paths for specialized comparators
+    (cond
+      (identical? cmp order/long-compare)   (tree/node-find-val-long root (long k) not-found)
+      (identical? cmp order/string-compare) (tree/node-find-val-string root k not-found)
+      :else (tree/node-find-val root k not-found cmp)))
+  (valAt [this k]
+    (.valAt this k nil))
+
+  clojure.lang.IFn
+  (invoke [this k not-found]
+    (.valAt this k not-found))
+  (invoke [this k]
+    (.valAt this k))
+  (applyTo [this args]
+    (let [n (RT/boundedLength args 2)]
+      (case n
+        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
+        1 (.invoke this (first args))
+        2 (.invoke this (first args) (second args))
+        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
+
+  java.lang.Comparable
+  (compareTo [this o]
+    (with-compare this
+      (cond
+        (identical? this o) 0
+        (.isCompatible this o) (tree/node-map-compare root (.getRoot ^INodeCollection o))
+        (.isSimilar    this o) (.compareTo ^Comparable (into (empty o) this) o)
+        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
+
+  clojure.lang.Counted
+  (count [this]
+    (tree/node-size root))
+
+  clojure.lang.Associative
+  (containsKey [this k]
+    ;; Fast paths for specialized comparators
+    (cond
+      (identical? cmp order/long-compare)   (tree/node-contains-long? root (long k))
+      (identical? cmp order/string-compare) (tree/node-contains-string? root k)
+      :else (tree/node-contains? root k cmp)))
+  (entryAt [this k]
+    ;; Fast paths for specialized comparators
+    (when-let [n (cond
+                   (identical? cmp order/long-compare)   (tree/node-find-long root (long k))
+                   (identical? cmp order/string-compare) (tree/node-find-string root k)
+                   :else (tree/node-find root k cmp))]
+      (node/-kv n)))
+  (assoc [this k v]
+    (OrderedMap. (tree/node-add root k v cmp tree/node-create-weight-balanced) cmp alloc stitch _meta))
+  (empty [this]
+    (OrderedMap. (node/leaf) cmp alloc stitch _meta))
+
+  java.util.Map
+  (get [this k]
+    (.valAt this k))
+  (isEmpty [_]
+    (node/leaf? root))
+  (size [_]
+    (tree/node-size root))
+  (keySet [this]
+    (with-compare this
+      (set (tree/node-vec root :accessor :k))))
+  (put [_ _ _]
+    (throw (UnsupportedOperationException.)))
+  (putAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (clear [_]
+    (throw (UnsupportedOperationException.)))
+  (values [this]
+    (with-compare this
+      (tree/node-vec root :accessor :v)))
+  (entrySet [this]
+    (with-compare this
+      (set (tree/node-vec root :accessor :kv))))
+  (iterator [this]
+    (clojure.lang.SeqIterator. (seq this)))
+
+  clojure.lang.IPersistentCollection
+  (equiv [this o]
+    (with-compare this
+      (cond
+        (identical? this o) true
+        (not (instance? clojure.lang.Counted o)) false
+        (not= (tree/node-size root) (.count ^clojure.lang.Counted o)) false
+        (.isCompatible this o) (zero? (tree/node-map-compare root (.getRoot ^INodeCollection o)))
+        (map? o) (every? (fn [e] (= (val e) (get o (key e) ::not-found))) this)
+        :else false)))
+
+  (cons [this o]
+    (.assoc this (nth o 0) (nth o 1)))
+
+  clojure.lang.IReduceInit
+  (reduce [this f init]
+    (tree/node-reduce-entries f init root))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (tree/node-reduce-entries f root))
+
+  clojure.core.protocols/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^clojure.lang.IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^clojure.lang.IReduceInit this f init))
+
+  clojure.lang.IKVReduce
+  (kvreduce [this f init]
+    (tree/node-reduce-kv f init root))
+
+  clojure.core.reducers.CollFold
+  (coll-fold [this n combinef reducef]
+    (with-compare this
+      (tree/node-fold n root combinef
+        (fn [acc node] (reducef acc (node/-kv node))))))
+
+  clojure.lang.IPersistentMap
+  (assocEx [this k v]
+    (if-let [new-root (tree/node-add-if-absent root k v cmp tree/node-create-weight-balanced)]
+      (OrderedMap. new-root cmp alloc stitch _meta)
+      (throw (Exception. "Key or value already present"))))
+  (without [this k]
+    (OrderedMap. (tree/node-remove root k cmp tree/node-create-weight-balanced) cmp alloc stitch _meta))
+
+  java.util.SortedMap
+  (comparator [_]
+    cmp)
+  (firstKey [this]
+    (with-compare this
+      (first (tree/node-least-kv root))))
+  (lastKey [this]
+    (with-compare this
+      (first (tree/node-greatest-kv root))))
+  (headMap [this k]
+    (with-compare this
+      (OrderedMap. (tree/node-split-lesser root k) cmp alloc stitch _meta)))
+  (tailMap [this k]
+    (with-compare this
+      (let [[_ present gt] (tree/node-split root k)]
+        (if present
+          (OrderedMap. (tree/node-add gt (first present) (second present)) cmp alloc stitch _meta)
+          (OrderedMap. gt cmp alloc stitch _meta)))))
+  (subMap [this from to]
+    (with-compare this
+      (let [[_ from-present from-gt] (tree/node-split root from)
+            from-tree (if from-present
+                        (tree/node-add from-gt (first from-present) (second from-present))
+                        from-gt)
+            to-tree (tree/node-split-lesser root to)
+            result (tree/node-set-intersection from-tree to-tree)]
+        (OrderedMap. result cmp alloc stitch _meta))))
+
+  clojure.lang.Sorted
+  (entryKey [_ entry]
+    (key entry))
+  (seq [_ ascending]
+    (if ascending
+      (tree/node-entry-seq root)
+      (tree/node-entry-seq-reverse root)))
+  (seqFrom [this k ascending]
+    (with-compare this
+      (let [[lt present gt] (tree/node-split root k)]
+        (if ascending
+          (if present
+            (cons (clojure.lang.MapEntry. (first present) (second present))
+                  (tree/node-entry-seq gt))
+            (tree/node-entry-seq gt))
+          (if present
+            (cons (clojure.lang.MapEntry. (first present) (second present))
+                  (tree/node-entry-seq-reverse lt))
+            (tree/node-entry-seq-reverse lt))))))
+
+  Object
+  (toString [this]
+    (pr-str this))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    ;; Must match APersistentMap: sum of hasheq(MapEntry) for each entry, then mixCollHash
+    (Murmur3/mixCollHash
+      (unchecked-int
+        (tree/node-reduce
+          (fn [^long acc n]
+            (unchecked-add acc (long (clojure.lang.Util/hasheq
+                                       (clojure.lang.MapEntry. (node/-k n) (node/-v n))))))
+          (long 0)
+          root))
+      (tree/node-size root)))
+
+  PNearest
+  (nearest [this test k]
+    (with-compare this
+      (case test
+        :< (when-let [n (tree/node-predecessor root k)]
+             [(node/-k n) (node/-v n)])
+        :<= (when-let [n (tree/node-find-nearest root k :<)]
+              [(node/-k n) (node/-v n)])
+        :> (when-let [n (tree/node-successor root k)]
+             [(node/-k n) (node/-v n)])
+        :>= (when-let [n (tree/node-find-nearest root k :>)]
+              [(node/-k n) (node/-v n)])
+        (throw (ex-info "nearest test must be :<, :<=, :>, or :>=" {:test test})))))
+  (subrange [this test k]
+    (with-compare this
+      (let [result-root (case test
+                          (:< :<=) (tree/node-split-lesser root k)
+                          (:> :>=) (tree/node-split-greater root k)
+                          (throw (ex-info "subrange test must be :<, :<=, :>, or :>=" {:test test})))
+            ;; For <= and >=, include the key itself if present
+            result-root (case test
+                          (:<= :>=) (if-let [n (tree/node-find root k)]
+                                      (tree/node-add result-root (node/-k n) (node/-v n))
+                                      result-root)
+                          result-root)]
+        (OrderedMap. result-root cmp alloc stitch _meta))))
+
+  PRanked
+  (rank-of [_ k]
+    (or (tree/node-rank root k cmp) -1))
+  (slice [_ start end]
+    (let [n (tree/node-size root)
+          start (max 0 (long start))
+          end (min n (long end))]
+      (when (< start end)
+        (binding [order/*compare* cmp]
+          (map (fn [node] (clojure.lang.MapEntry. (node/-k node) (node/-v node)))
+               (tree/node-subseq root start (dec end)))))))
+  (median [_]
+    (let [n (tree/node-size root)]
+      (when (pos? n)
+        (binding [order/*compare* cmp]
+          (let [node (tree/node-nth root (quot (dec n) 2))]
+            (clojure.lang.MapEntry. (node/-k node) (node/-v node)))))))
+  (percentile [_ pct]
+    (let [n (tree/node-size root)]
+      (when (pos? n)
+        (let [idx (min (dec n) (long (* (/ (double pct) 100.0) n)))]
+          (binding [order/*compare* cmp]
+            (let [node (tree/node-nth root idx)]
+              (clojure.lang.MapEntry. (node/-k node) (node/-v node))))))))
+
+  PSplittable
+  (split-key [this k]
+    (with-compare this
+      (let [[l present r] (tree/node-split root k)
+            entry (when present [(first present) (second present)])]
+        [(OrderedMap. l cmp alloc stitch _meta)
+         entry
+         (OrderedMap. r cmp alloc stitch _meta)])))
+  (split-at [this i]
+    (with-compare this
+      (let [n (tree/node-size root)]
+        (cond
+          (<= i 0) [(.empty this) this]
+          (>= i n) [this (.empty this)]
+          :else
+          (let [left-root  (tree/node-split-lesser root (node/-k (tree/node-nth root i)))
+                right-root (tree/node-split-nth root i)]
+            [(OrderedMap. left-root cmp alloc stitch _meta)
+             (OrderedMap. right-root cmp alloc stitch _meta)])))))
+
+  proto/PExclusiveAssoc
+  (assoc-new [this k v]
+    (if-let [new-root (tree/node-add-if-absent root k v cmp tree/node-create-weight-balanced)]
+      (OrderedMap. new-root cmp alloc stitch _meta)
+      this)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Merge
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn ordered-merge-with
+  "Merge ordered maps with a function to resolve conflicts.
+   When the same key appears in multiple maps, (f key val-in-result val-in-latter) is called.
+   Uses the same conservative parallel threshold as ordered-set algebra for
+   large compatible ordered-maps.
+
+   Examples:
+     (ordered-merge-with (fn [k a b] (+ a b)) m1 m2)
+     (ordered-merge-with (fn [k a b] b) m1 m2 m3)  ; last-wins"
+  [f & maps]
+  (when (some identity maps)
+    (let [merge-fn (fn [k v1 v2] (f k v2 v1))  ;; swap order to match clojure.core/merge-with semantics
+          maps (filter identity maps)]
+      (if (empty? maps)
+        nil
+        (reduce
+          (fn [m1 m2]
+            (if (and (instance? OrderedMap m1)
+                     (instance? OrderedMap m2)
+                     (.isCompatible ^IOrderedCollection m1 m2))
+              ;; Both are compatible ordered-maps: use fast tree merge
+              (let [^INodeCollection m1c m1
+                    ^INodeCollection m2c m2
+                    root1 (.getRoot m1c)
+                    root2 (.getRoot m2c)
+                    cmp (.getCmp ^IOrderedCollection m1)
+                    use-parallel? (>= (+ (tree/node-size root1) (tree/node-size root2))
+                                      tree/+parallel-merge-root-threshold+)]
+                (binding [order/*compare* cmp]
+                  (->OrderedMap
+                    (if use-parallel?
+                      (tree/node-map-merge-parallel root1 root2 merge-fn)
+                      (tree/node-map-merge root1 root2 merge-fn))
+                    cmp nil nil {})))
+              ;; Fallback: use sequential assoc
+              (reduce-kv (fn [m k v]
+                           (if-let [existing (get m k)]
+                             (assoc m k (f k existing v))
+                             (assoc m k v)))
+                         m1 m2)))
+          maps)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method OrderedMap [^OrderedMap m ^java.io.Writer w]
+  (if (order/default-comparator? (.getCmp ^IOrderedCollection m))
+    (do (.write w "#ordered/map [")
+        (let [s (seq m)]
+          (when s
+            (print-method (vec (first s)) w)
+            (doseq [e (rest s)]
+              (.write w " ")
+              (print-method (vec e) w))))
+        (.write w "]"))
+    (do (.write w "#<OrderedMap {")
+        (let [s (seq m)]
+          (when s
+            (let [[k v] (first s)]
+              (print-method k w) (.write w " ") (print-method v w))
+            (doseq [[k v] (rest s)]
+              (.write w ", ")
+              (print-method k w) (.write w " ") (print-method v w))))
+        (.write w "}>"))))
diff --git a/src/ordered_collections/types/ordered_multiset.clj b/src/ordered_collections/types/ordered_multiset.clj
new file mode 100644
index 0000000..33dbc9d
--- /dev/null
+++ b/src/ordered_collections/types/ordered_multiset.clj
@@ -0,0 +1,538 @@
+(ns ordered-collections.types.ordered-multiset
+  "Persistent sorted multiset (bag) backed by a weight-balanced tree.
+
+  Internally an ordered map from elements to counts (longs). The public
+  API expands each entry into repeated elements: an element with count 3
+  appears three times in seq, reduce, and nth."
+  (:require [clojure.core.reducers :as r :refer [coll-fold]]
+            [ordered-collections.types.shared :refer [with-compare]]
+            [ordered-collections.kernel.node     :as node]
+            [ordered-collections.kernel.order    :as order]
+            [ordered-collections.protocol      :as proto]
+            [ordered-collections.kernel.root]
+            [ordered-collections.kernel.tree     :as tree])
+  (:import  [clojure.lang RT Murmur3]
+            [java.util Comparator]
+            [ordered_collections.kernel.root INodeCollection
+                                           IBalancedCollection
+                                           IOrderedCollection]))
+
+
+(def ^:private not-found-sentinel ::not-found)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Expanding Seq Views
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; The tree stores [element -> count] entries. These seq types expand each
+;; node into `count` repetitions of the element, walking the tree via
+;; enumerator and the repetition count via an index.
+
+(defn- seq-equiv
+  "Element-wise sequential equivalence (non-recursive through equiv)."
+  [s1 o]
+  (if-not (or (instance? clojure.lang.Sequential o) (instance? java.util.List o))
+    false
+    (loop [s1 (seq s1) s2 (seq o)]
+      (cond
+        (nil? s1) (nil? s2)
+        (nil? s2) false
+        (not (clojure.lang.Util/equiv (first s1) (first s2))) false
+        :else (recur (next s1) (next s2))))))
+
+
+(deftype MultisetSeq [enum ^long ri cnt _meta]
+  ;; enum = tree enumerator, ri = repetition index (0-based into current count)
+
+  clojure.lang.ISeq
+  (first [_]
+    (node/-k (tree/node-enum-first enum)))
+  (next [_]
+    (let [node (tree/node-enum-first enum)
+          c    (long (node/-v node))]
+      (if (< (inc ri) c)
+        (MultisetSeq. enum (inc ri) (when cnt (unchecked-dec-int cnt)) nil)
+        (when-let [e (tree/node-enum-rest enum)]
+          (MultisetSeq. e 0 (when cnt (unchecked-dec-int cnt)) nil)))))
+  (more [this]
+    (or (.next this) ()))
+  (cons [this o]
+    (clojure.lang.Cons. o this))
+
+  clojure.lang.Seqable
+  (seq [this] this)
+
+  clojure.lang.Sequential
+
+  java.lang.Iterable
+  (iterator [this]
+    (clojure.lang.SeqIterator. this))
+
+  clojure.lang.Counted
+  (count [_]
+    (if cnt cnt
+      (loop [e enum, ri ri, n 0]
+        (if (nil? e)
+          n
+          (let [c (long (node/-v (tree/node-enum-first e)))
+                remaining (- c ri)]
+            (recur (tree/node-enum-rest e) 0 (+ n remaining)))))))
+
+  clojure.lang.IReduceInit
+  (reduce [_ f init]
+    (loop [e enum, ri (long ri), acc init]
+      (if (nil? e)
+        acc
+        (let [node (tree/node-enum-first e)
+              elem (node/-k node)
+              c    (long (node/-v node))]
+          (let [acc (loop [i ri, acc acc]
+                      (if (>= i c)
+                        acc
+                        (let [ret (f acc elem)]
+                          (if (reduced? ret)
+                            ret
+                            (recur (inc i) ret)))))]
+            (if (reduced? acc)
+              @acc
+              (recur (tree/node-enum-rest e) 0 acc)))))))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (if enum
+      (let [acc (node/-k (tree/node-enum-first enum))]
+        (let [node (tree/node-enum-first enum)
+              c    (long (node/-v node))
+              remaining-start (inc ri)]
+          (let [[acc e] (loop [i remaining-start, acc acc]
+                          (if (>= i c)
+                            [acc (tree/node-enum-rest enum)]
+                            (let [ret (f acc (node/-k node))]
+                              (if (reduced? ret)
+                                [ret nil]
+                                (recur (inc i) ret)))))]
+            (if (or (reduced? acc) (nil? e))
+              (if (reduced? acc) @acc acc)
+              (.reduce ^clojure.lang.IReduceInit
+                (MultisetSeq. e 0 nil nil) f acc)))))
+      (f)))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/hashOrdered this))
+
+  clojure.lang.IPersistentCollection
+  (empty [_] ())
+  (equiv [this o]
+    (seq-equiv this o))
+
+  Object
+  (hashCode [this]
+    (clojure.lang.Util/hash this))
+  (equals [this o]
+    (clojure.lang.Util/equals this o))
+
+  clojure.lang.IMeta
+  (meta [_] _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (MultisetSeq. enum ri cnt m)))
+
+(deftype MultisetSeqReverse [enum ^long ri cnt _meta]
+  ;; enum = reverse tree enumerator, ri = repetition index (counting down from count-1)
+
+  clojure.lang.ISeq
+  (first [_]
+    (node/-k (tree/node-enum-first enum)))
+  (next [_]
+    (if (pos? ri)
+      (MultisetSeqReverse. enum (dec ri) (when cnt (unchecked-dec-int cnt)) nil)
+      (when-let [e (tree/node-enum-prior enum)]
+        (let [c (long (node/-v (tree/node-enum-first e)))]
+          (MultisetSeqReverse. e (dec c) (when cnt (unchecked-dec-int cnt)) nil)))))
+  (more [this]
+    (or (.next this) ()))
+  (cons [this o]
+    (clojure.lang.Cons. o this))
+
+  clojure.lang.Seqable
+  (seq [this] this)
+
+  clojure.lang.Sequential
+
+  java.lang.Iterable
+  (iterator [this]
+    (clojure.lang.SeqIterator. this))
+
+  clojure.lang.Counted
+  (count [_]
+    (if cnt cnt
+      (loop [e enum, ri ri, n 0]
+        (if (nil? e)
+          n
+          (let [remaining (inc ri)]
+            (recur (tree/node-enum-prior e)
+                   (if-let [e2 (tree/node-enum-prior e)]
+                     (dec (long (node/-v (tree/node-enum-first e2))))
+                     0)
+                   (+ n remaining)))))))
+
+  clojure.lang.IReduceInit
+  (reduce [_ f init]
+    (loop [e enum, ri (long ri), acc init]
+      (if (nil? e)
+        acc
+        (let [elem (node/-k (tree/node-enum-first e))]
+          (let [acc (loop [i ri, acc acc]
+                      (if (neg? i)
+                        acc
+                        (let [ret (f acc elem)]
+                          (if (reduced? ret)
+                            ret
+                            (recur (dec i) ret)))))]
+            (if (reduced? acc)
+              @acc
+              (if-let [e2 (tree/node-enum-prior e)]
+                (recur e2 (dec (long (node/-v (tree/node-enum-first e2)))) acc)
+                acc)))))))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (if enum
+      (let [acc (node/-k (tree/node-enum-first enum))]
+        (if (pos? ri)
+          (.reduce ^clojure.lang.IReduceInit
+            (MultisetSeqReverse. enum (dec ri) nil nil) f acc)
+          (if-let [e2 (tree/node-enum-prior enum)]
+            (.reduce ^clojure.lang.IReduceInit
+              (MultisetSeqReverse. e2 (dec (long (node/-v (tree/node-enum-first e2)))) nil nil)
+              f acc)
+            acc)))
+      (f)))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/hashOrdered this))
+
+  clojure.lang.IPersistentCollection
+  (empty [_] ())
+  (equiv [this o]
+    (seq-equiv this o))
+
+  Object
+  (hashCode [this]
+    (clojure.lang.Util/hash this))
+  (equals [this o]
+    (clojure.lang.Util/equals this o))
+
+  clojure.lang.IMeta
+  (meta [_] _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (MultisetSeqReverse. enum ri cnt m)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Multiset
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields:
+;;   root — weight-balanced tree mapping element -> count (long)
+;;   cmp  — java.util.Comparator for element ordering (user's comparator directly)
+;;   cnt  — total element count (sum of all counts)
+;;   _meta — metadata map
+;;
+;; No seqnum, no synthetic comparator. Duplicate elements increment the
+;; count stored at that key. The public API expands counts into repeated
+;; elements in seq/reduce/nth.
+
+(deftype OrderedMultiset [root ^Comparator cmp ^long cnt _meta]
+
+  java.io.Serializable
+
+  INodeCollection
+  (getAllocator [_] nil)
+  (getRoot [_] root)
+
+  IOrderedCollection
+  (getCmp [_] cmp)
+  (isCompatible [_ o]
+    (and (instance? OrderedMultiset o)
+         (= cmp (.getCmp ^IOrderedCollection o))))
+  (isSimilar [_ _] false)
+
+  IBalancedCollection
+  (getStitch [_] nil)
+
+  clojure.lang.IMeta
+  (meta [_] _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (OrderedMultiset. root cmp cnt m))
+
+  clojure.lang.Seqable
+  (seq [_]
+    (when-let [e (tree/node-enumerator root nil)]
+      (MultisetSeq. e 0 cnt nil)))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (when-let [e (tree/node-enumerator-reverse root)]
+      (let [c (long (node/-v (tree/node-enum-first e)))]
+        (MultisetSeqReverse. e (dec c) cnt nil))))
+
+  clojure.lang.Counted
+  (count [_] cnt)
+
+  clojure.lang.Indexed
+  (nth [this i]
+    (loop [s (seq this) j (long i)]
+      (cond
+        (nil? s) (throw (IndexOutOfBoundsException. (str "Index: " i)))
+        (zero? j) (first s)
+        :else (recur (next s) (dec j)))))
+  (nth [this i not-found]
+    (if (and (>= i 0) (< i cnt))
+      (.nth this i)
+      not-found))
+
+  clojure.lang.ILookup
+  (valAt [_ k not-found]
+    (let [result (tree/node-find-val root k not-found-sentinel cmp)]
+      (if (identical? result not-found-sentinel)
+        not-found
+        k)))
+  (valAt [this k]
+    (.valAt this k nil))
+
+  clojure.lang.IFn
+  (invoke [this k]
+    (.valAt this k))
+  (invoke [this k not-found]
+    (.valAt this k not-found))
+  (applyTo [this args]
+    (let [n (RT/boundedLength args 2)]
+      (case n
+        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
+        1 (.invoke this (first args))
+        2 (.invoke this (first args) (second args))
+        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
+
+  clojure.lang.IPersistentCollection
+  (cons [_ x]
+    (let [existing (tree/node-find-val root x not-found-sentinel cmp)
+          new-count (if (identical? existing not-found-sentinel) 1 (inc (long existing)))
+          new-root  (tree/node-add root x new-count cmp tree/node-create-weight-balanced)]
+      (OrderedMultiset. new-root cmp (inc cnt) _meta)))
+  (empty [_]
+    (OrderedMultiset. (node/leaf) cmp 0 _meta))
+  (equiv [this o]
+    (cond
+      (identical? this o) true
+      (not (instance? clojure.lang.Counted o)) false
+      (not= cnt (.count ^clojure.lang.Counted o)) false
+      :else (= (seq this) (seq o))))
+
+  clojure.lang.IReduceInit
+  (reduce [_ f init]
+    (tree/node-reduce
+      (fn [acc n]
+        (let [elem (node/-k n)
+              c    (long (node/-v n))]
+          (loop [i (long 0), acc acc]
+            (if (>= i c)
+              acc
+              (let [ret (f acc elem)]
+                (if (reduced? ret)
+                  (reduced ret)
+                  (recur (inc i) ret)))))))
+      init root))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (if (node/leaf? root)
+      (f)
+      (let [s (seq this)]
+        (if s
+          (reduce f (first s) (rest s))
+          (f)))))
+
+  clojure.core.protocols/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^clojure.lang.IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^clojure.lang.IReduceInit this f init))
+
+  clojure.core.reducers.CollFold
+  (coll-fold [this chunk-size combinef reducef]
+    (with-compare this
+      (tree/node-fold chunk-size root combinef
+        (fn [acc node]
+          (let [elem (node/-k node)
+                c    (long (node/-v node))]
+            (loop [i (long 0), acc acc]
+              (if (>= i c)
+                acc
+                (recur (inc i) (reducef acc elem)))))))))
+
+  java.lang.Comparable
+  (compareTo [this o]
+    (if (instance? OrderedMultiset o)
+      (compare (vec (seq this)) (vec (seq o)))
+      (throw (ex-info "Cannot compare OrderedMultiset to non-multiset" {:other o}))))
+
+  java.util.Collection
+  (toArray [this]
+    (object-array (seq this)))
+  (isEmpty [_]
+    (node/leaf? root))
+  (size [_] cnt)
+  (iterator [this]
+    (clojure.lang.SeqIterator. (seq this)))
+  (add [_ _]
+    (throw (UnsupportedOperationException.)))
+  (addAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (remove [_ _]
+    (throw (UnsupportedOperationException.)))
+  (removeAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (retainAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (clear [_]
+    (throw (UnsupportedOperationException.)))
+  (contains [this x]
+    (not (identical? not-found-sentinel
+                     (tree/node-find-val root x not-found-sentinel cmp))))
+  (containsAll [this coll]
+    (every? #(.contains this %) coll))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/hashOrdered this))
+
+  Object
+  (toString [this]
+    (pr-str this))
+  (hashCode [this]
+    (.hasheq this))
+  (equals [this o]
+    (.equiv this o))
+
+  proto/PMultiset
+  (multiplicity [_ x]
+    (let [result (tree/node-find-val root x not-found-sentinel cmp)]
+      (if (identical? result not-found-sentinel) 0 (long result))))
+  (disj-one [this x]
+    (let [existing (tree/node-find-val root x not-found-sentinel cmp)]
+      (if (identical? existing not-found-sentinel)
+        this
+        (let [c (long existing)
+              new-root (if (> c 1)
+                         (tree/node-add root x (dec c) cmp tree/node-create-weight-balanced)
+                         (tree/node-remove root x cmp tree/node-create-weight-balanced))]
+          (OrderedMultiset. new-root cmp (dec cnt) _meta)))))
+  (disj-all [this x]
+    (let [existing (tree/node-find-val root x not-found-sentinel cmp)]
+      (if (identical? existing not-found-sentinel)
+        this
+        (let [c (long existing)
+              new-root (tree/node-remove root x cmp tree/node-create-weight-balanced)]
+          (OrderedMultiset. new-root cmp (- cnt c) _meta)))))
+  (distinct-elements [_]
+    (tree/node-key-seq root))
+  (element-frequencies [_]
+    (persistent!
+      (tree/node-reduce
+        (fn [acc n] (assoc! acc (node/-k n) (node/-v n)))
+        (transient {})
+        root))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Extended API (delegate to protocol)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn multiplicity
+  "Return the number of occurrences of x in the multiset. O(log n)."
+  [ms x]
+  (proto/multiplicity ms x))
+
+(defn disj-one
+  "Remove one occurrence of x from the multiset. O(log n).
+  Returns the same multiset if x is not present."
+  [ms x]
+  (proto/disj-one ms x))
+
+(defn disj-all
+  "Remove all occurrences of x from the multiset. O(log n).
+  Returns the same multiset if x is not present."
+  [ms x]
+  (proto/disj-all ms x))
+
+(defn distinct-elements
+  "Return a seq of distinct elements in the multiset, in sorted order. O(n)."
+  [ms]
+  (proto/distinct-elements ms))
+
+(defn element-frequencies
+  "Return a map of {element -> count} for all elements. O(n)."
+  [ms]
+  (proto/element-frequencies ms))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Constructors
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn ordered-multiset
+  "Create an ordered multiset from a collection.
+  Elements are sorted by natural order (clojure.core/compare).
+  Duplicates are allowed.
+
+  Examples:
+    (ordered-multiset)
+    (ordered-multiset [3 1 4 1 5 9 2 6 5 3 5])"
+  ([] (OrderedMultiset. (node/leaf) order/normal-compare 0 {}))
+  ([coll]
+   (into (ordered-multiset) coll)))
+
+(defn ordered-multiset-by
+  "Create an ordered multiset with custom ordering via a predicate.
+
+  Example:
+    (ordered-multiset-by > [3 1 4 1 5])"
+  [pred coll]
+  (let [cmp (order/compare-by pred)]
+    (into (OrderedMultiset. (node/leaf) cmp 0 {}) coll)))
+
+(defn ordered-multiset-with
+  "Create an ordered multiset with a custom java.util.Comparator.
+
+  Example:
+    (ordered-multiset-with long-compare [3 1 4 1 5])"
+  ([^Comparator comparator]
+   (OrderedMultiset. (node/leaf) comparator 0 {}))
+  ([^Comparator comparator coll]
+   (into (OrderedMultiset. (node/leaf) comparator 0 {}) coll)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method OrderedMultiset [^OrderedMultiset ms ^java.io.Writer w]
+  (if (order/default-comparator? (.cmp ms))
+    (do (.write w "#ordered/multiset [")
+        (when-let [s (seq ms)]
+          (print-method (first s) w)
+          (doseq [x (rest s)]
+            (.write w " ")
+            (print-method x w)))
+        (.write w "]"))
+    (do (.write w "#<OrderedMultiset [")
+        (when-let [s (seq ms)]
+          (print-method (first s) w)
+          (doseq [x (rest s)]
+            (.write w " ")
+            (print-method x w)))
+        (.write w "]>"))))
diff --git a/src/ordered_collections/types/ordered_set.clj b/src/ordered_collections/types/ordered_set.clj
new file mode 100644
index 0000000..3987920
--- /dev/null
+++ b/src/ordered_collections/types/ordered_set.clj
@@ -0,0 +1,429 @@
+(ns ordered-collections.types.ordered-set
+  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
+            [clojure.set]
+            [ordered-collections.types.shared :refer [with-compare with-tree-env]]
+            [ordered-collections.kernel.node     :as node]
+            [ordered-collections.kernel.order    :as order]
+            [ordered-collections.protocol      :as proto]
+            [ordered-collections.kernel.root]
+            [ordered-collections.kernel.tree     :as tree])
+  (:import  [clojure.lang                RT Murmur3]
+            [ordered_collections.protocol PExtensibleSet PNearest PRanked PSplittable]
+            [ordered_collections.kernel.root     INodeCollection
+                                         IBalancedCollection
+                                         IOrderedCollection]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Set
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields:
+;;   root   — weight-balanced tree of elements (k = v = element)
+;;   cmp    — java.util.Comparator for element ordering
+;;   alloc  — node constructor for primitive variants (e.g. node-create-weight-balanced-long)
+;;   stitch — balanced node constructor; paired with alloc
+;;   _meta  — metadata map
+;;
+;; Lookup dispatch uses identity checks on cmp to select primitive-
+;; specialized search (Long, String) before falling back to generic
+;; Comparator. Set algebra operations (union, intersection, difference)
+;; delegate to tree-level parallel/sequential implementations based on
+;; combined size thresholds. Cross-type fallback (e.g. ordered-set vs
+;; hash-set) goes through clojure.set.
+
+(deftype OrderedSet [root cmp alloc stitch _meta]
+
+  java.io.Serializable  ;; marker interface for serialization
+
+  INodeCollection
+  (getAllocator [_]
+    alloc)
+  (getRoot [_]
+    root)
+
+  IOrderedCollection
+  (getCmp [_]
+    cmp)
+  (isCompatible [_ o]
+    (and (instance? OrderedSet o) (= cmp (.getCmp ^OrderedSet o))))
+  (isSimilar [_ o]
+    (set? o))
+
+  IBalancedCollection
+  (getStitch [_]
+    stitch)
+
+  PExtensibleSet
+  (intersection [this that]
+    (with-tree-env this
+      (cond
+        (identical? this that)    this
+        (.isCompatible this that)
+        (let [that-root (.getRoot ^OrderedSet that)
+              use-parallel? (>= (+ (tree/node-size root) (tree/node-size that-root))
+                                tree/+parallel-intersection-root-threshold+)]
+          (new OrderedSet
+               (if use-parallel?
+                 (tree/node-set-intersection-parallel root that-root)
+                 (tree/node-set-intersection root that-root))
+               cmp alloc stitch _meta))
+        (.isSimilar this that)    (clojure.set/intersection (into #{} this) that)
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+  (union [this that]
+    (with-tree-env this
+      (cond
+        (identical? this that)    this
+        (.isCompatible this that)
+        (let [that-root (.getRoot ^OrderedSet that)
+              use-parallel? (>= (+ (tree/node-size root) (tree/node-size that-root))
+                                tree/+parallel-union-root-threshold+)]
+          (new OrderedSet
+               (if use-parallel?
+                 (tree/node-set-union-parallel root that-root)
+                 (tree/node-set-union root that-root))
+               cmp alloc stitch _meta))
+        (.isSimilar this that)    (clojure.set/union (into #{} this) that)
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+  (difference [this that]
+    (with-tree-env this
+      (cond
+        (identical? this that)    (.empty this)
+        (.isCompatible this that)
+        (let [that-root (.getRoot ^OrderedSet that)
+              use-parallel? (>= (+ (tree/node-size root) (tree/node-size that-root))
+                                tree/+parallel-difference-root-threshold+)]
+          (new OrderedSet
+               (if use-parallel?
+                 (tree/node-set-difference-parallel root that-root)
+                 (tree/node-set-difference root that-root))
+               cmp alloc stitch _meta))
+        (.isSimilar this that)    (clojure.set/difference (into #{} this) that)
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+  (subset? [this that]
+    (with-compare this
+      (cond
+        (identical? this that)    true
+        (.isCompatible this that) (tree/node-subset? (.getRoot ^OrderedSet that) root) ;; Grr. reverse args of tree/subset
+        (.isSimilar this that)    (clojure.set/subset? (into #{} this) that)
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+  (superset? [this that]
+    (with-compare this
+      (cond
+        (identical? this that)    true
+        (.isCompatible this that) (tree/node-subset? root (.getRoot ^OrderedSet that))
+        (.isSimilar this that)    (clojure.set/subset? that (into #{} this))
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+  (disjoint? [this that]
+    (with-compare this
+      (cond
+        (identical? this that)    (zero? (tree/node-size root))
+        (.isCompatible this that) (tree/node-disjoint? root (.getRoot ^OrderedSet that))
+        (.isSimilar this that)    (empty? (clojure.set/intersection (into #{} this) that))
+        true (throw (ex-info "unsupported set operands: " {:this this :that that})))))
+
+  clojure.lang.IMeta
+  (meta [_]
+    _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (new OrderedSet root cmp alloc stitch m))
+
+  clojure.lang.Indexed
+  (nth [_ i]
+    ;; nth doesn't need comparator - only uses subtree sizes
+    (node/-k (tree/node-nth root i)))
+  (nth [_ i not-found]
+    (if (and (>= i 0) (< i (tree/node-size root)))
+      (node/-k (tree/node-nth root i))
+      not-found))
+
+  clojure.lang.Seqable
+  (seq [_]
+    (tree/node-key-seq root (tree/node-size root)))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (tree/node-key-seq-reverse root (tree/node-size root)))
+
+  clojure.lang.ILookup
+  (valAt [this k not-found]
+    ;; Fast paths for specialized comparators
+    (if (cond
+          (identical? cmp order/long-compare)   (tree/node-contains-long? root (long k))
+          (identical? cmp order/string-compare) (tree/node-contains-string? root k)
+          :else (tree/node-contains? root k cmp))
+      k not-found))
+  (valAt [this k]
+    (.valAt this k nil))
+
+  clojure.lang.IFn
+  (invoke [this k not-found]
+    (.valAt this k not-found))
+  (invoke [this k]
+    (.valAt this k))
+  (applyTo [this args]
+    (let [n (RT/boundedLength args 2)]
+      (case n
+        0 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName))))
+        1 (.invoke this (first args))
+        2 (.invoke this (first args) (second args))
+        3 (throw (clojure.lang.ArityException. n (.. this (getClass) (getSimpleName)))))))
+
+  java.lang.Comparable
+  (compareTo [this o]
+    (with-compare this
+      (cond
+        (identical? this o)   0
+        (.isCompatible this o) (tree/node-set-compare root (.getRoot ^OrderedSet o))
+        (.isSimilar    this o) (.compareTo ^Comparable (into (empty o) this) o)
+        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
+
+  java.util.Collection
+  (toArray [this]
+    (with-compare this
+      (object-array (tree/node-vec root :accessor :k)))) ; better constructor not a priority
+  (isEmpty [_]
+    (node/leaf? root))
+  (add [_ _]
+    (throw (UnsupportedOperationException.)))
+  (addAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (removeAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (retainAll [_ _]
+    (throw (UnsupportedOperationException.)))
+
+  java.util.List
+  (indexOf [_ x]
+    (or (tree/node-rank root x cmp) -1))
+  (lastIndexOf [this x]
+    (.indexOf this x))
+
+  java.util.Set
+  (size [_]
+    (tree/node-size root))
+  (iterator [this]
+    (clojure.lang.SeqIterator. (seq this)))
+  (containsAll [this s]
+    (with-compare this
+      (cond
+        (identical? this s)    true
+        (.isCompatible this s) (tree/node-subset? root (.getRoot ^OrderedSet s))
+        (coll? s)              (every? #(.contains this %) s)
+        true     (throw (ex-info "unsupported comparison: " {:this this :s s})))))
+
+  java.util.SortedSet
+  (comparator [_]
+    cmp)
+  (first [this]
+    (with-compare this
+      (first (tree/node-least-kv root))))
+  (last [this]
+    (with-compare this
+      (first (tree/node-greatest-kv root))))
+  (headSet [this x]
+    ;; elements < x (exclusive)
+    (with-compare this
+      (new OrderedSet (tree/node-split-lesser root x) cmp alloc stitch _meta)))
+  (tailSet [this x]
+    ;; elements >= x (inclusive)
+    (with-compare this
+      (let [[_ present gt] (tree/node-split root x)]
+        (if present
+          ;; x exists: add it to the greater-than tree
+          (new OrderedSet (tree/node-add gt (first present) (first present)) cmp alloc stitch _meta)
+          ;; x doesn't exist: just return greater-than tree
+          (new OrderedSet gt cmp alloc stitch _meta)))))
+  (subSet [this from to]
+    ;; elements >= from and < to
+    (with-compare this
+      (let [[_ from-present from-gt] (tree/node-split root from)
+            ;; Start with elements > from
+            from-tree (if from-present
+                        (tree/node-add from-gt (first from-present) (first from-present))
+                        from-gt)
+            ;; Intersect with elements < to
+            to-tree (tree/node-split-lesser root to)
+            result  (tree/node-set-intersection from-tree to-tree)]
+        (new OrderedSet result cmp alloc stitch _meta))))
+
+  java.util.NavigableSet
+  (ceiling [this x]
+    (with-compare this
+      (let [[_ x' r] (tree/node-split root x)]
+        (if (some? x')
+          (first x')
+          (when-not (node/leaf? r)
+            (first (tree/node-least-kv r)))))))
+  (floor [this x]
+    (with-compare this
+      (let [[l x' _] (tree/node-split root x)]
+        (if (some? x')
+          (first x')
+          (when-not (node/leaf? l)
+            (first (tree/node-greatest-kv l)))))))
+
+  clojure.lang.Sorted
+  ;; comparator method is inherited from java.util.SortedSet above
+  (entryKey [_ entry]
+    entry)  ;; for sets, the entry IS the key
+  (seq [_ ascending]
+    (if ascending
+      (tree/node-key-seq root)
+      (tree/node-key-seq-reverse root)))
+  (seqFrom [this k ascending]
+    (with-compare this
+      (let [[lt present gt] (tree/node-split root k)]
+        (if ascending
+          ;; ascending: elements >= k (present + gt)
+          (if present
+            (cons (first present) (tree/node-key-seq gt))
+            (tree/node-key-seq gt))
+          ;; descending: elements <= k (present + lt in reverse)
+          (if present
+            (cons (first present) (tree/node-key-seq-reverse lt))
+            (tree/node-key-seq-reverse lt))))))
+
+  clojure.lang.IPersistentSet
+  (equiv [this o]
+    (with-compare this
+      (cond
+        (identical? this o) true
+        (not (instance? clojure.lang.Counted o)) false
+        (not= (tree/node-size root) (.count ^clojure.lang.Counted o)) false
+        (.isCompatible this o) (zero? (tree/node-set-compare root (.getRoot ^OrderedSet o)))
+        (.isSimilar    this o) (every? #(contains? o %) this)
+        :else false)))
+  (count [_]
+    (tree/node-size root))
+  (empty [_]
+    (new OrderedSet (node/leaf) cmp alloc stitch _meta))
+  (contains [this k]
+    ;; Fast paths for specialized comparators
+    (cond
+      (identical? cmp order/long-compare)   (tree/node-contains-long? root (long k))
+      (identical? cmp order/string-compare) (tree/node-contains-string? root k)
+      :else (tree/node-contains? root k cmp)))
+  (disjoin [this k]
+    (new OrderedSet (tree/node-remove root k cmp tree/node-create-weight-balanced) cmp alloc stitch _meta))
+  (cons [this k]
+    (new OrderedSet (tree/node-add root k k cmp tree/node-create-weight-balanced) cmp alloc stitch _meta))
+
+  Object
+  (toString [this]
+    (pr-str this))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    ;; Must match APersistentSet: sum of hasheq(element), then mixCollHash
+    (Murmur3/mixCollHash
+      (unchecked-int
+        (tree/node-reduce
+          (fn [^long acc n]
+            (unchecked-add acc (long (clojure.lang.Util/hasheq (node/-k n)))))
+          (long 0)
+          root))
+      (tree/node-size root)))
+
+  clojure.lang.IReduceInit
+  (reduce [this f init]
+    (tree/node-reduce-keys f init root))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (tree/node-reduce-keys f root))
+
+  clojure.core.protocols/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^clojure.lang.IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^clojure.lang.IReduceInit this f init))
+
+  clojure.core.reducers.CollFold
+  (coll-fold [this n combinef reducef]
+    (with-compare this
+      (tree/node-fold n root combinef
+        (fn [acc node] (reducef acc (node/-k node))))))
+
+  PNearest
+  (nearest [this test k]
+    (with-compare this
+      (case test
+        :< (when-let [n (tree/node-predecessor root k)]
+             (node/-k n))
+        :<= (when-let [n (tree/node-find-nearest root k :<)]
+              (node/-k n))
+        :> (when-let [n (tree/node-successor root k)]
+             (node/-k n))
+        :>= (when-let [n (tree/node-find-nearest root k :>)]
+              (node/-k n))
+        (throw (ex-info "nearest test must be :<, :<=, :>, or :>=" {:test test})))))
+  (subrange [this test k]
+    (with-compare this
+      (let [result-root (case test
+                          (:< :<=) (tree/node-split-lesser root k)
+                          (:> :>=) (tree/node-split-greater root k)
+                          (throw (ex-info "subrange test must be :<, :<=, :>, or :>=" {:test test})))
+            ;; For <= and >=, include the key itself if present
+            result-root (case test
+                          (:<= :>=) (if-let [n (tree/node-find root k)]
+                                      (tree/node-add result-root (node/-k n) (node/-v n))
+                                      result-root)
+                          result-root)]
+        (new OrderedSet result-root cmp alloc stitch _meta))))
+
+  PRanked
+  (rank-of [_ x]
+    (or (tree/node-rank root x cmp) -1))
+  (slice [_ start end]
+    (let [n (tree/node-size root)
+          start (max 0 (long start))
+          end (min n (long end))]
+      (when (< start end)
+        (binding [order/*compare* cmp]
+          (map node/-k (tree/node-subseq root start (dec end)))))))
+  (median [_]
+    (let [n (tree/node-size root)]
+      (when (pos? n)
+        (binding [order/*compare* cmp]
+          (node/-k (tree/node-nth root (quot (dec n) 2)))))))
+  (percentile [_ pct]
+    (let [n (tree/node-size root)]
+      (when (pos? n)
+        (let [idx (min (dec n) (long (* (/ (double pct) 100.0) n)))]
+          (binding [order/*compare* cmp]
+            (node/-k (tree/node-nth root idx)))))))
+
+  PSplittable
+  (split-key [this k]
+    (with-compare this
+      (let [[l present r] (tree/node-split root k)
+            entry (when present (first present))]
+        [(new OrderedSet l cmp alloc stitch _meta)
+         entry
+         (new OrderedSet r cmp alloc stitch _meta)])))
+  (split-at [this i]
+    (with-compare this
+      (let [n (tree/node-size root)]
+        (cond
+          (<= i 0) [(.empty this) this]
+          (>= i n) [this (.empty this)]
+          :else
+          (let [left-root  (tree/node-split-lesser root (node/-k (tree/node-nth root i)))
+                right-root (tree/node-split-nth root i)]
+            [(new OrderedSet left-root cmp alloc stitch _meta)
+             (new OrderedSet right-root cmp alloc stitch _meta)]))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method OrderedSet [^OrderedSet s ^java.io.Writer w]
+  (if (order/default-comparator? (.getCmp ^IOrderedCollection s))
+    (do (.write w "#ordered/set ")
+        (print-method (vec s) w))
+    (do (.write w "#<OrderedSet ")
+        (print-method (vec s) w)
+        (.write w ">"))))
diff --git a/src/ordered_collections/types/priority_queue.clj b/src/ordered_collections/types/priority_queue.clj
new file mode 100644
index 0000000..8c20444
--- /dev/null
+++ b/src/ordered_collections/types/priority_queue.clj
@@ -0,0 +1,549 @@
+(ns ordered-collections.types.priority-queue
+  "Persistent priority queue backed by a weight-balanced tree.
+
+  Internally an ordered map from priorities to vectors of values. Duplicate
+  priorities are stable in insertion order. The public API exposes
+  [priority value] pairs; the vector grouping is hidden."
+  (:require [clojure.core.reducers :as r :refer [coll-fold]]
+            [ordered-collections.types.shared :refer [with-compare]]
+            [ordered-collections.kernel.node     :as node]
+            [ordered-collections.kernel.order    :as order]
+            [ordered-collections.protocol      :as proto]
+            [ordered-collections.kernel.root]
+            [ordered-collections.kernel.tree     :as tree])
+  (:import  [clojure.lang RT Murmur3]
+            [java.util Comparator]
+            [ordered_collections.kernel.root INodeCollection
+                                           IBalancedCollection
+                                           IOrderedCollection]))
+
+
+(declare ->PriorityQueue)
+
+(def ^:private not-found-sentinel ::not-found)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Expanding Seq Views
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; The tree stores [priority -> [v1 v2 ...]] entries. These seq types expand
+;; each node into [priority v1] [priority v2] ... pairs, walking the tree
+;; via enumerator and the value vector via an index.
+
+(defn- seq-equiv
+  "Element-wise sequential equivalence (non-recursive through equiv)."
+  [s1 o]
+  (if-not (or (instance? clojure.lang.Sequential o) (instance? java.util.List o))
+    false
+    (loop [s1 (seq s1) s2 (seq o)]
+      (cond
+        (nil? s1) (nil? s2)
+        (nil? s2) false
+        (not (clojure.lang.Util/equiv (first s1) (first s2))) false
+        :else (recur (next s1) (next s2))))))
+
+
+(deftype PriorityQueueSeq [enum ^long vi cnt _meta]
+  clojure.lang.ISeq
+  (first [_]
+    (let [node (tree/node-enum-first enum)]
+      [(node/-k node) (nth (node/-v node) vi)]))
+  (next [_]
+    (let [node (tree/node-enum-first enum)
+          vals (node/-v node)]
+      (if (< (inc vi) (count vals))
+        (PriorityQueueSeq. enum (inc vi) (when cnt (unchecked-dec-int cnt)) nil)
+        (when-let [e (tree/node-enum-rest enum)]
+          (PriorityQueueSeq. e 0 (when cnt (unchecked-dec-int cnt)) nil)))))
+  (more [this]
+    (or (.next this) ()))
+  (cons [this o]
+    (clojure.lang.Cons. o this))
+
+  clojure.lang.Seqable
+  (seq [this] this)
+
+  clojure.lang.Sequential
+
+  java.lang.Iterable
+  (iterator [this]
+    (clojure.lang.SeqIterator. this))
+
+  clojure.lang.Counted
+  (count [_]
+    (if cnt cnt
+      (loop [e enum, vi vi, n 0]
+        (if (nil? e)
+          n
+          (let [node (tree/node-enum-first e)
+                vlen (count (node/-v node))
+                remaining (- vlen vi)]
+            (recur (tree/node-enum-rest e) 0 (+ n remaining)))))))
+
+  clojure.lang.IReduceInit
+  (reduce [_ f init]
+    (loop [e enum, vi (long vi), acc init]
+      (if (nil? e)
+        acc
+        (let [node (tree/node-enum-first e)
+              p    (node/-k node)
+              vals (node/-v node)
+              vlen (count vals)]
+          (let [acc (loop [i vi, acc acc]
+                      (if (>= i vlen)
+                        acc
+                        (let [ret (f acc [p (nth vals i)])]
+                          (if (reduced? ret)
+                            ret
+                            (recur (inc i) ret)))))]
+            (if (reduced? acc)
+              @acc
+              (recur (tree/node-enum-rest e) 0 acc)))))))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (if enum
+      (let [node (tree/node-enum-first enum)
+            p    (node/-k node)
+            vals (node/-v node)
+            acc  [p (nth vals vi)]]
+        (let [remaining-start (inc vi)
+              vlen (count vals)]
+          ;; First reduce within the current node's remaining values
+          (let [[acc e] (loop [i remaining-start, acc acc]
+                          (if (>= i vlen)
+                            [acc (tree/node-enum-rest enum)]
+                            (let [ret (f acc [p (nth vals i)])]
+                              (if (reduced? ret)
+                                [ret nil]
+                                (recur (inc i) ret)))))]
+            (if (or (reduced? acc) (nil? e))
+              (if (reduced? acc) @acc acc)
+              ;; Continue with remaining nodes
+              (.reduce ^clojure.lang.IReduceInit
+                (PriorityQueueSeq. e 0 nil nil) f acc)))))
+      (f)))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/hashOrdered this))
+
+  clojure.lang.IPersistentCollection
+  (empty [_] ())
+  (equiv [this o]
+    (seq-equiv this o))
+
+  Object
+  (hashCode [this]
+    (clojure.lang.Util/hash this))
+  (equals [this o]
+    (clojure.lang.Util/equals this o))
+
+  clojure.lang.IMeta
+  (meta [_] _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (PriorityQueueSeq. enum vi cnt m)))
+
+(deftype PriorityQueueSeqReverse [enum ^long vi cnt _meta]
+  clojure.lang.ISeq
+  (first [_]
+    (let [node (tree/node-enum-first enum)]
+      [(node/-k node) (nth (node/-v node) vi)]))
+  (next [_]
+    (if (pos? vi)
+      (PriorityQueueSeqReverse. enum (dec vi) (when cnt (unchecked-dec-int cnt)) nil)
+      (when-let [e (tree/node-enum-prior enum)]
+        (let [vals (node/-v (tree/node-enum-first e))]
+          (PriorityQueueSeqReverse. e (dec (count vals))
+            (when cnt (unchecked-dec-int cnt)) nil)))))
+  (more [this]
+    (or (.next this) ()))
+  (cons [this o]
+    (clojure.lang.Cons. o this))
+
+  clojure.lang.Seqable
+  (seq [this] this)
+
+  clojure.lang.Sequential
+
+  java.lang.Iterable
+  (iterator [this]
+    (clojure.lang.SeqIterator. this))
+
+  clojure.lang.Counted
+  (count [_]
+    (if cnt cnt
+      (loop [e enum, vi vi, n 0]
+        (if (nil? e)
+          n
+          (let [remaining (inc vi)]
+            (recur (tree/node-enum-prior e)
+                   (if-let [e2 (tree/node-enum-prior e)]
+                     (dec (count (node/-v (tree/node-enum-first e2))))
+                     0)
+                   (+ n remaining)))))))
+
+  clojure.lang.IReduceInit
+  (reduce [_ f init]
+    (loop [e enum, vi (long vi), acc init]
+      (if (nil? e)
+        acc
+        (let [node (tree/node-enum-first e)
+              p    (node/-k node)
+              vals (node/-v node)]
+          (let [acc (loop [i vi, acc acc]
+                      (if (neg? i)
+                        acc
+                        (let [ret (f acc [p (nth vals i)])]
+                          (if (reduced? ret)
+                            ret
+                            (recur (dec i) ret)))))]
+            (if (reduced? acc)
+              @acc
+              (if-let [e2 (tree/node-enum-prior e)]
+                (recur e2 (dec (count (node/-v (tree/node-enum-first e2)))) acc)
+                acc)))))))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (if enum
+      (let [node (tree/node-enum-first enum)
+            acc  [(node/-k node) (nth (node/-v node) vi)]]
+        (if (pos? vi)
+          (.reduce ^clojure.lang.IReduceInit
+            (PriorityQueueSeqReverse. enum (dec vi) nil nil) f acc)
+          (if-let [e2 (tree/node-enum-prior enum)]
+            (.reduce ^clojure.lang.IReduceInit
+              (PriorityQueueSeqReverse. e2 (dec (count (node/-v (tree/node-enum-first e2)))) nil nil)
+              f acc)
+            acc)))
+      (f)))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/hashOrdered this))
+
+  clojure.lang.IPersistentCollection
+  (empty [_] ())
+  (equiv [this o]
+    (seq-equiv this o))
+
+  Object
+  (hashCode [this]
+    (clojure.lang.Util/hash this))
+  (equals [this o]
+    (clojure.lang.Util/equals this o))
+
+  clojure.lang.IMeta
+  (meta [_] _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (PriorityQueueSeqReverse. enum vi cnt m)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Priority Queue
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields:
+;;   root — weight-balanced tree mapping priority -> [values...] vector
+;;   cmp  — java.util.Comparator for priority ordering (user's comparator directly)
+;;   cnt  — total element count (sum of all value vector lengths)
+;;   _meta — metadata map
+;;
+;; Duplicate priorities append to the value vector via conj, preserving
+;; insertion order without synthetic seqnum. The public API expands tree
+;; entries into [priority value] pairs; the vector grouping is hidden.
+
+(deftype PriorityQueue [root ^Comparator cmp ^long cnt _meta]
+
+  java.io.Serializable
+
+  INodeCollection
+  (getAllocator [_] nil)
+  (getRoot [_] root)
+
+  IOrderedCollection
+  (getCmp [_] cmp)
+  (isCompatible [_ o]
+    (and (instance? PriorityQueue o)
+         (= cmp (.getCmp ^IOrderedCollection o))))
+  (isSimilar [_ _] false)
+
+  IBalancedCollection
+  (getStitch [_] nil)
+
+  clojure.lang.IMeta
+  (meta [_] _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m]
+    (PriorityQueue. root cmp cnt m))
+
+  clojure.lang.IPersistentStack
+  (peek [_]
+    (when-not (node/leaf? root)
+      (let [n (tree/node-least root)]
+        [(node/-k n) (first (node/-v n))])))
+  (pop [_]
+    (if (node/leaf? root)
+      (throw (IllegalStateException. "Can't pop empty queue"))
+      (let [n    (tree/node-least root)
+            p    (node/-k n)
+            vals (node/-v n)
+            new-root (if (> (count vals) 1)
+                       (tree/node-add root p (subvec vals 1) cmp tree/node-create-weight-balanced)
+                       (tree/node-remove root p cmp tree/node-create-weight-balanced))]
+        (PriorityQueue. new-root cmp (dec cnt) _meta))))
+  (cons [_ x]
+    (let [[p v] x
+          existing (tree/node-find-val root p not-found-sentinel cmp)
+          new-vals (if (identical? existing not-found-sentinel) [v] (conj existing v))
+          new-root (tree/node-add root p new-vals cmp tree/node-create-weight-balanced)]
+      (PriorityQueue. new-root cmp (inc cnt) _meta)))
+
+  clojure.lang.Seqable
+  (seq [_]
+    (when-let [e (tree/node-enumerator root nil)]
+      (PriorityQueueSeq. e 0 cnt nil)))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (when-let [e (tree/node-enumerator-reverse root)]
+      (let [vals (node/-v (tree/node-enum-first e))]
+        (PriorityQueueSeqReverse. e (dec (count vals)) cnt nil))))
+
+  clojure.lang.Counted
+  (count [_] cnt)
+
+  clojure.lang.IPersistentCollection
+  (empty [_]
+    (PriorityQueue. (node/leaf) cmp 0 _meta))
+  (equiv [this o]
+    (cond
+      (identical? this o) true
+      (not (instance? clojure.lang.Counted o)) false
+      (not= cnt (.count ^clojure.lang.Counted o)) false
+      :else (= (seq this) (seq o))))
+
+  clojure.lang.Indexed
+  (nth [this i]
+    (loop [s (seq this) j (long i)]
+      (cond
+        (nil? s) (throw (IndexOutOfBoundsException. (str "Index: " i)))
+        (zero? j) (first s)
+        :else (recur (next s) (dec j)))))
+  (nth [this i not-found]
+    (if (and (>= i 0) (< i cnt))
+      (.nth this i)
+      not-found))
+
+  clojure.lang.IReduceInit
+  (reduce [_ f init]
+    (tree/node-reduce
+      (fn [acc n]
+        (let [p    (node/-k n)
+              vals (node/-v n)]
+          (reduce (fn [a v]
+                    (let [ret (f a [p v])]
+                      (if (reduced? ret) (reduced ret) ret)))
+                  acc vals)))
+      init root))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (if (node/leaf? root)
+      (f)
+      (let [s (seq this)]
+        (if s
+          (reduce f (first s) (rest s))
+          (f)))))
+
+  clojure.core.protocols/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^clojure.lang.IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^clojure.lang.IReduceInit this f init))
+
+  clojure.core.reducers.CollFold
+  (coll-fold [this chunk-size combinef reducef]
+    (with-compare this
+      (tree/node-fold chunk-size root combinef
+        (fn [acc node]
+          (let [p    (node/-k node)
+                vals (node/-v node)]
+            (reduce (fn [a v] (reducef a [p v])) acc vals))))))
+
+  java.lang.Iterable
+  (iterator [this]
+    (clojure.lang.SeqIterator. (seq this)))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/hashOrdered this))
+
+  Object
+  (toString [this]
+    (pr-str this))
+  (hashCode [this]
+    (.hasheq this))
+  (equals [this o]
+    (and (instance? PriorityQueue o)
+         (.equiv this o)))
+
+  proto/PPriorityQueue
+  (push [_ priority value]
+    (let [existing (tree/node-find-val root priority not-found-sentinel cmp)
+          new-vals (if (identical? existing not-found-sentinel) [value] (conj existing value))
+          new-root (tree/node-add root priority new-vals cmp tree/node-create-weight-balanced)]
+      (PriorityQueue. new-root cmp (inc cnt) _meta)))
+  (push-all [this pairs]
+    (reduce (fn [q [p v]] (proto/push q p v)) this pairs))
+  (peek-min [_]
+    (when-not (node/leaf? root)
+      (let [n (tree/node-least root)]
+        [(node/-k n) (first (node/-v n))])))
+  (peek-min-val [_]
+    (when-not (node/leaf? root)
+      (first (node/-v (tree/node-least root)))))
+  (pop-min [this]
+    (if (node/leaf? root)
+      this
+      (let [n    (tree/node-least root)
+            p    (node/-k n)
+            vals (node/-v n)
+            new-root (if (> (count vals) 1)
+                       (tree/node-add root p (subvec vals 1) cmp tree/node-create-weight-balanced)
+                       (tree/node-remove root p cmp tree/node-create-weight-balanced))]
+        (PriorityQueue. new-root cmp (dec cnt) _meta))))
+  (peek-max [_]
+    (when-not (node/leaf? root)
+      (let [n (tree/node-greatest root)]
+        [(node/-k n) (peek (node/-v n))])))
+  (peek-max-val [_]
+    (when-not (node/leaf? root)
+      (peek (node/-v (tree/node-greatest root)))))
+  (pop-max [this]
+    (if (node/leaf? root)
+      this
+      (let [n    (tree/node-greatest root)
+            p    (node/-k n)
+            vals (node/-v n)
+            new-root (if (> (count vals) 1)
+                       (tree/node-add root p (pop vals) cmp tree/node-create-weight-balanced)
+                       (tree/node-remove root p cmp tree/node-create-weight-balanced))]
+        (PriorityQueue. new-root cmp (dec cnt) _meta)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Extended API (delegate to protocol)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn push
+  "Add an element to the priority queue with the given priority.
+  Returns a new queue. O(log n).
+
+  Example:
+    (push pq 1 :urgent)"
+  [pq priority value]
+  (proto/push pq priority value))
+
+(defn push-all
+  "Add multiple [priority value] pairs to the queue. O(k log n).
+
+  Example:
+    (push-all pq [[1 :urgent] [5 :low] [2 :medium]])"
+  [pq pairs]
+  (proto/push-all pq pairs))
+
+(defn peek-min
+  "Return the first [priority value] in queue order, or nil if empty. O(log n)."
+  [pq]
+  (proto/peek-min pq))
+
+(defn peek-min-val
+  "Return just the value of the first element in queue order, or nil if empty. O(log n)."
+  [pq]
+  (proto/peek-min-val pq))
+
+(defn pop-min
+  "Remove the first element in queue order. O(log n).
+  Returns the queue unchanged if empty."
+  [pq]
+  (proto/pop-min pq))
+
+(defn peek-max
+  "Return the last [priority value] in queue order, or nil if empty. O(log n)."
+  [pq]
+  (proto/peek-max pq))
+
+(defn peek-max-val
+  "Return just the value of the last element in queue order, or nil if empty. O(log n)."
+  [pq]
+  (proto/peek-max-val pq))
+
+(defn pop-max
+  "Remove the last element in queue order. O(log n).
+  Returns the queue unchanged if empty."
+  [pq]
+  (proto/pop-max pq))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Constructors
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn priority-queue
+  "Create a priority queue from [priority value] pairs.
+  Priorities are ordered by clojure.core/compare (natural ordering).
+  For custom ordering, use priority-queue-by or priority-queue-with.
+
+  Examples:
+    (priority-queue)
+    (priority-queue [[1 :a] [3 :c] [2 :b]])
+    (priority-queue [[\"beta\" :b] [\"alpha\" :a]])"
+  ([] (PriorityQueue. (node/leaf) order/normal-compare 0 {}))
+  ([pairs]
+   (push-all (priority-queue) pairs)))
+
+(defn priority-queue-by
+  "Create a priority queue with custom ordering via a predicate.
+
+  Examples:
+    (priority-queue-by > [[1 :a] [3 :c] [2 :b]])   ; max-heap
+    (priority-queue-by > [])"
+  [pred pairs]
+  (let [cmp (order/compare-by pred)]
+    (push-all (PriorityQueue. (node/leaf) cmp 0 {}) pairs)))
+
+(defn priority-queue-with
+  "Create a priority queue with a custom java.util.Comparator for priorities.
+
+  Examples:
+    (priority-queue-with long-compare [[1 :a] [2 :b]])
+    (priority-queue-with string-compare)"
+  ([^Comparator comparator]
+   (PriorityQueue. (node/leaf) comparator 0 {}))
+  ([^Comparator comparator pairs]
+   (push-all (PriorityQueue. (node/leaf) comparator 0 {}) pairs)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method PriorityQueue [^PriorityQueue pq ^java.io.Writer w]
+  (if (order/default-comparator? (.cmp pq))
+    (do (.write w "#ordered/priority-queue [")
+        (when-let [s (seq pq)]
+          (print-method (first s) w)
+          (doseq [x (rest s)]
+            (.write w " ")
+            (print-method x w)))
+        (.write w "]"))
+    (do (.write w "#<PriorityQueue [")
+        (when-let [s (seq pq)]
+          (print-method (first s) w)
+          (doseq [x (rest s)]
+            (.write w " ")
+            (print-method x w)))
+        (.write w "]>"))))
diff --git a/src/ordered_collections/types/range_map.clj b/src/ordered_collections/types/range_map.clj
new file mode 100644
index 0000000..e25dde9
--- /dev/null
+++ b/src/ordered_collections/types/range_map.clj
@@ -0,0 +1,460 @@
+(ns ordered-collections.types.range-map
+  "A map from non-overlapping ranges to values.
+
+   Unlike IntervalMap (which allows overlapping intervals), RangeMap enforces
+   that ranges never overlap. When inserting a new range, any overlapping
+   portions of existing ranges are removed.
+
+   SEMANTICS (compatible with Guava's TreeRangeMap):
+   - `assoc` (put): inserts range, carving out overlaps. Does NOT coalesce.
+   - `assoc-coalescing` (putCoalescing): inserts and coalesces adjacent
+     same-value ranges.
+
+   RANGE SEMANTICS:
+   Ranges are half-open intervals [lo, hi) by default:
+   - [0 10] contains 0, 1, 2, ..., 9 but NOT 10
+
+   PERFORMANCE:
+   - Point lookup: O(log n)
+   - Insert/assoc: O(k log n) where k = number of overlapping ranges
+   - Coalescing insert: O(k log n)
+   - Remove: O(k log n)
+   For typical use (k=1-3 overlaps), effectively O(log n)."
+  (:require [clojure.core.reducers       :as r :refer [coll-fold]]
+            [ordered-collections.kernel.node     :as node]
+            [ordered-collections.kernel.order    :as order]
+            [ordered-collections.protocol      :as proto]
+            [ordered-collections.kernel.tree     :as tree])
+  (:import  [clojure.lang MapEntry Murmur3]
+            [ordered_collections.protocol PRangeMap PSpan]
+            [ordered_collections.kernel.tree EnumFrame]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Range Utilities
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- range-lo [[lo _]] lo)
+(defn- range-hi [[_ hi]] hi)
+
+(deftype ^:private RangeComparator []
+  java.io.Serializable
+  java.util.Comparator
+  (compare [_ a b]
+    (clojure.core/compare (range-lo a) (range-lo b)))
+  Object
+  (equals [_ o] (instance? RangeComparator o))
+  (hashCode [_] 99))
+
+(def ^:private range-compare (->RangeComparator))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Efficient Overlap Detection - O(log n + k)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; For a query range [lo, hi), a stored range [rl, rh) overlaps iff:
+;;   rl < hi AND rh > lo
+;;
+;; Since ranges are sorted by lower bound (rl), we can efficiently find
+;; all overlapping ranges:
+;; 1. Find floor(lo) - the range with largest start <= lo
+;;    This might overlap if its end > lo
+;; 2. Iterate forward from there while start < hi
+;;
+;; This is O(log n) to find the starting point + O(k) to iterate over
+;; k overlapping ranges.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- find-floor-range
+  "Find the range with the largest lower bound <= lo.
+   Returns [range value] or nil."
+  [root lo]
+  (loop [n root
+         best nil]
+    (if (node/leaf? n)
+      best
+      (let [[rl _] (node/-k n)]
+        (cond
+          (= rl lo)  [(node/-k n) (node/-v n)]
+          (< rl lo)  (recur (node/-r n) [(node/-k n) (node/-v n)])
+          :else      (recur (node/-l n) best))))))
+
+(defn- find-ceiling-range
+  "Find the range with the smallest lower bound >= lo.
+   Returns [range value] or nil."
+  [root lo]
+  (loop [n root
+         best nil]
+    (if (node/leaf? n)
+      best
+      (let [[rl _] (node/-k n)]
+        (cond
+          (= rl lo)  [(node/-k n) (node/-v n)]
+          (> rl lo)  (recur (node/-l n) [(node/-k n) (node/-v n)])
+          :else      (recur (node/-r n) best))))))
+
+(defn- collect-overlapping
+  "Collect all ranges that overlap [lo, hi). Returns vector of [range value].
+   Time: O(log n + k) where k = number of overlapping ranges."
+  [root lo hi]
+  (if (node/leaf? root)
+    []
+    (let [floor (find-floor-range root lo)
+          start (if (and floor (> (range-hi (first floor)) lo))
+                  floor
+                  (find-ceiling-range root lo))]
+      (if-not start
+        []
+        (let [start-lo (range-lo (first start))
+              ;; Navigate to start position and build enumerator
+              enum (loop [n root, frames nil]
+                     (if (node/leaf? n)
+                       frames
+                       (let [rl (range-lo (node/-k n))]
+                         (cond
+                           (< start-lo rl) (recur (node/-l n) (EnumFrame. n (node/-r n) frames))
+                           (> start-lo rl) (recur (node/-r n) frames)
+                           :else           (EnumFrame. n (node/-r n) frames)))))
+              acc (transient [])]
+          ;; Walk forward collecting overlapping ranges
+          (loop [e enum]
+            (when e
+              (let [node (tree/node-enum-first e)
+                    [rl rh] (node/-k node)]
+                (when (< rl hi)
+                  (when (> rh lo)
+                    (conj! acc [(node/-k node) (node/-v node)]))
+                  (recur (tree/node-enum-rest e))))))
+          (persistent! acc))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Adjacent Range Detection for Coalescing
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- find-adjacent-left
+  "Find range that ends exactly at `lo`, if any. O(log n)."
+  [root lo]
+  (loop [n root
+         candidate nil]
+    (if (node/leaf? n)
+      candidate
+      (let [[rl rh] (node/-k n)]
+        (cond
+          (= rh lo) (recur (node/-r n) [(node/-k n) (node/-v n)])
+          (< lo rh) (recur (node/-l n) candidate)
+          :else     (recur (node/-r n) candidate))))))
+
+(defn- find-adjacent-right
+  "Find range that starts exactly at `hi`, if any. O(log n)."
+  [root hi]
+  (loop [n root]
+    (if (node/leaf? n)
+      nil
+      (let [[rl _] (node/-k n)]
+        (cond
+          (= rl hi) [(node/-k n) (node/-v n)]
+          (< hi rl) (recur (node/-l n))
+          :else     (recur (node/-r n)))))))
+
+(declare range-map-assoc range-map-remove ->RangeMap)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; RangeMap Type
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields:
+;;   root  — weight-balanced tree keyed by [lo hi] ranges
+;;   cmp   — fixed range-compare (by lower bound); not user-configurable
+;;   _meta — metadata map
+;;
+;; No alloc/stitch fields — uses default SimpleNode throughout.
+;; Comparator is fixed (ranges always sort by lower bound), so no
+;; IOrderedCollection. Manages *compare* binding directly.
+;; Assoc implements Guava TreeRangeMap carve-out semantics:
+;; collect overlapping ranges, remove them, re-add trimmed portions.
+
+(deftype RangeMap [root cmp _meta]
+
+  java.io.Serializable
+
+  clojure.lang.IMeta
+  (meta [_] _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m] (RangeMap. root cmp m))
+
+  clojure.lang.Counted
+  (count [_] (tree/node-size root))
+
+  clojure.lang.Seqable
+  (seq [_]
+    (tree/node-entry-seq root (tree/node-size root)))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (tree/node-entry-seq-reverse root (tree/node-size root)))
+
+  clojure.lang.IReduceInit
+  (reduce [_ f init]
+    (tree/node-reduce-entries f init root))
+
+  clojure.lang.IReduce
+  (reduce [_ f]
+    (tree/node-reduce-entries f root))
+
+  clojure.core.protocols/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^clojure.lang.IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^clojure.lang.IReduceInit this f init))
+
+  clojure.lang.IKVReduce
+  (kvreduce [_ f init]
+    (tree/node-reduce-kv f init root))
+
+  clojure.core.reducers.CollFold
+  (coll-fold [_ chunk-size combinef reducef]
+    (binding [order/*compare* cmp]
+      (tree/node-fold chunk-size root combinef
+        (fn [acc node] (reducef acc (node/-kv node))))))
+
+  clojure.lang.ILookup
+  (valAt [this x] (.valAt this x nil))
+  (valAt [_ x not-found]
+    (binding [order/*compare* cmp]
+      (loop [n root]
+        (if (node/leaf? n)
+          not-found
+          (let [rng (node/-k n)
+                lo  (range-lo rng)
+                hi  (range-hi rng)]
+            (cond
+              (< x lo)  (recur (node/-l n))
+              (>= x hi) (recur (node/-r n))
+              :else     (node/-v n)))))))
+
+  clojure.lang.IFn
+  (invoke [this x] (.valAt this x nil))
+  (invoke [this x not-found] (.valAt this x not-found))
+
+  clojure.lang.Associative
+  (containsKey [this x]
+    (not= ::not-found (.valAt this x ::not-found)))
+  (entryAt [this x]
+    (let [v (.valAt this x ::not-found)]
+      (when-not (identical? v ::not-found)
+        (MapEntry. x v))))
+  (assoc [this rng v]
+    (range-map-assoc this rng v false))
+
+  clojure.lang.IPersistentCollection
+  (empty [_]
+    (RangeMap. (node/leaf) cmp _meta))
+  (cons [this x]
+    (if (instance? MapEntry x)
+      (.assoc this (key x) (val x))
+      (.assoc this (first x) (second x))))
+  (equiv [this o]
+    (cond
+      (identical? this o) true
+      (not (instance? RangeMap o)) false
+      (not= (tree/node-size root) (tree/node-size (.root ^RangeMap o))) false
+      :else (= (seq this) (seq o))))
+
+  Object
+  (toString [this]
+    (pr-str this))
+  (hashCode [this]
+    (.hasheq this))
+  (equals [this o]
+    (.equiv this o))
+
+  clojure.lang.IHashEq
+  (hasheq [_]
+    (Murmur3/mixCollHash
+      (unchecked-int
+        (tree/node-reduce
+          (fn [^long acc n]
+            (unchecked-add acc (long (clojure.lang.Util/hasheq
+                                       (MapEntry. (node/-k n) (node/-v n))))))
+          (long 0)
+          root))
+      (tree/node-size root)))
+
+  PRangeMap
+  (ranges [this]
+    (seq this))
+  (get-entry [_ point]
+    (binding [order/*compare* cmp]
+      (loop [n root]
+        (if (node/leaf? n)
+          nil
+          (let [rng (node/-k n)
+                lo  (range-lo rng)
+                hi  (range-hi rng)]
+            (cond
+              (< point lo)  (recur (node/-l n))
+              (>= point hi) (recur (node/-r n))
+              :else         [rng (node/-v n)]))))))
+  (assoc-coalescing [this rng val]
+    (range-map-assoc this rng val true))
+  (range-remove [this rng]
+    (range-map-remove this rng))
+  (gaps [this]
+    (when-let [s (seq this)]
+      (let [pairs (partition 2 1 s)]
+        (for [[[[_ h1] _] [[l2 _] _]] pairs
+              :when (< h1 l2)]
+          [h1 l2]))))
+
+  PSpan
+  (span [_]
+    (when-not (node/leaf? root)
+      (binding [order/*compare* cmp]
+        [(range-lo (node/-k (tree/node-least root)))
+         (range-hi (node/-k (tree/node-greatest root)))]))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Carve-Out and Insertion
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- carve-out
+  "Remove overlapping ranges and re-add trimmed non-overlapping portions."
+  [root lo hi overlapping]
+  (let [root (reduce (fn [n [r _]] (tree/node-remove n r))
+                     root overlapping)]
+    (reduce (fn [n [[rl rh] rv]]
+              (cond-> n
+                (< rl lo) (tree/node-add [rl lo] rv)
+                (> rh hi) (tree/node-add [hi rh] rv)))
+            root overlapping)))
+
+(defn- coalesce-and-insert
+  "Insert [lo hi) -> v, merging with adjacent same-value ranges."
+  [root lo hi v]
+  (let [left-adj  (find-adjacent-left root lo)
+        right-adj (find-adjacent-right root hi)
+        [lo root] (if (and left-adj (= (second left-adj) v))
+                    [(range-lo (first left-adj))
+                     (tree/node-remove root (first left-adj))]
+                    [lo root])
+        [hi root] (if (and right-adj (= (second right-adj) v))
+                    [(range-hi (first right-adj))
+                     (tree/node-remove root (first right-adj))]
+                    [hi root])]
+    (tree/node-add root [lo hi] v)))
+
+(defn- range-map-assoc
+  "Insert range [lo hi) -> val, removing any overlapping portions.
+   If coalesce? is true, adjacent ranges with the same value are merged."
+  [^RangeMap rm rng v coalesce?]
+  (let [[lo hi] rng
+        cmp (.-cmp rm)]
+    (when (>= lo hi)
+      (throw (ex-info "Invalid range: lo must be < hi" {:range rng})))
+    (binding [order/*compare* cmp]
+      (let [overlapping (collect-overlapping (.-root rm) lo hi)
+            root (carve-out (.-root rm) lo hi overlapping)
+            root (if coalesce?
+                   (coalesce-and-insert root lo hi v)
+                   (tree/node-add root [lo hi] v))]
+        (RangeMap. root cmp (.-_meta rm))))))
+
+(defn- range-map-remove
+  "Remove all mappings in [lo hi). Overlapping ranges are trimmed."
+  [^RangeMap rm rng]
+  (let [[lo hi] rng
+        cmp (.-cmp rm)]
+    (when (>= lo hi)
+      (throw (ex-info "Invalid range: lo must be < hi" {:range rng})))
+    (binding [order/*compare* cmp]
+      (let [overlapping (collect-overlapping (.-root rm) lo hi)
+            root (carve-out (.-root rm) lo hi overlapping)]
+        (RangeMap. root cmp (.-_meta rm))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Constructor
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn range-map
+  "Create a range map from a collection of [range value] pairs.
+
+   Ranges are [lo hi) (half-open, hi exclusive).
+
+   Example:
+     (range-map {[0 10] :a [20 30] :b})
+     (range-map [[[0 10] :a] [[20 30] :b]])"
+  ([]
+   (RangeMap. (node/leaf) range-compare {}))
+  ([coll]
+   (binding [order/*compare* range-compare]
+     (reduce
+       (fn [rm [rng v]] (range-map-assoc rm rng v false))
+       (RangeMap. (node/leaf) range-compare {})
+       coll))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Public API (delegates to protocol)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn assoc-coalescing
+  "Insert range with coalescing. Adjacent ranges with the same value
+   are automatically merged. Equivalent to Guava's putCoalescing.
+
+   Example:
+     (-> (range-map)
+         (assoc-coalescing [0 100] :a)
+         (assoc-coalescing [100 200] :a))
+     ;; => single range [0 200) :a"
+  [rm rng v]
+  (proto/assoc-coalescing rm rng v))
+
+(defn ranges
+  "Return a seq of all [range value] pairs."
+  [rm]
+  (proto/ranges rm))
+
+(defn span
+  "Return [lo hi] spanning all ranges, or nil if empty."
+  [rm]
+  (proto/span rm))
+
+(defn gaps
+  "Return a seq of [lo hi) ranges that have no mapping."
+  [rm]
+  (proto/gaps rm))
+
+(defn get-entry
+  "Return [range value] for the range containing point x, or nil.
+   Equivalent to Guava's getEntry(K).
+
+   Example:
+     (get-entry rm 50) ;; => [[0 100] :a]"
+  [rm x]
+  (proto/get-entry rm x))
+
+(defn range-remove
+  "Remove all mappings in the given range [lo hi).
+   Any overlapping ranges are trimmed; ranges fully contained are removed.
+   Equivalent to Guava's remove(Range).
+
+   Example:
+     (range-remove rm [25 75])
+     ;; [0 100]:a becomes [0 25):a and [75 100):a"
+  [rm rng]
+  (proto/range-remove rm rng))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method RangeMap [^RangeMap m ^java.io.Writer w]
+  (.write w "#ordered/range-map [")
+  (let [s (seq m)]
+    (when s
+      (let [[k v] (first s)]
+        (print-method [(vec k) v] w))
+      (doseq [[k v] (rest s)]
+        (.write w " ")
+        (print-method [(vec k) v] w))))
+  (.write w "]"))
diff --git a/src/ordered_collections/types/rope.clj b/src/ordered_collections/types/rope.clj
new file mode 100644
index 0000000..278aba7
--- /dev/null
+++ b/src/ordered_collections/types/rope.clj
@@ -0,0 +1,557 @@
+(ns ordered-collections.types.rope
+  "Persistent rope-like indexed sequence backed by an implicit-index
+  weight-balanced tree."
+  (:require [clojure.core.protocols :as cp]
+            [clojure.core.reducers :as r]
+            [ordered-collections.protocol :as proto]
+            [ordered-collections.kernel.node :as node]
+            [ordered-collections.kernel.rope :as ropetree])
+  (:import  [clojure.lang RT Murmur3 MapEntry Indexed Util
+                           IPersistentCollection IPersistentStack IPersistentVector
+                           IEditableCollection ITransientCollection
+                           IReduce IReduceInit SeqIterator]
+            [java.util ArrayList]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- valid-index?
+  [^long n k]
+  (and (integer? k)
+       (let [i (long k)]
+         (and (<= 0 i) (< i n)))))
+
+(defn- insert-index?
+  [^long n k]
+  (and (integer? k)
+       (let [i (long k)]
+         (and (<= 0 i) (<= i n)))))
+
+(defn- check-index!
+  [n k]
+  (when-not (valid-index? n k)
+    (throw (IndexOutOfBoundsException.))))
+
+(defn- check-insert-index!
+  [n k]
+  (when-not (insert-index? n k)
+    (throw (IndexOutOfBoundsException.))))
+
+(defn- check-range!
+  "Validate [start, end) against rope of size n."
+  [start end ^long n]
+  (when (or (not (integer? start))
+            (not (integer? end))
+            (neg? (long start))
+            (neg? (long end))
+            (> (long start) (long end))
+            (> (long end) n))
+    (throw (IndexOutOfBoundsException.))))
+
+(declare ->rope rope-root)
+
+(defn- rope-equiv
+  "Sequential equality with an indexed fast path for vectors.
+   If both sides are IPersistentVector, compare by index. Otherwise fall back
+   to element-wise sequential equivalence."
+  [^IPersistentVector this o]
+  (cond
+    (identical? this o) true
+
+    (instance? IPersistentVector o)
+    (let [n (.length this)]
+      (and (= n (.length ^IPersistentVector o))
+           (loop [i 0]
+             (if (= i n)
+               true
+               (if (Util/equiv (.nth this i) (.nth ^IPersistentVector o i))
+                 (recur (unchecked-inc i))
+                 false)))))
+
+    (or (instance? clojure.lang.Sequential o)
+        (instance? java.util.List o))
+    (let [n (.length this)]
+      (if (and (instance? clojure.lang.Counted o)
+               (not= n (.count ^clojure.lang.Counted o)))
+        false
+        (loop [s (seq o) i 0]
+          (cond
+            (= i n) (nil? s)
+            (nil? s) false
+            (not (Util/equiv (.nth this i) (first s))) false
+            :else (recur (next s) (unchecked-inc i))))))
+
+    :else false))
+
+(defn- seq-compare
+  "Lexicographic comparison of two sequential collections.
+   This is ordering, not equality: it uses `compare` element-by-element rather
+   than `Util/equiv`."
+  [s1 s2]
+  (loop [s1 (seq s1) s2 (seq s2)]
+    (cond
+      (nil? s1) (if (nil? s2) 0 -1)
+      (nil? s2) 1
+      :else
+      (let [c (compare (first s1) (first s2))]
+        (if (zero? c)
+          (recur (next s1) (next s2))
+          c)))))
+
+(defn- linear-index-of
+  "Linear scan for first index of x, or -1."
+  [root x]
+  (let [n      (ropetree/rope-size root)
+        result (ropetree/rope-reduce
+                 (fn [^long i elem]
+                   (if (Util/equiv elem x)
+                     (reduced i)
+                     (unchecked-inc i)))
+                 (long 0)
+                 root)]
+    (if (< (long result) n) (long result) -1)))
+
+(defn- linear-last-index-of
+  "Forward linear scan tracking the last matching index. O(n)."
+  [root x]
+  (let [found (volatile! (long -1))]
+    (ropetree/rope-reduce
+      (fn [^long i elem]
+        (when (Util/equiv elem x) (vreset! found i))
+        (unchecked-inc i))
+      (long 0)
+      root)
+    (long @found)))
+
+(defn- rope-to-array
+  ^objects [root]
+  (let [n   (ropetree/rope-size root)
+        arr (object-array n)]
+    (ropetree/rope-reduce
+      (fn [^long i x]
+        (aset arr i x)
+        (unchecked-inc i))
+      (long 0)
+      root)
+    arr))
+
+(declare ->TransientRope)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Rope
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields:
+;;   root  — implicit-index weight-balanced tree of chunk vectors, or nil
+;;   _meta — metadata map
+;;
+;; Each tree node stores a chunk vector in the key slot and the total
+;; element count of the subtree in the value slot. Implements
+;; IPersistentVector for full vector-contract compatibility, including
+;; indexed access, assoc, conj-to-end, peek/pop-right.
+
+(deftype Rope [root _meta]
+
+  java.io.Serializable
+  java.util.RandomAccess
+
+  clojure.lang.IMeta
+  (meta [_] _meta)
+
+  clojure.lang.IObj
+  (withMeta [_ m] (Rope. root m))
+
+  clojure.lang.Counted
+  (count [_]
+    (ropetree/rope-size root))
+
+  Indexed
+  (nth [_ i]
+    (if (valid-index? (ropetree/rope-size root) i)
+      (ropetree/rope-nth root (long i))
+      (throw (IndexOutOfBoundsException.))))
+  (nth [_ i not-found]
+    (if (valid-index? (ropetree/rope-size root) i)
+      (ropetree/rope-nth root (long i))
+      not-found))
+
+  clojure.lang.ILookup
+  (valAt [this k]
+    (.nth this k nil))
+  (valAt [this k not-found]
+    (.nth this k not-found))
+
+  clojure.lang.IFn
+  (invoke [this k]
+    (.valAt this k))
+  (invoke [this k not-found]
+    (.valAt this k not-found))
+  (applyTo [this args]
+    (let [n (RT/boundedLength args 2)]
+      (case n
+        0 (throw (clojure.lang.ArityException. n (.. this getClass getSimpleName)))
+        1 (.invoke this (first args))
+        2 (.invoke this (first args) (second args))
+        (throw (clojure.lang.ArityException. n (.. this getClass getSimpleName))))))
+
+  clojure.lang.Associative
+  (containsKey [_ k]
+    (valid-index? (ropetree/rope-size root) k))
+  (entryAt [this k]
+    (when (.containsKey this k)
+      (MapEntry. k (.nth this k))))
+  (assoc [this k v]
+    (let [n (ropetree/rope-size root)]
+      (cond
+        (not (insert-index? n k))
+        (throw (IndexOutOfBoundsException.))
+
+        (= (long k) n)
+        (Rope. (ropetree/rope-conj-right root v) _meta)
+
+        :else
+        (Rope. (ropetree/rope-assoc root (long k) v) _meta))))
+
+  IPersistentVector
+  (assocN [this i v]
+    (.assoc this i v))
+  (length [_]
+    (ropetree/rope-size root))
+
+  IPersistentCollection
+  (cons [_ o]
+    (Rope. (ropetree/rope-conj-right root o) _meta))
+  (empty [_]
+    (Rope. nil _meta))
+  (equiv [this o]
+    (rope-equiv this o))
+
+  IPersistentStack
+  (peek [_]
+    (ropetree/rope-peek-right root))
+  (pop [_]
+    (Rope. (ropetree/rope-pop-right root) _meta))
+
+  clojure.lang.Seqable
+  (seq [_]
+    (ropetree/rope-seq root))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (ropetree/rope-rseq root))
+
+  clojure.lang.Sequential
+
+  java.lang.Comparable
+  (compareTo [this o]
+    (if (identical? this o)
+      0
+      (seq-compare this o)))
+
+  java.lang.Iterable
+  (iterator [this]
+    (SeqIterator. (seq this)))
+
+  IReduceInit
+  (reduce [_ f init]
+    (ropetree/rope-reduce f init root))
+
+  IReduce
+  (reduce [_ f]
+    (ropetree/rope-reduce f root))
+
+  cp/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^IReduceInit this f init))
+
+  r/CollFold
+  (coll-fold [this n combinef reducef]
+    (ropetree/rope-fold root (long n) combinef reducef))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/hashOrdered this))
+
+  java.util.Collection
+  (toArray [_]
+    (rope-to-array root))
+  (isEmpty [_]
+    (nil? root))
+  (^boolean contains [_ x]
+    (not (neg? (linear-index-of root x))))
+  (containsAll [this c]
+    (every? #(.contains this %) c))
+  (size [_]
+    (ropetree/rope-size root))
+  (add [_ _]
+    (throw (UnsupportedOperationException.)))
+  (addAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (^boolean remove [_ _]
+    (throw (UnsupportedOperationException.)))
+  (removeAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (retainAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (clear [_]
+    (throw (UnsupportedOperationException.)))
+
+  java.util.List
+  (get [_ i]
+    (if (valid-index? (ropetree/rope-size root) i)
+      (ropetree/rope-nth root (long i))
+      (throw (IndexOutOfBoundsException.))))
+  (indexOf [_ x]
+    (linear-index-of root x))
+  (lastIndexOf [_ x]
+    (linear-last-index-of root x))
+  (set [_ _ _]
+    (throw (UnsupportedOperationException.)))
+  (subList [this from to]
+    (proto/rope-sub this from to))
+
+  proto/PRope
+  (rope-cat [this other]
+    (Rope. (ropetree/rope-concat root (.-root ^Rope other)) _meta))
+  (rope-split [_ i]
+    (check-insert-index! (ropetree/rope-size root) i)
+    (let [[l r] (ropetree/ensure-split-parts
+                  (ropetree/rope-split-at root (long i)))]
+      [(Rope. l _meta) (Rope. r _meta)]))
+  (rope-sub [_ start end]
+    (let [n (ropetree/rope-size root)]
+      (check-range! start end n)
+      (Rope. (ropetree/rope-subvec-root root (long start) (long end)) _meta)))
+  (rope-insert [this i coll]
+    (let [n (ropetree/rope-size root)]
+      (check-insert-index! n i)
+      (let [mid (->rope coll)]
+        (Rope. (ropetree/rope-insert-root root (long i) (.-root ^Rope mid)) _meta))))
+  (rope-remove [this start end]
+    (check-range! start end (ropetree/rope-size root))
+    (let [start (long start)
+          end   (long end)]
+      (Rope. (ropetree/rope-remove-root root start end) _meta)))
+  (rope-splice [this start end coll]
+    (check-range! start end (ropetree/rope-size root))
+    (let [start (long start)
+          end   (long end)
+          mid   (->rope coll)]
+      (Rope. (ropetree/rope-splice-root root start end (.-root ^Rope mid)) _meta)))
+  (rope-chunks [_]
+    (ropetree/rope-chunks-seq root))
+  (rope-str [_]
+    (ropetree/rope->str root))
+
+  IEditableCollection
+  (asTransient [_]
+    (->TransientRope root (ArrayList.) (ArrayList.) 0 true _meta))
+
+  Object
+  (hashCode [this]
+    (Util/hash this))
+  (equals [this o]
+    (Util/equals this o))
+  (toString [this]
+    (pr-str this)))
+
+
+(defn- ->rope
+  "Coerce x to a Rope, returning x if already a Rope."
+  [x]
+  (if (instance? Rope x)
+    x
+    (Rope. (ropetree/coll->root x) {})))
+
+(defn rope-concat
+  "Concatenate ropes or rope-coercible collections.
+   One argument: returns it as a rope.
+   Two arguments: O(log n) binary tree join.
+   Three or more: O(total chunks) bulk construction."
+  ([x]
+   (->rope x))
+  ([left right]
+   (proto/rope-cat (->rope left) (->rope right)))
+  ([left right & more]
+   (Rope. (ropetree/chunks->root-csi
+            (into [] (mapcat (comp ropetree/root->chunks rope-root))
+                  (list* left right more)))
+     (or (meta left) {}))))
+
+(defn- transient-appended-root
+  [^ArrayList chunks ^ArrayList tail]
+  (let [chunk-count (.size chunks)
+        tail-empty? (.isEmpty tail)]
+    (cond
+      (and (zero? chunk-count) tail-empty?)
+      nil
+
+      (zero? chunk-count)
+      (ropetree/chunks->root [(vec tail)])
+
+      tail-empty?
+      (ropetree/chunks->root (vec chunks))
+
+      :else
+      (ropetree/chunks->root-csi
+        (conj (vec chunks) (vec tail))))))
+
+(def ^:const +transient-rebuild-threshold+
+  4)
+
+(defn- transient-final-root
+  [root ^ArrayList chunks ^ArrayList tail]
+  (cond
+    ;; Fast path: nothing appended — return original root unchanged
+    (and (zero? (.size chunks)) (.isEmpty tail))
+    root
+
+    ;; Fast path: small tail only, no flushed chunks — append elements
+    ;; directly via rope-conj-right, avoiding subtree construction + concat
+    (and (zero? (.size chunks)) (<= (.size tail) 32))
+    (reduce ropetree/rope-conj-right (or root (node/leaf)) tail)
+
+    ;; Normal path: build appended content and merge
+    :else
+    (let [appended-root (transient-appended-root chunks tail)
+          appended-chunks (+ (.size chunks) (if (.isEmpty tail) 0 1))]
+      (cond
+        (nil? root)
+        appended-root
+
+        (<= appended-chunks +transient-rebuild-threshold+)
+        (ropetree/rope-concat root appended-root)
+
+        :else
+        (ropetree/chunks->root-csi
+          (cond-> (vec (ropetree/root->chunks root))
+            (pos? (.size chunks)) (into (vec chunks))
+            (not (.isEmpty tail)) (conj (vec tail))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Transient Rope
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; A TransientRope is a narrow construction-oriented companion to the
+;; persistent Rope type. Its purpose is not to provide a fully mutable rope
+;; editor, but to make append-heavy assembly cheaper by buffering a mutable
+;; tail chunk and only flushing that chunk into the tree when it fills or when
+;; `persistent!` is called.
+;;
+;; This design exists because bulk building and structural editing have
+;; different needs:
+;;
+;; - persistent Rope operations optimize sharing, split/join, and snapshots
+;; - transient construction wants cheap repeated `conj` without rebuilding
+;;   tree structure for every appended element
+;;
+;; So the transient keeps the implementation deliberately small:
+;;
+;; - immutable tree prefix in `root`
+;; - mutable append buffer in `tail`
+;; - no attempt to support arbitrary in-place splice/update semantics
+;;
+;; That makes it useful for workloads like:
+;;
+;; - building a large rope from a stream of values
+;; - accumulating output incrementally before freezing a persistent result
+;; - amortizing append cost without weakening the persistent rope model
+;;
+;; In other words, TransientRope is a builder, not a mutable general-purpose
+;; rope API.
+
+(deftype TransientRope [^:unsynchronized-mutable root
+                        ^ArrayList chunks
+                        ^ArrayList tail
+                        ^:unsynchronized-mutable chunk-elems
+                        ^:unsynchronized-mutable edit
+                        _meta]
+  ITransientCollection
+  (conj [this x]
+    (when-not edit (throw (IllegalAccessError. "Transient used after persistent! call")))
+    (.add tail x)
+    (when (>= (.size tail) ropetree/+target-chunk-size+)
+      (.add chunks (vec tail))
+      (set! chunk-elems (+ chunk-elems ropetree/+target-chunk-size+))
+      (.clear tail))
+    this)
+
+  (persistent [_]
+    (when-not edit (throw (IllegalAccessError. "Transient used after persistent! call")))
+    (set! edit false)
+    (Rope. (transient-final-root root chunks tail) _meta))
+
+  clojure.lang.Counted
+  (count [_]
+    (+ (ropetree/rope-size root) chunk-elems (.size tail)))
+
+  Indexed
+  (nth [this i]
+    (let [rs (ropetree/rope-size root)
+          ts (.size tail)
+          j  (- i rs)]
+      (cond
+        (and (>= i 0) (< i rs))   (ropetree/rope-nth root i)
+        (and (>= j 0) (< j chunk-elems))
+        (let [chunk-idx (quot j ropetree/+target-chunk-size+)
+              offset    (rem j ropetree/+target-chunk-size+)
+              chunk     (.get chunks chunk-idx)]
+          (.nth ^clojure.lang.Indexed chunk offset))
+
+        (< (- j chunk-elems) ts)   (.get tail (- j chunk-elems))
+        :else                      (throw (IndexOutOfBoundsException.)))))
+  (nth [this i not-found]
+    (let [rs (ropetree/rope-size root)
+          n  (+ rs chunk-elems (.size tail))]
+      (if (and (>= i 0) (< i n))
+        (.nth this i)
+        not-found))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Constructors
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn rope
+  ([] (Rope. nil {}))
+  ([coll]
+   (Rope. (ropetree/coll->root coll) {})))
+
+(defn- rope-root
+  [x]
+  (if (instance? Rope x)
+    (.-root ^Rope x)
+    (ropetree/coll->root x)))
+
+(defn rope-concat-all
+  "Bulk concatenation of rope values or rope-coercible collections.
+  Collects all chunks and builds the tree directly in O(total chunks),
+  avoiding pairwise tree operations."
+  [& xs]
+  (Rope. (ropetree/chunks->root-csi
+           (into [] (mapcat (comp ropetree/root->chunks rope-root)) xs))
+    (or (meta (first xs)) {})))
+
+(defn rope-chunks-reverse
+  "Reverse seq of internal chunk vectors."
+  [v]
+  (ropetree/rope-chunks-rseq (rope-root v)))
+
+(defn rope-chunk-count
+  "Number of internal chunks. O(1)."
+  [v]
+  (let [root (rope-root v)]
+    (if (nil? root) 0 (ropetree/chunk-count root))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method Rope [^Rope r ^java.io.Writer w]
+  (.write w "#ordered/rope ")
+  (print-method (into [] r) w))
diff --git a/src/ordered_collections/types/segment_tree.clj b/src/ordered_collections/types/segment_tree.clj
new file mode 100644
index 0000000..7ee55e5
--- /dev/null
+++ b/src/ordered_collections/types/segment_tree.clj
@@ -0,0 +1,502 @@
+(ns ordered-collections.types.segment-tree
+  "A segment tree for efficient range aggregate queries.
+
+   Supports O(log n) point updates and O(log n) range queries for any
+   associative operation (sum, min, max, gcd, etc.).
+
+   CONCEPT:
+   Each node stores an aggregate of its entire subtree. For sum:
+
+                    ┌─────────────┐
+                    │ key: 3      │
+                    │ val: 40     │
+                    │ agg: 150 ◄──────── sum of entire tree
+                    └──────┬──────┘
+               ┌───────────┴───────────┐
+        ┌──────┴──────┐         ┌──────┴──────┐
+        │ key: 1      │         │ key: 4      │
+        │ val: 20     │         │ val: 50     │
+        │ agg: 30 ◄───────      │ agg: 80 ◄───────
+        └──────┬──────┘   │     └──────┬──────┘   │
+               │          │            │          │
+        ┌──────┴──────┐   │     ┌──────┴──────┐   │
+        │ key: 0      │   │     │ key: 5      │   │
+        │ val: 10     │   │     │ val: 30     │   │
+        │ agg: 10     │   │     │ agg: 30     │   │
+        └─────────────┘   │     └─────────────┘   │
+                          │                       │
+               10 + 20 = 30              50 + 30 = 80
+
+   RANGE QUERY: query(1, 4) = sum of indices 1,2,3,4
+   Uses aggregates to avoid visiting every node - O(log n).
+
+   EXAMPLE:
+     (def st (segment-tree + 0 {0 10, 1 20, 2 30, 3 40, 4 50}))
+     (query st 0 4)     ; => 150 (sum of all)
+     (query st 1 3)     ; => 90 (20 + 30 + 40)
+     (update st 2 100)  ; => new tree with index 2 = 100
+     (query st 1 3)     ; => 160 (20 + 100 + 40)"
+  (:require [ordered-collections.kernel.node     :as node]
+            [ordered-collections.kernel.order    :as order]
+            [ordered-collections.kernel.root]
+            [ordered-collections.kernel.tree     :as tree]
+            [ordered-collections.protocol      :as proto]
+            [ordered-collections.types.shared :refer [with-tree-env]
+             :rename {with-tree-env with-segment-tree}])
+  (:import  [clojure.lang ILookup Associative IPersistentCollection Seqable
+             Counted IFn IMeta IObj MapEntry Murmur3]
+            [java.util Comparator]
+            [ordered_collections.protocol PRangeAggregate]
+            [ordered_collections.kernel.root INodeCollection
+                                         IBalancedCollection
+                                         IOrderedCollection]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Aggregate Helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- node-agg
+  "Return the cached aggregate for subtree n, or identity for an empty subtree."
+  [n identity]
+  (if (node/leaf? n) identity (node/-z n)))
+
+(defn- make-agg-creator
+  "Create a node constructor that computes aggregates using op and identity."
+  [op identity]
+  (fn [k v l r]
+    (let [l-agg (if (node/leaf? l) identity (node/-z l))
+          r-agg (if (node/leaf? r) identity (node/-z r))
+          agg   (op l-agg (op v r-agg))]
+      (node/->AggregateNode k v l r (+ 1 (tree/node-size l) (tree/node-size r)) agg))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Range Query Algorithm
+;;
+;; Query uses two splits:
+;;   1. split at lo  =>  (< lo)  [= lo]  (> lo)
+;;   2. split >lo at hi => (lo,hi) [= hi] (> hi)
+;;
+;; The middle tree already stores the aggregate for all keys strictly between
+;; lo and hi. We then combine that cached aggregate with exact lo/hi matches.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- query-range-fast
+  "Compute op over all values with keys in [lo, hi] inclusive."
+  [root lo hi op identity cmp]
+  (if (node/leaf? root)
+    identity
+    (binding [order/*compare* cmp]
+      (if (pos? (order/compare lo hi))
+        identity
+        (let [[_ lo-present gt] (tree/node-split root lo)
+              [mid hi-present _] (tree/node-split gt hi)
+              acc0 (if lo-present
+                     (second lo-present)
+                     identity)
+              acc1 (op acc0 (node-agg mid identity))]
+          (if hi-present
+            (op acc1 (second hi-present))
+            acc1))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; SegmentTree Type
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Fields:
+;;   root     — tree of AggregateNode (subtree aggregate cached in -z field)
+;;   op       — associative binary operation (+, min, max, etc.)
+;;   identity — identity element for op (0 for +, Long/MAX_VALUE for min)
+;;   creator  — node constructor that recomputes agg = op(left.agg, val, right.agg)
+;;   cmp      — key comparator
+;;   _meta    — metadata map
+;;
+;; Range queries split twice and combine cached aggregates — O(log n).
+;; Point updates rebuild aggregates bottom-up via creator.
+
+(declare seg-assoc)
+
+(deftype SegmentTree [root op identity creator cmp _meta]
+
+  java.io.Serializable
+
+  INodeCollection
+  (getAllocator [_]
+    creator)
+  (getRoot [_]
+    root)
+
+  IOrderedCollection
+  (getCmp [_]
+    cmp)
+  (isCompatible [_ o]
+    (and (instance? SegmentTree o)
+         (= cmp (.getCmp ^IOrderedCollection o))))
+  (isSimilar [_ o]
+    (map? o))
+
+  IBalancedCollection
+  (getStitch [_]
+    creator)
+
+  IMeta
+  (meta [_] _meta)
+
+  IObj
+  (withMeta [_ m] (SegmentTree. root op identity creator cmp m))
+
+  Counted
+  (count [_] (tree/node-size root))
+
+  Seqable
+  (seq [_]
+    (tree/node-entry-seq root (tree/node-size root)))
+
+  clojure.lang.Reversible
+  (rseq [_]
+    (tree/node-entry-seq-reverse root (tree/node-size root)))
+
+  clojure.lang.IReduceInit
+  (reduce [this f init]
+    (tree/node-reduce-entries f init root))
+
+  clojure.lang.IReduce
+  (reduce [this f]
+    (tree/node-reduce-entries f root))
+
+  clojure.core.protocols/CollReduce
+  (coll-reduce [this f]
+    (.reduce ^clojure.lang.IReduce this f))
+  (coll-reduce [this f init]
+    (.reduce ^clojure.lang.IReduceInit this f init))
+
+  clojure.lang.IKVReduce
+  (kvreduce [this f init]
+    (tree/node-reduce-kv f init root))
+
+  clojure.lang.MapEquivalence
+
+  ILookup
+  (valAt [_ k] (.valAt _ k nil))
+  (valAt [this k not-found]
+    (with-segment-tree this
+      (if-let [n (tree/node-find root k)]
+        (node/-v n)
+        not-found)))
+
+  IFn
+  (invoke [this k] (.valAt this k nil))
+  (invoke [this k not-found] (.valAt this k not-found))
+
+  Associative
+  (containsKey [this k]
+    (with-segment-tree this
+      (some? (tree/node-find root k))))
+  (entryAt [this k]
+    (let [v (.valAt this k ::not-found)]
+      (when-not (= v ::not-found)
+        (MapEntry. k v))))
+  (assoc [this k v]
+    (seg-assoc this k v))
+
+  IPersistentCollection
+  (empty [_]
+    (SegmentTree. (node/leaf) op identity creator cmp _meta))
+  (cons [this x]
+    (if (instance? MapEntry x)
+      (.assoc this (key x) (val x))
+      (.assoc this (first x) (second x))))
+  (equiv [this that]
+    (and (instance? SegmentTree that)
+         (= (seq this) (seq that))))
+
+  Object
+  (toString [this]
+    (pr-str this))
+
+  java.lang.Comparable
+  (compareTo [this o]
+    (with-segment-tree this
+      (cond
+        (identical? this o) 0
+        (.isCompatible this o) (tree/node-map-compare root (.getRoot ^INodeCollection o))
+        (.isSimilar this o) (.compareTo ^Comparable (into (empty o) this) o)
+        true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
+
+  java.util.Map
+  (get [this k]
+    (.valAt this k))
+  (isEmpty [_]
+    (node/leaf? root))
+  (size [_]
+    (tree/node-size root))
+  (keySet [this]
+    (with-segment-tree this
+      (set (tree/node-vec root :accessor :k))))
+  (put [_ _ _]
+    (throw (UnsupportedOperationException.)))
+  (putAll [_ _]
+    (throw (UnsupportedOperationException.)))
+  (clear [_]
+    (throw (UnsupportedOperationException.)))
+  (values [this]
+    (with-segment-tree this
+      (tree/node-vec root :accessor :v)))
+  (entrySet [this]
+    (with-segment-tree this
+      (set (tree/node-vec root :accessor :kv))))
+  (iterator [this]
+    (clojure.lang.SeqIterator. (seq this)))
+
+  clojure.lang.IPersistentMap
+  (assocEx [this k v]
+    (with-segment-tree this
+      (if-let [new-root (tree/node-add-if-absent root k v)]
+        (SegmentTree. new-root op identity creator cmp _meta)
+        (throw (Exception. "Key already present")))))
+  (without [this k]
+    (with-segment-tree this
+      (SegmentTree. (tree/node-remove root k) op identity creator cmp _meta)))
+
+  java.util.SortedMap
+  (comparator [_]
+    cmp)
+  (firstKey [this]
+    (with-segment-tree this
+      (first (tree/node-least-kv root))))
+  (lastKey [this]
+    (with-segment-tree this
+      (first (tree/node-greatest-kv root))))
+  (headMap [this k]
+    (with-segment-tree this
+      (SegmentTree. (tree/node-split-lesser root k) op identity creator cmp _meta)))
+  (tailMap [this k]
+    (with-segment-tree this
+      (let [[_ present gt] (tree/node-split root k)]
+        (if present
+          (SegmentTree. (tree/node-add gt (first present) (second present))
+                        op identity creator cmp _meta)
+          (SegmentTree. gt op identity creator cmp _meta)))))
+  (subMap [this from to]
+    (with-segment-tree this
+      (let [[_ from-present from-gt] (tree/node-split root from)
+            from-tree (if from-present
+                        (tree/node-add from-gt (first from-present) (second from-present))
+                        from-gt)
+            to-tree   (tree/node-split-lesser root to)
+            result    (tree/node-set-intersection from-tree to-tree)]
+        (SegmentTree. result op identity creator cmp _meta))))
+
+  clojure.lang.Sorted
+  (entryKey [_ entry]
+    (key entry))
+  (seq [_ ascending]
+    (if ascending
+      (tree/node-entry-seq root)
+      (tree/node-entry-seq-reverse root)))
+  (seqFrom [this k ascending]
+    (with-segment-tree this
+      (let [[lt present gt] (tree/node-split root k)]
+        (if ascending
+          (if present
+            (cons (MapEntry. (first present) (second present))
+                  (tree/node-entry-seq gt))
+            (tree/node-entry-seq gt))
+          (if present
+            (cons (MapEntry. (first present) (second present))
+                  (tree/node-entry-seq-reverse lt))
+            (tree/node-entry-seq-reverse lt))))))
+
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (Murmur3/mixCollHash
+      (unchecked-int
+        (tree/node-reduce
+          (fn [^long acc n]
+            (unchecked-add acc (long (clojure.lang.Util/hasheq
+                                       (MapEntry. (node/-k n) (node/-v n))))))
+          (long 0)
+          root))
+      (tree/node-size root)))
+
+  PRangeAggregate
+  (aggregate-range [this lo hi]
+    (with-segment-tree this
+      (query-range-fast root lo hi op identity cmp)))
+  (aggregate [this]
+    (if (node/leaf? root)
+      identity
+      (node/-z root)))
+  (update-val [this k v]
+    (seg-assoc this k v))
+  (update-fn [this k f]
+    (let [old-val (get this k identity)]
+      (seg-assoc this k (f old-val)))))
+
+(extend-type SegmentTree
+  proto/PNearest
+  (nearest [this test k]
+    (with-segment-tree this
+      (case test
+        :< (when-let [n (tree/node-predecessor (.getRoot ^INodeCollection this) k)]
+             [(node/-k n) (node/-v n)])
+        :<= (when-let [n (tree/node-find-nearest (.getRoot ^INodeCollection this) k :<)]
+              [(node/-k n) (node/-v n)])
+        :> (when-let [n (tree/node-successor (.getRoot ^INodeCollection this) k)]
+             [(node/-k n) (node/-v n)])
+        :>= (when-let [n (tree/node-find-nearest (.getRoot ^INodeCollection this) k :>)]
+              [(node/-k n) (node/-v n)])
+        (throw (ex-info "nearest test must be :<, :<=, :>, or :>=" {:test test})))))
+  (subrange [this test k]
+    (with-segment-tree this
+      (let [root        (.getRoot ^INodeCollection this)
+            result-root (case test
+                          (:< :<=) (tree/node-split-lesser root k)
+                          (:> :>=) (tree/node-split-greater root k)
+                          (throw (ex-info "subrange test must be :<, :<=, :>, or :>=" {:test test})))
+            result-root (case test
+                          (:<= :>=) (if-let [n (tree/node-find root k)]
+                                      (tree/node-add result-root (node/-k n) (node/-v n))
+                                      result-root)
+                          result-root)]
+        (SegmentTree. result-root (.-op this) (.-identity this) (.-creator this) (.-cmp this) (.-_meta this)))))
+
+  proto/PRanked
+  (rank-of [this k]
+    (or (tree/node-rank (.getRoot ^INodeCollection this) k (.getCmp ^IOrderedCollection this)) -1))
+  (slice [this start end]
+    (let [root  (.getRoot ^INodeCollection this)
+          n     (tree/node-size root)
+          start (max 0 (long start))
+          end   (min n (long end))]
+      (when (< start end)
+        (with-segment-tree this
+          (map (fn [n] (MapEntry. (node/-k n) (node/-v n)))
+               (tree/node-subseq root start (dec end)))))))
+  (median [this]
+    (let [root (.getRoot ^INodeCollection this)
+          n    (tree/node-size root)]
+      (when (pos? n)
+        (with-segment-tree this
+          (let [n (tree/node-nth root (quot (dec n) 2))]
+            (MapEntry. (node/-k n) (node/-v n)))))))
+  (percentile [this pct]
+    (let [root (.getRoot ^INodeCollection this)
+          n    (tree/node-size root)]
+      (when (pos? n)
+        (let [idx (min (dec n) (long (* (/ (double pct) 100.0) n)))]
+          (with-segment-tree this
+            (let [n (tree/node-nth root idx)]
+              (MapEntry. (node/-k n) (node/-v n))))))))
+
+  proto/PSplittable
+  (split-key [this k]
+    (with-segment-tree this
+      (let [root         (.getRoot ^INodeCollection this)
+            [l present r] (tree/node-split root k)
+            entry         (when present [(first present) (second present)])]
+        [(SegmentTree. l (.-op this) (.-identity this) (.-creator this) (.-cmp this) (.-_meta this))
+         entry
+         (SegmentTree. r (.-op this) (.-identity this) (.-creator this) (.-cmp this) (.-_meta this))])))
+  (split-at [this i]
+    (with-segment-tree this
+      (let [root (.getRoot ^INodeCollection this)
+            n    (tree/node-size root)]
+        (cond
+          (<= i 0) [(.empty this) this]
+          (>= i n) [this (.empty this)]
+          :else
+          (let [left-root  (tree/node-split-lesser root (node/-k (tree/node-nth root i)))
+                right-root (tree/node-split-nth root i)]
+            [(SegmentTree. left-root (.-op this) (.-identity this) (.-creator this) (.-cmp this) (.-_meta this))
+             (SegmentTree. right-root (.-op this) (.-identity this) (.-creator this) (.-cmp this) (.-_meta this))]))))))
+
+(defn- seg-assoc [^SegmentTree st k v]
+  (with-segment-tree st
+    (SegmentTree.
+      (tree/node-add (.-root st) k v)
+      (.-op st)
+      (.-identity st)
+      (.-creator st)
+      (.-cmp st)
+      (.-_meta st))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Public API
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn segment-tree-with
+  "Create a segment tree with a custom comparator.
+
+   The comparator controls key ordering for point lookups, updates,
+   and range queries."
+  ([^Comparator comparator op identity]
+   (segment-tree-with comparator op identity nil))
+  ([^Comparator comparator op identity coll]
+   (let [creator (make-agg-creator op identity)]
+     (binding [order/*compare* comparator
+               tree/*t-join*   creator]
+       (SegmentTree.
+         (reduce (fn [n [k v]]
+                   (tree/node-add n k v))
+                 (node/leaf)
+                 coll)
+         op identity creator comparator {})))))
+
+(defn segment-tree-by
+  "Create a segment tree with a custom ordering predicate.
+
+   The predicate should define a total order like < or >."
+  [pred op identity coll]
+  (segment-tree-with (order/compare-by pred) op identity coll))
+
+(defn segment-tree
+  "Create a segment tree with the given associative operation and identity.
+
+   Arguments:
+     op       - associative binary operation (e.g., +, min, max)
+     identity - identity element for op (e.g., 0 for +, Long/MAX_VALUE for min)
+     coll     - map or seq of [key value] pairs
+
+   Example:
+     ;; Sum segment tree
+     (segment-tree + 0 {0 10, 1 20, 2 30})
+
+     ;; Min segment tree
+     (segment-tree min Long/MAX_VALUE {0 5, 1 3, 2 8})
+
+     ;; Max segment tree
+     (segment-tree max Long/MIN_VALUE [[0 5] [1 3] [2 8]])"
+  ([op identity]
+   (segment-tree op identity nil))
+  ([op identity coll]
+   (segment-tree-with order/normal-compare op identity coll)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Literal Representation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod print-method SegmentTree [^SegmentTree st ^java.io.Writer w]
+  (.write w "#<SegmentTree ")
+  (print-method (into {} (seq st)) w)
+  (.write w ">"))
+
+;; Convenience constructors for common operations
+
+(defn sum-tree
+  "Create a segment tree for range sums.
+   (query st lo hi) returns sum of values in [lo, hi]."
+  [coll]
+  (segment-tree + 0 coll))
+
+(defn min-tree
+  "Create a segment tree for range minimum queries.
+   (query st lo hi) returns minimum value in [lo, hi]."
+  [coll]
+  (segment-tree min Long/MAX_VALUE coll))
+
+(defn max-tree
+  "Create a segment tree for range maximum queries.
+   (query st lo hi) returns maximum value in [lo, hi]."
+  [coll]
+  (segment-tree max Long/MIN_VALUE coll))
diff --git a/src/ordered_collections/types/shared.clj b/src/ordered_collections/types/shared.clj
new file mode 100644
index 0000000..4ccc74a
--- /dev/null
+++ b/src/ordered_collections/types/shared.clj
@@ -0,0 +1,19 @@
+(ns ordered-collections.types.shared
+  (:require [ordered-collections.kernel.order :as order]
+            [ordered-collections.kernel.tree :as tree]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Shared Boilerplate
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmacro with-compare
+  [x & body]
+  `(binding [order/*compare* (.getCmp ~(with-meta x {:tag 'ordered_collections.kernel.root.IOrderedCollection}))]
+     ~@body))
+
+(defmacro with-tree-env
+  [x & body]
+  `(binding [order/*compare* (.getCmp ~(with-meta x {:tag 'ordered_collections.kernel.root.IOrderedCollection}))
+             tree/*t-join*   (.getAllocator ~(with-meta x {:tag 'ordered_collections.kernel.root.INodeCollection}))]
+     ~@body))
diff --git a/src/ordered_collections/util.clj b/src/ordered_collections/util.clj
new file mode 100644
index 0000000..ff8fefb
--- /dev/null
+++ b/src/ordered_collections/util.clj
@@ -0,0 +1,21 @@
+(ns ordered-collections.util)
+
+(defmacro defalias
+  "Define a var as an alias for another var, copying :arglists from the source.
+
+   Usage:
+     (defalias my-fn \"Optional docstring.\" other-ns/fn)
+
+   Copies :arglists metadata from the source var so that (doc my-fn) shows
+   the correct argument list in the REPL. The docstring on the alias, if
+   provided, overrides the source's docstring."
+  ([name src]
+   `(do
+      (def ~name ~src)
+      (alter-meta! (var ~name) merge (select-keys (meta (var ~src)) [:arglists]))
+      (var ~name)))
+  ([name doc src]
+   `(do
+      (def ~name ~doc ~src)
+      (alter-meta! (var ~name) merge (select-keys (meta (var ~src)) [:arglists]))
+      (var ~name))))
diff --git a/test/com/dean/interval_tree/ordered_map_test.clj b/test/com/dean/interval_tree/ordered_map_test.clj
deleted file mode 100644
index e7ee68e..0000000
--- a/test/com/dean/interval_tree/ordered_map_test.clj
+++ /dev/null
@@ -1,57 +0,0 @@
-(ns com.dean.interval-tree.ordered-map-test
-  (:require [clojure.test                :refer :all]
-            [com.dean.interval-tree.core :refer [ordered-map ordered-map-by]])
-  (:import  [java.util UUID]))
-
-
-;; TODO: more
-
-(deftest smoke-check
-  (is (= {} (ordered-map)))
-  (is (map? (ordered-map))) ;; => true
-  (is (= {:a 4, :b 5, :x 1, :y 2, :z 3}
-          (ordered-map {:x 1 :y 2 :z 3 :a 4 :b 5})))
-  (is (= [[:a 4] [:b 5] [:x 1] [:y 2] [:z 3]]
-         (seq (ordered-map {:x 1 :y 2 :z 3 :a 4 :b 5}))))
-  (is (= {:a 4, :b 5, :x 1, :y 2, :z 3}
-         (assoc (ordered-map) :x 1 :y 2 :z 3 :a 4 :b 5)))
-  (is (= [[1 "a"] [2 "b"] [3 "c"] [4 "d"]]
-         (seq (ordered-map [[2 "b"] [3 "c"] [1 "a"] [4 "d"]]))))
-  (is (= {:a "a", :b "b", :c "c"}
-         (-> (ordered-map) (assoc :b "b") (assoc :a "a") (assoc :c "c"))))
-  (is (= {:b "b", :c "c"}
-         (-> (ordered-map) (assoc :b "b") (assoc :a "a") (assoc :c "c")
-             (dissoc :a))))
-  (is (= "c" ((ordered-map {:a "a", :b "b", :c "c", :d "d"}) :c)))
-  (is (= ::not-found
-         ((ordered-map {:a "a", :b "b", :c "c", :d "d"}) :z ::not-found))))
-
-(defn random-entry []
-  (vector (UUID/randomUUID) (UUID/randomUUID)))
-
-(defn random-map
-  ([size]
-   (random-map (sorted-map) size))
-  ([this size]
-   (into this (repeatedly size random-entry))))
-
-(deftest map-equivalence-check
-  (doseq [size [10 100 1000 10000 100000 500000]]
-    (let [s     (random-map size)
-          t     (random-map 1000)
-          x     (ordered-map s)
-          [k v] (random-entry)]
-      (is (= s x))
-      (is (= (count s) (count x)))
-      (is (= (reverse s) (reverse x)))
-      (is (= (seq s) (seq x)))
-      (is (= (keys s) (keys x)))
-      (is (= (vals s) (vals x)))
-      (is (= (vals s) (map x (keys s))))
-      (is (= nil (x k)))
-      (is (= ::nope (x k ::nope)))
-      (is (= v ((assoc x k v) k)))
-      (is (= (assoc s k v) (assoc x k v)))
-      (is (= s (-> x (assoc k v) (dissoc k))))
-      (is (= (into s t) (into x t)))
-      (is (= (into s t) (-> x (into t) (into t)))))))
diff --git a/test/com/dean/interval_tree/ordered_set_test.clj b/test/com/dean/interval_tree/ordered_set_test.clj
deleted file mode 100644
index c9e7106..0000000
--- a/test/com/dean/interval_tree/ordered_set_test.clj
+++ /dev/null
@@ -1,106 +0,0 @@
-(ns com.dean.interval-tree.ordered-set-test
-  (:require [clojure.core.reducers        :as r]
-            [clojure.math.combinatorics   :as combo]
-            [clojure.set                  :as set]
-            [clojure.test                 :refer :all]
-            [com.dean.interval-tree.core  :refer :all]))
-
-;; TODO: more coverage
-
-(deftest simple-checks
-  (let [x (ordered-set (shuffle (range 8)))
-        y (ordered-set (shuffle (range 20)))
-        z (ordered-set (shuffle (range 0 20 2)))]
-    (is (= #{} (ordered-set)))
-    (is (= #{} (disj (ordered-set) 1)))
-    (is (= #{} (disj (ordered-set [1]) 1)))
-    (is (set? (ordered-set)))
-    (is (= #{0 1 2 3 4 5 6 7}     (conj x 5)))
-    (is (= #{0 1 2 3 4 5 6 7 9}   (conj x 9)))
-    (is (= #{-1 0 1 2 3 4 5 6 7}  (conj x -1)))
-    (is (= #{1 2 3 4 5 6 7}       (disj x 0)))
-    (is (= [9 0 1 2 3 4 5 6 7]    (cons 9 x)))
-    (is (= 0 (first x)))
-    (is (= 7 (last x)))
-    (doseq [i (range 20)]
-      (is (= i (nth y i)))
-      (is (= i (y i)))
-      (is (= i (get y i)))
-      (is (= ::nope (get y (+ 100 i) ::nope)))
-      (is (= i (.ceiling y i)))
-      (is (= i (.floor y i)))
-      (is (= (if (even? i) i (dec i)) (.floor z i)))
-      (is (= i (->> y (drop i) first))))
-    (is (= #{4 5 6}  (.subSet x 3 7)))))
-
-(deftest set-algebra-checks
-  (doseq [size [10 100 1000 10000 100000]]
-    (let [x   (ordered-set (rest (shuffle (range size))))    ;; rest randomizes among runs
-          y   (ordered-set (rest (shuffle (range (* 2 size)))))
-          v   (ordered-set (rest (shuffle (range 0 (* 2 size) 7))))
-          w   (ordered-set (rest (shuffle (range 0 size 3))))
-          z   (ordered-set (rest (shuffle (range 0 size 2))))
-          chk (fn [x y]
-                (doseq [[theirs ours] [[set/intersection intersection]
-                                       [set/union        union]
-                                       [set/difference   difference]
-                                       [set/subset?      subset]
-                                       [set/superset?    superset]]]
-                  (is (= (theirs (set x) (set y)) (ours x y)))
-                  (is (= (theirs (set y) (set x)) (ours y x)))
-                  (is (= (theirs (set x) (set y)) (ours x (set y))))
-                  (is (= (theirs (set y) (set x)) (ours y (set x))))))]
-      (doseq [xy (combo/combinations [x y v w z] 2)]
-        (apply chk xy)))))
-
-(deftest set-equivalence-checks
-  (doseq [size [1 10 100 1000 10000 100000]]
-    (is (= (range size)
-           (seq (ordered-set (shuffle (range size))))))
-    (is (= (range size)
-           (seq (ordered-set-by < (shuffle (range size))))))
-    (is (= (reverse (range size))
-           (seq (ordered-set-by > (shuffle (range size))))))
-    (is (not= (range (inc size))
-              (seq (ordered-set (shuffle (range size))))))
-    (is (= (range size)
-           (ordered-set (shuffle (range size)))))
-    (is (not= (range size)
-              (ordered-set (shuffle (range (inc size))))))
-    (is (= (ordered-set (shuffle (range size)))
-           (set (range size))))
-    (is (= (set (range size))
-           (ordered-set (shuffle (range size)))))
-    (is (not= (set (range 100000))
-              (ordered-set (shuffle (range (inc size))))))
-    (is (= (ordered-set (shuffle (range size)))
-           (ordered-set (shuffle (range size)))))
-    (is (not= (ordered-set (shuffle (range 1 (inc size))))
-              (ordered-set (shuffle (range size)))))))
-
-(deftest sets-of-various-size-and-element-types
-  (doseq [size [1 10 100 1000 10000 100000 250000 500000]
-          f    [identity str gensym
-                #(java.util.Date. %)
-                (fn [_] (java.util.UUID/randomUUID))]]
-    (let [data (mapv f (shuffle (range size)))
-          this (ordered-set data)
-          that (apply sorted-set data)
-          afew (take 1000 data)]
-      (is (= that this))
-      (is (= that (into this afew)))
-      (is (= (apply disj that afew) (apply disj this afew)))
-      (is (= (seq this) (seq that)))
-      (is (= (count this) (count that)))
-      (is (every? #(= (nth this %) (->> that (drop %) first))
-                  (take 10 (repeatedly #(rand-int size)))))
-      (is (every? #(= (this %) (that %)) afew)))))
-
-(deftest foldable-reducible-collection-check
-  (doseq [size  [1 10 100 1000 10000 100000 250000 500000 1000000]
-          chunk [1 10 100 1000]]
-    (let [data (shuffle (range size))
-          sum  (reduce + data)
-          this (ordered-set data)]
-      (is (= sum (r/fold chunk + + this)))
-      (is (= sum (reduce + this))))))
diff --git a/test/ordered_collections/bench_runner.clj b/test/ordered_collections/bench_runner.clj
new file mode 100644
index 0000000..846593f
--- /dev/null
+++ b/test/ordered_collections/bench_runner.clj
@@ -0,0 +1,945 @@
+(ns ordered-collections.bench-runner
+  "Benchmark runner with EDN output for permanent record keeping.
+
+   Usage:
+     lein bench                  # Default: N=100K (~5 min)
+     lein bench --full           # N=10K,100K,500K (~20-30 min)
+     lein bench --sizes 50000    # Custom sizes
+
+   Output is written to bench-results/<timestamp>.edn"
+  (:require [criterium.core :as crit]
+            [clojure.core.reducers :as r]
+            [clojure.data.avl :as avl]
+            [clojure.set :as cset]
+            [clojure.string :as str]
+            [clojure.java.io :as io]
+            [clojure.java.shell :as sh]
+            [clojure.pprint :as pp]
+            [ordered-collections.bench-utils :as bu
+             :refer [generate-pairs generate-elements generate-lookup-keys
+                     generate-string-keys build-map-variants build-set-variants
+                     build-string-map-variants overlapping-set-variants
+                     split-workload fold-frequency-workload set-comparison-workload format-ns
+                     parse-standard-args]]
+            [ordered-collections.core :as core]
+            [ordered-collections.kernel.order :as order]
+            [ordered-collections.kernel.rope :as ropetree])
+  (:import [java.lang.management ManagementFactory]
+           [java.net InetAddress]
+           [java.time Duration Instant LocalDateTime]
+           [java.time.format DateTimeFormatter])
+  (:gen-class))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Configuration
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def sizes-default [100000])
+(def sizes-full    [10000 100000 500000])
+
+(defn timestamp []
+  (.format (LocalDateTime/now)
+           (DateTimeFormatter/ofPattern "yyyy-MM-dd_HH-mm-ss")))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Benchmark Execution
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- nanos [seconds]
+  (long (* 1e9 (double seconds))))
+
+(defn- estimate-point [[point _]]
+  point)
+
+(defn- estimate-interval [[_ interval]]
+  (when interval
+    (mapv nanos interval)))
+
+(defn- estimate-nanos [estimate]
+  (when estimate
+    (nanos (estimate-point estimate))))
+
+(defn- estimate-stdev-nanos [estimate]
+  (when estimate
+    (nanos (Math/sqrt (double (estimate-point estimate))))))
+
+(defn- normalize-criterium-result [results]
+  {:mean-ns           (estimate-nanos (:mean results))
+   :mean-ci-ns        (estimate-interval (:mean results))
+   :sample-mean-ns    (estimate-nanos (:sample-mean results))
+   :sample-mean-ci-ns (estimate-interval (:sample-mean results))
+   :stdev-ns          (estimate-stdev-nanos (:variance results))
+   :sample-stdev-ns   (estimate-stdev-nanos (:sample-variance results))
+   :lower-q-ns        (estimate-nanos (:lower-q results))
+   :lower-q-ci-ns     (estimate-interval (:lower-q results))
+   :upper-q-ns        (estimate-nanos (:upper-q results))
+   :upper-q-ci-ns     (estimate-interval (:upper-q results))
+   :sample-count      (:sample-count results)
+   :execution-count   (:execution-count results)
+   :warmup-jit-period (:warmup-jit-period results)
+   :samples           (:sample-count results)
+   :outliers          (:outliers results)})
+
+(defn- bench-thunk
+  "Run benchmark thunk using Criterium quick-benchmark* and return normalized results."
+  [thunk]
+  (normalize-criterium-result (crit/quick-benchmark* thunk {})))
+
+(defn- progress! []
+  (print ".")
+  (flush))
+
+(defn- run-case [thunk]
+  (progress!)
+  (bench-thunk thunk))
+
+(defn- run-cases
+  "Run a map of benchmark label -> zero-arg thunk."
+  [cases]
+  (reduce-kv (fn [m k thunk]
+               (assoc m k (run-case thunk)))
+             {}
+             cases))
+
+(def format-time format-ns)
+
+(defn- run-benchmark!
+  [results n bench-key bench-fn]
+  (print (str "  " (name bench-key)))
+  (swap! results assoc-in [n bench-key] (bench-fn n))
+  (println))
+
+(defn- run-benchmarks-for-size!
+  [results n bench-specs]
+  (println)
+  (println (str "===== N = " n " ====="))
+  (doseq [spec bench-specs
+          :let [{:keys [key fn when]} (if (map? spec)
+                                        spec
+                                        {:key (first spec) :fn (second spec)})]
+          :when (if when (when n) true)]
+    (run-benchmark! results n key fn)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Individual Benchmarks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-map-construction [n]
+  (let [pairs (generate-pairs n)]
+    (run-cases
+      {:sorted-map  #(into (sorted-map) pairs)
+       :data-avl    #(into (avl/sorted-map) pairs)
+       :ordered-map #(core/ordered-map pairs)})))
+
+(defn bench-map-insert [n]
+  (let [ks (generate-elements n)]
+    (run-cases
+      {:sorted-map  #(loop [m (sorted-map), xs (seq ks)]
+                       (if xs (recur (assoc m (first xs) true) (next xs)) m))
+       :data-avl    #(loop [m (avl/sorted-map), xs (seq ks)]
+                       (if xs (recur (assoc m (first xs) true) (next xs)) m))
+       :ordered-map #(loop [m (core/ordered-map), xs (seq ks)]
+                       (if xs (recur (assoc m (first xs) true) (next xs)) m))})))
+
+(defn bench-map-delete [n]
+  (let [pairs   (map #(vector % true) (range n))
+        to-del  (vec (take (quot n 2) (shuffle (range n))))
+        sm      (into (sorted-map) pairs)
+        am      (into (avl/sorted-map) pairs)
+        om      (core/ordered-map pairs)]
+    (run-cases
+      {:sorted-map  #(reduce (fn [m k] (dissoc m k)) sm to-del)
+       :data-avl    #(reduce (fn [m k] (dissoc m k)) am to-del)
+       :ordered-map #(reduce (fn [m k] (dissoc m k)) om to-del)})))
+
+(defn bench-map-lookup [n & {:keys [num-lookups] :or {num-lookups 10000}}]
+  (let [pairs (generate-pairs n)
+        {:keys [sorted-map data-avl ordered-map]} (build-map-variants pairs)
+        ^ints ks (generate-lookup-keys n num-lookups)]
+    (run-cases
+      {:sorted-map  #(dotimes [i num-lookups] (get sorted-map (aget ks i)))
+       :data-avl    #(dotimes [i num-lookups] (get data-avl (aget ks i)))
+       :ordered-map #(dotimes [i num-lookups] (ordered-map (aget ks i)))})))
+
+(defn bench-map-iteration [n]
+  (let [pairs (generate-pairs n)
+        sm    (into (sorted-map) pairs)
+        am    (into (avl/sorted-map) pairs)
+        om    (core/ordered-map pairs)]
+    (run-cases
+      {:sorted-map  #(reduce (fn [^long acc [k _]] (+ acc (long k))) 0 sm)
+       :data-avl    #(reduce (fn [^long acc [k _]] (+ acc (long k))) 0 am)
+       :ordered-map #(reduce (fn [^long acc [k _]] (+ acc (long k))) 0 om)})))
+
+(defn bench-map-fold [n]
+  (let [pairs (generate-pairs n)
+        {:keys [sorted-map data-avl ordered-map]} (build-map-variants pairs)
+        sum-keys (fn [^long acc entry] (+ acc (long (key entry))))]
+    (run-cases
+      {:sorted-map-reduce  #(reduce sum-keys 0 sorted-map)
+       :data-avl-reduce    #(reduce sum-keys 0 data-avl)
+       :ordered-map-reduce #(reduce sum-keys 0 ordered-map)
+       :ordered-map-fold   #(r/fold + sum-keys ordered-map)})))
+
+(defn bench-set-construction [n]
+  (let [elems (generate-elements n)]
+    (run-cases
+      {:sorted-set  #(into (sorted-set) elems)
+       :data-avl    #(into (avl/sorted-set) elems)
+       :ordered-set #(core/ordered-set elems)})))
+
+(defn bench-set-insert [n]
+  (let [elems (generate-elements n)]
+    (run-cases
+      {:sorted-set  #(loop [s (sorted-set), xs (seq elems)]
+                       (if xs (recur (conj s (first xs)) (next xs)) s))
+       :data-avl    #(loop [s (avl/sorted-set), xs (seq elems)]
+                       (if xs (recur (conj s (first xs)) (next xs)) s))
+       :ordered-set #(loop [s (core/ordered-set), xs (seq elems)]
+                       (if xs (recur (conj s (first xs)) (next xs)) s))})))
+
+(defn bench-set-delete [n]
+  (let [elems  (range n)
+        to-del (vec (take (quot n 2) (shuffle (range n))))
+        ss     (into (sorted-set) elems)
+        as     (into (avl/sorted-set) elems)
+        os     (core/ordered-set elems)]
+    (run-cases
+      {:sorted-set  #(reduce (fn [s x] (disj s x)) ss to-del)
+       :data-avl    #(reduce (fn [s x] (disj s x)) as to-del)
+       :ordered-set #(reduce (fn [s x] (disj s x)) os to-del)})))
+
+(defn bench-set-lookup [n & {:keys [num-lookups] :or {num-lookups 10000}}]
+  (let [elems (generate-elements n)
+        {:keys [sorted-set data-avl ordered-set]} (build-set-variants elems)
+        ^ints ks (generate-lookup-keys n num-lookups)]
+    (run-cases
+      {:sorted-set  #(dotimes [i num-lookups] (contains? sorted-set (aget ks i)))
+       :data-avl    #(dotimes [i num-lookups] (contains? data-avl (aget ks i)))
+       :ordered-set #(dotimes [i num-lookups] (contains? ordered-set (aget ks i)))})))
+
+(defn bench-set-iteration [n]
+  (let [elems (generate-elements n)
+        ss    (into (sorted-set) elems)
+        as    (into (avl/sorted-set) elems)
+        os    (core/ordered-set elems)]
+    (run-cases
+      {:sorted-set  #(reduce (fn [^long acc x] (+ acc (long x))) 0 ss)
+       :data-avl    #(reduce (fn [^long acc x] (+ acc (long x))) 0 as)
+       :ordered-set #(reduce (fn [^long acc x] (+ acc (long x))) 0 os)})))
+
+(defn bench-set-equality [n]
+  (let [{equal :equal
+         different :different
+         size-different :size-different} (set-comparison-workload n)
+        cases {:equal equal
+               :different different
+               :size-different size-different}]
+    (into {}
+          (for [[case-key {:keys [left right]}] cases
+                :let [hs1 (:hash-set left), hs2 (:hash-set right)
+                      as1 (:data-avl left), as2 (:data-avl right)
+                      os1 (:ordered-set left), os2 (:ordered-set right)]]
+            [case-key
+             (run-cases
+               {:hash-set    #(= hs1 hs2)
+                :sorted-set  #(= (:sorted-set left) (:sorted-set right))
+                :data-avl    #(= as1 as2)
+                :ordered-set #(= os1 os2)})]))))
+
+(defn bench-set-fold [n]
+  (let [elems (generate-elements n)
+        {:keys [sorted-set data-avl ordered-set]} (build-set-variants elems)
+        sum-elems (fn [^long acc x] (+ acc (long x)))]
+    (run-cases
+      {:sorted-set-fold  #(r/fold + sum-elems sorted-set)
+       :data-avl-fold    #(r/fold + sum-elems data-avl)
+       :ordered-set-fold #(r/fold + sum-elems ordered-set)})))
+
+(defn bench-set-fold-freq [n]
+  (let [elems (generate-elements n)
+        {:keys [sets combinef reducef]} (fold-frequency-workload elems)
+        {:keys [sorted-set data-avl ordered-set]} sets]
+    (run-cases
+      {:sorted-set-fold-freq  #(r/fold combinef reducef sorted-set)
+       :data-avl-fold-freq    #(r/fold combinef reducef data-avl)
+       :ordered-set-fold-freq #(r/fold combinef reducef ordered-set)})))
+
+(defn bench-set-reduce-vs-fold-freq [n]
+  (let [elems (generate-elements n)
+        {:keys [sets combinef reducef]} (fold-frequency-workload elems)
+        {:keys [sorted-set data-avl ordered-set]} sets]
+    (run-cases
+      {:sorted-set-reduce-freq  #(reduce reducef {} sorted-set)
+       :sorted-set-fold-freq    #(r/fold combinef reducef sorted-set)
+       :data-avl-reduce-freq    #(reduce reducef {} data-avl)
+       :data-avl-fold-freq      #(r/fold combinef reducef data-avl)
+       :ordered-set-reduce-freq #(reduce reducef {} ordered-set)
+       :ordered-set-fold-freq   #(r/fold combinef reducef ordered-set)})))
+
+(defn bench-set-union [n]
+  (let [{left :left right :right} (overlapping-set-variants n)
+        hs1 (:hash-set left), hs2 (:hash-set right)
+        ss1 (:sorted-set left), ss2 (:sorted-set right)
+        as1 (:data-avl left), as2 (:data-avl right)
+        os1 (:ordered-set left), os2 (:ordered-set right)]
+    (run-cases
+      {:clojure-set #(cset/union hs1 hs2)
+       :sorted-set  #(cset/union ss1 ss2)
+       :data-avl    #(cset/union as1 as2)
+       :ordered-set #(core/union os1 os2)})))
+
+(defn bench-set-intersection [n]
+  (let [{left :left right :right} (overlapping-set-variants n)
+        hs1 (:hash-set left), hs2 (:hash-set right)
+        ss1 (:sorted-set left), ss2 (:sorted-set right)
+        as1 (:data-avl left), as2 (:data-avl right)
+        os1 (:ordered-set left), os2 (:ordered-set right)]
+    (run-cases
+      {:clojure-set #(cset/intersection hs1 hs2)
+       :sorted-set  #(cset/intersection ss1 ss2)
+       :data-avl    #(cset/intersection as1 as2)
+       :ordered-set #(core/intersection os1 os2)})))
+
+(defn bench-set-difference [n]
+  (let [{left :left right :right} (overlapping-set-variants n)
+        hs1 (:hash-set left), hs2 (:hash-set right)
+        ss1 (:sorted-set left), ss2 (:sorted-set right)
+        as1 (:data-avl left), as2 (:data-avl right)
+        os1 (:ordered-set left), os2 (:ordered-set right)]
+    (run-cases
+      {:clojure-set #(cset/difference hs1 hs2)
+       :sorted-set  #(cset/difference ss1 ss2)
+       :data-avl    #(cset/difference as1 as2)
+       :ordered-set #(core/difference os1 os2)})))
+
+(defn bench-first-last [n & {:keys [num-ops] :or {num-ops 1000}}]
+  (let [elems (range n)
+        ss    (into (sorted-set) elems)
+        as    (into (avl/sorted-set) elems)
+        os    (core/ordered-set elems)]
+    (run-cases
+      {:sorted-set-first  #(dotimes [_ num-ops] (first ss))
+       :sorted-set-last   #(dotimes [_ num-ops] (last ss))
+       :data-avl-first    #(dotimes [_ num-ops] (first as))
+       :data-avl-last     #(dotimes [_ num-ops] (last as))
+       :ordered-set-first #(dotimes [_ num-ops] (.first ^java.util.SortedSet os))
+       :ordered-set-last  #(dotimes [_ num-ops] (.last ^java.util.SortedSet os))})))
+
+(defn bench-rank-access [n & {:keys [num-lookups] :or {num-lookups 10000}}]
+  (let [elems (generate-elements n)
+        as    (into (avl/sorted-set) elems)
+        os    (core/ordered-set elems)
+        ^ints idxs (generate-lookup-keys n num-lookups)]
+    (run-cases
+      {:data-avl    #(dotimes [i num-lookups] (nth as (aget idxs i)))
+       :ordered-set #(dotimes [i num-lookups] (nth os (aget idxs i)))})))
+
+(defn bench-rank-lookup [n & {:keys [num-lookups] :or {num-lookups 10000}}]
+  (let [elems (generate-elements n)
+        as    (into (avl/sorted-set) elems)
+        os    (core/ordered-set elems)
+        ^ints ks (generate-lookup-keys n num-lookups)]
+    (run-cases
+      {:data-avl    #(dotimes [i num-lookups] (avl/rank-of as (aget ks i)))
+       :ordered-set #(dotimes [i num-lookups] (core/rank os (aget ks i)))})))
+
+(defn bench-split [n & {:keys [num-ops] :or {num-ops 100}}]
+  (let [{:keys [data-avl ordered-set keys]} (split-workload n num-ops)
+        ^ints ks keys]
+    (run-cases
+      {:data-avl    #(dotimes [i num-ops] (avl/split-key (aget ks i) data-avl))
+       :ordered-set #(dotimes [i num-ops] (core/split-key (aget ks i) ordered-set))})))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Long-Specialized Set Benchmarks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- make-long-sets
+  "Build test sets with Long elements for all four contenders."
+  [n]
+  (let [elems (vec (shuffle (range n)))]
+    {:hash-set     (into #{} elems)
+     :sorted-set   (into (sorted-set) elems)
+     :data-avl     (into (avl/sorted-set) elems)
+     :long-ordered (core/long-ordered-set elems)}))
+
+(defn- make-long-set-pair
+  "Build overlapping Long set pairs for set algebra benchmarks.
+  Matches the standard overlapping-set-elements workload: two sets of
+  size n with 50% overlap."
+  [n]
+  (let [elems1 (range 0 n)
+        elems2 (range (quot n 2) (+ n (quot n 2)))]
+    {:left  {:hash-set     (into #{} elems1)
+             :sorted-set   (into (sorted-set) elems1)
+             :data-avl     (into (avl/sorted-set) elems1)
+             :long-ordered (core/long-ordered-set elems1)}
+     :right {:hash-set     (into #{} elems2)
+             :sorted-set   (into (sorted-set) elems2)
+             :data-avl     (into (avl/sorted-set) elems2)
+             :long-ordered (core/long-ordered-set elems2)}}))
+
+(defn bench-long-construction [n]
+  (let [elems (vec (shuffle (range n)))]
+    (run-cases
+      {:hash-set     #(into #{} elems)
+       :sorted-set   #(into (sorted-set) elems)
+       :data-avl     #(into (avl/sorted-set) elems)
+       :long-ordered #(core/long-ordered-set elems)})))
+
+(defn bench-long-lookup [n & {:keys [num-lookups] :or {num-lookups 10000}}]
+  (let [{:keys [hash-set sorted-set data-avl long-ordered]} (make-long-sets n)
+        ^longs ks (long-array (repeatedly num-lookups #(rand-int n)))]
+    (run-cases
+      {:hash-set     #(dotimes [i num-lookups] (contains? hash-set (aget ks i)))
+       :sorted-set   #(dotimes [i num-lookups] (contains? sorted-set (aget ks i)))
+       :data-avl     #(dotimes [i num-lookups] (contains? data-avl (aget ks i)))
+       :long-ordered #(dotimes [i num-lookups] (contains? long-ordered (aget ks i)))})))
+
+(defn bench-long-insert [n]
+  (let [elems (vec (shuffle (range n)))]
+    (run-cases
+      {:sorted-set   #(reduce conj (sorted-set) elems)
+       :data-avl     #(reduce conj (avl/sorted-set) elems)
+       :long-ordered #(reduce conj (core/long-ordered-set) elems)})))
+
+(defn bench-long-delete [n]
+  (let [{:keys [sorted-set data-avl long-ordered]} (make-long-sets n)
+        to-del (vec (take (quot n 2) (shuffle (range n))))]
+    (run-cases
+      {:sorted-set   #(reduce disj sorted-set to-del)
+       :data-avl     #(reduce disj data-avl to-del)
+       :long-ordered #(reduce disj long-ordered to-del)})))
+
+(defn bench-long-iteration [n]
+  (let [{:keys [sorted-set data-avl long-ordered]} (make-long-sets n)]
+    (run-cases
+      {:sorted-set   #(reduce (fn [^long acc x] (+ acc (long x))) 0 sorted-set)
+       :data-avl     #(reduce (fn [^long acc x] (+ acc (long x))) 0 data-avl)
+       :long-ordered #(reduce (fn [^long acc x] (+ acc (long x))) 0 long-ordered)})))
+
+(defn bench-long-fold [n]
+  (let [{:keys [sorted-set data-avl long-ordered]} (make-long-sets n)
+        sum-fn (fn [^long acc x] (+ acc (long x)))]
+    (run-cases
+      {:sorted-set-fold   #(r/fold + sum-fn sorted-set)
+       :data-avl-fold     #(r/fold + sum-fn data-avl)
+       :long-ordered-fold #(r/fold + sum-fn long-ordered)})))
+
+(defn bench-long-union [n]
+  (let [{left :left right :right} (make-long-set-pair n)]
+    (run-cases
+      {:clojure-set  #(cset/union (:hash-set left) (:hash-set right))
+       :sorted-set   #(cset/union (:sorted-set left) (:sorted-set right))
+       :data-avl     #(cset/union (:data-avl left) (:data-avl right))
+       :long-ordered #(core/union (:long-ordered left) (:long-ordered right))})))
+
+(defn bench-long-intersection [n]
+  (let [{left :left right :right} (make-long-set-pair n)]
+    (run-cases
+      {:clojure-set  #(cset/intersection (:hash-set left) (:hash-set right))
+       :sorted-set   #(cset/intersection (:sorted-set left) (:sorted-set right))
+       :data-avl     #(cset/intersection (:data-avl left) (:data-avl right))
+       :long-ordered #(core/intersection (:long-ordered left) (:long-ordered right))})))
+
+(defn bench-long-difference [n]
+  (let [{left :left right :right} (make-long-set-pair n)]
+    (run-cases
+      {:clojure-set  #(cset/difference (:hash-set left) (:hash-set right))
+       :sorted-set   #(cset/difference (:sorted-set left) (:sorted-set right))
+       :data-avl     #(cset/difference (:data-avl left) (:data-avl right))
+       :long-ordered #(core/difference (:long-ordered left) (:long-ordered right))})))
+
+(defn bench-long-split [n & {:keys [num-ops] :or {num-ops 100}}]
+  (let [as (into (avl/sorted-set) (range n))
+        ls (core/long-ordered-set (range n))
+        ^longs ks (long-array (repeatedly num-ops #(rand-int n)))]
+    (run-cases
+      {:data-avl     #(dotimes [i num-ops] (avl/split-key (aget ks i) as))
+       :long-ordered #(dotimes [i num-ops] (core/split-key (aget ks i) ls))})))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; String Benchmarks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def ^:private string-cmp
+  (order/compare-by #(neg? (compare (str %1) (str %2)))))
+
+(defn bench-string-construction [n]
+  (let [ks    (generate-string-keys n)
+        pairs (mapv (fn [k] [k k]) ks)
+        cmp   #(compare (str %1) (str %2))]
+    (run-cases
+      {:sorted-map-by #(into (sorted-map-by cmp) pairs)
+       :data-avl      #(into (avl/sorted-map-by cmp) pairs)
+       :ordered-map   #(core/ordered-map-with string-cmp pairs)})))
+
+(defn bench-string-lookup [n & {:keys [num-lookups] :or {num-lookups 10000}}]
+  (let [ks    (generate-string-keys n)
+        pairs (mapv (fn [k] [k k]) ks)
+        cmp   #(compare (str %1) (str %2))
+        {:keys [sorted-map-by data-avl ordered-map]} (build-string-map-variants pairs cmp string-cmp)
+        ^objects look (object-array (repeatedly num-lookups #(nth ks (rand-int n))))]
+    (run-cases
+      {:sorted-map-by #(dotimes [i num-lookups] (get sorted-map-by (aget look i)))
+       :data-avl      #(dotimes [i num-lookups] (get data-avl (aget look i)))
+       :ordered-map   #(dotimes [i num-lookups] (ordered-map (aget look i)))})))
+
+(defn bench-string-iteration [n]
+  (let [ks    (generate-string-keys n)
+        pairs (mapv (fn [k] [k k]) ks)
+        cmp   #(compare (str %1) (str %2))
+        sm    (into (sorted-map-by cmp) pairs)
+        am    (into (avl/sorted-map-by cmp) pairs)
+        om    (core/ordered-map-with string-cmp pairs)]
+    (run-cases
+      {:sorted-map-by #(reduce (fn [^long acc [k _]] (+ acc (long (hash k)))) 0 sm)
+       :data-avl      #(reduce (fn [^long acc [k _]] (+ acc (long (hash k)))) 0 am)
+       :ordered-map   #(reduce (fn [^long acc [k _]] (+ acc (long (hash k)))) 0 om)})))
+
+(defn- make-string-set-pair
+  "Build overlapping string set pairs for set algebra benchmarks.
+  Two sets of size n with 50% overlap, matching the standard workload."
+  [n]
+  (let [ks1 (generate-string-keys n)
+        half (quot n 2)
+        ks2 (into (subvec ks1 half) (generate-string-keys half))
+        cmp #(compare (str %1) (str %2))]
+    {:left  {:sorted-set   (into (sorted-set-by cmp) ks1)
+             :data-avl     (into (avl/sorted-set-by cmp) ks1)
+             :string-ordered (core/string-ordered-set ks1)}
+     :right {:sorted-set   (into (sorted-set-by cmp) ks2)
+             :data-avl     (into (avl/sorted-set-by cmp) ks2)
+             :string-ordered (core/string-ordered-set ks2)}}))
+
+(defn bench-string-set-construction [n]
+  (let [ks  (generate-string-keys n)
+        cmp #(compare (str %1) (str %2))]
+    (run-cases
+      {:sorted-set-by   #(into (sorted-set-by cmp) ks)
+       :data-avl        #(into (avl/sorted-set-by cmp) ks)
+       :string-ordered  #(core/string-ordered-set ks)})))
+
+(defn bench-string-set-lookup [n & {:keys [num-lookups] :or {num-lookups 10000}}]
+  (let [ks   (generate-string-keys n)
+        cmp  #(compare (str %1) (str %2))
+        ss   (into (sorted-set-by cmp) ks)
+        as   (into (avl/sorted-set-by cmp) ks)
+        os   (core/string-ordered-set ks)
+        ^objects look (object-array (repeatedly num-lookups #(nth ks (rand-int n))))]
+    (run-cases
+      {:sorted-set-by   #(dotimes [i num-lookups] (contains? ss (aget look i)))
+       :data-avl        #(dotimes [i num-lookups] (contains? as (aget look i)))
+       :string-ordered  #(dotimes [i num-lookups] (contains? os (aget look i)))})))
+
+(defn bench-string-set-union [n]
+  (let [{left :left right :right} (make-string-set-pair n)]
+    (run-cases
+      {:sorted-set-by   #(cset/union (:sorted-set left) (:sorted-set right))
+       :data-avl        #(cset/union (:data-avl left) (:data-avl right))
+       :string-ordered  #(core/union (:string-ordered left) (:string-ordered right))})))
+
+(defn bench-string-set-intersection [n]
+  (let [{left :left right :right} (make-string-set-pair n)]
+    (run-cases
+      {:sorted-set-by   #(cset/intersection (:sorted-set left) (:sorted-set right))
+       :data-avl        #(cset/intersection (:data-avl left) (:data-avl right))
+       :string-ordered  #(core/intersection (:string-ordered left) (:string-ordered right))})))
+
+(defn bench-string-set-difference [n]
+  (let [{left :left right :right} (make-string-set-pair n)]
+    (run-cases
+      {:sorted-set-by   #(cset/difference (:sorted-set left) (:sorted-set right))
+       :data-avl        #(cset/difference (:data-avl left) (:data-avl right))
+       :string-ordered  #(core/difference (:string-ordered left) (:string-ordered right))})))
+
+(defn bench-interval-construction [n]
+  (let [intervals (mapv (fn [i] [(* i 2) (inc (* i 2))]) (shuffle (range n)))]
+    (run-cases
+      {:interval-set #(core/interval-set intervals)})))
+
+(defn bench-interval-map-construction [n]
+  (let [intervals (mapv (fn [i] [[(* i 2) (inc (* i 2))] (str "val-" i)])
+                        (shuffle (range n)))]
+    (run-cases
+      {:interval-map #(core/interval-map (into {} intervals))})))
+
+(defn bench-interval-lookup [n & {:keys [num-lookups] :or {num-lookups 10000}}]
+  (let [intervals (mapv (fn [i] [[(* i 2) (inc (* i 2))] (str "val-" i)])
+                        (range n))
+        im        (core/interval-map (into {} intervals))
+        max-point (* 2 n)
+        ^ints points (int-array (repeatedly num-lookups #(rand-int max-point)))]
+    (run-cases
+      {:interval-map #(dotimes [i num-lookups] (im (aget points i)))})))
+
+(defn bench-interval-fold [n]
+  (let [intervals (mapv (fn [i] [(* i 2) (inc (* i 2))]) (range n))
+        is        (core/interval-set intervals)
+        sum-intervals (fn [^long acc interval] (+ acc (long (first interval))))]
+    (run-cases
+      {:interval-set-reduce #(reduce sum-intervals 0 is)
+       :interval-set-fold   #(r/fold + sum-intervals is)})))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Rope Benchmarks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-rope-concat [n]
+  (let [piece-size ropetree/+target-chunk-size+
+        pieces     (->> (range n)
+                     (partition-all piece-size)
+                     (mapv vec))
+        rope-parts (mapv core/rope pieces)
+        vec-parts  pieces]
+    (run-cases
+      {:rope   #(apply core/rope-concat rope-parts)
+       :vector #(reduce into [] vec-parts)})))
+
+(defn bench-rope-splice [n]
+  (let [r     (core/rope (range n))
+        v     (vec (range n))
+        mid   (quot n 2)
+        start (max 0 (- mid 16))
+        end   (min n (+ mid 16))
+        ins   (vec (range 32))]
+    (run-cases
+      {:rope   #(core/rope-splice r start end ins)
+       :vector #(vec (concat (subvec v 0 start) ins (subvec v end)))})))
+
+(defn bench-rope-repeated-edits [n]
+  (let [r     (core/rope (range n))
+        v     (vec (range n))
+        rng   (java.util.Random. 42)
+        nops  200
+        idxs  (vec (repeatedly nops #(.nextInt rng (max 1 n))))
+        ins   (vec (range nops))]
+    (run-cases
+      {:rope   #(loop [r r, i 0]
+                  (if (< i nops)
+                    (let [pos (rem (nth idxs i) (count r))]
+                      (recur (core/rope-splice r pos (min (+ pos 5) (count r)) [(nth ins i)])
+                        (inc i)))
+                    r))
+       :vector #(loop [v v, i 0]
+                  (if (< i nops)
+                    (let [pos (rem (nth idxs i) (count v))]
+                      (recur (vec (concat (subvec v 0 pos) [(nth ins i)] (subvec v (min (+ pos 5) (count v)))))
+                        (inc i)))
+                    v))})))
+
+(defn bench-rope-reduce [n]
+  (let [r (core/rope (range n))
+        v (vec (range n))]
+    (run-cases
+      {:rope   #(reduce + 0 r)
+       :vector #(reduce + 0 v)})))
+
+(defn bench-rope-nth [n & {:keys [num-ops] :or {num-ops 1000}}]
+  (let [r    (core/rope (range n))
+        v    (vec (range n))
+        rng  (java.util.Random. 42)
+        idxs (int-array (repeatedly num-ops #(.nextInt rng (max 1 n))))]
+    (run-cases
+      {:rope   #(areduce idxs i acc nil (nth r (aget idxs i)))
+       :vector #(areduce idxs i acc nil (nth v (aget idxs i)))})))
+
+(defn bench-rope-chunk-iteration [n]
+  (let [r (core/rope (range n))
+        v (vec (range n))]
+    (run-cases
+      {:rope   #(reduce (fn [_ chunk] (reduce (fn [acc x] x) nil chunk))
+                         nil (core/rope-chunks r))
+       :vector #(reduce (fn [acc x] x) nil v)})))
+
+(defn bench-rope-fold-sum [n]
+  (let [r (core/rope (range n))
+        v (vec (range n))]
+    (run-cases
+      {:rope   #(r/fold + r)
+       :vector #(r/fold + v)})))
+
+(defn bench-rope-fold-freq [n]
+  (let [r         (core/rope (range n))
+        v         (vec (range n))
+        combinef  (fn ([] {}) ([m1 m2] (merge-with + m1 m2)))
+        reducef   (fn [m x] (update m (rem (long x) 100) (fnil inc 0)))]
+    (run-cases
+      {:rope   #(r/fold combinef reducef r)
+       :vector #(r/fold combinef reducef v)})))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Suite Runners
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def ^:private wins-benchmark-specs
+  [[:set-construction bench-set-construction]
+   [:map-construction bench-map-construction]
+   [:set-fold bench-set-fold]
+   [:set-fold-freq bench-set-fold-freq]
+   [:set-reduce-vs-fold-freq bench-set-reduce-vs-fold-freq]
+   [:map-fold bench-map-fold]
+   [:set-union bench-set-union]
+   [:set-intersection bench-set-intersection]
+   [:set-difference bench-set-difference]
+   [:split bench-split]
+   {:key :first-last :fn bench-first-last :when #(<= % 100000)}
+   [:rank-access bench-rank-access]
+   [:rope-concat bench-rope-concat]
+   [:rope-splice bench-rope-splice]
+   [:rope-repeated-edits bench-rope-repeated-edits]
+   [:rope-reduce bench-rope-reduce]
+   {:key :rope-nth :fn bench-rope-nth :when #(<= % 500000)}
+   [:rope-chunk-iteration bench-rope-chunk-iteration]
+   [:rope-fold-sum bench-rope-fold-sum]
+   [:rope-fold-freq bench-rope-fold-freq]
+   [:long-construction bench-long-construction]
+   [:long-lookup bench-long-lookup]
+   [:long-union bench-long-union]
+   [:long-intersection bench-long-intersection]
+   [:long-difference bench-long-difference]])
+
+(def ^:private readme-benchmark-specs
+  [[:set-construction bench-set-construction]
+   [:set-lookup bench-set-lookup]
+   [:set-union bench-set-union]
+   [:set-intersection bench-set-intersection]
+   [:set-difference bench-set-difference]
+   [:set-fold bench-set-fold]
+   [:set-fold-freq bench-set-fold-freq]
+   [:set-reduce-vs-fold-freq bench-set-reduce-vs-fold-freq]
+   [:split bench-split]])
+
+(def ^:private all-benchmark-specs
+  [[:map-construction bench-map-construction]
+   [:map-insert bench-map-insert]
+   [:map-delete bench-map-delete]
+   [:map-lookup bench-map-lookup]
+   [:map-iteration bench-map-iteration]
+   [:map-fold bench-map-fold]
+   [:set-construction bench-set-construction]
+   [:set-insert bench-set-insert]
+   [:set-delete bench-set-delete]
+   [:set-lookup bench-set-lookup]
+   [:set-iteration bench-set-iteration]
+   [:set-equality bench-set-equality]
+   [:set-fold bench-set-fold]
+   [:set-fold-freq bench-set-fold-freq]
+   [:set-reduce-vs-fold-freq bench-set-reduce-vs-fold-freq]
+   [:set-union bench-set-union]
+   [:set-intersection bench-set-intersection]
+   [:set-difference bench-set-difference]
+   [:rank-access bench-rank-access]
+   [:rank-lookup bench-rank-lookup]
+   [:split bench-split]
+   {:key :first-last :fn bench-first-last :when #(<= % 100000)}
+   [:string-construction bench-string-construction]
+   [:string-lookup bench-string-lookup]
+   [:string-iteration bench-string-iteration]
+   [:interval-construction bench-interval-construction]
+   [:interval-map-construction bench-interval-map-construction]
+   [:interval-lookup bench-interval-lookup]
+   [:interval-fold bench-interval-fold]
+   [:rope-concat bench-rope-concat]
+   [:rope-splice bench-rope-splice]
+   [:rope-repeated-edits bench-rope-repeated-edits]
+   [:rope-reduce bench-rope-reduce]
+   {:key :rope-nth :fn bench-rope-nth :when #(<= % 500000)}
+   [:rope-chunk-iteration bench-rope-chunk-iteration]
+   [:rope-fold-sum bench-rope-fold-sum]
+   [:rope-fold-freq bench-rope-fold-freq]
+   [:long-construction bench-long-construction]
+   [:long-lookup bench-long-lookup]
+   [:long-insert bench-long-insert]
+   [:long-delete bench-long-delete]
+   [:long-iteration bench-long-iteration]
+   [:long-fold bench-long-fold]
+   [:long-union bench-long-union]
+   [:long-intersection bench-long-intersection]
+   [:long-difference bench-long-difference]
+   [:long-split bench-long-split]
+   [:string-set-construction bench-string-set-construction]
+   [:string-set-lookup bench-string-set-lookup]
+   [:string-set-union bench-string-set-union]
+   [:string-set-intersection bench-string-set-intersection]
+   [:string-set-difference bench-string-set-difference]])
+
+(defn run-wins-benchmarks
+  "Run benchmarks focused on where ordered-collections wins."
+  [sizes]
+  (let [results (atom {})]
+    (doseq [n sizes]
+      (run-benchmarks-for-size! results n wins-benchmark-specs))
+
+    @results))
+
+(defn run-readme-benchmarks
+  "Run only the benchmarks used in README tables (~5 min for 3 sizes)."
+  [sizes]
+  (let [results (atom {})]
+    (doseq [n sizes]
+      (run-benchmarks-for-size! results n readme-benchmark-specs))
+    @results))
+
+(defn run-all-benchmarks
+  "Run all benchmarks comprehensively."
+  [sizes]
+  (let [results (atom {})]
+    (doseq [n sizes]
+      (run-benchmarks-for-size! results n all-benchmark-specs))
+
+    @results))
+
+(defn- safe-command-output [& args]
+  (try
+    (let [{:keys [exit out]} (apply sh/sh args)]
+      (when (zero? exit)
+        (str/trim out)))
+    (catch Throwable _
+      nil)))
+
+(defn- git-info []
+  {:git-rev       (safe-command-output "git" "rev-parse" "HEAD")
+   :git-branch    (safe-command-output "git" "rev-parse" "--abbrev-ref" "HEAD")
+   :git-dirty?    (boolean (seq (safe-command-output "git" "status" "--porcelain")))
+   :git-describe  (safe-command-output "git" "describe" "--always" "--dirty" "--tags")})
+
+(defn- project-version []
+  (when-let [[_ version] (re-find #"defproject\s+[^\s]+\s+\"([^\"]+)\"" (slurp "project.clj"))]
+    version))
+
+(defn- lein-version []
+  (safe-command-output "lein" "version"))
+
+(defn- runtime-info []
+  (let [rt          (Runtime/getRuntime)
+        rt-mx       (ManagementFactory/getRuntimeMXBean)
+        mem-mx      (ManagementFactory/getMemoryMXBean)
+        heap-usage  (.getHeapMemoryUsage mem-mx)
+        non-heap    (.getNonHeapMemoryUsage mem-mx)]
+    {:clojure               (clojure-version)
+     :project-version       (project-version)
+     :lein-version          (lein-version)
+     :hostname              (try (.getHostName (InetAddress/getLocalHost))
+                                 (catch Throwable _ nil))
+     :user-timezone         (.getID (java.util.TimeZone/getDefault))
+     :java-version          (System/getProperty "java.version")
+     :java-vendor           (System/getProperty "java.vendor")
+     :java-vm               (System/getProperty "java.vm.name")
+     :java-vm-vendor        (System/getProperty "java.vm.vendor")
+     :os-name               (System/getProperty "os.name")
+     :os-version            (System/getProperty "os.version")
+     :os-arch               (System/getProperty "os.arch")
+     :processors            (.availableProcessors rt)
+     :max-memory-mb         (quot (.maxMemory rt) (* 1024 1024))
+     :total-memory-mb       (quot (.totalMemory rt) (* 1024 1024))
+     :free-memory-mb        (quot (.freeMemory rt) (* 1024 1024))
+     :heap-init-mb          (quot (.getInit heap-usage) (* 1024 1024))
+     :heap-used-mb          (quot (.getUsed heap-usage) (* 1024 1024))
+     :heap-committed-mb     (quot (.getCommitted heap-usage) (* 1024 1024))
+     :heap-max-mb           (quot (.getMax heap-usage) (* 1024 1024))
+     :non-heap-used-mb      (quot (.getUsed non-heap) (* 1024 1024))
+     :jvm-input-args        (vec (.getInputArguments rt-mx))
+     :start-time-ms         (.getStartTime rt-mx)
+     :uptime-ms             (.getUptime rt-mx)}))
+
+(defn system-info []
+  (merge (runtime-info) (git-info)))
+
+(defn write-results [results output-file opts started-at]
+  (let [finished-at   (Instant/now)
+        full-results  {:artifact-version 3
+                       :timestamp        (str finished-at)
+                       :started-at       (str started-at)
+                       :duration-ms      (.toMillis (Duration/between started-at finished-at))
+                       :cwd              (.getAbsolutePath (io/file "."))
+                       :system           (system-info)
+                       :mode             (cond
+                                           (:readme opts) :readme
+                                           (:quick opts)  :quick
+                                           :else          :full)
+                       :opts             (dissoc opts :args)
+                       :argv             (:args opts)
+                       :sizes            (:sizes opts)
+                       :benchmarks       results}]
+    (io/make-parents output-file)
+    (spit output-file (with-out-str (binding [pp/*print-right-margin* 120]
+                                      (pp/pprint full-results))))
+    (println)
+    (println (str "Results written to: " output-file))))
+
+(defn- leaf-bench-result? [x]
+  (and (map? x) (contains? x :mean-ns)))
+
+(defn- print-summary-node [indent m]
+  (doseq [[k v] (sort-by key m)]
+    (if (leaf-bench-result? v)
+      (println (str indent (name k) ": " (format-time (:mean-ns v))))
+      (do
+        (println (str indent (name k) ":"))
+        (print-summary-node (str indent "  ") v)))))
+
+(defn print-summary [results]
+  (println)
+  (println "===== SUMMARY =====")
+  (println)
+  (doseq [[n benches] (sort-by key results)]
+    (println (str "N = " n))
+    (doseq [[bench-name bench-results] (sort-by key benches)]
+      (println (str "  " (name bench-name) ":"))
+      (print-summary-node "    " bench-results))
+    (println)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Main Entry Point
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn parse-args [args]
+  (let [base (parse-standard-args args sizes-default sizes-default sizes-full)]
+    (assoc base :readme (bu/has-flag? args "--readme")
+                :args   (vec args))))
+
+(defn print-usage []
+  (println "Usage: lein bench [options]")
+  (println)
+  (println "Options:")
+  (println "  --readme           README table benchmarks only (~5 min for --full)")
+  (println "  --full             N=10K,100K,500K")
+  (println "  --sizes N,N,...    Custom sizes (comma-separated)")
+  (println "  --help             Show this help")
+  (println)
+  (println "Default: N=100K (~3 min)")
+  (println "Output is written to bench-results/<timestamp>.edn"))
+
+(defn -main [& args]
+  (let [opts (parse-args args)]
+    (if (:help opts)
+      (print-usage)
+      (let [output-dir "bench-results"
+            output-file (str output-dir "/" (timestamp) ".edn")
+            runner (if (:readme opts) run-readme-benchmarks run-all-benchmarks)
+            started-at (Instant/now)]
+        (println)
+        (println "========================================================================")
+        (println "  Ordered Collections Benchmark Suite")
+        (println "========================================================================")
+        (println)
+        (println "System info:")
+        (doseq [[k v] (system-info)]
+          (println (str "  " (name k) ": " v)))
+        (println)
+        (when (:readme opts)
+          (println "Mode: README tables only"))
+        (println (str "Sizes: " (pr-str (:sizes opts))))
+        (println (str "Output: " output-file))
+        (println)
+
+        (let [results (runner (:sizes opts))]
+          (print-summary results)
+          (write-results results output-file opts started-at))
+
+        (println)
+        (println "Benchmark suite complete.")))
+    (shutdown-agents)))
diff --git a/test/ordered_collections/bench_utils.clj b/test/ordered_collections/bench_utils.clj
new file mode 100644
index 0000000..25ae813
--- /dev/null
+++ b/test/ordered_collections/bench_utils.clj
@@ -0,0 +1,227 @@
+(ns ordered-collections.bench-utils
+  "Shared benchmarking infrastructure.
+
+   Provides:
+   1. Simple bench macro for quick iteration (no external deps)
+   2. Test data generators
+   3. Shared benchmark workload/build helpers
+   4. Table printing utilities
+   5. CLI argument parsing helpers
+
+   Usage:
+     (:require [ordered-collections.bench-utils :as bu])"
+  (:require [clojure.data.avl :as avl]
+            [clojure.string :as str]
+            [ordered-collections.core :as oc]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Time Formatting
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn format-ns
+  "Format nanoseconds as human-readable string."
+  [ns]
+  (cond
+    (>= ns 1e9) (format "%.2fs" (/ ns 1e9))
+    (>= ns 1e6) (format "%.2fms" (/ ns 1e6))
+    (>= ns 1e3) (format "%.1fµs" (/ ns 1e3))
+    :else       (format "%dns" (long ns))))
+
+(defn format-result
+  "Format [mean std] pair as string."
+  [[mean std]]
+  (str (format-ns mean) " ± " (format-ns std)))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Simple Benchmarking (no external deps)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmacro bench
+  "Run body warmup-n times, then measure-n times, return [mean-ns std-ns].
+
+   For accurate results, warmup-n should be at least 15-20 to allow
+   JIT compilation. Lower values will show artificially slow times."
+  [warmup-n measure-n & body]
+  `(do
+     (dotimes [_# ~warmup-n] ~@body)
+     (System/gc)
+     (Thread/sleep 100)
+     (let [times# (long-array ~measure-n)]
+       (dotimes [i# ~measure-n]
+         (let [t0# (System/nanoTime)
+               _#  ~@body
+               t1# (System/nanoTime)]
+           (aset times# i# (- t1# t0#))))
+       (let [n#    (alength times#)
+             sum#  (areduce times# i# acc# 0.0 (+ acc# (aget times# i#)))
+             mean# (/ sum# n#)
+             var#  (areduce times# i# acc# 0.0
+                     (let [d# (- (aget times# i#) mean#)]
+                       (+ acc# (* d# d#))))
+             std#  (Math/sqrt (/ var# n#))]
+         [(long mean#) (long std#)]))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Test Data Generation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn generate-pairs
+  "Generate n random [k v] pairs with integer keys."
+  [n]
+  (mapv (fn [k] [k (str "value-" k)]) (shuffle (range n))))
+
+(defn generate-elements
+  "Generate n shuffled integers [0, n)."
+  [n]
+  (vec (shuffle (range n))))
+
+(defn generate-lookup-keys
+  "Generate int-array of num-lookups random keys in [0, n)."
+  ^ints [n num-lookups]
+  (int-array (repeatedly num-lookups #(rand-int n))))
+
+(defn generate-string-keys
+  "Generate n formatted string keys."
+  [n]
+  (mapv #(format "key-%08d" %) (shuffle (range n))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Shared Benchmark Workloads
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn build-map-variants
+  "Build the standard map competitors for the given key/value pairs."
+  [pairs]
+  {:sorted-map  (into (sorted-map) pairs)
+   :data-avl    (into (avl/sorted-map) pairs)
+   :ordered-map (oc/ordered-map pairs)})
+
+(defn build-set-variants
+  "Build the standard set competitors for the given elements."
+  [elems]
+  {:hash-set    (set elems)
+   :sorted-set  (into (sorted-set) elems)
+   :data-avl    (into (avl/sorted-set) elems)
+   :ordered-set (oc/ordered-set elems)})
+
+(defn build-string-map-variants
+  "Build the standard string-key map competitors for [k v] pairs."
+  [pairs cmp ordered-cmp]
+  {:sorted-map-by (into (sorted-map-by cmp) pairs)
+   :data-avl      (into (avl/sorted-map-by cmp) pairs)
+   :ordered-map   (oc/ordered-map-with ordered-cmp pairs)})
+
+(defn overlapping-set-elements
+  "Generate two element ranges of size n with 50% overlap."
+  [n]
+  [(range 0 n)
+   (range (quot n 2) (+ n (quot n 2)))])
+
+(defn overlapping-set-variants
+  "Build the standard set competitors for the 50%-overlap set-op workload."
+  [n]
+  (let [[elems1 elems2] (overlapping-set-elements n)]
+    {:left  (build-set-variants elems1)
+     :right (build-set-variants elems2)}))
+
+(defn split-workload
+  "Build the standard split benchmark workload."
+  [n num-ops]
+  (let [elems (generate-elements n)
+        sets  (build-set-variants elems)]
+    {:data-avl (:data-avl sets)
+     :ordered-set (:ordered-set sets)
+     :keys (generate-lookup-keys n num-ops)}))
+
+(defn fold-frequency-workload
+  "Build the nontrivial frequency-map fold workload and its reducers."
+  [elems]
+  {:sets     (build-set-variants elems)
+   :combinef (fn ([] {}) ([m1 m2] (merge-with + m1 m2)))
+   :reducef  (fn [m x] (update m (mod (long x) 100) (fnil inc 0)))})
+
+(defn set-comparison-workload
+  "Build same-content and near-miss set comparison workloads from randomized
+   integer elements.
+
+   Cases:
+   - :equal: same contents
+   - :different: same size, one element replaced
+   - :size-different: second set is missing one element"
+  [n]
+  (let [elems       (generate-elements n)
+        missing     n
+        different   (assoc elems (dec n) missing)
+        shorter     (subvec elems 0 (dec n))]
+    {:equal          {:left  (build-set-variants elems)
+                      :right (build-set-variants elems)}
+     :different      {:left  (build-set-variants elems)
+                      :right (build-set-variants different)}
+     :size-different {:left  (build-set-variants elems)
+                      :right (build-set-variants shorter)}}))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Table Printing
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn print-header
+  "Print benchmark header with title and column names."
+  [title cols]
+  (println)
+  (println (str "=== " title " ==="))
+  (println (apply format (str "%-10s" (apply str (repeat (count cols) " %-20s"))) "N" cols))
+  (println (apply str (repeat (+ 10 (* 21 (count cols))) "-"))))
+
+(defn print-row
+  "Print benchmark row with N and results."
+  [n results]
+  (println (apply format (str "%-10d" (apply str (repeat (count results) " %-20s")))
+                  n (map format-result results))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; CLI Argument Parsing
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn has-flag?
+  "Check if args contains any of the given flags."
+  [args & flags]
+  (boolean (some (set flags) args)))
+
+(defn parse-sizes
+  "Parse comma-separated sizes string into vector of longs."
+  [s]
+  (mapv #(Long/parseLong (str/trim %)) (str/split s #",")))
+
+(defn get-arg-value
+  "Get the value following an argument flag, or nil if not present."
+  [args flag]
+  (when-let [idx (some #(when (= (nth args %) flag) %) (range (dec (count args))))]
+    (nth args (inc idx))))
+
+(defn parse-standard-args
+  "Parse standard benchmark arguments: --quick, --full, -q, --sizes, --help.
+   Returns map with :sizes (vector), :quick (bool), :help (bool).
+
+   Arguments:
+     args         - command line arguments
+     sizes-quick  - sizes for --quick mode
+     sizes-default - default sizes
+     sizes-full   - sizes for --full mode"
+  [args sizes-quick sizes-default sizes-full]
+  (let [help?  (has-flag? args "--help" "-h")
+        quick? (has-flag? args "--quick" "-q")
+        full?  (has-flag? args "--full")
+        custom (get-arg-value (vec args) "--sizes")]
+    {:help  help?
+     :quick quick?
+     :sizes (cond
+              custom (parse-sizes custom)
+              quick? sizes-quick
+              full?  sizes-full
+              :else  sizes-default)}))
diff --git a/test/ordered_collections/cookbook_test.clj b/test/ordered_collections/cookbook_test.clj
new file mode 100644
index 0000000..a9cc072
--- /dev/null
+++ b/test/ordered_collections/cookbook_test.clj
@@ -0,0 +1,531 @@
+(ns ordered-collections.cookbook-test
+  "Tests for examples in doc/cookbook.md
+
+   Ensures all cookbook code snippets work correctly."
+  (:refer-clojure :exclude [split-at])
+  (:require [clojure.test :refer [deftest testing is are]]
+            [clojure.core.reducers :as r]
+            [ordered-collections.core :as oc]))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 1. Leaderboard with Rank Queries
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn make-leaderboard []
+  ;; Use ordered-map-with for custom comparator without initial entries
+  (oc/ordered-map-with (fn [[s1 id1] [s2 id2]]
+                         (let [c (compare s2 s1)]  ; descending by score
+                           (if (zero? c)
+                             (compare id1 id2)     ; then ascending by id
+                             c)))))
+
+(defn add-score [board player-id score data]
+  (assoc board [score player-id] data))
+
+(defn top-n [board n]
+  (->> board (take n) (map (fn [[[score id] data]]
+                             {:id id :score score :data data}))))
+
+(defn rank-of-player [board player-id score]
+  (oc/rank board [score player-id]))
+
+(defn players-around-rank [board rank window]
+  (let [start (max 0 (- rank window))
+        end   (min (count board) (+ rank window 1))]
+    (map-indexed (fn [i [[score id] _]]
+                   {:rank (+ start i) :id id :score score})
+                 (oc/slice board start end))))
+
+(deftest leaderboard-test
+  (let [board (-> (make-leaderboard)
+                  (add-score "alice" 1500 {:name "Alice"})
+                  (add-score "bob" 1450 {:name "Bob"})
+                  (add-score "carol" 1600 {:name "Carol"})
+                  (add-score "dave" 1550 {:name "Dave"}))]
+
+    (testing "top-n returns highest scorers"
+      (is (= [{:id "carol" :score 1600 :data {:name "Carol"}}
+              {:id "dave" :score 1550 :data {:name "Dave"}}
+              {:id "alice" :score 1500 :data {:name "Alice"}}]
+             (top-n board 3))))
+
+    (testing "rank-of-player returns position"
+      (is (= 0 (rank-of-player board "carol" 1600)))
+      (is (= 2 (rank-of-player board "alice" 1500)))
+      (is (= 3 (rank-of-player board "bob" 1450))))
+
+    (testing "players-around-rank"
+      (let [around (players-around-rank board 2 1)]
+        (is (= 3 (count around)))
+        (is (= "dave" (:id (first around))))
+        (is (= "alice" (:id (second around))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 2. Time-Series Windowing
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn make-event-log []
+  (oc/ordered-map))
+
+(defn add-event [log timestamp event]
+  (assoc log timestamp event))
+
+(defn events-between [log start-time end-time]
+  (subseq log >= start-time < end-time))
+
+(defn latest-events [log n]
+  ;; rsubseq requires test and key; use rseq for full reverse
+  (take n (rseq log)))
+
+(defn count-events-in-window [log start-time end-time]
+  (reduce (fn [acc _] (inc acc)) 0
+          (subseq log >= start-time < end-time)))
+
+(deftest time-series-windowing-test
+  (let [log (-> (make-event-log)
+                (add-event 1000 {:type :login :user "alice"})
+                (add-event 2000 {:type :click :page "/home"})
+                (add-event 3000 {:type :purchase :item "widget"})
+                (add-event 4000 {:type :logout :user "alice"}))]
+
+    (testing "events-between"
+      (let [events (vec (events-between log 1500 3500))]
+        (is (= 2 (count events)))
+        (is (= 2000 (ffirst events)))
+        (is (= 3000 (first (second events))))))
+
+    (testing "latest-events"
+      (let [events (vec (latest-events log 2))]
+        (is (= 2 (count events)))
+        (is (= 4000 (ffirst events)))
+        (is (= 3000 (first (second events))))))
+
+    (testing "count-events-in-window"
+      (is (= 2 (count-events-in-window log 1500 3500)))
+      (is (= 4 (count-events-in-window log 0 5000)))
+      (is (= 0 (count-events-in-window log 5000 6000))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Meeting Room Scheduler
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn make-room-schedule []
+  (oc/interval-map))
+
+(defn book-room [schedule start end booking]
+  (assoc schedule [start end] booking))
+
+(defn conflicts-at [schedule time]
+  (schedule time))
+
+(defn conflicts-during [schedule start end]
+  (schedule [start end]))
+
+(defn is-available? [schedule start end]
+  (empty? (conflicts-during schedule start end)))
+
+(deftest meeting-room-scheduler-test
+  (let [room-a (-> (make-room-schedule)
+                   (book-room 900 1000 {:title "Standup" :organizer "alice"})
+                   (book-room 1030 1130 {:title "Design Review" :organizer "bob"})
+                   (book-room 1400 1500 {:title "1:1" :organizer "carol"}))]
+
+    (testing "conflicts-at point query"
+      (is (= [{:title "Standup" :organizer "alice"}]
+             (conflicts-at room-a 930)))
+      (is (empty? (conflicts-at room-a 1200))))
+
+    (testing "conflicts-during range query"
+      ;; Range [1000, 1100] overlaps with [900, 1000] (at endpoint) and [1030, 1130]
+      (let [conflicts (set (conflicts-during room-a 1030 1100))]
+        (is (contains? conflicts {:title "Design Review" :organizer "bob"}))))
+
+    (testing "is-available? for non-overlapping slot"
+      ;; [1200, 1400) doesn't overlap with any meeting
+      (is (empty? (conflicts-during room-a 1200 1399))))
+
+    (testing "is-available? for overlapping slot"
+      ;; [1430, 1530] overlaps with [1400, 1500]
+      (is (not (empty? (conflicts-during room-a 1430 1530)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 4. Persistent Work Queue
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn make-work-queue []
+  (oc/priority-queue))
+
+(defn enqueue [q priority task]
+  (oc/push q priority task))
+
+(defn next-task [q]
+  (oc/peek-min q))
+
+(defn run-next [q]
+  (let [[_ task] (oc/peek-min q)]
+    {:task task
+     :remaining (oc/pop-min q)}))
+
+(deftest priority-queue-cookbook-test
+  (let [q (-> (make-work-queue)
+              (enqueue 5 {:job :backup})
+              (enqueue 1 {:job :page-oncall})
+              (enqueue 2 {:job :send-email})
+              (enqueue 1 {:job :invalidate-cache}))]
+    (testing "peek-min returns first element in queue order"
+      (is (= [1 {:job :page-oncall}] (next-task q))))
+
+    (testing "pop-min preserves stable equal-priority ordering"
+      (is (= {:job :page-oncall} (:task (run-next q))))
+      (is (= [1 {:job :invalidate-cache}]
+             (-> q run-next :remaining next-task))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 5. Parallel Aggregation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest parallel-aggregation-test
+  (let [transactions (oc/ordered-map
+                       (for [i (range 10000)]
+                         [i {:amount (mod i 100)
+                             :category (nth [:food :transport :entertainment :utilities]
+                                           (mod i 4))}]))]
+
+    (testing "sequential reduce"
+      (let [total (reduce (fn [acc [_ {:keys [amount]}]] (+ acc amount))
+                          0 transactions)]
+        (is (= 495000 total))))  ; sum of 0..99 repeated 100 times
+
+    (testing "parallel fold produces same result"
+      (let [total (r/fold
+                    +
+                    (fn [acc [_ {:keys [amount]}]] (+ acc amount))
+                    transactions)]
+        (is (= 495000 total))))
+
+    (testing "parallel group-by"
+      (let [by-category (r/fold
+                          (partial merge-with +)
+                          (fn [acc [_ {:keys [amount category]}]]
+                            (update acc category (fnil + 0) amount))
+                          transactions)]
+        (is (= 4 (count by-category)))
+        (is (every? pos? (vals by-category)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 6. Efficient Set Algebra
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest efficient-set-algebra-test
+  (let [premium-users (oc/ordered-set (range 0 10000 2))
+        active-users (oc/ordered-set (range 0 10000 3))]
+
+    (testing "intersection"
+      (let [premium-active (oc/intersection premium-users active-users)]
+        ;; Elements divisible by both 2 and 3 = divisible by 6
+        (is (= (count (range 0 10000 6)) (count premium-active)))
+        (is (every? #(and (zero? (mod % 2)) (zero? (mod % 3))) premium-active))))
+
+    (testing "difference"
+      (let [premium-only (oc/difference premium-users active-users)]
+        ;; Premium (div by 2) but not active (div by 3)
+        (is (every? #(zero? (mod % 2)) premium-only))
+        (is (not-any? #(zero? (mod % 6)) premium-only))))
+
+    (testing "union"
+      (let [all-users (oc/union premium-users active-users)]
+        ;; Union of div-by-2 and div-by-3
+        (is (every? #(or (zero? (mod % 2)) (zero? (mod % 3))) all-users))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 7. Sliding Window Statistics
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn make-window [max-age-ms]
+  {:data (oc/ordered-map)
+   :max-age max-age-ms})
+
+(defn add-sample [{:keys [data max-age] :as window} timestamp value]
+  (let [cutoff (- timestamp max-age)
+        fresh-data (oc/subrange data :>= cutoff)]
+    (assoc window :data (assoc fresh-data timestamp value))))
+
+(defn window-stats [{:keys [data]}]
+  (when (seq data)
+    (let [values (map val data)
+          n (count values)
+          sum (reduce + values)]
+      {:count n
+       :sum sum
+       :mean (/ sum n)
+       :min (apply min values)
+       :max (apply max values)})))
+
+(deftest sliding-window-statistics-test
+  (testing "basic windowing"
+    (let [w (-> (make-window 5000)
+                (add-sample 1000 10)
+                (add-sample 2000 20)
+                (add-sample 3000 15))]
+      (is (= {:count 3 :sum 45 :mean 15 :min 10 :max 20}
+             (window-stats w)))))
+
+  (testing "old samples are evicted"
+    (let [w (-> (make-window 5000)
+                (add-sample 1000 10)
+                (add-sample 2000 20)
+                (add-sample 3000 15)
+                (add-sample 6500 25))]  ; evicts 1000
+      (is (= 3 (:count (window-stats w))))
+      (is (= 60 (:sum (window-stats w)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 8. Range Aggregate Queries (Segment Tree)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest segment-tree-test
+  (let [sales (oc/segment-tree + 0
+                {0 1200, 1 1500, 2 1100, 3 1800, 4 2200, 5 1900, 6 1600})]
+
+    (testing "range sum queries"
+      (is (= (+ 1100 1800 2200 1900) (oc/query sales 2 5)))  ; days 2-5
+      (is (= (+ 1200 1500 1100 1800 2200 1900 1600) (oc/query sales 0 6))))  ; all
+
+    (testing "update preserves structure"
+      (let [updated (assoc sales 3 2500)]
+        (is (= (+ 1100 2500 2200 1900) (oc/query updated 2 5)))))
+
+    (testing "max tree"
+      (let [peaks (oc/segment-tree max 0
+                    {0 1200, 1 1500, 2 1100, 3 1800, 4 2200, 5 1900, 6 1600})]
+        (is (= 2200 (oc/query peaks 0 6)))    ; max across all
+        (is (= 1500 (oc/query peaks 0 2)))))  ; max for days 0-2
+
+    (testing "sum-tree shorthand"
+      (let [st (oc/sum-tree {0 100, 1 200, 2 300, 3 400})]
+        (is (= 900 (oc/query st 1 3)))))))    ; 200 + 300 + 400
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 9. Database Index Simulation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn make-index []
+  (oc/ordered-map))
+
+(defn index-add [idx value pk]
+  (update idx value (fnil conj #{}) pk))
+
+(defn index-remove [idx value pk]
+  (let [pks (disj (get idx value #{}) pk)]
+    (if (empty? pks)
+      (dissoc idx value)
+      (assoc idx value pks))))
+
+(defn index-lookup [idx value]
+  (get idx value #{}))
+
+(defn index-range [idx min-val max-val]
+  (->> (subseq idx >= min-val < max-val)
+       (mapcat val)
+       set))
+
+(deftest database-index-simulation-test
+  (let [age-index (-> (make-index)
+                      (index-add 25 "user-1")
+                      (index-add 30 "user-2")
+                      (index-add 25 "user-3")
+                      (index-add 35 "user-4")
+                      (index-add 28 "user-5"))]
+
+    (testing "exact lookup"
+      (is (= #{"user-1" "user-3"} (index-lookup age-index 25)))
+      (is (= #{"user-2"} (index-lookup age-index 30)))
+      (is (= #{} (index-lookup age-index 99))))
+
+    (testing "range lookup"
+      (is (= #{"user-1" "user-2" "user-3" "user-5"}
+             (index-range age-index 25 31))))
+
+    (testing "index-remove"
+      (let [idx' (index-remove age-index 25 "user-1")]
+        (is (= #{"user-3"} (index-lookup idx' 25)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 10. Ordered Multiset
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-multiset-cookbook-test
+  (let [readings (oc/ordered-multiset [72 68 72 70 68 72 71])]
+    (testing "duplicates stay sorted"
+      (is (= [68 68 70 71 72 72 72] (vec (seq readings)))))
+
+    (testing "multiplicity and distinct-elements"
+      (is (= 3 (oc/multiplicity readings 72)))
+      (is (= [68 70 71 72] (vec (oc/distinct-elements readings)))))
+
+    (testing "frequency map and disj-one"
+      (is (= {68 2, 70 1, 71 1, 72 3}
+             (oc/element-frequencies readings)))
+      (is (= 2 (-> readings (oc/disj-one 72) (oc/multiplicity 72)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 11. Fuzzy Lookup / Nearest Neighbor
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest fuzzy-lookup-test
+  (let [calibration (oc/fuzzy-map {0.0 1.000
+                                    25.0 1.012
+                                    50.0 1.025
+                                    75.0 1.041
+                                    100.0 1.058})]
+
+    (testing "fuzzy-map lookup"
+      (is (= 1.012 (calibration 23.5)))
+      (is (= 1.025 (calibration 60.0)))
+      (is (= 1.041 (calibration 87.5))))
+
+    (testing "fuzzy-nearest returns key, value, and distance"
+      (let [result (oc/fuzzy-nearest calibration 60.0)]
+        ;; Result is [key value distance]
+        (is (vector? result))
+        (is (= 3 (count result)))
+        (let [[k v dist] result]
+          (is (= 50.0 k))
+          (is (= 1.025 v))
+          (is (= 10.0 dist))))))
+
+  (testing "fuzzy-map with tiebreak"
+    (let [fm (oc/fuzzy-map {0 :a 10 :b 20 :c} :tiebreak :>)]
+      (is (= :b (fm 5)))))
+
+  (testing "fuzzy-set"
+    (let [grid-points (oc/fuzzy-set (range 0 101 10))]
+      (is (= 20 (grid-points 23)))
+      (is (= 30 (grid-points 27)))
+      (is (= 20 (grid-points 25)))))  ; default tiebreak :<
+
+  (testing "fuzzy-nearest on set"
+    (let [grid-points (oc/fuzzy-set (range 0 101 10))
+          [val dist] (oc/fuzzy-nearest grid-points 23)]
+      (is (= 20 val))
+      (is (== 3 dist)))))  ; use == for numeric equality
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 11. Splitting Collections
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest splitting-collections-test
+  (let [prices (oc/ordered-set [100 200 300 400 500 600 700 800 900 1000])]
+
+    (testing "split-key with existing key"
+      (let [[below match above] (oc/split-key 500 prices)]
+        (is (= [100 200 300 400] (vec below)))
+        (is (= 500 match))
+        (is (= [600 700 800 900 1000] (vec above)))))
+
+    (testing "split-key with non-existing key"
+      (let [[below match above] (oc/split-key 550 prices)]
+        (is (= [100 200 300 400 500] (vec below)))
+        (is (nil? match))
+        (is (= [600 700 800 900 1000] (vec above)))))
+
+    (testing "split-at"
+      (let [[left right] (oc/split-at 3 prices)]
+        (is (= [100 200 300] (vec left)))
+        (is (= [400 500 600 700 800 900 1000] (vec right)))))
+
+    (testing "pagination using split-at"
+      (let [paginate (fn [coll page-size page-num]
+                       (let [offset (* page-size page-num)
+                             [_ remaining] (oc/split-at offset coll)
+                             [page _] (oc/split-at page-size remaining)]
+                         (vec page)))]
+        (is (= [100 200 300] (paginate prices 3 0)))
+        (is (= [400 500 600] (paginate prices 3 1)))
+        (is (= [700 800 900] (paginate prices 3 2)))
+        (is (= [1000] (paginate prices 3 3)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 12. Subrange Extraction
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest subrange-extraction-test
+  (let [inventory (oc/ordered-map
+                    [[10 "widget-a"] [20 "widget-b"] [30 "widget-c"]
+                     [40 "widget-d"] [50 "widget-e"] [60 "widget-f"]])]
+
+    (testing "two-sided bounds >="
+      (let [sub (oc/subrange inventory :>= 25 :<= 50)]
+        (is (= 3 (count sub)))
+        (is (contains? sub 30))
+        (is (contains? sub 50))
+        (is (not (contains? sub 20)))))
+
+    (testing "one-sided bound >"
+      (let [sub (oc/subrange inventory :> 40)]
+        (is (= 2 (count sub)))
+        (is (contains? sub 50))
+        (is (contains? sub 60))))
+
+    (testing "one-sided bound <"
+      (let [sub (oc/subrange inventory :< 30)]
+        (is (= 2 (count sub)))
+        (is (contains? sub 10))
+        (is (contains? sub 20)))))
+
+  (testing "subrange on set"
+    (let [ids (oc/ordered-set (range 0 100 5))]
+      (is (= [20 25 30 35] (vec (oc/subrange ids :>= 20 :< 40))))
+      (is (= 7 (count (oc/subrange ids :>= 50 :<= 80)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 13. Floor/Ceiling Queries
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest floor-ceiling-queries-test
+  (let [versions (oc/ordered-set [100 200 300 450 500 800])]
+
+    (testing "nearest :<="
+      (is (= 300 (oc/nearest versions :<= 350)))
+      (is (= 300 (oc/nearest versions :<= 300)))
+      (is (nil? (oc/nearest versions :<= 50))))
+
+    (testing "nearest :<"
+      (is (= 200 (oc/nearest versions :< 300)))
+      (is (= 300 (oc/nearest versions :< 350))))
+
+    (testing "nearest :>="
+      (is (= 450 (oc/nearest versions :>= 350)))
+      (is (= 800 (oc/nearest versions :>= 800))))
+
+    (testing "nearest :>"
+      (is (= 800 (oc/nearest versions :> 500)))
+      (is (nil? (oc/nearest versions :> 800)))))
+
+  (testing "nearest on ordered-map"
+    (let [config-versions (oc/ordered-map
+                            [[100 {:feature-a true}]
+                             [200 {:feature-a true :feature-b true}]
+                             [350 {:feature-a true :feature-b true :feature-c true}]])]
+      (is (= [200 {:feature-a true :feature-b true}]
+             (oc/nearest config-versions :<= 300)))
+      (is (= [350 {:feature-a true :feature-b true :feature-c true}]
+             (oc/nearest config-versions :>= 300))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Performance Tips Validation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest performance-tips-test
+  (testing "specialized constructors work"
+    (let [long-set (oc/long-ordered-set (range 100))
+          string-set (oc/string-ordered-set ["alice" "bob" "carol"])]
+      (is (= 100 (count long-set)))
+      (is (contains? long-set 50))
+      (is (= 3 (count string-set)))
+      (is (contains? string-set "bob"))))
+
+  (testing "r/fold works on ordered collections"
+    (let [s (oc/ordered-set (range 1000))]
+      (is (= (reduce + (range 1000))
+             (r/fold + s))))))
diff --git a/test/ordered_collections/coverage_test.clj b/test/ordered_collections/coverage_test.clj
new file mode 100644
index 0000000..5cc07e8
--- /dev/null
+++ b/test/ordered_collections/coverage_test.clj
@@ -0,0 +1,448 @@
+(ns ordered-collections.coverage-test
+  "Additional tests to improve code coverage."
+  (:refer-clojure :exclude [split-at])
+  (:require [clojure.core.reducers :as r]
+            [clojure.test :refer :all]
+            [ordered-collections.core :refer :all])
+  (:import [java.util Collection Set SortedSet]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; OrderedSet Coverage Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-set-java-collection-interface
+  (let [os (ordered-set [3 1 4 1 5 9 2 6])]
+    ;; isEmpty
+    (is (false? (.isEmpty ^Collection os)))
+    (is (true? (.isEmpty ^Collection (ordered-set))))
+
+    ;; size
+    (is (= 7 (.size ^Collection os)))
+
+    ;; toArray
+    (is (= [1 2 3 4 5 6 9] (vec (.toArray ^Collection os))))
+
+    ;; iterator
+    (let [iter (.iterator ^Collection os)]
+      (is (= 1 (.next iter))))
+
+    ;; contains
+    (is (true? (.contains ^Collection os 5)))
+    (is (false? (.contains ^Collection os 100)))
+
+    ;; containsAll
+    (is (true? (.containsAll ^Set os [1 2 3])))
+    (is (false? (.containsAll ^Set os [1 2 100])))
+
+    ;; Unsupported mutating operations
+    (is (thrown? UnsupportedOperationException (.add ^Collection os 10)))
+    (is (thrown? UnsupportedOperationException (.addAll ^Collection os [10 11])))
+    (is (thrown? UnsupportedOperationException (.removeAll ^Collection os [1 2])))
+    (is (thrown? UnsupportedOperationException (.retainAll ^Collection os [1 2])))))
+
+(deftest ordered-set-java-sorted-set-interface
+  (let [os (ordered-set [3 1 4 1 5 9 2 6])]
+    ;; comparator
+    (is (some? (.comparator ^SortedSet os)))
+
+    ;; first
+    (is (= 1 (.first ^SortedSet os)))
+
+    ;; last
+    (is (= 9 (.last ^SortedSet os)))
+
+    ;; headSet - elements < x
+    (is (= #{1 2 3} (.headSet ^SortedSet os 4)))
+
+    ;; tailSet - elements >= x
+    (is (= #{4 5 6 9} (.tailSet ^SortedSet os 4)))
+
+    ;; subSet - elements >= from and < to
+    (is (= #{3 4 5} (.subSet ^SortedSet os 3 6)))))
+
+(deftest ordered-set-clojure-sorted-interface
+  (let [os (ordered-set [3 1 4 1 5 9 2 6])]
+    ;; subseq >= 3
+    (is (= [3 4 5 6 9] (subseq os >= 3)))
+
+    ;; subseq > 3
+    (is (= [4 5 6 9] (subseq os > 3)))
+
+    ;; subseq >= 3 < 6
+    (is (= [3 4 5] (subseq os >= 3 < 6)))
+
+    ;; rsubseq <= 5
+    (is (= [5 4 3 2 1] (rsubseq os <= 5)))))
+
+(deftest ordered-set-meta-and-equiv
+  (let [os1 (ordered-set [1 2 3])
+        os2 (with-meta os1 {:foo :bar})]
+    ;; meta (empty map by default)
+    (is (= {} (meta os1)))
+    (is (= {:foo :bar} (meta os2)))
+
+    ;; equiv
+    (is (= os1 os2))
+    (is (= os1 #{1 2 3}))))
+
+(deftest ordered-set-metadata-propagation
+  (let [os (with-meta (ordered-set [1 2 3 4]) {:tag :ordered-set})]
+    (is (= {:tag :ordered-set} (meta (empty os))))
+    (is (= {:tag :ordered-set} (meta (.headSet ^SortedSet os 3))))
+    (is (= {:tag :ordered-set} (meta (.tailSet ^SortedSet os 3))))
+    (is (= {:tag :ordered-set} (meta (.subSet ^SortedSet os 2 4))))
+    (is (= {:tag :ordered-set} (meta (subrange os :>= 2))))
+    (is (= {:tag :ordered-set} (meta (first (split-at 2 os)))))
+    (is (= {:tag :ordered-set} (meta (last (split-at 2 os)))))
+    (is (= {:tag :ordered-set} (meta (first (split-key 2 os)))))
+    (is (= {:tag :ordered-set} (meta (last (split-key 2 os)))))
+    (is (= {:tag :ordered-set} (meta (union os (ordered-set [5])))))))
+
+(deftest ordered-set-reduce
+  (let [os (ordered-set [1 2 3 4 5])]
+    ;; IReduce
+    (is (= 15 (reduce + os)))
+    ;; IReduceInit
+    (is (= 115 (reduce + 100 os)))
+    ;; empty
+    (is (= 0 (reduce + (ordered-set))))))
+
+(deftest ordered-set-empty-edge-cases
+  (let [os (ordered-set)]
+    (is (= os (empty (ordered-set [1 2 3]))))
+    (is (= 0 (count os)))
+    ;; seq/rseq on empty returns empty list
+    (is (empty? (seq os)))
+    (is (empty? (rseq os)))))
+
+(deftest ordered-set-reverse-comparator
+  (let [os (ordered-set-by > [3 1 4 1 5 9 2 6])]
+    (is (= [9 6 5 4 3 2 1] (seq os)))
+    (is (= 9 (first os)))
+    (is (= 1 (last os)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; OrderedMap Coverage Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-map-basic-interface
+  (let [om (ordered-map [[3 :c] [1 :a] [4 :d] [1 :A] [5 :e]])]
+    ;; count
+    (is (= 4 (count om)))
+    (is (= 0 (count (ordered-map))))
+
+    ;; containsKey
+    (is (contains? om 3))
+    (is (not (contains? om 100)))))
+
+(deftest ordered-map-clojure-sorted-interface
+  (let [om (ordered-map [[3 :c] [1 :a] [4 :d] [5 :e]])]
+    ;; subseq
+    (is (= [[3 :c] [4 :d] [5 :e]] (subseq om >= 3)))
+    (is (= [[4 :d] [5 :e]] (subseq om > 3)))
+
+    ;; rsubseq
+    (is (= [[4 :d] [3 :c] [1 :a]] (rsubseq om <= 4)))))
+
+(deftest ordered-map-meta-and-equiv
+  (let [om1 (ordered-map [[1 :a] [2 :b]])
+        om2 (with-meta om1 {:foo :bar})]
+    ;; meta (empty map by default)
+    (is (= {} (meta om1)))
+    (is (= {:foo :bar} (meta om2)))
+
+    ;; equiv
+    (is (= om1 om2))
+    (is (= om1 {1 :a 2 :b}))))
+
+(deftest ordered-map-metadata-propagation
+  (let [om (with-meta (ordered-map [[1 :a] [2 :b] [3 :c] [4 :d]]) {:tag :ordered-map})]
+    (is (= {:tag :ordered-map} (meta (empty om))))
+    (is (= {:tag :ordered-map} (meta (.headMap ^java.util.SortedMap om 3))))
+    (is (= {:tag :ordered-map} (meta (.tailMap ^java.util.SortedMap om 3))))
+    (is (= {:tag :ordered-map} (meta (.subMap ^java.util.SortedMap om 2 4))))
+    (is (= {:tag :ordered-map} (meta (subrange om :>= 2))))
+    (is (= {:tag :ordered-map} (meta (first (split-at 2 om)))))
+    (is (= {:tag :ordered-map} (meta (last (split-at 2 om)))))
+    (is (= {:tag :ordered-map} (meta (first (split-key 2 om)))))
+    (is (= {:tag :ordered-map} (meta (last (split-key 2 om)))))))
+
+(deftest ordered-map-reduce
+  (let [om (ordered-map [[1 :a] [2 :b] [3 :c]])]
+    ;; IReduceInit
+    (is (= 6 (reduce (fn [acc [k _]] (+ acc k)) 0 om)))
+    ;; empty
+    (is (= 100 (reduce (fn [acc [k _]] (+ acc k)) 100 (ordered-map))))))
+
+(deftest ordered-map-entry-at
+  (let [om (ordered-map [[1 :a] [2 :b] [3 :c]])]
+    (let [entry (.entryAt ^clojure.lang.Associative om 2)]
+      (is (= 2 (key entry)))
+      (is (= :b (val entry))))
+    (is (nil? (.entryAt ^clojure.lang.Associative om 100)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; IntervalSet Coverage Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest interval-set-basic-coverage
+  (let [iset (interval-set [[1 5] [10 15] [20 25]])]
+    ;; Basic operations
+    (is (= 3 (count iset)))
+
+    ;; Interval queries - returns matching intervals or nil
+    (is (= [[1 5]] (iset 3)))
+    (is (= [[10 15]] (iset 12)))
+    (is (nil? (iset 7)))))
+
+(deftest interval-set-metadata-propagation
+  (let [iset (with-meta (interval-set [[1 5] [10 15] [20 25]]) {:tag :interval-set})]
+    (is (= {:tag :interval-set} (meta (empty iset))))
+    (is (= {:tag :interval-set} (meta (.headSet ^SortedSet iset [20 25]))))
+    (is (= {:tag :interval-set} (meta (.tailSet ^SortedSet iset [10 15]))))
+    (is (= {:tag :interval-set} (meta (.subSet ^SortedSet iset [10 15] [20 25]))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; IntervalMap Coverage Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest interval-map-basic-coverage
+  (let [im (interval-map {[1 5] :a [10 15] :b [20 25] :c})]
+    ;; Basic operations
+    (is (= 3 (count im)))
+
+    ;; Interval queries - returns values or empty vec or nil
+    (is (= [:a] (im 3)))
+    (is (= [:b] (im 12)))
+    ;; No matching interval returns empty vec or nil depending on implementation
+    (is (or (= [] (im 7)) (nil? (im 7))))))
+
+(deftest interval-map-metadata-propagation
+  (let [im (with-meta (interval-map {[1 5] :a [10 15] :b}) {:tag :interval-map})]
+    (is (= {:tag :interval-map} (meta (empty im))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; FuzzySet Coverage Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest fuzzy-set-basic-coverage
+  (let [fs (fuzzy-set [1 5 10 20 50])]
+    ;; Exact matches
+    (is (= 1 (fs 1)))
+    (is (= 10 (fs 10)))
+
+    ;; Fuzzy matches
+    (is (= 5 (fs 7)))
+    (is (= 10 (fs 13)))))
+
+(deftest fuzzy-set-tiebreak
+  (let [fs-lo (fuzzy-set [0 10 20] :tiebreak :<)
+        fs-hi (fuzzy-set [0 10 20] :tiebreak :>)]
+    ;; At equidistant point
+    (is (= 0 (fs-lo 5)))
+    (is (= 10 (fs-hi 5)))))
+
+(deftest fuzzy-set-empty
+  (let [fs (fuzzy-set [])]
+    (is (nil? (fs 5)))))
+
+(deftest fuzzy-set-metadata-propagation
+  (let [fs (with-meta (fuzzy-set [1 5 10 20]) {:tag :fuzzy-set})]
+    (is (= {:tag :fuzzy-set} (meta (empty fs))))
+    (is (= {:tag :fuzzy-set} (meta (.headSet ^SortedSet fs 10))))
+    (is (= {:tag :fuzzy-set} (meta (.tailSet ^SortedSet fs 10))))
+    (is (= {:tag :fuzzy-set} (meta (.subSet ^SortedSet fs 5 20))))))
+
+(deftest fuzzy-set-reduce
+  (let [fs (fuzzy-set [1 2 3 4 5])]
+    (is (= 15 (reduce + fs)))
+    (is (= 115 (reduce + 100 fs)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; FuzzyMap Coverage Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest fuzzy-map-basic-coverage
+  (let [fm (fuzzy-map {0 :zero 10 :ten 100 :hundred})]
+    ;; Exact matches
+    (is (= :zero (fm 0)))
+    (is (= :ten (fm 10)))
+
+    ;; Fuzzy matches
+    (is (= :ten (fm 7)))
+    (is (= :ten (fm 50)))
+    (is (= :hundred (fm 60)))))
+
+(deftest fuzzy-map-exact-get
+  (let [fm (fuzzy-map {0 :zero 10 :ten 100 :hundred})]
+    (is (= :ten (fuzzy-exact-get fm 10)))
+    (is (nil? (fuzzy-exact-get fm 11)))
+    (is (= :nope (fuzzy-exact-get fm 11 :nope)))))
+
+(deftest fuzzy-map-empty
+  (let [fm (fuzzy-map {})]
+    (is (nil? (fm 5)))))
+
+(deftest fuzzy-map-metadata-propagation
+  (let [fm (with-meta (fuzzy-map {0 :zero 10 :ten 20 :twenty}) {:tag :fuzzy-map})]
+    (is (= {:tag :fuzzy-map} (meta (empty fm))))
+    (is (= {:tag :fuzzy-map} (meta (.headMap ^java.util.SortedMap fm 20))))
+    (is (= {:tag :fuzzy-map} (meta (.tailMap ^java.util.SortedMap fm 10))))
+    (is (= {:tag :fuzzy-map} (meta (.subMap ^java.util.SortedMap fm 10 20))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Additional Type Metadata Coverage
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest segment-tree-metadata-propagation
+  (let [st (with-meta (segment-tree + 0 {1 10 2 20 3 30 4 40}) {:tag :segment-tree})]
+    (is (= {:tag :segment-tree} (meta (empty st))))
+    (is (= {:tag :segment-tree} (meta (.headMap ^java.util.SortedMap st 3))))
+    (is (= {:tag :segment-tree} (meta (.tailMap ^java.util.SortedMap st 3))))
+    (is (= {:tag :segment-tree} (meta (.subMap ^java.util.SortedMap st 2 4))))
+    (is (= {:tag :segment-tree} (meta (subrange st :>= 2))))
+    (is (= {:tag :segment-tree} (meta (first (split-at 2 st)))))
+    (is (= {:tag :segment-tree} (meta (last (split-at 2 st)))))
+    (is (= {:tag :segment-tree} (meta (first (split-key 2 st)))))
+    (is (= {:tag :segment-tree} (meta (last (split-key 2 st)))))))
+
+(deftest range-map-metadata-propagation
+  (let [rm (with-meta (-> (range-map)
+                          (assoc [0 10] :a)
+                          (assoc [10 20] :b))
+             {:tag :range-map})]
+    (is (= {:tag :range-map} (meta (empty rm))))
+    (is (= {:tag :range-map} (meta (assoc-coalescing rm [20 30] :c))))
+    (is (= {:tag :range-map} (meta (range-remove rm [5 15]))))))
+
+(deftest ordered-multiset-metadata-propagation
+  (let [ms (with-meta (ordered-multiset [1 1 2 3]) {:tag :multiset})]
+    (is (= {:tag :multiset} (meta (empty ms))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PriorityQueue Coverage Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest priority-queue-basic-coverage
+  (let [pq (priority-queue [[5 :e] [3 :c] [8 :h] [1 :a] [9 :i] [2 :b] [7 :g]])]
+    (is (= [1 :a] (peek pq)))
+    (is (= [2 :b] (peek (pop pq))))
+    (is (= 7 (count pq)))))
+
+(deftest priority-queue-push
+  (let [pq (priority-queue [[5 :e] [3 :c] [8 :h]])]
+    ;; push adds value with given priority
+    (let [pq2 (push pq 0 :zero)]
+      (is (= [0 :zero] (peek pq2)))
+      (is (= 4 (count pq2))))))
+
+(deftest priority-queue-empty
+  (let [pq (priority-queue [])]
+    (is (nil? (peek pq)))
+    (is (thrown? IllegalStateException (pop pq)))
+    (is (= 0 (count pq)))))
+
+(deftest priority-queue-reduce
+  (let [pq (priority-queue [[1 10] [2 20] [3 30] [4 40] [5 50]])]
+    ;; reduce over [priority value] pairs
+    (is (= 15 (reduce (fn [acc [p _]] (+ acc p)) 0 pq)))
+    (is (= 150 (reduce (fn [acc [_ v]] (+ acc v)) 0 pq)))))
+
+(deftest priority-queue-fold
+  (let [pairs (vec (for [i (range 1000)] [i i]))
+        pq (priority-queue pairs)]
+    (is (= (reduce + (range 1000))
+           (r/fold + (fn [acc [p _]] (+ acc p)) pq)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; OrderedMultiset Coverage Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-multiset-basic-coverage
+  (let [ms (ordered-multiset [3 1 4 1 5 9 2 6 5 3 5])]
+    (is (= 11 (count ms)))
+    (is (= 3 (multiplicity ms 5)))
+    (is (= 2 (multiplicity ms 1)))
+    (is (= 0 (multiplicity ms 100)))
+    (is (= [1 1 2 3 3 4 5 5 5 6 9] (seq ms)))))
+
+(deftest ordered-multiset-disj-one
+  (let [ms (ordered-multiset [1 1 1 2 2 3])]
+    (is (= [1 1 2 2 3] (seq (disj-one ms 1))))
+    (is (= [1 1 1 2 3] (seq (disj-one ms 2))))
+    (is (= [1 1 1 2 2 3] (seq (disj-one ms 100))))))
+
+(deftest ordered-multiset-disj-all
+  (let [ms (ordered-multiset [1 1 1 2 2 3])]
+    (is (= [2 2 3] (seq (disj-all ms 1))))
+    (is (= [1 1 1 3] (seq (disj-all ms 2))))))
+
+(deftest ordered-multiset-empty
+  (let [ms (ordered-multiset [])]
+    (is (= 0 (count ms)))
+    (is (nil? (seq ms)))))
+
+(deftest ordered-multiset-reduce
+  (let [ms (ordered-multiset [1 2 2 3 3 3])]
+    (is (= 14 (reduce + ms)))
+    (is (= 114 (reduce + 100 ms)))))
+
+(deftest ordered-multiset-fold
+  (let [ms (ordered-multiset (range 1000))]
+    (is (= (reduce + (range 1000)) (r/fold + ms)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Core namespace coverage
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest core-constructors-coverage
+  (is (some? (ordered-set)))
+  (is (some? (ordered-set-by < [])))
+  (is (some? (ordered-map)))
+  (is (some? (ordered-map-by < [])))
+  (is (some? (interval-set)))
+  (is (some? (interval-map)))
+  (is (some? (priority-queue [])))
+  (is (some? (priority-queue-by > [])))
+  (is (some? (ordered-multiset [])))
+  (is (some? (ordered-multiset-by < [])))
+  (is (some? (fuzzy-set [])))
+  (is (some? (fuzzy-set-by < [])))
+  (is (some? (fuzzy-map {})))
+  (is (some? (fuzzy-map-by < {}))))
+
+(deftest core-protocol-functions
+  (let [os (ordered-set [1 2 3])]
+    (is (= #{1 2} (intersection os (ordered-set [1 2 4]))))
+    (is (= #{1 2 3 4} (union os (ordered-set [2 3 4]))))
+    (is (= #{3} (difference os (ordered-set [1 2]))))
+    (is (subset? os (ordered-set [1 2 3 4 5])))
+    (is (superset? (ordered-set [1 2 3 4 5]) os))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; README Quick Start examples
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest readme-quickstart-rope
+  (let [r (rope [:a :b :c :d :e])]
+    (is (= [:a :b :c :d :e] (vec r)))
+    ;; split and reverse-concat
+    (is (= [:c :d :e :a :b]
+           (vec (apply rope-concat (reverse (rope-split r 2))))))
+    ;; insert
+    (is (= [:a :b :x :y :c :d :e]
+           (vec (rope-insert r 2 [:x :y]))))))
+
+(deftest readme-quickstart-sets
+  (let [s (ordered-set [3 1 4 1 5 9 2 6])]
+    (is (= [1 2 3 4 5 6 9] (vec s)))
+    (is (= 4 (s 4)))
+    (is (nil? (s 7)))
+    (is (= [0 1 2 3 4 5 6 9] (vec (conj s 0))))))
+
+(deftest readme-quickstart-maps
+  (let [m (ordered-map {:b 2 :a 1 :c 3})]
+    (is (= [[:a 1] [:b 2] [:c 3]] (vec m)))
+    (is (= 2 (m :b)))
+    (is (= [[:a 1] [:b 2] [:c 3] [:d 4]] (vec (assoc m :d 4))))))
diff --git a/test/ordered_collections/edn_test.clj b/test/ordered_collections/edn_test.clj
new file mode 100644
index 0000000..385fb64
--- /dev/null
+++ b/test/ordered_collections/edn_test.clj
@@ -0,0 +1,319 @@
+(ns ordered-collections.edn-test
+  "Tests for EDN/tagged-literal round-tripping of ordered collections.
+
+   Verifies that pr-str produces tagged literals that read-string can
+   reconstruct into equivalent collections."
+  (:require [clojure.test :refer [deftest testing is]]
+            [clojure.edn  :as edn]
+            [ordered-collections.core    :as oc]
+            [ordered-collections.readers  :as readers]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn round-trip
+  "pr-str then read-string — uses data_readers.clj on classpath."
+  [coll]
+  (read-string (pr-str coll)))
+
+(defn edn-round-trip
+  "pr-str then clojure.edn/read-string with explicit readers."
+  [coll]
+  (edn/read-string {:readers readers/readers} (pr-str coll)))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Set
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-set-tagged-literal-format
+  (testing "pr-str produces #ordered/set tag"
+    (let [s (oc/ordered-set [3 1 2])]
+      (is (= "#ordered/set [1 2 3]" (pr-str s))))))
+
+(deftest ordered-set-round-trip
+  (testing "read-string round-trip"
+    (let [s (oc/ordered-set [3 1 4 1 5 9 2 6])]
+      (is (= s (round-trip s)))
+      (is (= (vec s) (vec (round-trip s))))))
+  (testing "clojure.edn round-trip"
+    (let [s (oc/ordered-set [10 20 30])]
+      (is (= s (edn-round-trip s)))))
+  (testing "empty set"
+    (let [s (oc/ordered-set)]
+      (is (= "#ordered/set []" (pr-str s)))
+      (is (= s (round-trip s)))))
+  (testing "single element"
+    (let [s (oc/ordered-set [42])]
+      (is (= s (round-trip s)))))
+  (testing "keyword elements"
+    (let [s (oc/ordered-set [:a :b :c :d])]
+      (is (= s (round-trip s)))))
+  (testing "string elements"
+    (let [s (oc/ordered-set ["alpha" "beta" "gamma"])]
+      (is (= s (round-trip s)))))
+  (testing "large set"
+    (let [s (oc/ordered-set (range 1000))]
+      (is (= s (round-trip s))))))
+
+(deftest ordered-set-read-from-literal
+  (testing "read literal string directly"
+    (let [s (read-string "#ordered/set [5 3 1]")]
+      (is (= 3 (count s)))
+      (is (= [1 3 5] (vec s)))
+      (is (= 1 (first s))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-map-tagged-literal-format
+  (testing "pr-str produces #ordered/map tag"
+    (let [m (oc/ordered-map [[2 :b] [1 :a] [3 :c]])]
+      (is (= "#ordered/map [[1 :a] [2 :b] [3 :c]]" (pr-str m))))))
+
+(deftest ordered-map-round-trip
+  (testing "read-string round-trip"
+    (let [m (oc/ordered-map {:a 1 :b 2 :c 3})]
+      (is (= m (round-trip m)))
+      (is (= (vec m) (vec (round-trip m))))))
+  (testing "clojure.edn round-trip"
+    (let [m (oc/ordered-map [[1 :a] [2 :b]])]
+      (is (= m (edn-round-trip m)))))
+  (testing "empty map"
+    (let [m (oc/ordered-map)]
+      (is (= "#ordered/map []" (pr-str m)))
+      (is (= m (round-trip m)))))
+  (testing "single entry"
+    (let [m (oc/ordered-map [[1 :only]])]
+      (is (= m (round-trip m)))))
+  (testing "complex values"
+    (let [m (oc/ordered-map [[1 {:name "alice" :tags [:a :b]}]
+                             [2 {:name "bob" :tags [:c]}]])]
+      (is (= (vec m) (vec (round-trip m))))))
+  (testing "large map"
+    (let [m (oc/ordered-map (map #(vector % (* % %)) (range 1000)))]
+      (is (= m (round-trip m))))))
+
+(deftest ordered-map-read-from-literal
+  (testing "read literal string directly"
+    (let [m (read-string "#ordered/map [[1 :a] [2 :b]]")]
+      (is (= 2 (count m)))
+      (is (= :a (m 1)))
+      (is (= :b (m 2))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Set
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest interval-set-tagged-literal-format
+  (testing "pr-str produces #ordered/interval-set tag"
+    (let [s (oc/interval-set [[1 5] [10 20]])]
+      (is (clojure.string/starts-with? (pr-str s) "#ordered/interval-set ")))))
+
+(deftest interval-set-round-trip
+  (testing "read-string round-trip"
+    (let [s (oc/interval-set [[1 5] [10 20] [3 8]])]
+      (is (= (vec s) (vec (round-trip s))))))
+  (testing "clojure.edn round-trip"
+    (let [s (oc/interval-set [[1 5] [10 20]])]
+      (is (= (vec s) (vec (edn-round-trip s))))))
+  (testing "empty interval-set"
+    (let [s (oc/interval-set)]
+      (is (= s (round-trip s)))))
+  (testing "single interval"
+    (let [s (oc/interval-set [[1 10]])]
+      (is (= (vec s) (vec (round-trip s))))))
+  (testing "overlapping queries work after round-trip"
+    (let [s (round-trip (oc/interval-set [[1 5] [3 8] [10 20]]))]
+      (is (seq (oc/overlapping s 4))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest interval-map-tagged-literal-format
+  (testing "pr-str produces #ordered/interval-map tag"
+    (let [m (oc/interval-map {[1 5] :a [10 20] :b})]
+      (is (clojure.string/starts-with? (pr-str m) "#ordered/interval-map ")))))
+
+(deftest interval-map-round-trip
+  (testing "read-string round-trip"
+    (let [m (oc/interval-map {[1 5] :a [10 20] :b [3 8] :c})]
+      (is (= (set (map (fn [[k v]] [(vec k) v]) m))
+             (set (map (fn [[k v]] [(vec k) v]) (round-trip m)))))))
+  (testing "clojure.edn round-trip"
+    (let [m (oc/interval-map {[1 5] :a [10 20] :b})]
+      (is (= (count m) (count (edn-round-trip m))))))
+  (testing "empty interval-map"
+    (let [m (oc/interval-map)]
+      (is (= m (round-trip m)))))
+  (testing "overlapping queries work after round-trip"
+    (let [m (round-trip (oc/interval-map {[1 5] :a [3 8] :b}))]
+      (is (seq (oc/overlapping m 4))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Range Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest range-map-tagged-literal-format
+  (testing "pr-str produces #ordered/range-map tag"
+    (let [rm (oc/range-map [[[0 10] :a] [[20 30] :b]])]
+      (is (clojure.string/starts-with? (pr-str rm) "#ordered/range-map ")))))
+
+(deftest range-map-round-trip
+  (testing "read-string round-trip"
+    (let [rm (oc/range-map [[[0 10] :a] [[20 30] :b]])]
+      (is (= (set (seq rm)) (set (seq (round-trip rm)))))))
+  (testing "clojure.edn round-trip"
+    (let [rm (oc/range-map [[[0 10] :a] [[20 30] :b]])]
+      (is (= (count rm) (count (edn-round-trip rm))))))
+  (testing "empty range-map"
+    (let [rm (oc/range-map)]
+      (is (= rm (round-trip rm))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Priority Queue
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest priority-queue-tagged-literal-format
+  (testing "pr-str produces #ordered/priority-queue tag"
+    (let [pq (oc/priority-queue [[1 :a] [3 :c] [2 :b]])]
+      (is (clojure.string/starts-with? (pr-str pq) "#ordered/priority-queue ")))))
+
+(deftest priority-queue-round-trip
+  (testing "read-string round-trip"
+    (let [pq (oc/priority-queue [[1 :a] [3 :c] [2 :b]])]
+      (is (= (vec (seq pq)) (vec (seq (round-trip pq)))))))
+  (testing "clojure.edn round-trip"
+    (let [pq (oc/priority-queue [[1 :a] [3 :c] [2 :b]])]
+      (is (= (vec (seq pq)) (vec (seq (edn-round-trip pq)))))))
+  (testing "empty priority-queue"
+    (let [pq (oc/priority-queue [])]
+      (is (= 0 (count (round-trip pq)))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Multiset
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-multiset-tagged-literal-format
+  (testing "pr-str produces #ordered/multiset tag"
+    (let [ms (oc/ordered-multiset [3 1 2 1])]
+      (is (clojure.string/starts-with? (pr-str ms) "#ordered/multiset ")))))
+
+(deftest ordered-multiset-round-trip
+  (testing "read-string round-trip"
+    (let [ms (oc/ordered-multiset [3 1 4 1 5])]
+      (is (= (vec (seq ms)) (vec (seq (round-trip ms)))))))
+  (testing "clojure.edn round-trip"
+    (let [ms (oc/ordered-multiset [1 2 2 3])]
+      (is (= (vec (seq ms)) (vec (seq (edn-round-trip ms)))))))
+  (testing "empty multiset"
+    (let [ms (oc/ordered-multiset [])]
+      (is (= 0 (count (round-trip ms)))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Custom Comparator Guarding
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest custom-comparator-prints-unreadable
+  (testing "ordered-set with custom comparator prints unreadable form"
+    (let [s (oc/ordered-set-by > [3 1 2])]
+      (is (clojure.string/starts-with? (pr-str s) "#<OrderedSet "))))
+  (testing "ordered-map with custom comparator prints unreadable form"
+    (let [m (oc/ordered-map-by > [[3 :c] [1 :a] [2 :b]])]
+      (is (clojure.string/starts-with? (pr-str m) "#<OrderedMap "))))
+  (testing "priority-queue with custom comparator prints unreadable form"
+    (let [pq (oc/priority-queue-by > [[1 :a] [3 :c]])]
+      (is (clojure.string/starts-with? (pr-str pq) "#<PriorityQueue "))))
+  (testing "ordered-multiset with custom comparator prints unreadable form"
+    (let [ms (oc/ordered-multiset-by > [3 1 2])]
+      (is (clojure.string/starts-with? (pr-str ms) "#<OrderedMultiset ")))))
+
+(deftest unreadable-forms-throw-on-read
+  (testing "unreadable forms cannot be read back"
+    (let [s (oc/ordered-set-by > [3 1 2])]
+      (is (thrown? Exception (read-string (pr-str s)))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Non-Round-Trippable Types (always unreadable)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest non-round-trippable-types-print-unreadable
+  (testing "FuzzySet prints unreadable form"
+    (let [fs (oc/fuzzy-set [1 5 10 20])]
+      (is (clojure.string/starts-with? (pr-str fs) "#<FuzzySet "))))
+  (testing "FuzzyMap prints unreadable form"
+    (let [fm (oc/fuzzy-map {1 :a 5 :b 10 :c})]
+      (is (clojure.string/starts-with? (pr-str fm) "#<FuzzyMap "))))
+  (testing "SegmentTree prints unreadable form"
+    (let [st (oc/segment-tree + 0 {0 10 1 20 2 30})]
+      (is (clojure.string/starts-with? (pr-str st) "#<SegmentTree ")))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Functional Verification After Round-Trip
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest operations-after-round-trip
+  (testing "ordered-set operations work after EDN round-trip"
+    (let [s (round-trip (oc/ordered-set [10 20 30 40 50]))]
+      (is (= 30 (nth s 2)))
+      (is (= 2 (oc/rank s 30)))
+      (is (= 30 (oc/nearest s :<= 35)))
+      (is (= 40 (oc/nearest s :>= 35)))
+      (is (contains? (conj s 25) 25))
+      (is (not (contains? (disj s 30) 30)))))
+  (testing "ordered-map operations work after EDN round-trip"
+    (let [m (round-trip (oc/ordered-map [[1 :a] [2 :b] [3 :c]]))]
+      (is (= :b (m 2)))
+      (is (= :d (get (assoc m 4 :d) 4)))
+      (is (nil? (get (dissoc m 2) 2))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Rope
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-tagged-literal-format
+  (testing "pr-str produces #ordered/rope tag"
+    (is (= "#ordered/rope [1 2 3]" (pr-str (oc/rope [1 2 3])))))
+  (testing "empty rope"
+    (is (= "#ordered/rope []" (pr-str (oc/rope)))))
+  (testing "slice materializes with same tag"
+    (is (= "#ordered/rope [2 3 4]"
+          (pr-str (oc/rope-sub (oc/rope (range 6)) 2 5))))))
+
+(deftest rope-round-trip
+  (testing "read-string round-trip"
+    (let [r (oc/rope [10 20 30 40 50])]
+      (is (= r (round-trip r)))
+      (is (= (into [] r) (into [] (round-trip r))))))
+  (testing "edn/read-string round-trip"
+    (let [r (oc/rope (range 100))]
+      (is (= r (edn-round-trip r)))))
+  (testing "empty round-trip"
+    (let [r (oc/rope)]
+      (is (= r (round-trip r)))))
+  (testing "slice round-trips as rope"
+    (let [sl (oc/rope-sub (oc/rope (range 20)) 5 15)
+          rt (round-trip sl)]
+      (is (= (into [] sl) (into [] rt))))))
+
+(deftest rope-operations-after-round-trip
+  (testing "operations work after EDN round-trip"
+    (let [r (round-trip (oc/rope [10 20 30 40 50]))]
+      (is (= 30 (nth r 2)))
+      (is (= [10 20 30 40 50 60] (into [] (conj r 60))))
+      (is (= [10 20 99 40 50] (into [] (assoc r 2 99))))
+      (is (= [10 20] (into [] (first (oc/rope-split r 2)))))
+      (is (= 150 (reduce + r))))))
diff --git a/test/ordered_collections/equality_test.clj b/test/ordered_collections/equality_test.clj
new file mode 100644
index 0000000..9ece053
--- /dev/null
+++ b/test/ordered_collections/equality_test.clj
@@ -0,0 +1,306 @@
+(ns ordered-collections.equality-test
+  "Generative tests for equality and hashing across all ordered collection types.
+
+   Verifies:
+   - Cross-type equality (ordered-set ↔ sorted-set ↔ hash-set ↔ data.avl, etc.)
+   - Hash contract compliance (equals → same hash, across types)
+   - Hash consistency (insertion order independence)
+   - Equality symmetry (a = b ↔ b = a)
+   - Specialized variant equality (long-ordered-set = ordered-set, etc.)"
+  (:require [clojure.data.avl :as avl]
+            [clojure.test :refer [deftest is testing]]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.core :as oc]
+            [ordered-collections.test-utils :as tu]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Generators
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def gen-intervals
+  "Vectors of [lo hi] interval pairs."
+  (gen/vector
+    (gen/fmap (fn [[a b]] [(min a b) (max a b)])
+              (gen/tuple (gen/choose -100 100) (gen/choose -100 100)))
+    0 50))
+
+(def gen-interval-entries
+  "Vectors of [[lo hi] value] pairs with distinct interval keys."
+  (gen/fmap
+    (fn [kvs] (mapv (fn [[k v]] [[(* k 2) (inc (* k 2))] v]) kvs))
+    tu/gen-int-map-entries))
+
+(def gen-multiset-elements
+  "Vectors of integers (duplicates allowed)."
+  (gen/vector (gen/choose -50 50) 0 100))
+
+(def gen-non-overlapping-ranges
+  "Vectors of [[lo hi] value] with non-overlapping ranges."
+  (gen/fmap
+    (fn [points]
+      (let [sorted (sort (distinct points))
+            pairs  (partition 2 sorted)]
+        (mapv (fn [[lo hi]] [[lo hi] lo]) pairs)))
+    (gen/vector (gen/choose -100 100) 0 20)))
+
+(def gen-segment-entries
+  "Maps of {int-index int-value}."
+  (gen/fmap #(into {} (map-indexed vector %))
+            (gen/vector gen/small-integer 0 50)))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Set
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-set-cross-type-equality-and-hash 100
+  (prop/for-all [xs tu/gen-int-set]
+    (let [os  (tu/->os xs)
+          ss  (tu/->ss xs)
+          hs  (tu/->hs xs)
+          avl (tu/->as xs)]
+      (and (= os ss) (= ss os)
+           (= os hs) (= hs os)
+           (= os avl) (= avl os)
+           (= (hash os) (hash ss) (hash hs) (hash avl))))))
+
+(defspec prop-set-variant-equality-and-hash 100
+  (prop/for-all [xs tu/gen-int-set]
+    (let [os  (tu/->os xs)
+          los (tu/->los xs)
+          ros (oc/ordered-set-by > xs)
+          ss  (tu/->ss xs)]
+      (and (= os los) (= los os) (= los ss)
+           (= os ros) (= ros os) (= ros ss)
+           (= (hash os) (hash los) (hash ros) (hash ss))))))
+
+(defspec prop-set-string-variant-equality-and-hash 100
+  (prop/for-all [xs (gen/vector-distinct gen/string-alphanumeric
+                                         {:min-elements 0 :max-elements 100})]
+    (let [os  (oc/ordered-set xs)
+          sos (oc/string-ordered-set xs)
+          ss  (into (sorted-set) xs)]
+      (and (= os sos) (= sos os) (= os ss) (= ss os)
+           (= (hash os) (hash sos) (hash ss))))))
+
+(defspec prop-set-hash-insertion-order 100
+  (prop/for-all [xs tu/gen-int-set]
+    (= (hash (tu/->os xs))
+       (hash (tu/->os (shuffle xs))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-map-cross-type-equality-and-hash 100
+  (prop/for-all [kvs tu/gen-int-map-entries]
+    (let [om  (tu/->om kvs)
+          sm  (tu/->sm kvs)
+          hm  (into {} kvs)
+          avl (tu/->am kvs)]
+      (and (= om sm) (= sm om)
+           (= om hm) (= hm om)
+           (= om avl) (= avl om)
+           (= (hash om) (hash sm) (hash hm) (hash avl))))))
+
+(defspec prop-map-variant-equality-and-hash 100
+  (prop/for-all [kvs tu/gen-int-map-entries]
+    (let [om  (tu/->om kvs)
+          lom (oc/long-ordered-map kvs)
+          rom (oc/ordered-map-by > kvs)
+          sm  (tu/->sm kvs)
+          hm  (into {} kvs)
+          avl (tu/->am kvs)]
+      (and ;; cross-variant equality (symmetric)
+           (= om lom)  (= lom om)
+           (= om rom)  (= rom om)
+           (= lom rom) (= rom lom)
+           ;; each variant equals reference implementations
+           (= lom sm) (= sm lom) (= lom hm) (= hm lom) (= lom avl) (= avl lom)
+           (= rom sm) (= sm rom) (= rom hm) (= hm rom) (= rom avl) (= avl rom)
+           ;; hash contract across all variants
+           (= (hash om) (hash lom) (hash rom) (hash sm) (hash hm) (hash avl))))))
+
+(defspec prop-map-hash-insertion-order 100
+  (prop/for-all [kvs tu/gen-int-map-entries]
+    (= (hash (tu/->om kvs))
+       (hash (tu/->om (shuffle kvs))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fuzzy Set
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-fuzzy-set-cross-type-equality-and-hash 100
+  (prop/for-all [xs tu/gen-int-set]
+    (let [fs  (oc/fuzzy-set xs)
+          os  (tu/->os xs)
+          ss  (tu/->ss xs)
+          hs  (tu/->hs xs)
+          avl (tu/->as xs)]
+      (and (= fs os) (= os fs)
+           (= fs ss) (= ss fs)
+           (= fs hs) (= hs fs)
+           (= fs avl) (= avl fs)
+           (= (hash fs) (hash os) (hash ss) (hash hs) (hash avl))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fuzzy Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-fuzzy-map-cross-type-equality-and-hash 100
+  (prop/for-all [kvs tu/gen-int-map-entries]
+    (let [fm  (oc/fuzzy-map kvs)
+          om  (tu/->om kvs)
+          sm  (tu/->sm kvs)
+          hm  (into {} kvs)
+          avl (tu/->am kvs)]
+      (and (= fm om) (= om fm)
+           (= fm sm) (= sm fm)
+           (= fm hm) (= hm fm)
+           (= fm avl) (= avl fm)
+           (= (hash fm) (hash om) (hash sm) (hash hm) (hash avl))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Set
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-interval-set-equality-and-hash 100
+  (prop/for-all [intervals gen-intervals]
+    (let [is1 (oc/interval-set intervals)
+          is2 (oc/interval-set (shuffle intervals))]
+      (and (= is1 is2) (= is2 is1)
+           (= (hash is1) (hash is2))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-interval-map-equality-and-hash 100
+  (prop/for-all [entries gen-interval-entries]
+    (let [im1 (oc/interval-map entries)
+          im2 (oc/interval-map (shuffle entries))]
+      (and (= im1 im2) (= im2 im1)
+           (= (hash im1) (hash im2))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Multiset
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-multiset-equality-and-hash 100
+  (prop/for-all [xs gen-multiset-elements]
+    (let [ms1 (oc/ordered-multiset xs)
+          ms2 (oc/ordered-multiset (shuffle xs))]
+      (and (= ms1 ms2) (= ms2 ms1)
+           (= (hash ms1) (hash ms2))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Priority Queue
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-pq-equality-and-hash 100
+  (prop/for-all [kvs tu/gen-int-map-entries]
+    (let [pq1 (oc/priority-queue kvs)
+          pq2 (oc/priority-queue (shuffle kvs))]
+      (and (= pq1 pq2) (= pq2 pq1)
+           (= (hash pq1) (hash pq2))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Range Map
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-range-map-equality-and-hash 100
+  (prop/for-all [entries gen-non-overlapping-ranges]
+    (let [rm1 (oc/range-map entries)
+          rm2 (oc/range-map (shuffle entries))]
+      (and (= rm1 rm2) (= rm2 rm1)
+           (= (hash rm1) (hash rm2))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Segment Tree
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-segment-tree-equality-and-hash 100
+  (prop/for-all [entries gen-segment-entries]
+    (let [st1 (oc/segment-tree + 0 entries)
+          st2 (oc/segment-tree + 0 (shuffle (vec entries)))]
+      (and (= st1 st2) (= st2 st1)
+           (= (hash st1) (hash st2))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Focused Equality Cases
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest large-set-equality-cases
+  (let [n         10000
+        xs        (vec (shuffle (range n)))
+        ys        (assoc xs (dec n) n)
+        shorter   (subvec xs 0 (dec n))
+        os        (oc/ordered-set xs)
+        os-same   (oc/ordered-set (reverse xs))
+        os-diff   (oc/ordered-set ys)
+        os-short  (oc/ordered-set shorter)
+        ss        (into (sorted-set) xs)
+        hs        (set xs)
+        avl-set   (into (avl/sorted-set) xs)]
+    (testing "equal sets across construction paths and compatible types"
+      (is (= os os-same))
+      (is (= os ss))
+      (is (= os hs))
+      (is (= os avl-set))
+      (is (= (hash os) (hash os-same) (hash ss) (hash hs) (hash avl-set))))
+    (testing "same-size one-different set is not equal"
+      (is (not= os os-diff))
+      (is (not= os-diff os))
+      (is (not= os (into (sorted-set) ys)))
+      (is (not= os (set ys)))
+      (is (not= os (into (avl/sorted-set) ys))))
+    (testing "count-different set is not equal"
+      (is (not= os os-short))
+      (is (not= os-short os))
+      (is (not= os (into (sorted-set) shorter)))
+      (is (not= os (set shorter)))
+      (is (not= os (into (avl/sorted-set) shorter))))))
+
+(deftest large-map-equality-cases
+  (let [n         10000
+        kvs       (mapv (fn [k] [k (str k)]) (shuffle (range n)))
+        kvs-diff  (assoc kvs (dec n) [(dec n) ::different])
+        kvs-short (subvec kvs 0 (dec n))
+        om        (oc/ordered-map kvs)
+        om-same   (oc/ordered-map (reverse kvs))
+        om-diff   (oc/ordered-map kvs-diff)
+        om-short  (oc/ordered-map kvs-short)
+        sm        (into (sorted-map) kvs)
+        hm        (into {} kvs)
+        avl-map   (into (avl/sorted-map) kvs)]
+    (testing "equal maps across construction paths and compatible types"
+      (is (= om om-same))
+      (is (= om sm))
+      (is (= om hm))
+      (is (= om avl-map))
+      (is (= (hash om) (hash om-same) (hash sm) (hash hm) (hash avl-map))))
+    (testing "same-size one-different map is not equal"
+      (is (not= om om-diff))
+      (is (not= om-diff om))
+      (is (not= om (into (sorted-map) kvs-diff)))
+      (is (not= om (into {} kvs-diff)))
+      (is (not= om (into (avl/sorted-map) kvs-diff))))
+    (testing "count-different map is not equal"
+      (is (not= om om-short))
+      (is (not= om-short om))
+      (is (not= om (into (sorted-map) kvs-short)))
+      (is (not= om (into {} kvs-short)))
+      (is (not= om (into (avl/sorted-map) kvs-short))))))
diff --git a/test/ordered_collections/equivalence_test.clj b/test/ordered_collections/equivalence_test.clj
new file mode 100644
index 0000000..4c13c56
--- /dev/null
+++ b/test/ordered_collections/equivalence_test.clj
@@ -0,0 +1,528 @@
+(ns ordered-collections.equivalence-test
+  "Rigorous equivalence tests comparing ordered-collections to sorted-set,
+   sorted-map, and clojure.data.avl across multiple scales.
+
+   Test categories:
+   - Equivalence tests: Verify identical behavior with reference implementations
+   - Correctness tests: Verify invariants hold at high cardinality (1M+)
+   - Property tests: Generative testing via test.check"
+  (:require [clojure.data.avl :as avl]
+            [clojure.set :as cset]
+            [clojure.test :refer [deftest testing is]]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.core :as oc]
+            [ordered-collections.test-utils :as tu
+             :refer [small medium large huge massive extreme
+                     rand-longs rand-ints rand-strings rand-map-entries
+                     ->ss ->as ->os ->los ->sm ->am ->om
+                     assert-eq with-iterations]]
+            [ordered-collections.protocol :as proto]))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PART 1: SET EQUIVALENCE TESTS
+;;
+;; These compare ordered-set behavior to sorted-set and data.avl
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest set-construction-equivalence
+  (testing "Sets contain same elements in same order"
+    (with-iterations 20
+      (doseq [[label n] [[:small small] [:medium medium] [:large large]]]
+        (let [xs (rand-longs n (* n 10))
+              ss (->ss xs), as (->as xs), os (->os xs)]
+          (assert-eq (str "construction " label) (vec ss) (vec as) (vec os))
+          (assert-eq (str "count " label) (count ss) (count as) (count os)))))))
+
+(deftest set-construction-with-negatives
+  (testing "Negative numbers sort correctly"
+    (with-iterations 20
+      (let [xs (rand-ints medium (* medium 10))
+            ss (->ss xs), as (->as xs), os (->os xs)]
+        (assert-eq "negative ints" (vec ss) (vec as) (vec os))
+        (is (apply < (vec ss)) "ascending order")))))
+
+(deftest set-construction-strings
+  (testing "String sets are equivalent"
+    (with-iterations 20
+      (let [xs (rand-strings medium)
+            ss (->ss xs), as (->as xs), os (oc/string-ordered-set xs)]
+        (assert-eq "string set" (vec ss) (vec as) (vec os))))))
+
+(deftest set-mutation-conj
+  (testing "Incremental conj produces same result"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))]
+        (loop [ss (sorted-set), as (avl/sorted-set), os (oc/ordered-set), xs xs]
+          (if (empty? xs)
+            (assert-eq "incremental conj" (vec ss) (vec as) (vec os))
+            (let [x (first xs)]
+              (recur (conj ss x) (conj as x) (conj os x) (rest xs)))))))))
+
+(deftest set-mutation-disj
+  (testing "Deletion produces same result"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            del (take (quot medium 2) (shuffle xs))
+            ss (reduce disj (->ss xs) del)
+            as (reduce disj (->as xs) del)
+            os (reduce disj (->os xs) del)]
+        (assert-eq "deletion" (vec ss) (vec as) (vec os))))))
+
+(deftest set-mutation-interleaved
+  (testing "Interleaved insert/delete matches"
+    (with-iterations 20
+      (let [ops (for [_ (range (* 2 medium))]
+                  (if (< (rand) 0.65)
+                    [:conj (rand-int (* medium 10))]
+                    [:disj (rand-int (* medium 10))]))]
+        (loop [ss (sorted-set), as (avl/sorted-set), os (oc/ordered-set), ops ops]
+          (if (empty? ops)
+            (assert-eq "interleaved ops" (vec ss) (vec as) (vec os))
+            (let [[op v] (first ops)]
+              (case op
+                :conj (recur (conj ss v) (conj as v) (conj os v) (rest ops))
+                :disj (recur (disj ss v) (disj as v) (disj os v) (rest ops))))))))))
+
+(deftest set-lookup
+  (testing "Lookups produce identical results"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            ss (->ss xs), as (->as xs), os (->os xs)
+            ks (concat (take 100 xs) (rand-longs 100 (* medium 10)))]
+        (doseq [k ks]
+          (assert-eq (str "contains? " k) (contains? ss k) (contains? as k) (contains? os k))
+          (assert-eq (str "get " k) (get ss k) (get as k) (get os k)))))))
+
+(deftest set-iteration
+  (testing "Iteration order matches"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            ss (->ss xs), as (->as xs), os (->os xs)]
+        (assert-eq "forward" (vec ss) (vec as) (vec os))
+        (assert-eq "reverse" (vec (rseq ss)) (vec (rseq as)) (vec (rseq os)))))))
+
+(deftest set-reduce
+  (testing "Reduce produces identical results"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            ss (->ss xs), as (->as xs), os (->os xs)]
+        (assert-eq "sum" (reduce + 0 ss) (reduce + 0 as) (reduce + 0 os))
+        (assert-eq "count via reduce"
+                   (reduce (fn [n _] (inc n)) 0 ss)
+                   (reduce (fn [n _] (inc n)) 0 as)
+                   (reduce (fn [n _] (inc n)) 0 os))))))
+
+(deftest set-reduce-no-init
+  (testing "Reduce without init matches"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            ss (->ss xs), as (->as xs), os (->os xs)]
+        (assert-eq "sum no init" (reduce + ss) (reduce + as) (reduce + os))
+        (assert-eq "max no init" (reduce max ss) (reduce max as) (reduce max os))
+        (assert-eq "min no init" (reduce min ss) (reduce min as) (reduce min os))))))
+
+(deftest set-algebra-union
+  (testing "Union produces identical results"
+    (with-iterations 20
+      (let [xs1 (rand-longs medium (* medium 10))
+            xs2 (rand-longs medium (* medium 10))
+            ss-u (cset/union (->ss xs1) (->ss xs2))
+            os-u (proto/union (->os xs1) (->os xs2))]
+        (assert-eq "union" (vec ss-u) (vec os-u))))))
+
+(deftest set-algebra-intersection
+  (testing "Intersection produces identical results"
+    (with-iterations 20
+      (let [base (rand-longs (quot medium 3) (* medium 5))
+            xs1 (concat base (rand-longs (quot medium 3) (* medium 5)))
+            xs2 (concat base (rand-longs (quot medium 3) (* medium 5)))
+            ss-i (cset/intersection (->ss xs1) (->ss xs2))
+            os-i (proto/intersection (->os xs1) (->os xs2))]
+        (assert-eq "intersection" (vec ss-i) (vec os-i))
+        (is (>= (count os-i) (count (set base))) "intersection contains base")))))
+
+(deftest set-algebra-difference
+  (testing "Difference produces identical results"
+    (with-iterations 20
+      (let [base (rand-longs (quot medium 3) (* medium 5))
+            xs1 (concat base (rand-longs (quot medium 3) (* medium 5)))
+            xs2 (concat base (rand-longs (quot medium 3) (* medium 5)))
+            ss-d (cset/difference (->ss xs1) (->ss xs2))
+            os-d (proto/difference (->os xs1) (->os xs2))]
+        (assert-eq "difference" (vec ss-d) (vec os-d))))))
+
+(deftest set-algebra-subset
+  (testing "subset?/superset? match"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            half (take (quot medium 2) xs)
+            ss-full (->ss xs), ss-half (->ss half)
+            os-full (->os xs), os-half (->os half)]
+        (assert-eq "subset?" (cset/subset? ss-half ss-full) (proto/subset? os-half os-full))
+        (assert-eq "superset?" (cset/superset? ss-full ss-half) (proto/superset? os-full os-half))
+        (assert-eq "subset? self" (cset/subset? ss-full ss-full) (proto/subset? os-full os-full))))))
+
+(deftest set-sorted-interface
+  (testing "subseq/rsubseq match"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            ss (->ss xs), os (->os xs)
+            sorted (vec (sort xs))
+            lo (nth sorted (quot (count sorted) 4))
+            hi (nth sorted (* 3 (quot (count sorted) 4)))]
+        (assert-eq "subseq >=" (vec (subseq ss >= lo)) (vec (subseq os >= lo)))
+        (assert-eq "subseq >"  (vec (subseq ss > lo))  (vec (subseq os > lo)))
+        (assert-eq "subseq <"  (vec (subseq ss < hi))  (vec (subseq os < hi)))
+        (assert-eq "subseq <=" (vec (subseq ss <= hi)) (vec (subseq os <= hi)))
+        (assert-eq "subseq >= <" (vec (subseq ss >= lo < hi)) (vec (subseq os >= lo < hi)))
+        (assert-eq "rsubseq >=" (vec (rsubseq ss >= lo)) (vec (rsubseq os >= lo)))
+        (assert-eq "rsubseq <=" (vec (rsubseq ss <= hi)) (vec (rsubseq os <= hi)))))))
+
+(deftest set-first-last
+  (testing "first/last match"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            ss (->ss xs), as (->as xs), os (->os xs)]
+        (assert-eq "first" (first ss) (first as) (first os))
+        (assert-eq "last" (last ss) (last as) (last os))
+        ;; Java SortedSet interface
+        (let [^java.util.SortedSet jos os]
+          (assert-eq ".first" (first ss) (.first jos))
+          (assert-eq ".last" (last ss) (.last jos)))))))
+
+(deftest set-java-sorted-interface
+  (testing "headSet/tailSet/subSet match"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            ss (->ss xs)
+            os ^java.util.SortedSet (->os xs)
+            sorted (vec (sort xs))
+            lo (nth sorted (quot (count sorted) 4))
+            hi (nth sorted (* 3 (quot (count sorted) 4)))]
+        (assert-eq ".headSet" (vec (take-while #(< % hi) ss)) (vec (.headSet os hi)))
+        (assert-eq ".tailSet" (vec (drop-while #(< % lo) ss)) (vec (.tailSet os lo)))
+        (assert-eq ".subSet" (vec (filter #(and (>= % lo) (< % hi)) ss)) (vec (.subSet os lo hi)))))))
+
+(deftest set-nth-equivalence
+  (testing "nth matches data.avl"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            as (->as xs), os (->os xs)
+            idxs (repeatedly 100 #(rand-int (count xs)))]
+        (doseq [i idxs]
+          (assert-eq (str "nth " i) (nth as i) (nth os i)))))))
+
+(deftest set-rank-equivalence
+  (testing "rank matches data.avl"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            as (->as xs), os (->os xs)]
+        (doseq [i (range 0 (count xs) (max 1 (quot (count xs) 50)))]
+          (let [k (nth as i)]
+            (assert-eq (str "rank " k) (avl/rank-of as k) (.indexOf ^java.util.List os k))))))))
+
+(deftest set-hash-consistency
+  (testing "Hash is consistent for equal sets"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            os1 (->os xs)
+            os2 (->os (shuffle xs))]
+        (assert-eq "hash of same data" (hash os1) (hash os2))
+        (assert-eq "hash is stable" (hash os1) (hash os1))))))
+
+(deftest set-equality
+  (testing "Equality semantics"
+    (with-iterations 20
+      (let [xs (rand-longs medium (* medium 10))
+            ss (->ss xs), os (->os xs), hs (set xs)]
+        (is (= ss os) "sorted-set = ordered-set")
+        (is (= os ss) "ordered-set = sorted-set")
+        (is (= ss hs) "sorted-set = hash-set")
+        (is (= os hs) "ordered-set = hash-set")
+        (is (= os (->os (shuffle xs))) "ordered-set = shuffled ordered-set")))))
+
+(deftest set-empty
+  (testing "Empty set operations"
+    (let [ss (sorted-set), as (avl/sorted-set), os (oc/ordered-set)]
+      (assert-eq "count" 0 (count ss) (count as) (count os))
+      (assert-eq "seq" nil (seq ss) (seq as) (seq os))
+      (assert-eq "first" nil (first ss) (first as) (first os))
+      (assert-eq "disj empty" [] (vec (disj ss 1)) (vec (disj as 1)) (vec (disj os 1))))))
+
+(deftest set-single-element
+  (testing "Single element operations"
+    (let [ss (sorted-set 42), as (avl/sorted-set 42), os (oc/ordered-set [42])]
+      (assert-eq "count" 1 (count ss) (count as) (count os))
+      (assert-eq "first" 42 (first ss) (first as) (first os))
+      (assert-eq "contains?" true (contains? ss 42) (contains? as 42) (contains? os 42))
+      (assert-eq "disj" [] (vec (disj ss 42)) (vec (disj as 42)) (vec (disj os 42))))))
+
+(deftest set-duplicates
+  (testing "Duplicates are ignored"
+    (let [xs (concat (range 100) (range 50) (range 25))
+          ss (into (sorted-set) xs)
+          as (into (avl/sorted-set) xs)
+          os (oc/ordered-set xs)]
+      (assert-eq "count" 100 (count ss) (count as) (count os))
+      (assert-eq "seq" (vec ss) (vec as) (vec os)))))
+
+(deftest set-boundary-values
+  (testing "Long boundary values"
+    (let [xs [Long/MIN_VALUE -1 0 1 Long/MAX_VALUE]
+          ss (->ss xs), os (->los xs)]
+      (assert-eq "boundary values" (vec ss) (vec os))
+      (is (= Long/MIN_VALUE (first os)))
+      (is (= Long/MAX_VALUE (last os))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PART 2: MAP EQUIVALENCE TESTS
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest map-construction-equivalence
+  (testing "Maps contain same entries in same order"
+    (with-iterations 20
+      (let [xs (rand-map-entries medium (* medium 10))
+            sm (->sm xs), am (->am xs), om (->om xs)]
+        (assert-eq "construction" (vec sm) (vec am) (vec om))
+        (assert-eq "count" (count sm) (count am) (count om))))))
+
+(deftest map-mutation
+  (testing "Map mutations match"
+    (with-iterations 20
+      (let [xs (rand-map-entries medium (* medium 10))
+            sm (->sm xs), om (->om xs)
+            new-k (+ (* medium 10) (rand-int 1000))
+            new-v (rand-int 1000000)]
+        ;; assoc
+        (assert-eq "assoc" (vec (assoc sm new-k new-v)) (vec (assoc om new-k new-v)))
+        ;; dissoc
+        (let [k (ffirst sm)]
+          (assert-eq "dissoc" (vec (dissoc sm k)) (vec (dissoc om k))))
+        ;; update
+        (let [k (ffirst sm)]
+          (assert-eq "update" (vec (update sm k inc)) (vec (update om k inc))))))))
+
+(deftest map-lookup
+  (testing "Map lookups match"
+    (with-iterations 20
+      (let [xs (rand-map-entries medium (* medium 10))
+            sm (->sm xs), om (->om xs)
+            ks (concat (take 100 (keys sm)) (rand-longs 100 (* medium 20)))]
+        (doseq [k ks]
+          (assert-eq (str "get " k) (get sm k) (get om k))
+          (assert-eq (str "get default " k) (get sm k ::not-found) (get om k ::not-found))
+          (assert-eq (str "contains? " k) (contains? sm k) (contains? om k))
+          (assert-eq (str "find " k) (find sm k) (find om k)))))))
+
+(deftest map-iteration
+  (testing "Map iteration matches"
+    (with-iterations 20
+      (let [xs (rand-map-entries medium (* medium 10))
+            sm (->sm xs), om (->om xs)]
+        (assert-eq "keys" (vec (keys sm)) (vec (keys om)))
+        (assert-eq "vals" (vec (vals sm)) (vec (vals om)))
+        (assert-eq "seq" (vec sm) (vec om))
+        (assert-eq "rseq" (vec (rseq sm)) (vec (rseq om)))))))
+
+(deftest map-reduce
+  (testing "Map reduce matches"
+    (with-iterations 20
+      (let [xs (rand-map-entries medium (* medium 10))
+            sm (->sm xs), om (->om xs)]
+        (assert-eq "reduce-kv"
+                   (reduce-kv (fn [acc k v] (+ acc k v)) 0 sm)
+                   (reduce-kv (fn [acc k v] (+ acc k v)) 0 om))))))
+
+(deftest map-hash-consistency
+  (testing "Map hash is consistent"
+    (with-iterations 20
+      (let [xs (rand-map-entries medium (* medium 10))
+            om1 (->om xs)
+            om2 (->om (shuffle xs))]
+        (assert-eq "hash of same data" (hash om1) (hash om2))))))
+
+(deftest map-equality
+  (testing "Map equality semantics"
+    (with-iterations 20
+      (let [xs (rand-map-entries medium (* medium 10))
+            sm (->sm xs), om (->om xs), hm (into {} xs)]
+        (is (= sm om) "sorted-map = ordered-map")
+        (is (= om sm) "ordered-map = sorted-map")
+        (is (= sm hm) "sorted-map = hash-map")
+        (is (= om hm) "ordered-map = hash-map")))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PART 3: HIGH CARDINALITY CORRECTNESS TESTS
+;;
+;; These test ordered-set invariants at extreme scales (1M, 5M elements)
+;; without comparing to sorted-set (which would be prohibitively slow).
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest high-cardinality-construction
+  (testing "Construction at 1M elements"
+    (let [xs (rand-longs massive (* massive 2))
+          os (oc/long-ordered-set xs)]
+      (is (= (count (set xs)) (count os)) "count matches unique elements")
+      (is (= (first os) (apply min xs)) "first is minimum")
+      (is (= (last os) (apply max xs)) "last is maximum"))))
+
+(deftest high-cardinality-construction-5m
+  (testing "Construction at 5M elements"
+    (let [xs (rand-longs extreme (* extreme 2))
+          os (oc/long-ordered-set xs)]
+      (is (= (count (set xs)) (count os)) "count matches unique elements")
+      (is (= (first os) (apply min xs)) "first is minimum")
+      (is (= (last os) (apply max xs)) "last is maximum"))))
+
+(deftest high-cardinality-sorted-invariant
+  (testing "Sorted invariant holds at 1M elements"
+    (let [xs (rand-longs massive (* massive 2))
+          os (oc/long-ordered-set xs)
+          sample-indices (repeatedly 1000 #(rand-int (count os)))]
+      ;; Sample pairs of adjacent indices to verify order
+      (doseq [i sample-indices]
+        (when (< (inc i) (count os))
+          (is (< (long (nth os i)) (long (nth os (inc i))))
+              (str "element at " i " < element at " (inc i))))))))
+
+(deftest high-cardinality-nth
+  (testing "nth at 1M elements"
+    (let [xs (rand-longs massive (* massive 2))
+          os (oc/long-ordered-set xs)
+          sorted-vec (vec (sort (distinct xs)))]
+      ;; Test specific indices
+      (is (= (nth sorted-vec 0) (nth os 0)) "nth 0")
+      (is (= (nth sorted-vec (dec (count os))) (nth os (dec (count os)))) "nth last")
+      (is (= (nth sorted-vec (quot (count os) 2)) (nth os (quot (count os) 2))) "nth middle")
+      ;; Sample random indices
+      (doseq [i (repeatedly 100 #(rand-int (count os)))]
+        (is (= (nth sorted-vec i) (nth os i)) (str "nth " i))))))
+
+(deftest high-cardinality-reduce
+  (testing "Reduce at 1M elements"
+    (let [xs (rand-longs massive (* massive 2))
+          os (oc/long-ordered-set xs)
+          expected-sum (reduce + 0 (distinct xs))]
+      (is (= expected-sum (reduce + 0 os)) "reduce sum"))))
+
+(deftest high-cardinality-contains
+  (testing "contains? at 1M elements"
+    (let [xs (rand-longs massive (* massive 2))
+          xs-set (set xs)
+          os (oc/long-ordered-set xs)
+          ;; Test with known members
+          members (take 1000 xs)
+          ;; Test with known non-members
+          non-members (take 1000 (filter #(not (xs-set %)) (rand-longs 2000 (* massive 3))))]
+      (doseq [x members]
+        (is (contains? os x) (str "contains member " x)))
+      (doseq [x non-members]
+        (is (not (contains? os x)) (str "not contains non-member " x))))))
+
+(deftest high-cardinality-subseq
+  (testing "subseq at 1M elements"
+    (let [xs (rand-longs massive (* massive 2))
+          os (oc/long-ordered-set xs)
+          sorted-vec (vec (sort (distinct xs)))
+          lo (nth sorted-vec (quot (count os) 4))
+          hi (nth sorted-vec (* 3 (quot (count os) 4)))]
+      ;; Just verify the subseq produces correct bounds
+      (let [sub (vec (subseq os >= lo < hi))]
+        (is (every? #(and (>= % lo) (< % hi)) sub) "subseq bounds correct")
+        (is (> (count sub) 0) "subseq not empty")))))
+
+(deftest high-cardinality-set-algebra
+  (testing "Set algebra at 100K elements"
+    (let [xs1 (rand-longs huge (* huge 5))
+          xs2 (rand-longs huge (* huge 5))
+          os1 (oc/long-ordered-set xs1)
+          os2 (oc/long-ordered-set xs2)
+          ss1 (set xs1)
+          ss2 (set xs2)]
+      ;; Union
+      (let [os-u (proto/union os1 os2)]
+        (is (= (count (cset/union ss1 ss2)) (count os-u)) "union count"))
+      ;; Intersection
+      (let [os-i (proto/intersection os1 os2)]
+        (is (= (count (cset/intersection ss1 ss2)) (count os-i)) "intersection count"))
+      ;; Difference
+      (let [os-d (proto/difference os1 os2)]
+        (is (= (count (cset/difference ss1 ss2)) (count os-d)) "difference count")))))
+
+(deftest high-cardinality-map
+  (testing "Map at 1M entries"
+    (let [xs (rand-map-entries massive (* massive 2))
+          om (oc/ordered-map xs)]
+      (is (= (count (into {} xs)) (count om)) "count matches")
+      ;; Sample lookups
+      (doseq [[k v] (take 1000 xs)]
+        (is (= v (get om k)) (str "get " k))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PART 4: PROPERTY-BASED TESTS (test.check)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def gen-int-set tu/gen-int-set)
+(def gen-int-map-entries tu/gen-int-map-entries)
+
+(defspec prop-set-construction 100
+  (prop/for-all [xs gen-int-set]
+    (= (vec (->ss xs)) (vec (->os xs)))))
+
+(defspec prop-set-conj 100
+  (prop/for-all [xs gen-int-set, x gen/small-integer]
+    (= (vec (conj (->ss xs) x)) (vec (conj (->os xs) x)))))
+
+(defspec prop-set-disj 100
+  (prop/for-all [xs gen-int-set]
+    (or (empty? xs)
+        (let [x (first xs)]
+          (= (vec (disj (->ss xs) x)) (vec (disj (->os xs) x)))))))
+
+(defspec prop-set-contains 100
+  (prop/for-all [xs gen-int-set, x gen/small-integer]
+    (= (contains? (->ss xs) x) (contains? (->os xs) x))))
+
+(defspec prop-set-count 100
+  (prop/for-all [xs gen-int-set]
+    (= (count (->ss xs)) (count (->os xs)))))
+
+(defspec prop-set-reduce 100
+  (prop/for-all [xs gen-int-set]
+    (= (reduce + 0 (->ss xs)) (reduce + 0 (->os xs)))))
+
+(defspec prop-set-hash-consistent 100
+  (prop/for-all [xs gen-int-set]
+    (= (hash (->os xs)) (hash (->os (shuffle xs))))))
+
+(defspec prop-set-equality 100
+  (prop/for-all [xs gen-int-set]
+    (= (->ss xs) (->os xs))))
+
+(defspec prop-map-construction 100
+  (prop/for-all [xs gen-int-map-entries]
+    (= (vec (->sm xs)) (vec (->om xs)))))
+
+(defspec prop-map-assoc 100
+  (prop/for-all [xs gen-int-map-entries, k gen/small-integer, v gen/small-integer]
+    (= (vec (assoc (->sm xs) k v)) (vec (assoc (->om xs) k v)))))
+
+(defspec prop-map-dissoc 100
+  (prop/for-all [xs gen-int-map-entries]
+    (or (empty? xs)
+        (let [k (ffirst xs)]
+          (= (vec (dissoc (->sm xs) k)) (vec (dissoc (->om xs) k)))))))
+
+(defspec prop-map-get 100
+  (prop/for-all [xs gen-int-map-entries, k gen/small-integer]
+    (= (get (->sm xs) k ::nf) (get (->om xs) k ::nf))))
+
+(defspec prop-map-hash-consistent 100
+  (prop/for-all [xs gen-int-map-entries]
+    (= (hash (->om xs)) (hash (->om (shuffle xs))))))
+
+(defspec prop-map-equality 100
+  (prop/for-all [xs gen-int-map-entries]
+    (= (->sm xs) (->om xs))))
diff --git a/test/ordered_collections/fuzzy_test.clj b/test/ordered_collections/fuzzy_test.clj
new file mode 100644
index 0000000..2f0cb54
--- /dev/null
+++ b/test/ordered_collections/fuzzy_test.clj
@@ -0,0 +1,407 @@
+(ns ordered-collections.fuzzy-test
+  (:require [clojure.test :refer [deftest testing is are]]
+            [clojure.core.reducers :as r]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.test-utils :as tu]
+            [ordered-collections.core :as oc]))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fuzzy Set Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest fuzzy-set-basic-test
+  (testing "Basic fuzzy set operations"
+    (let [fs (oc/fuzzy-set [1 5 10 20 50 100])]
+      ;; Exact matches
+      (is (= 1 (fs 1)))
+      (is (= 10 (fs 10)))
+      (is (= 100 (fs 100)))
+
+      ;; Closest matches
+      (is (= 1 (fs 0)))     ; 0 is closest to 1
+      (is (= 1 (fs 2)))     ; 2 is closest to 1
+      (is (= 5 (fs 4)))     ; 4 is closest to 5
+      (is (= 5 (fs 6)))     ; 6 is closest to 5
+      (is (= 5 (fs 7)))     ; 7 is closest to 5
+      (is (= 10 (fs 8)))    ; 8 is closest to 10
+      (is (= 10 (fs 12)))   ; 12 is closest to 10
+      (is (= 20 (fs 16)))   ; 16 is closest to 20
+      (is (= 100 (fs 200))) ; 200 is closest to 100
+      )))
+
+(deftest fuzzy-set-tiebreak-test
+  (testing "Tiebreaker with :< (prefer smaller)"
+    (let [fs (oc/fuzzy-set [0 10 20] :tiebreak :<)]
+      (is (= 0 (fs 5)))     ; 5 is equidistant from 0 and 10, prefer smaller
+      (is (= 10 (fs 15))))) ; 15 is equidistant from 10 and 20, prefer smaller
+
+  (testing "Tiebreaker with :> (prefer larger)"
+    (let [fs (oc/fuzzy-set [0 10 20] :tiebreak :>)]
+      (is (= 10 (fs 5)))    ; 5 is equidistant from 0 and 10, prefer larger
+      (is (= 20 (fs 15))))) ; 15 is equidistant from 10 and 20, prefer larger
+  )
+
+(deftest fuzzy-set-edge-cases-test
+  (testing "Empty fuzzy set"
+    (let [fs (oc/fuzzy-set [])]
+      (is (nil? (fs 5)))
+      (is (= :not-found (fs 5 :not-found)))))
+
+  (testing "Single element fuzzy set"
+    (let [fs (oc/fuzzy-set [42])]
+      (is (= 42 (fs 0)))
+      (is (= 42 (fs 100)))
+      (is (= 42 (fs 42)))))
+
+  (testing "Query at extremes"
+    (let [fs (oc/fuzzy-set [10 20 30])]
+      (is (= 10 (fs -1000)))   ; far below range
+      (is (= 30 (fs 1000))))) ; far above range
+  )
+
+(deftest fuzzy-set-exact-contains-test
+  (testing "exact-contains? for precise membership"
+    (let [fs (oc/fuzzy-set [1 5 10])]
+      (is (oc/fuzzy-exact-contains? fs 5))
+      (is (not (oc/fuzzy-exact-contains? fs 6)))
+      (is (not (oc/fuzzy-exact-contains? fs 7))))))
+
+(deftest fuzzy-set-nearest-test
+  (testing "fuzzy-nearest returns element and distance"
+    (let [fs (oc/fuzzy-set [0 10 20])]
+      (is (= [10 0.0] (oc/fuzzy-nearest fs 10)))  ; exact match
+      (is (= [10 3.0] (oc/fuzzy-nearest fs 7)))   ; closest with distance
+      (is (= [0 5.0] (oc/fuzzy-nearest fs -5)))))); negative query
+
+(deftest fuzzy-set-collection-ops-test
+  (testing "Standard collection operations"
+    (let [fs (oc/fuzzy-set [3 1 4 1 5 9 2 6])]
+      (is (= 7 (count fs)))  ; duplicates removed (1 appears twice)
+      (is (= [1 2 3 4 5 6 9] (vec (seq fs))))
+      (is (= [9 6 5 4 3 2 1] (vec (rseq fs))))
+      (is (= 1 (first fs)))
+      (is (= 9 (last fs)))))
+
+  (testing "conj and disj"
+    (let [fs (oc/fuzzy-set [1 5 10])]
+      (is (= 4 (count (conj fs 7))))
+      (is (= [1 5 7 10] (vec (seq (conj fs 7)))))
+      (is (= 2 (count (disj fs 5))))
+      (is (= [1 10] (vec (seq (disj fs 5)))))))
+
+  (testing "reduce"
+    (let [fs (oc/fuzzy-set [1 2 3 4 5])]
+      (is (= 15 (reduce + fs)))
+      (is (= 15 (reduce + 0 fs))))))
+
+(deftest fuzzy-set-fold-test
+  (testing "Parallel fold"
+    (let [fs (oc/fuzzy-set (range 1000))]
+      (is (= (reduce + (range 1000))
+             (r/fold + fs))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fuzzy Map Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest fuzzy-map-basic-test
+  (testing "Basic fuzzy map operations"
+    (let [fm (oc/fuzzy-map {0 :zero 10 :ten 100 :hundred})]
+      ;; Exact matches
+      (is (= :zero (fm 0)))
+      (is (= :ten (fm 10)))
+      (is (= :hundred (fm 100)))
+
+      ;; Closest matches
+      (is (= :zero (fm -5)))    ; -5 is closest to 0
+      (is (= :zero (fm 4)))     ; 4 is closest to 0
+      (is (= :ten (fm 6)))      ; 6 is closest to 10
+      (is (= :ten (fm 50)))     ; 50 is closer to 10 than 100
+      (is (= :hundred (fm 56))) ; 56 is closer to 100 than 10
+      (is (= :hundred (fm 200))))))
+
+(deftest fuzzy-map-tiebreak-test
+  (testing "Tiebreaker with :< (prefer smaller key)"
+    (let [fm (oc/fuzzy-map {0 :a 10 :b 20 :c} :tiebreak :<)]
+      (is (= :a (fm 5)))    ; 5 is equidistant from 0 and 10
+      (is (= :b (fm 15))))) ; 15 is equidistant from 10 and 20
+
+  (testing "Tiebreaker with :> (prefer larger key)"
+    (let [fm (oc/fuzzy-map {0 :a 10 :b 20 :c} :tiebreak :>)]
+      (is (= :b (fm 5)))    ; 5 is equidistant from 0 and 10
+      (is (= :c (fm 15))))) ; 15 is equidistant from 10 and 20
+  )
+
+(deftest fuzzy-map-edge-cases-test
+  (testing "Empty fuzzy map"
+    (let [fm (oc/fuzzy-map {})]
+      (is (nil? (fm 5)))
+      (is (= :not-found (fm 5 :not-found)))))
+
+  (testing "Single entry fuzzy map"
+    (let [fm (oc/fuzzy-map {50 :middle})]
+      (is (= :middle (fm 0)))
+      (is (= :middle (fm 100)))
+      (is (= :middle (fm 50))))))
+
+(deftest fuzzy-map-exact-ops-test
+  (testing "exact-contains? for precise key membership"
+    (let [fm (oc/fuzzy-map {1 :a 5 :b 10 :c})]
+      (is (oc/fuzzy-exact-contains? fm 5))
+      (is (not (oc/fuzzy-exact-contains? fm 6)))))
+
+  (testing "exact-get for non-fuzzy lookup"
+    (let [fm (oc/fuzzy-map {1 :a 5 :b 10 :c})]
+      (is (= :b (oc/fuzzy-exact-get fm 5)))
+      (is (nil? (oc/fuzzy-exact-get fm 6)))
+      (is (= :default (oc/fuzzy-exact-get fm 6 :default))))))
+
+(deftest fuzzy-map-nearest-test
+  (testing "fuzzy-nearest returns key, value, and distance"
+    (let [fm (oc/fuzzy-map {0 :a 10 :b 20 :c})]
+      (is (= [10 :b 0.0] (oc/fuzzy-nearest fm 10)))  ; exact match
+      (is (= [10 :b 3.0] (oc/fuzzy-nearest fm 7)))   ; closest with distance
+      (is (= [0 :a 5.0] (oc/fuzzy-nearest fm -5))))))
+
+(deftest fuzzy-map-collection-ops-test
+  (testing "Standard map operations"
+    (let [fm (oc/fuzzy-map {3 :c 1 :a 4 :d 2 :b})]
+      (is (= 4 (count fm)))
+      (is (= [[1 :a] [2 :b] [3 :c] [4 :d]] (vec (seq fm))))
+      (is (= [[4 :d] [3 :c] [2 :b] [1 :a]] (vec (rseq fm))))
+      (is (= 1 (.firstKey ^java.util.SortedMap fm)))
+      (is (= 4 (.lastKey ^java.util.SortedMap fm)))))
+
+  (testing "assoc and dissoc"
+    (let [fm (oc/fuzzy-map {1 :a 5 :b 10 :c})]
+      (is (= 4 (count (assoc fm 7 :d))))
+      (is (= :d ((assoc fm 7 :d) 7)))  ; exact lookup of new key
+      (is (= 2 (count (dissoc fm 5))))
+      (is (= [[1 :a] [10 :c]] (vec (seq (dissoc fm 5)))))))
+
+  (testing "reduce"
+    (let [fm (oc/fuzzy-map {1 10 2 20 3 30})]
+      (is (= 60 (reduce (fn [acc [k v]] (+ acc v)) 0 fm))))))
+
+(deftest fuzzy-map-fold-test
+  (testing "Parallel fold"
+    (let [fm (oc/fuzzy-map (zipmap (range 1000) (range 1000)))]
+      (is (= (reduce + (range 1000))
+             (r/fold + (fn [acc [k v]] (+ acc v)) fm))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Custom Distance Function Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest custom-distance-test
+  ;; Note: The fuzzy algorithm finds floor/ceiling neighbors in sort order,
+  ;; then compares by distance. This works correctly when the distance
+  ;; function correlates with the sort order (i.e., closest by distance
+  ;; is always a sort-order neighbor).
+
+  (testing "Fuzzy map with linear distance - standard case"
+    ;; Standard numeric distance works with default comparator
+    (let [fm (oc/fuzzy-map {0 :zero 3 :three 6 :six 9 :nine})]
+      ;; 1 is closest to 0 (distance 1)
+      (is (= :zero (fm 1)))
+      ;; 4 is closest to 3 (distance 1)
+      (is (= :three (fm 4)))
+      ;; 7 is closest to 6 (distance 1)
+      (is (= :six (fm 7)))
+      ;; 7.5 is closest to 6 (distance 1.5 vs 1.5 to 9, tiebreak :< prefers smaller)
+      (is (= :six (fm 7.5))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Floating Point Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest floating-point-test
+  (testing "Fuzzy set with floating point values"
+    (let [fs (oc/fuzzy-set [0.0 0.5 1.0 1.5 2.0])]
+      (is (= 0.5 (fs 0.4)))
+      (is (= 1.0 (fs 0.9)))
+      (is (= 1.5 (fs 1.4)))))
+
+  (testing "Fuzzy map with floating point keys"
+    (let [fm (oc/fuzzy-map {0.0 :a 1.0 :b 2.0 :c})]
+      (is (= :a (fm 0.3)))
+      (is (= :b (fm 0.7)))
+      (is (= :b (fm 1.4)))
+      (is (= :c (fm 1.6))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fuzzy Set: Navigation, Split, Rank
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest fuzzy-set-nearest-protocol-test
+  (testing "PNearest on fuzzy-set (ordered-set style navigation)"
+    (let [fs (oc/fuzzy-set [1 3 5 7 9])]
+      (is (= 5 (oc/nearest fs :< 6)))
+      (is (= 3 (oc/nearest fs :< 5)))
+      (is (= 5 (oc/nearest fs :<= 5)))
+      (is (= 7 (oc/nearest fs :> 6)))
+      (is (= 7 (oc/nearest fs :> 5)))
+      (is (= 5 (oc/nearest fs :>= 5)))
+      (is (nil? (oc/nearest fs :< 1)))
+      (is (nil? (oc/nearest fs :> 9))))))
+
+(deftest fuzzy-set-subrange-test
+  (testing "subrange on fuzzy-set"
+    (let [fs (oc/fuzzy-set (range 10))]
+      (is (= #{3 4 5 6} (set (seq (oc/subrange fs :>= 3 :< 7)))))
+      (is (= #{0 1 2 3 4} (set (seq (oc/subrange fs :<= 4)))))
+      (is (= #{7 8 9} (set (seq (oc/subrange fs :> 6))))))))
+
+(deftest fuzzy-set-split-test
+  (testing "split-key on fuzzy-set"
+    (let [fs (oc/fuzzy-set [1 2 3 4 5])]
+      (let [[left entry right] (oc/split-key 3 fs)]
+        (is (= #{1 2} (set (seq left))))
+        (is (= 3 entry))
+        (is (= #{4 5} (set (seq right)))))
+      (let [[left entry right] (oc/split-key 2.5 fs)]
+        (is (= #{1 2} (set (seq left))))
+        (is (nil? entry))
+        (is (= #{3 4 5} (set (seq right)))))))
+  (testing "split-at on fuzzy-set"
+    (let [fs (oc/fuzzy-set [1 2 3 4 5])]
+      (let [[left right] (oc/split-at 2 fs)]
+        (is (= #{1 2} (set (seq left))))
+        (is (= #{3 4 5} (set (seq right))))))))
+
+(deftest fuzzy-set-navigable-test
+  (testing "ceiling and floor via NavigableSet"
+    (let [^java.util.NavigableSet fs (oc/fuzzy-set [1 3 5 7 9])]
+      (is (= 5 (.ceiling fs 5)))
+      (is (= 5 (.ceiling fs 4)))
+      (is (= 5 (.floor fs 5)))
+      (is (= 3 (.floor fs 4)))
+      (is (= 1 (.ceiling fs 0)))
+      (is (nil? (.floor fs 0))))))
+
+(deftest fuzzy-set-rank-test
+  (testing "rank/slice/median/percentile"
+    (let [fs (oc/fuzzy-set [10 20 30 40 50])]
+      (is (= 0 (oc/rank fs 10)))
+      (is (= 2 (oc/rank fs 30)))
+      (is (= 4 (oc/rank fs 50)))
+      (is (nil? (oc/rank fs 25)))
+      (is (= (list 20 30 40) (oc/slice fs 1 4)))
+      (is (= 30 (oc/median fs)))
+      (is (= 50 (oc/percentile fs 90))))))
+
+(deftest fuzzy-set-subseq-test
+  (testing "subseq/rsubseq via Sorted interface"
+    (let [fs (oc/fuzzy-set [1 3 5 7 9])]
+      (is (= [5 7 9] (subseq fs >= 5)))
+      (is (= [5 7 9] (subseq fs > 4)))
+      (is (= [1 3 5] (subseq fs <= 5)))
+      (is (= [5 3 1] (rsubseq fs <= 5))))))
+
+(deftest fuzzy-set-comparable-test
+  (testing "compareTo"
+    (let [fs1 (oc/fuzzy-set [1 2 3])
+          fs2 (oc/fuzzy-set [1 2 3])
+          fs3 (oc/fuzzy-set [1 2 4])]
+      (is (zero? (compare fs1 fs2)))
+      (is (neg? (compare fs1 fs3))))))
+
+(deftest fuzzy-set-larger-data-test
+  (testing "fuzzy set at 10K elements"
+    (let [elems (vec (shuffle (range 10000)))
+          fs    (oc/fuzzy-set elems)]
+      (is (= 10000 (count fs)))
+      (is (= 0 (first fs)))
+      (is (= 9999 (last fs)))
+      ;; fuzzy lookup snaps to nearest
+      (is (= 5000 (fs 5000)))
+      (is (= 5000 (fs 5000.3)))
+      ;; reduce
+      (is (= (reduce + (range 10000)) (reduce + fs)))
+      ;; fold
+      (is (= (reduce + (range 10000)) (r/fold + fs))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fuzzy Map: Navigation, Rank, Larger Data
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest fuzzy-map-rank-test
+  (testing "rank/slice/median/percentile on fuzzy-map"
+    (let [fm (oc/fuzzy-map {10 :a 20 :b 30 :c 40 :d 50 :e})]
+      (is (= 0 (oc/rank fm 10)))
+      (is (= 2 (oc/rank fm 30)))
+      (is (nil? (oc/rank fm 25)))
+      (is (= [[20 :b] [30 :c] [40 :d]] (oc/slice fm 1 4)))
+      (is (= [30 :c] (oc/median fm))))))
+
+(deftest fuzzy-map-subseq-test
+  (testing "subseq/rsubseq via Sorted interface"
+    (let [fm (oc/fuzzy-map {1 :a 3 :b 5 :c 7 :d 9 :e})]
+      (is (= [[5 :c] [7 :d] [9 :e]] (subseq fm >= 5)))
+      (is (= [[5 :c] [3 :b] [1 :a]] (rsubseq fm <= 5))))))
+
+(deftest fuzzy-map-larger-data-test
+  (testing "fuzzy map at 10K entries"
+    (let [pairs (zipmap (range 10000) (range 10000))
+          fm    (oc/fuzzy-map pairs)]
+      (is (= 10000 (count fm)))
+      (is (= 0 (.firstKey ^java.util.SortedMap fm)))
+      (is (= 9999 (.lastKey ^java.util.SortedMap fm)))
+      ;; fuzzy lookup
+      (is (= 5000 (fm 5000)))
+      (is (= 5000 (fm 5000.3)))
+      ;; reduce-kv
+      (is (= (reduce + (range 10000))
+             (reduce-kv (fn [acc _ v] (+ acc v)) 0 fm))))))
+
+(deftest fuzzy-set-string-keys-test
+  (testing "fuzzy set with string elements"
+    (let [fs (oc/fuzzy-set ["apple" "banana" "cherry" "date" "elderberry"]
+               :distance (fn [a b] (Math/abs (- (count (str a)) (count (str b))))))]
+      (is (= 5 (count fs)))
+      (is (= "apple" (first fs)))
+      ;; exact membership
+      (is (oc/fuzzy-exact-contains? fs "cherry"))
+      (is (not (oc/fuzzy-exact-contains? fs "coconut"))))))
+
+(deftest fuzzy-map-string-keys-test
+  (testing "fuzzy map with string keys"
+    (let [fm (oc/fuzzy-map {"alpha" 1 "beta" 2 "gamma" 3 "delta" 4}
+               :distance (fn [a b] (Math/abs (- (count (str a)) (count (str b))))))]
+      (is (= 4 (count fm)))
+      (is (oc/fuzzy-exact-contains? fm "beta"))
+      (is (not (oc/fuzzy-exact-contains? fm "epsilon"))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Property Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-fuzzy-set-nearest-bruteforce 100
+  (prop/for-all [xs tu/gen-non-empty-int-set
+                 q  gen/small-integer
+                 tiebreak (gen/elements [:< :>])]
+    (let [fs (oc/fuzzy-set xs :tiebreak tiebreak)
+          expected (tu/fuzzy-nearest-ref (set xs) q tiebreak)]
+      (= expected (fs q)))))
+
+(defspec prop-fuzzy-map-nearest-bruteforce 100
+  (prop/for-all [entries tu/gen-non-empty-int-map-entries
+                 q       gen/small-integer
+                 tiebreak (gen/elements [:< :>])]
+    (let [m (into {} entries)
+          fm (oc/fuzzy-map m :tiebreak tiebreak)
+          [expected-k expected-v] (tu/fuzzy-nearest-map-ref m q tiebreak)]
+      (= expected-v (fm q)))))
+
+(defspec prop-fuzzy-map-nearest-triplet-bruteforce 100
+  (prop/for-all [entries tu/gen-non-empty-int-map-entries
+                 q       gen/small-integer
+                 tiebreak (gen/elements [:< :>])]
+    (let [m (into {} entries)
+          fm (oc/fuzzy-map m :tiebreak tiebreak)
+          [expected-k expected-v] (tu/fuzzy-nearest-map-ref m q tiebreak)
+          expected-dist (double (Math/abs ^long (- (long q) (long expected-k))))]
+      (= [expected-k expected-v expected-dist]
+         (oc/fuzzy-nearest fm q)))))
diff --git a/test/ordered_collections/interop_test.clj b/test/ordered_collections/interop_test.clj
new file mode 100644
index 0000000..f26d3b7
--- /dev/null
+++ b/test/ordered_collections/interop_test.clj
@@ -0,0 +1,435 @@
+(ns ordered-collections.interop-test
+  "Property-based tests verifying protocol extensions on standard Clojure collections.
+
+   Tests that protocol operations on PersistentTreeSet/PersistentTreeMap produce
+   results equivalent to:
+   1. Reference implementations (clojure.set, subseq/rsubseq, etc.)
+   2. ordered-set/ordered-map implementations"
+  (:require [clojure.set :as cset]
+            [clojure.test :refer [deftest testing is]]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.test-utils :as tu
+             :refer [gen-int-set gen-non-empty-int-set
+                     gen-int-map-entries gen-non-empty-int-map-entries
+                     gen-test-symbol
+                     ->ss ->hs ->os ->sm ->om]]
+            [ordered-collections.types.interop]
+            [ordered-collections.protocol :as proto]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PExtensibleSet - Set algebra operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-tree-set-union 100
+  (prop/for-all [xs1 gen-int-set, xs2 gen-int-set]
+    (let [ts1 (->ss xs1), ts2 (->ss xs2)
+          proto-result (proto/union ts1 ts2)
+          ref-result (cset/union ts1 ts2)]
+      (= (set proto-result) (set ref-result)))))
+
+(defspec prop-tree-set-intersection 100
+  (prop/for-all [xs1 gen-int-set, xs2 gen-int-set]
+    (let [ts1 (->ss xs1), ts2 (->ss xs2)
+          proto-result (proto/intersection ts1 ts2)
+          ref-result (cset/intersection ts1 ts2)]
+      (= (set proto-result) (set ref-result)))))
+
+(defspec prop-tree-set-difference 100
+  (prop/for-all [xs1 gen-int-set, xs2 gen-int-set]
+    (let [ts1 (->ss xs1), ts2 (->ss xs2)
+          proto-result (proto/difference ts1 ts2)
+          ref-result (cset/difference ts1 ts2)]
+      (= (set proto-result) (set ref-result)))))
+
+(defspec prop-tree-set-subset 100
+  (prop/for-all [xs gen-int-set]
+    (let [ts-full (->ss xs)
+          ts-half (->ss (take (quot (count xs) 2) xs))]
+      (and (= (proto/subset? ts-half ts-full) (cset/subset? ts-half ts-full))
+           (= (proto/subset? ts-full ts-full) (cset/subset? ts-full ts-full))
+           (= (proto/subset? ts-full ts-half) (cset/subset? ts-full ts-half))))))
+
+(defspec prop-tree-set-superset 100
+  (prop/for-all [xs gen-int-set]
+    (let [ts-full (->ss xs)
+          ts-half (->ss (take (quot (count xs) 2) xs))]
+      (and (= (proto/superset? ts-full ts-half) (cset/superset? ts-full ts-half))
+           (= (proto/superset? ts-full ts-full) (cset/superset? ts-full ts-full))
+           (= (proto/superset? ts-half ts-full) (cset/superset? ts-half ts-full))))))
+
+(defspec prop-hash-set-union 100
+  (prop/for-all [xs1 gen-int-set, xs2 gen-int-set]
+    (let [hs1 (->hs xs1), hs2 (->hs xs2)
+          proto-result (proto/union hs1 hs2)
+          ref-result (cset/union hs1 hs2)]
+      (= proto-result ref-result))))
+
+(defspec prop-hash-set-intersection 100
+  (prop/for-all [xs1 gen-int-set, xs2 gen-int-set]
+    (let [hs1 (->hs xs1), hs2 (->hs xs2)
+          proto-result (proto/intersection hs1 hs2)
+          ref-result (cset/intersection hs1 hs2)]
+      (= proto-result ref-result))))
+
+(defspec prop-hash-set-difference 100
+  (prop/for-all [xs1 gen-int-set, xs2 gen-int-set]
+    (let [hs1 (->hs xs1), hs2 (->hs xs2)
+          proto-result (proto/difference hs1 hs2)
+          ref-result (cset/difference hs1 hs2)]
+      (= proto-result ref-result))))
+
+;; Cross-implementation compatibility: tree-set and ordered-set produce same results
+(defspec prop-set-algebra-cross-compatible 100
+  (prop/for-all [xs1 gen-int-set, xs2 gen-int-set]
+    (let [ts1 (->ss xs1), ts2 (->ss xs2)
+          os1 (->os xs1), os2 (->os xs2)]
+      (and (= (set (proto/union ts1 ts2)) (set (proto/union os1 os2)))
+           (= (set (proto/intersection ts1 ts2)) (set (proto/intersection os1 os2)))
+           (= (set (proto/difference ts1 ts2)) (set (proto/difference os1 os2)))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PNearest - Floor/ceiling/predecessor/successor operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-tree-set-nearest-floor 100
+  (prop/for-all [xs gen-non-empty-int-set, k gen/small-integer]
+    (let [ts (->ss xs)
+          proto-result (proto/nearest ts :<= k)
+          ref-result (tu/nearest-ref ts :<= k)]
+      (= proto-result ref-result))))
+
+(defspec prop-tree-set-nearest-ceiling 100
+  (prop/for-all [xs gen-non-empty-int-set, k gen/small-integer]
+    (let [ts (->ss xs)
+          proto-result (proto/nearest ts :>= k)
+          ref-result (tu/nearest-ref ts :>= k)]
+      (= proto-result ref-result))))
+
+(defspec prop-tree-set-nearest-predecessor 100
+  (prop/for-all [xs gen-non-empty-int-set, k gen/small-integer]
+    (let [ts (->ss xs)
+          proto-result (proto/nearest ts :< k)
+          ref-result (tu/nearest-ref ts :< k)]
+      (= proto-result ref-result))))
+
+(defspec prop-tree-set-nearest-successor 100
+  (prop/for-all [xs gen-non-empty-int-set, k gen/small-integer]
+    (let [ts (->ss xs)
+          proto-result (proto/nearest ts :> k)
+          ref-result (tu/nearest-ref ts :> k)]
+      (= proto-result ref-result))))
+
+(defspec prop-tree-set-subrange 100
+  (prop/for-all [xs gen-non-empty-int-set, k gen/small-integer, test gen-test-symbol]
+    (let [ts (->ss xs)
+          proto-result (proto/subrange ts test k)
+          ref-result (into (sorted-set) (tu/subrange-ref ts test k))]
+      (= (vec proto-result) (vec ref-result)))))
+
+(defspec prop-tree-map-nearest-floor 100
+  (prop/for-all [xs gen-non-empty-int-map-entries, k gen/small-integer]
+    (let [tm (->sm xs)
+          proto-result (proto/nearest tm :<= k)
+          ref-entry (tu/nearest-ref tm :<= k)]
+      (= proto-result (when ref-entry [(key ref-entry) (val ref-entry)])))))
+
+(defspec prop-tree-map-nearest-ceiling 100
+  (prop/for-all [xs gen-non-empty-int-map-entries, k gen/small-integer]
+    (let [tm (->sm xs)
+          proto-result (proto/nearest tm :>= k)
+          ref-entry (tu/nearest-ref tm :>= k)]
+      (= proto-result (when ref-entry [(key ref-entry) (val ref-entry)])))))
+
+(defspec prop-tree-map-subrange 100
+  (prop/for-all [xs gen-non-empty-int-map-entries, k gen/small-integer, test gen-test-symbol]
+    (let [tm (->sm xs)
+          proto-result (proto/subrange tm test k)
+          ref-result (into (sorted-map) (tu/subrange-ref tm test k))]
+      (= (vec proto-result) (vec ref-result)))))
+
+;; Cross-implementation: tree-set/map and ordered-set/map produce same nearest results
+(defspec prop-nearest-cross-compatible-set 100
+  (prop/for-all [xs gen-non-empty-int-set, k gen/small-integer, test gen-test-symbol]
+    (let [ts (->ss xs)
+          os (->os xs)]
+      (= (proto/nearest ts test k) (proto/nearest os test k)))))
+
+(defspec prop-nearest-cross-compatible-map 100
+  (prop/for-all [xs gen-non-empty-int-map-entries, k gen/small-integer, test gen-test-symbol]
+    (let [tm (->sm xs)
+          om (->om xs)]
+      (= (proto/nearest tm test k) (proto/nearest om test k)))))
+
+(defspec prop-subrange-cross-compatible-set 100
+  (prop/for-all [xs gen-non-empty-int-set, k gen/small-integer, test gen-test-symbol]
+    (let [ts (->ss xs)
+          os (->os xs)]
+      (= (vec (proto/subrange ts test k)) (vec (proto/subrange os test k))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PRanked - Index-based operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-tree-set-rank-of-present 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          sorted-vec (vec ts)
+          x (rand-nth sorted-vec)
+          proto-rank (proto/rank-of ts x)
+          expected-rank (first (keep-indexed (fn [i y] (when (= x y) i)) sorted-vec))]
+      (= proto-rank expected-rank))))
+
+(defspec prop-tree-set-rank-of-absent 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          absent (tu/absent-small-int ts)]
+      (when absent
+        (= (proto/rank-of ts absent) -1)))))
+
+(defspec prop-tree-set-slice 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          n (count ts)
+          start (rand-int n)
+          end (+ start (rand-int (inc (- n start))))]
+      (let [proto-result (proto/slice ts start end)
+            expected (tu/slice-ref ts start end)]
+        (= (vec proto-result) (vec expected))))))
+
+(defspec prop-tree-set-median 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          n (count ts)
+          proto-result (proto/median ts)
+          expected (nth (seq ts) (quot (dec n) 2))]
+      (= proto-result expected))))
+
+(defspec prop-tree-set-percentile 100
+  (prop/for-all [xs gen-non-empty-int-set, pct (gen/choose 0 100)]
+    (let [ts (->ss xs)
+          n (count ts)
+          proto-result (proto/percentile ts pct)
+          idx (tu/percentile-index n pct)
+          expected (nth (seq ts) idx)]
+      (= proto-result expected))))
+
+(defspec prop-tree-map-rank-of 100
+  (prop/for-all [xs gen-non-empty-int-map-entries]
+    (let [tm (->sm xs)
+          k (key (rand-nth (vec tm)))
+          proto-rank (proto/rank-of tm k)
+          expected-rank (count (subseq tm < k))]
+      (= proto-rank expected-rank))))
+
+(defspec prop-tree-map-slice 100
+  (prop/for-all [xs gen-non-empty-int-map-entries]
+    (let [tm (->sm xs)
+          n (count tm)
+          start (rand-int n)
+          end (+ start (rand-int (inc (- n start))))]
+      (let [proto-result (proto/slice tm start end)
+            expected (tu/slice-ref tm start end)]
+        (= (vec proto-result) (vec expected))))))
+
+;; Cross-implementation: rank-of produces same results
+(defspec prop-rank-cross-compatible-set 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          os (->os xs)
+          sorted-vec (vec ts)
+          x (rand-nth sorted-vec)]
+      (= (proto/rank-of ts x) (proto/rank-of os x)))))
+
+(defspec prop-median-cross-compatible-set 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          os (->os xs)]
+      (= (proto/median ts) (proto/median os)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PSplittable - Split operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-tree-set-split-key-present 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          k (rand-nth (vec ts))
+          [left entry right] (proto/split-key ts k)
+          [ref-left ref-entry ref-right] (tu/split-key-ref ts k)]
+      (and (= entry k)
+           (= entry ref-entry)
+           (= (vec left) (vec ref-left))
+           (= (vec right) (vec ref-right))
+           (every? #(< % k) left)
+           (every? #(> % k) right)
+           (= (count ts) (+ (count left) 1 (count right)))))))
+
+(defspec prop-tree-set-split-key-absent 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          absent (tu/absent-small-int ts)]
+      (when absent
+        (let [[left entry right] (proto/split-key ts absent)
+              [ref-left ref-entry ref-right] (tu/split-key-ref ts absent)]
+          (and (nil? entry)
+               (= entry ref-entry)
+               (= (vec left) (vec ref-left))
+               (= (vec right) (vec ref-right))
+               (every? #(< % absent) left)
+               (every? #(> % absent) right)
+               (= (count ts) (+ (count left) (count right)))))))))
+
+(defspec prop-tree-set-split-at 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          n (count ts)
+          i (rand-int (inc n))
+          [left right] (proto/split-at ts i)
+          [ref-left ref-right] (tu/split-at-ref ts i)]
+      (and (= (count left) i)
+           (= (count right) (- n i))
+           (= (vec left) (vec ref-left))
+           (= (vec right) (vec ref-right))
+           (= (vec ts) (vec (concat left right)))))))
+
+(defspec prop-tree-map-split-key-present 100
+  (prop/for-all [xs gen-non-empty-int-map-entries]
+    (let [tm (->sm xs)
+          [k v] (rand-nth (vec tm))
+          [left entry right] (proto/split-key tm k)
+          [ref-left ref-entry ref-right] (tu/split-key-ref tm k)]
+      (and (= entry [k v])
+           (= entry ref-entry)
+           (= (vec left) (vec ref-left))
+           (= (vec right) (vec ref-right))
+           (every? #(< (key %) k) left)
+           (every? #(> (key %) k) right)
+           (= (count tm) (+ (count left) 1 (count right)))))))
+
+(defspec prop-tree-map-split-key-absent 100
+  (prop/for-all [xs gen-non-empty-int-map-entries]
+    (let [tm (->sm xs)
+          absent (tu/absent-small-int tm)]
+      (when absent
+        (let [[left entry right] (proto/split-key tm absent)
+              [ref-left ref-entry ref-right] (tu/split-key-ref tm absent)]
+          (and (nil? entry)
+               (= entry ref-entry)
+               (= (vec left) (vec ref-left))
+               (= (vec right) (vec ref-right))
+               (every? #(< (key %) absent) left)
+               (every? #(> (key %) absent) right)
+               (= (count tm) (+ (count left) (count right)))))))))
+
+(defspec prop-tree-map-split-at 100
+  (prop/for-all [xs gen-non-empty-int-map-entries]
+    (let [tm (->sm xs)
+          n (count tm)
+          i (rand-int (inc n))
+          [left right] (proto/split-at tm i)
+          [ref-left ref-right] (tu/split-at-ref tm i)]
+      (and (= (count left) i)
+           (= (count right) (- n i))
+           (= (vec left) (vec ref-left))
+           (= (vec right) (vec ref-right))
+           (= (vec tm) (vec (concat left right)))))))
+
+;; Cross-implementation: split operations produce equivalent results
+(defspec prop-split-key-cross-compatible-set 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          os (->os xs)
+          k (rand-nth (vec ts))
+          [ts-left ts-entry ts-right] (proto/split-key ts k)
+          [os-left os-entry os-right] (proto/split-key os k)]
+      (and (= ts-entry os-entry)
+           (= (vec ts-left) (vec os-left))
+           (= (vec ts-right) (vec os-right))))))
+
+(defspec prop-split-at-cross-compatible-set 100
+  (prop/for-all [xs gen-non-empty-int-set]
+    (let [ts (->ss xs)
+          os (->os xs)
+          i (rand-int (inc (count ts)))
+          [ts-left ts-right] (proto/split-at ts i)
+          [os-left os-right] (proto/split-at os i)]
+      (and (= (vec ts-left) (vec os-left))
+           (= (vec ts-right) (vec os-right))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Edge Cases
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest empty-set-operations
+  (testing "Protocol operations on empty sorted-set"
+    (let [ts (sorted-set)]
+      (is (= #{} (proto/union ts ts)))
+      (is (= #{} (proto/intersection ts ts)))
+      (is (= #{} (proto/difference ts ts)))
+      (is (true? (proto/subset? ts ts)))
+      (is (true? (proto/superset? ts ts)))
+      (is (nil? (proto/nearest ts :>= 0)))
+      (is (= -1 (proto/rank-of ts 0)))
+      (is (nil? (proto/median ts)))
+      (let [[left entry right] (proto/split-key ts 0)]
+        (is (empty? left))
+        (is (nil? entry))
+        (is (empty? right))))))
+
+(deftest empty-map-operations
+  (testing "Protocol operations on empty sorted-map"
+    (let [tm (sorted-map)]
+      (is (nil? (proto/nearest tm :>= 0)))
+      (is (= -1 (proto/rank-of tm 0)))
+      (is (nil? (proto/median tm)))
+      (let [[left entry right] (proto/split-key tm 0)]
+        (is (empty? left))
+        (is (nil? entry))
+        (is (empty? right))))))
+
+(deftest single-element-operations
+  (testing "Protocol operations on single-element sorted-set"
+    (let [ts (sorted-set 42)]
+      (is (= 42 (proto/nearest ts :>= 0)))
+      (is (= 42 (proto/nearest ts :<= 100)))
+      (is (nil? (proto/nearest ts :< 42)))
+      (is (nil? (proto/nearest ts :> 42)))
+      (is (= 0 (proto/rank-of ts 42)))
+      (is (= -1 (proto/rank-of ts 0)))
+      (is (= 42 (proto/median ts)))
+      (is (= 42 (proto/percentile ts 50)))
+      (let [[left entry right] (proto/split-key ts 42)]
+        (is (empty? left))
+        (is (= 42 entry))
+        (is (empty? right))))))
+
+(deftest boundary-values
+  (testing "Protocol operations with Long boundary values"
+    (let [ts (sorted-set Long/MIN_VALUE -1 0 1 Long/MAX_VALUE)]
+      (is (= Long/MIN_VALUE (proto/nearest ts :>= Long/MIN_VALUE)))
+      (is (= Long/MAX_VALUE (proto/nearest ts :<= Long/MAX_VALUE)))
+      (is (= 0 (proto/median ts)))
+      (is (= 2 (proto/rank-of ts 0)))          ;; 0 is at index 2
+      (is (= 0 (proto/rank-of ts Long/MIN_VALUE))))))
+
+(deftest subrange-preserves-type
+  (testing "subrange returns same collection type"
+    (let [ts (sorted-set 1 2 3 4 5)]
+      (is (instance? clojure.lang.PersistentTreeSet (proto/subrange ts :> 2)))
+      (is (sorted? (proto/subrange ts :> 2))))))
+
+(deftest split-preserves-type
+  (testing "split returns same collection type"
+    (let [ts (sorted-set 1 2 3 4 5)
+          [left _ right] (proto/split-key ts 3)]
+      (is (instance? clojure.lang.PersistentTreeSet left))
+      (is (instance? clojure.lang.PersistentTreeSet right))
+      (is (sorted? left))
+      (is (sorted? right)))))
diff --git a/test/com/dean/interval_tree/interval_map_test.clj b/test/ordered_collections/interval_map_test.clj
similarity index 91%
rename from test/com/dean/interval_tree/interval_map_test.clj
rename to test/ordered_collections/interval_map_test.clj
index ec74166..0efd060 100644
--- a/test/com/dean/interval_tree/interval_map_test.clj
+++ b/test/ordered_collections/interval_map_test.clj
@@ -1,6 +1,7 @@
-(ns com.dean.interval-tree.interval-map-test
+(ns ordered-collections.interval-map-test
   (:require [clojure.test       :refer :all]
-            [com.dean.interval-tree.core :refer [interval-map]]))
+            [ordered-collections.core :refer [interval-map span]]))
+
 
 
 ;; x8:                         +-----+
@@ -159,3 +160,22 @@
       (is (= [:x7 :x5 :x3 :x6]                 (x [8 9.5])))
       (is (= [:x7 :x3 :x6]                     (x [9 9])))
       (is (= [:x7 :x3 :x6]                     (x [9 9.5]))))))
+
+(deftest span-test
+  (testing "empty interval-map"
+    (is (nil? (span (interval-map)))))
+
+  (testing "single interval"
+    (is (= [1 5] (span (interval-map {[1 5] :a})))))
+
+  (testing "non-overlapping intervals"
+    (is (= [1 15] (span (interval-map {[1 5] :a [10 15] :b})))))
+
+  (testing "interval with max-end not in last-sorted interval"
+    (is (= [1 100] (span (interval-map {[1 100] :wide [50 60] :narrow})))))
+
+  ;; span of the fixture from interval-query-check: [0 5] to [9 9] → [0 9]
+  (testing "span of fixture intervals"
+    (let [x (interval-map {[1 3] :x1 [4 7] :x2 [8 9] :x3 [0 5] :x4
+                           [6 8] :x5 [9 9] :x6 [3 9] :x7 [4 5] :x8})]
+      (is (= [0 9] (span x))))))
diff --git a/test/com/dean/interval_tree/interval_set_test.clj b/test/ordered_collections/interval_set_test.clj
similarity index 63%
rename from test/com/dean/interval_tree/interval_set_test.clj
rename to test/ordered_collections/interval_set_test.clj
index 49ebb74..ec24254 100644
--- a/test/com/dean/interval_tree/interval_set_test.clj
+++ b/test/ordered_collections/interval_set_test.clj
@@ -1,6 +1,7 @@
-(ns com.dean.interval-tree.interval-set-test
+(ns ordered-collections.interval-set-test
   (:require [clojure.test                :refer :all]
-            [com.dean.interval-tree.core :refer [interval-set]]))
+            [ordered-collections.core :refer [interval-set span]]))
+
 
 ;; TODO: more
 
@@ -40,3 +41,23 @@
       (is (= 1 (count (x (- greatest 0.5)))))
       (is (= (seq x) (x [0 greatest])))
       (is (= size (count (x [0 greatest])))))))
+
+(deftest span-test
+  (testing "empty interval-set"
+    (is (nil? (span (interval-set)))))
+
+  (testing "single interval"
+    (is (= [1 5] (span (interval-set [[1 5]])))))
+
+  (testing "single point interval"
+    (is (= [3 3] (span (interval-set [[3 3]])))))
+
+  (testing "non-overlapping intervals"
+    (is (= [1 15] (span (interval-set [[1 5] [10 15]])))))
+
+  (testing "overlapping intervals"
+    (is (= [1 15] (span (interval-set [[1 5] [3 8] [10 15]])))))
+
+  (testing "interval with max-end not in last-sorted interval"
+    ;; [1 100] sorts first but has the largest endpoint
+    (is (= [1 100] (span (interval-set [[1 100] [50 60]]))))))
diff --git a/test/com/dean/interval_tree/interval_test.clj b/test/ordered_collections/interval_test.clj
similarity index 89%
rename from test/com/dean/interval_tree/interval_test.clj
rename to test/ordered_collections/interval_test.clj
index bbf7990..72ceb05 100644
--- a/test/com/dean/interval_tree/interval_test.clj
+++ b/test/ordered_collections/interval_test.clj
@@ -1,8 +1,9 @@
-(ns com.dean.interval-tree.interval-test
+(ns ordered-collections.interval-test
   (:require [clojure.test :refer :all]
-            [com.dean.interval-tree.tree.interval :as interval :refer :all])
+            [ordered-collections.kernel.interval :as interval :refer :all])
   (:import  [clojure.lang MapEntry]))
 
+
 (deftest pair-check
   (is (ordered-pair? (MapEntry. 0 1)))
   (is (ordered-pair? (vector 0 1)))
diff --git a/test/ordered_collections/interval_tree_test.clj b/test/ordered_collections/interval_tree_test.clj
new file mode 100644
index 0000000..5adfb63
--- /dev/null
+++ b/test/ordered_collections/interval_tree_test.clj
@@ -0,0 +1,349 @@
+(ns ordered-collections.interval-tree-test
+  "Comprehensive property-based tests for interval-set and interval-map.
+
+   Addresses gaps in interval tree testing:
+   1. Property-based tests with test.check
+   2. Equivalence against naive reference implementation
+   3. Mutation sequence testing (insert, delete, query)
+   4. Max-endpoint invariant verification
+   5. Edge cases (empty, touching, nested, identical intervals)"
+  (:require [clojure.test :refer [deftest testing is]]
+            [clojure.test.check :as tc]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.core :as oc]
+            [ordered-collections.kernel.node :as node]
+            [ordered-collections.kernel.interval :as interval])
+  (:import [ordered_collections.kernel.root INodeCollection]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Naive Reference Implementation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn naive-overlaps?
+  "Do intervals [a1,b1] and [a2,b2] overlap? (closed intervals)"
+  [[a1 b1] [a2 b2]]
+  (and (<= a1 b2) (<= a2 b1)))
+
+(defn naive-point-overlaps?
+  "Does interval [a,b] contain point p?"
+  [[a b] p]
+  (and (<= a p) (<= p b)))
+
+(defn naive-query-set
+  "Brute-force O(n) query: find all intervals overlapping query."
+  [intervals query]
+  (let [pred (if (number? query)
+               #(naive-point-overlaps? % query)
+               #(naive-overlaps? % query))]
+    (set (filter pred intervals))))
+
+(defn naive-query-map
+  "Brute-force O(n) query for interval-map: find all values for overlapping intervals.
+   Deduplicates by interval key (last-wins) to match map assoc semantics."
+  [entries query]
+  (let [deduped (into {} entries)
+        pred    (if (number? query)
+                  (fn [[iv _]] (naive-point-overlaps? iv query))
+                  (fn [[iv _]] (naive-overlaps? iv query)))]
+    (set (map val (filter pred deduped)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Max-Endpoint Invariant Verification
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn node-max-endpoint
+  "Compute what the max-endpoint should be for a node."
+  [n]
+  (when-not (node/leaf? n)
+    (let [interval (node/-k n)
+          b        (second interval)
+          left-z   (node-max-endpoint (node/-l n))
+          right-z  (node-max-endpoint (node/-r n))]
+      (cond
+        (and left-z right-z) (max b left-z right-z)
+        left-z               (max b left-z)
+        right-z              (max b right-z)
+        :else                b))))
+
+(defn verify-max-endpoint-invariant
+  "Verify that every node's z field equals max(b, left-z, right-z)."
+  [n]
+  (if (node/leaf? n)
+    true
+    (let [expected (node-max-endpoint n)
+          actual   (node/-z n)]
+      (and (= expected actual)
+           (verify-max-endpoint-invariant (node/-l n))
+           (verify-max-endpoint-invariant (node/-r n))))))
+
+(defn get-root [coll]
+  (.getRoot ^INodeCollection coll))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Generators
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def gen-point
+  "Generate a point (integer for simplicity)."
+  (gen/choose -1000 1000))
+
+(def gen-interval
+  "Generate a valid interval [a, b] where a <= b."
+  (gen/fmap (fn [[a b]] [(min a b) (max a b)])
+            (gen/tuple gen-point gen-point)))
+
+(def gen-interval-list
+  "Generate a list of intervals."
+  (gen/vector gen-interval 0 100))
+
+(def gen-non-empty-interval-list
+  "Generate a non-empty list of intervals."
+  (gen/vector gen-interval 1 100))
+
+(def gen-interval-map-entries
+  "Generate interval-map entries [[interval value] ...]."
+  (gen/fmap (fn [intervals]
+              (map-indexed (fn [i iv] [iv (keyword (str "v" i))]) intervals))
+            gen-interval-list))
+
+(def gen-query
+  "Generate either a point or interval query."
+  (gen/one-of [gen-point gen-interval]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Property: Query Equivalence
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-interval-set-query-equivalence 100
+  (prop/for-all [intervals gen-interval-list
+                 query     gen-query]
+    (let [iset   (oc/interval-set intervals)
+          result (set (iset query))
+          expected (naive-query-set intervals query)]
+      (= result expected))))
+
+(defspec prop-interval-map-query-equivalence 100
+  (prop/for-all [intervals gen-interval-list
+                 query     gen-query]
+    (let [entries  (map-indexed (fn [i iv] [iv (keyword (str "v" i))]) intervals)
+          imap     (oc/interval-map entries)
+          result   (set (imap query))
+          expected (naive-query-map entries query)]
+      (= result expected))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Property: Max-Endpoint Invariant
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-interval-set-max-endpoint-invariant 100
+  (prop/for-all [intervals gen-non-empty-interval-list]
+    (let [iset (oc/interval-set intervals)
+          root (get-root iset)]
+      (verify-max-endpoint-invariant root))))
+
+(defspec prop-interval-map-max-endpoint-invariant 100
+  (prop/for-all [intervals gen-non-empty-interval-list]
+    (let [entries (map-indexed (fn [i iv] [iv (keyword (str "v" i))]) intervals)
+          imap    (oc/interval-map entries)
+          root    (get-root imap)]
+      (verify-max-endpoint-invariant root))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Property: Mutation Sequences
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-interval-set-mutation-invariant 100
+  (prop/for-all [initial-intervals gen-interval-list
+                 add-intervals     gen-interval-list
+                 remove-intervals  gen-interval-list
+                 query             gen-query]
+    (let [;; Build set with initial intervals
+          iset0 (oc/interval-set initial-intervals)
+          ;; Add more intervals
+          iset1 (reduce conj iset0 add-intervals)
+          ;; Remove some intervals (only those that exist)
+          to-remove (filter #(contains? iset1 %) remove-intervals)
+          iset2 (reduce disj iset1 to-remove)
+          ;; Compute expected state
+          expected-intervals (-> (set initial-intervals)
+                                 (into add-intervals)
+                                 (clojure.set/difference (set to-remove)))
+          ;; Verify
+          result   (set (iset2 query))
+          expected (naive-query-set expected-intervals query)]
+      (and (= result expected)
+           (or (empty? iset2)
+               (verify-max-endpoint-invariant (get-root iset2)))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Property: Count and Membership
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-interval-set-count 100
+  (prop/for-all [intervals gen-interval-list]
+    (let [unique-intervals (set intervals)
+          iset (oc/interval-set intervals)]
+      (= (count iset) (count unique-intervals)))))
+
+(defspec prop-interval-set-membership 100
+  (prop/for-all [intervals gen-interval-list]
+    (let [iset (oc/interval-set intervals)]
+      (every? #(contains? iset %) intervals))))
+
+(defspec prop-interval-map-count 100
+  (prop/for-all [intervals gen-interval-list]
+    (let [entries (map-indexed (fn [i iv] [iv (keyword (str "v" i))]) intervals)
+          ;; For maps, later entries overwrite earlier ones with same key
+          unique-keys (set intervals)
+          imap (oc/interval-map entries)]
+      (= (count imap) (count unique-keys)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Property: Iteration Order
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-interval-set-sorted-order 100
+  (prop/for-all [intervals gen-interval-list]
+    (let [iset (oc/interval-set intervals)
+          result (vec iset)]
+      ;; Should be sorted by interval start, then by interval end
+      (= result (sort-by (fn [[a b]] [a b]) (set intervals))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Edge Case Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest edge-case-empty-interval-set
+  (let [iset (oc/interval-set [])]
+    (is (= 0 (count iset)))
+    (is (empty? (seq iset)))
+    (is (nil? (iset 5)))
+    (is (nil? (iset [0 10])))))
+
+(deftest edge-case-single-interval
+  (let [iset (oc/interval-set [[5 10]])]
+    (is (= 1 (count iset)))
+    (is (= [[5 10]] (vec iset)))
+    (is (nil? (iset 4)))
+    (is (= [[5 10]] (iset 5)))
+    (is (= [[5 10]] (iset 7)))
+    (is (= [[5 10]] (iset 10)))
+    (is (nil? (iset 11)))))
+
+(deftest edge-case-point-intervals
+  (testing "Degenerate intervals [x, x]"
+    (let [iset (oc/interval-set [[5 5] [10 10] [15 15]])]
+      (is (= 3 (count iset)))
+      (is (nil? (iset 4)))
+      (is (= [[5 5]] (iset 5)))
+      (is (nil? (iset 6)))
+      (is (= [[10 10]] (iset 10)))
+      (is (= [[5 5] [10 10]] (iset [5 10]))))))
+
+(deftest edge-case-touching-intervals
+  (testing "Intervals that touch but don't overlap: [0,5] and [5,10]"
+    (let [iset (oc/interval-set [[0 5] [5 10]])]
+      (is (= 2 (count iset)))
+      ;; Point 5 is in both intervals (closed intervals)
+      (is (= [[0 5] [5 10]] (sort (iset 5))))
+      ;; Query [0,5] overlaps both (they touch at 5)
+      (is (= [[0 5] [5 10]] (sort (iset [0 5])))))))
+
+(deftest edge-case-nested-intervals
+  (testing "Nested intervals: [0,10] contains [3,7] contains [4,6]"
+    (let [iset (oc/interval-set [[0 10] [3 7] [4 6]])]
+      (is (= 3 (count iset)))
+      (is (= [[0 10] [3 7] [4 6]] (sort (iset 5))))
+      (is (= [[0 10]] (iset 1)))
+      (is (= [[0 10] [3 7]] (sort (iset 3)))))))
+
+(deftest edge-case-identical-intervals
+  (testing "Duplicate intervals are deduplicated"
+    (let [iset (oc/interval-set [[1 5] [1 5] [1 5]])]
+      (is (= 1 (count iset)))
+      (is (= [[1 5]] (vec iset))))))
+
+(deftest edge-case-large-intervals
+  (testing "Very large intervals"
+    (let [iset (oc/interval-set [[Long/MIN_VALUE Long/MAX_VALUE]])]
+      (is (= 1 (count iset)))
+      (is (= [[Long/MIN_VALUE Long/MAX_VALUE]] (iset 0)))
+      (is (= [[Long/MIN_VALUE Long/MAX_VALUE]] (iset Long/MIN_VALUE)))
+      (is (= [[Long/MIN_VALUE Long/MAX_VALUE]] (iset Long/MAX_VALUE))))))
+
+(deftest edge-case-negative-intervals
+  (testing "Negative coordinate intervals"
+    (let [iset (oc/interval-set [[-10 -5] [-3 3] [5 10]])]
+      (is (= 3 (count iset)))
+      (is (= [[-10 -5]] (iset -7)))
+      (is (= [[-3 3]] (iset 0)))
+      (is (= [[5 10]] (iset 7)))
+      (is (= [[-10 -5] [-3 3]] (sort (iset [-10 0])))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Mutation Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest mutation-conj-maintains-invariant
+  (testing "conj maintains max-endpoint invariant"
+    (let [iset0 (oc/interval-set [[0 10] [20 30]])
+          iset1 (conj iset0 [5 50])  ; extends max-endpoint significantly
+          iset2 (conj iset1 [100 200])]
+      (is (verify-max-endpoint-invariant (get-root iset1)))
+      (is (verify-max-endpoint-invariant (get-root iset2)))
+      ;; Query should find the new interval
+      (is (= [[5 50]] (iset1 40)))
+      (is (= [[100 200]] (iset2 150))))))
+
+(deftest mutation-disj-maintains-invariant
+  (testing "disj maintains max-endpoint invariant"
+    (let [iset0 (oc/interval-set [[0 10] [20 100] [30 40]])
+          ;; Remove the interval with max endpoint
+          iset1 (disj iset0 [20 100])]
+      (is (verify-max-endpoint-invariant (get-root iset1)))
+      ;; The max endpoint should now be 40
+      (is (nil? (iset1 50))))))
+
+(deftest mutation-sequence-stress
+  (testing "Many mutations maintain invariant"
+    (let [initial (mapv (fn [i] [(* i 10) (+ (* i 10) 5)]) (range 100))
+          iset0   (oc/interval-set initial)
+          ;; Add 50 more
+          adds    (mapv (fn [i] [(+ 1000 (* i 10)) (+ 1005 (* i 10))]) (range 50))
+          iset1   (reduce conj iset0 adds)
+          ;; Remove first 30
+          removes (take 30 initial)
+          iset2   (reduce disj iset1 removes)]
+      (is (= (+ 100 50 (- 30)) (count iset2)))
+      (is (verify-max-endpoint-invariant (get-root iset2))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Scale Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest scale-test-large-interval-set
+  (testing "Large interval set maintains correctness"
+    (let [n         10000
+          intervals (mapv (fn [i] [i (+ i (rand-int 100))]) (range n))
+          iset      (oc/interval-set intervals)]
+      (is (= n (count iset)))
+      (is (verify-max-endpoint-invariant (get-root iset)))
+      ;; Sample queries
+      (dotimes [_ 100]
+        (let [q (rand-int n)
+              result (set (iset q))
+              expected (naive-query-set intervals q)]
+          (is (= result expected)))))))
diff --git a/test/ordered_collections/memory_test.clj b/test/ordered_collections/memory_test.clj
new file mode 100644
index 0000000..2bbaf98
--- /dev/null
+++ b/test/ordered_collections/memory_test.clj
@@ -0,0 +1,275 @@
+(ns ordered-collections.memory-test
+  "Memory overhead analysis for ordered-collections.
+
+   Compares memory usage per element across:
+   - clojure.core/sorted-set and sorted-map
+   - clojure.data.avl sorted collections
+   - ordered-collections
+
+   Run with: lein test :only ordered-collections.memory-test"
+  (:require [clojure.test :refer [deftest testing is]]
+            [clojure.data.avl :as avl]
+            [ordered-collections.core :as oc]
+            [clj-memory-meter.core :as mm]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Memory Measurement Helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn measure-bytes
+  "Measure total memory of object in bytes."
+  [obj]
+  (mm/measure obj :bytes true))
+
+(defn bytes-per-element
+  "Calculate bytes per element for a collection."
+  [coll n]
+  (double (/ (measure-bytes coll) n)))
+
+(defn format-bytes
+  "Format bytes as human-readable string."
+  [bytes]
+  (cond
+    (< bytes 1024) (format "%.0f B" (double bytes))
+    (< bytes (* 1024 1024)) (format "%.1f KB" (/ bytes 1024.0))
+    :else (format "%.1f MB" (/ bytes 1024.0 1024.0))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Set Memory Comparison
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest set-memory-comparison
+  (testing "Memory per element for sorted sets"
+    (doseq [n [1000 10000 100000]]
+      (let [data (vec (shuffle (range n)))
+
+            ;; Build each collection type
+            core-set   (into (sorted-set) data)
+            avl-set    (into (avl/sorted-set) data)
+            ordered    (oc/ordered-set data)
+            long-set   (oc/long-ordered-set data)
+
+            ;; Measure
+            core-bpe   (bytes-per-element core-set n)
+            avl-bpe    (bytes-per-element avl-set n)
+            ordered-bpe (bytes-per-element ordered n)
+            long-bpe   (bytes-per-element long-set n)]
+
+        (println)
+        (println (format "=== Set Memory at N=%,d ===" n))
+        (println (format "  sorted-set:      %5.1f bytes/elem  (total: %s)"
+                         core-bpe (format-bytes (measure-bytes core-set))))
+        (println (format "  data.avl:        %5.1f bytes/elem  (total: %s)"
+                         avl-bpe (format-bytes (measure-bytes avl-set))))
+        (println (format "  ordered-set:     %5.1f bytes/elem  (total: %s)"
+                         ordered-bpe (format-bytes (measure-bytes ordered))))
+        (println (format "  long-ordered:    %5.1f bytes/elem  (total: %s)"
+                         long-bpe (format-bytes (measure-bytes long-set))))
+
+        ;; Basic sanity checks - memory should be reasonable
+        (is (< ordered-bpe 100) "ordered-set should use < 100 bytes/element")
+        (is (< long-bpe 100) "long-ordered-set should use < 100 bytes/element")))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Map Memory Comparison
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest map-memory-comparison
+  (testing "Memory per entry for sorted maps"
+    (doseq [n [1000 10000 100000]]
+      (let [data (vec (for [i (shuffle (range n))] [i (* i 2)]))
+
+            ;; Build each collection type
+            core-map   (into (sorted-map) data)
+            avl-map    (into (avl/sorted-map) data)
+            ordered    (oc/ordered-map data)
+            long-map   (oc/long-ordered-map data)
+
+            ;; Measure
+            core-bpe   (bytes-per-element core-map n)
+            avl-bpe    (bytes-per-element avl-map n)
+            ordered-bpe (bytes-per-element ordered n)
+            long-bpe   (bytes-per-element long-map n)]
+
+        (println)
+        (println (format "=== Map Memory at N=%,d ===" n))
+        (println (format "  sorted-map:      %5.1f bytes/entry  (total: %s)"
+                         core-bpe (format-bytes (measure-bytes core-map))))
+        (println (format "  data.avl:        %5.1f bytes/entry  (total: %s)"
+                         avl-bpe (format-bytes (measure-bytes avl-map))))
+        (println (format "  ordered-map:     %5.1f bytes/entry  (total: %s)"
+                         ordered-bpe (format-bytes (measure-bytes ordered))))
+        (println (format "  long-ordered:    %5.1f bytes/entry  (total: %s)"
+                         long-bpe (format-bytes (measure-bytes long-map))))
+
+        ;; Basic sanity checks
+        (is (< ordered-bpe 150) "ordered-map should use < 150 bytes/entry")))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Specialized Collection Memory
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest specialized-collection-memory
+  (testing "Memory for specialized collection types"
+    (let [n 10000
+          data (vec (shuffle (range n)))
+          intervals (vec (for [i (range n)] [(* i 2) (+ (* i 2) (rand-int 10))]))
+
+          ;; Build collections
+          interval-set (oc/interval-set intervals)
+          interval-map (oc/interval-map (map #(vector % :val) intervals))
+          multiset     (oc/ordered-multiset (concat data data)) ; duplicates
+          priority-q   (oc/priority-queue (map #(vector % %) data))
+          fuzzy        (oc/fuzzy-set data)
+
+          ;; Measure
+          iset-bpe (bytes-per-element interval-set n)
+          imap-bpe (bytes-per-element interval-map n)
+          mset-bpe (bytes-per-element multiset (* 2 n))
+          pq-bpe   (bytes-per-element priority-q n)
+          fuzz-bpe (bytes-per-element fuzzy n)]
+
+      (println)
+      (println (format "=== Specialized Collections at N=%,d ===" n))
+      (println (format "  interval-set:    %5.1f bytes/interval  (total: %s)"
+                       iset-bpe (format-bytes (measure-bytes interval-set))))
+      (println (format "  interval-map:    %5.1f bytes/interval  (total: %s)"
+                       imap-bpe (format-bytes (measure-bytes interval-map))))
+      (println (format "  ordered-multiset:%5.1f bytes/elem  (total: %s)"
+                       mset-bpe (format-bytes (measure-bytes multiset))))
+      (println (format "  priority-queue:  %5.1f bytes/elem  (total: %s)"
+                       pq-bpe (format-bytes (measure-bytes priority-q))))
+      (println (format "  fuzzy-set:       %5.1f bytes/elem  (total: %s)"
+                       fuzz-bpe (format-bytes (measure-bytes fuzzy))))
+
+      ;; Sanity checks
+      (is (< iset-bpe 200) "interval-set should use < 200 bytes/interval"))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Node Structure Analysis
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest node-structure-analysis
+  (testing "Individual node memory breakdown"
+    (let [;; Create minimal collections to measure node overhead
+          small-set (oc/ordered-set [1 2 3])
+          small-map (oc/ordered-map [[1 :a] [2 :b] [3 :c]])
+
+          ;; Get root nodes via reflection (for analysis only)
+          set-root (.getRoot ^ordered_collections.kernel.root.INodeCollection small-set)
+          map-root (.getRoot ^ordered_collections.kernel.root.INodeCollection small-map)]
+
+      (println)
+      (println "=== Node Structure Analysis ===")
+      (println (format "  SimpleNode (3 elements): %s"
+                       (format-bytes (measure-bytes set-root))))
+      (println (format "  Single SimpleNode:       ~%d bytes (estimated)"
+                       (quot (measure-bytes set-root) 3)))
+
+      ;; Node should be reasonably sized
+      (is (< (measure-bytes set-root) 500) "3-element tree should be < 500 bytes"))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Memory Scaling Analysis
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest memory-scaling
+  (testing "Memory scales linearly with size"
+    (let [sizes [1000 2000 5000 10000 20000]
+          measurements (for [n sizes]
+                         (let [coll (oc/ordered-set (range n))]
+                           {:n n
+                            :bytes (measure-bytes coll)
+                            :per-elem (bytes-per-element coll n)}))]
+
+      (println)
+      (println "=== Memory Scaling ===")
+      (doseq [{:keys [n bytes per-elem]} measurements]
+        (println (format "  N=%,6d: %8s total, %.1f bytes/elem"
+                         n (format-bytes bytes) per-elem)))
+
+      ;; Per-element cost should be roughly constant
+      (let [per-elem-values (map :per-elem measurements)
+            min-pe (apply min per-elem-values)
+            max-pe (apply max per-elem-values)]
+        (is (< (- max-pe min-pe) 10)
+            "Per-element memory should be consistent across sizes")))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Rope Memory
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-memory
+  (testing "Rope memory vs PersistentVector"
+    (doseq [n [1000 10000 100000]]
+      (let [data     (range n)
+            r        (oc/rope data)
+            v        (vec data)
+            rope-bpe (bytes-per-element r n)
+            vec-bpe  (bytes-per-element v n)
+            ratio    (/ rope-bpe vec-bpe)]
+
+        (println)
+        (println (format "=== Rope Memory at N=%,d ===" n))
+        (println (format "  rope:   %5.1f bytes/elem  (total: %s)"
+                         rope-bpe (format-bytes (measure-bytes r))))
+        (println (format "  vector: %5.1f bytes/elem  (total: %s)"
+                         vec-bpe (format-bytes (measure-bytes v))))
+        (println (format "  ratio:  %.2fx" ratio))
+
+        ;; Rope should be within 10% of vector memory
+        (is (< ratio 1.10) (format "Rope overhead should be < 10%% at N=%d (was %.1f%%)"
+                                   n (* 100 (- ratio 1.0))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Summary Report
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest memory-summary-report
+  (testing "Generate memory summary for documentation"
+    (let [n 100000
+          data (vec (shuffle (range n)))
+          map-data (vec (for [i data] [i (* i 2)]))
+
+          ;; Sets
+          core-set (into (sorted-set) data)
+          avl-set (into (avl/sorted-set) data)
+          ordered-set (oc/ordered-set data)
+          long-set (oc/long-ordered-set data)
+
+          ;; Maps
+          core-map (into (sorted-map) map-data)
+          avl-map (into (avl/sorted-map) map-data)
+          ordered-map (oc/ordered-map map-data)
+          long-map (oc/long-ordered-map map-data)]
+
+      (println)
+      (println "╔══════════════════════════════════════════════════════════════╗")
+      (println "║           MEMORY OVERHEAD SUMMARY (N=100,000)                ║")
+      (println "╠══════════════════════════════════════════════════════════════╣")
+      (println "║ Collection Type      │ Bytes/Elem │ Total Memory │ vs sorted ║")
+      (println "╠══════════════════════════════════════════════════════════════╣")
+      (let [core-bpe (bytes-per-element core-set n)]
+        (doseq [[name coll] [["sorted-set" core-set]
+                             ["data.avl" avl-set]
+                             ["ordered-set" ordered-set]
+                             ["long-ordered-set" long-set]]]
+          (let [bpe (bytes-per-element coll n)
+                ratio (/ bpe core-bpe)]
+            (println (format "║ %-20s │ %10.1f │ %12s │ %8.2fx ║"
+                             name bpe (format-bytes (measure-bytes coll)) ratio)))))
+      (println "╠══════════════════════════════════════════════════════════════╣")
+      (let [core-bpe (bytes-per-element core-map n)]
+        (doseq [[name coll] [["sorted-map" core-map]
+                             ["data.avl map" avl-map]
+                             ["ordered-map" ordered-map]
+                             ["long-ordered-map" long-map]]]
+          (let [bpe (bytes-per-element coll n)
+                ratio (/ bpe core-bpe)]
+            (println (format "║ %-20s │ %10.1f │ %12s │ %8.2fx ║"
+                             name bpe (format-bytes (measure-bytes coll)) ratio)))))
+      (println "╚══════════════════════════════════════════════════════════════╝")
+
+      ;; Assertions for documentation accuracy
+      (is true "Summary report generated"))))
diff --git a/test/ordered_collections/ordered_map_test.clj b/test/ordered_collections/ordered_map_test.clj
new file mode 100644
index 0000000..981026a
--- /dev/null
+++ b/test/ordered_collections/ordered_map_test.clj
@@ -0,0 +1,191 @@
+(ns ordered-collections.ordered-map-test
+  (:require [clojure.string              :as str]
+            [clojure.test                :refer :all]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.core :refer [general-compare
+                                                       ordered-map ordered-map-by
+                                                       ordered-map-with
+                                                       ordered-merge-with assoc-new]]
+            [ordered-collections.test-utils :as tu])
+  (:import  [java.util UUID]))
+
+
+(deftest smoke-check
+  (is (= {} (ordered-map)))
+  (is (map? (ordered-map))) ;; => true
+  (is (= {:a 4, :b 5, :x 1, :y 2, :z 3}
+          (ordered-map {:x 1 :y 2 :z 3 :a 4 :b 5})))
+  (is (= [[:a 4] [:b 5] [:x 1] [:y 2] [:z 3]]
+         (seq (ordered-map {:x 1 :y 2 :z 3 :a 4 :b 5}))))
+  (is (= {:a 4, :b 5, :x 1, :y 2, :z 3}
+         (assoc (ordered-map) :x 1 :y 2 :z 3 :a 4 :b 5)))
+  (is (= [[1 "a"] [2 "b"] [3 "c"] [4 "d"]]
+         (seq (ordered-map [[2 "b"] [3 "c"] [1 "a"] [4 "d"]]))))
+  (is (= {:a "a", :b "b", :c "c"}
+         (-> (ordered-map) (assoc :b "b") (assoc :a "a") (assoc :c "c"))))
+  (is (= {:b "b", :c "c"}
+         (-> (ordered-map) (assoc :b "b") (assoc :a "a") (assoc :c "c")
+             (dissoc :a))))
+  (is (= "c" ((ordered-map {:a "a", :b "b", :c "c", :d "d"}) :c)))
+  (is (= ::not-found
+         ((ordered-map {:a "a", :b "b", :c "c", :d "d"}) :z ::not-found))))
+
+(defn random-entry []
+  (vector (UUID/randomUUID) (UUID/randomUUID)))
+
+(defn random-map
+  ([size]
+   (random-map (sorted-map) size))
+  ([this size]
+   (into this (repeatedly size random-entry))))
+
+(deftest map-equivalence-check
+  (doseq [size [10 100 1000 10000 100000 500000]]
+    (let [s     (random-map size)
+          t     (random-map 1000)
+          x     (ordered-map s)
+          [k v] (random-entry)]
+      (is (= s x))
+      (is (= (count s) (count x)))
+      (is (= (reverse s) (reverse x)))
+      (is (= (seq s) (seq x)))
+      (is (= (keys s) (keys x)))
+      (is (= (vals s) (vals x)))
+      (is (= (vals s) (map x (keys s))))
+      (is (= nil (x k)))
+      (is (= ::nope (x k ::nope)))
+      (is (= v ((assoc x k v) k)))
+      (is (= (assoc s k v) (assoc x k v)))
+      (is (= s (-> x (assoc k v) (dissoc k))))
+      (is (= (into s t) (into x t)))
+      (is (= (into s t) (-> x (into t) (into t)))))))
+
+(deftest assoc-new-test
+  (testing "assoc-new adds new key"
+    (let [m (ordered-map {:a 1 :b 2})]
+      (is (= {:a 1 :b 2 :c 3} (assoc-new m :c 3)))))
+
+  (testing "assoc-new returns original on existing key"
+    (let [m (ordered-map {:a 1 :b 2})]
+      (is (identical? m (assoc-new m :a 99)))
+      (is (= {:a 1 :b 2} (assoc-new m :a 99)))))
+
+  (testing "assoc-new works on empty map"
+    (let [m (ordered-map)]
+      (is (= {:x 1} (assoc-new m :x 1)))))
+
+  (testing "assoc-new preserves ordering"
+    (let [m (ordered-map [[1 :a] [3 :c] [5 :e]])]
+      (is (= [[1 :a] [2 :b] [3 :c] [5 :e]]
+             (seq (assoc-new m 2 :b)))))))
+
+(deftest general-comparator-supports-common-non-comparable-keys
+  (require 'clojure.edn 'clojure.string)
+  (testing "ordered-map accepts namespace keys"
+    (let [pairs [[(the-ns 'clojure.string) :string]
+                 [(the-ns 'clojure.core) :core]
+                 [(the-ns 'clojure.edn) :edn]]
+          om    (ordered-map-with general-compare (reverse pairs))]
+      (is (= (into {} pairs) om))
+      (is (= (sort-by (comp str first) pairs) (seq om)))))
+
+  (testing "ordered-map-with general-compare accepts var keys"
+    (let [pairs [[#'clojure.core/map :map]
+                 [#'clojure.core/filter :filter]
+                 [#'clojure.core/reduce :reduce]]
+          om    (ordered-map-with general-compare (reverse pairs))]
+      (is (= (into {} pairs) om))
+      (is (= (sort-by (comp str first) pairs) (seq om))))))
+
+(deftest general-compare-map-lookup-and-mutation
+  (let [pairs (mapv (fn [ns] [ns (str ns)]) (all-ns))
+        om    (ordered-map-with general-compare pairs)]
+    (testing "get finds every key"
+      (doseq [[k v] pairs]
+        (is (= v (get om k)))))
+    (testing "get returns not-found for absent key"
+      (is (= ::miss (get om :nope ::miss))))
+    (testing "assoc adds new entry"
+      (let [om' (assoc om :new-key :new-val)]
+        (is (= :new-val (get om' :new-key)))))
+    (testing "dissoc removes key"
+      (let [k (ffirst om)
+            om' (dissoc om k)]
+        (is (not (contains? om' k)))
+        (is (= (dec (count om)) (count om')))))))
+
+(deftest general-compare-map-comparable-match
+  (testing "integer-keyed map via general-compare has same order as normal"
+    (let [pairs (mapv (fn [i] [i (str i)]) (shuffle (range 500)))
+          om    (ordered-map pairs)
+          omg   (ordered-map-with general-compare pairs)]
+      (is (= (vec om) (vec omg))))))
+
+(deftest general-compare-map-prints-opaque
+  (let [om (ordered-map-with general-compare [[1 :a] [2 :b]])]
+    (is (str/starts-with? (pr-str om) "#<OrderedMap"))))
+
+(deftest ordered-merge-with-test
+  (testing "non-overlapping keys — simple union"
+    (let [m1 (ordered-map [[1 :a] [3 :c]])
+          m2 (ordered-map [[2 :b] [4 :d]])]
+      (is (= {1 :a 2 :b 3 :c 4 :d}
+             (ordered-merge-with (fn [k a b] a) m1 m2)))))
+
+  (testing "overlapping keys — merge function called with correct argument order"
+    (let [m1     (ordered-map [[1 10] [2 20] [3 30]])
+          m2     (ordered-map [[2 200] [3 300] [4 400]])
+          calls  (atom [])
+          result (ordered-merge-with
+                   (fn [k existing incoming]
+                     (swap! calls conj [k existing incoming])
+                     (+ existing incoming))
+                   m1 m2)]
+      ;; merge-fn receives (key, val-in-result, val-in-latter)
+      (is (= {1 10, 2 220, 3 330, 4 400} result))
+      (is (some #(= [2 20 200] %) @calls))
+      (is (some #(= [3 30 300] %) @calls))))
+
+  (testing "last-wins semantics"
+    (let [m1 (ordered-map [[1 :first] [2 :first]])
+          m2 (ordered-map [[2 :second] [3 :second]])
+          m3 (ordered-map [[3 :third] [4 :third]])]
+      (is (= {1 :first, 2 :second, 3 :third, 4 :third}
+             (ordered-merge-with (fn [k a b] b) m1 m2 m3)))))
+
+  (testing "first-wins semantics"
+    (let [m1 (ordered-map [[1 :first] [2 :first]])
+          m2 (ordered-map [[2 :second] [3 :second]])
+          m3 (ordered-map [[3 :third] [4 :third]])]
+      (is (= {1 :first, 2 :first, 3 :second, 4 :third}
+             (ordered-merge-with (fn [k a b] a) m1 m2 m3)))))
+
+  (testing "empty maps"
+    (is (nil? (ordered-merge-with (fn [k a b] b))))
+    (is (nil? (ordered-merge-with (fn [k a b] b) nil nil)))
+    (let [m (ordered-map [[1 :a]])]
+      (is (= m (ordered-merge-with (fn [k a b] b) m nil)))
+      (is (= m (ordered-merge-with (fn [k a b] b) nil m)))))
+
+  (testing "single map"
+    (let [m (ordered-map [[1 :a] [2 :b]])]
+      (is (= m (ordered-merge-with (fn [k a b] b) m))))))
+
+(defspec prop-merge-with-addition-is-commutative 100
+  (prop/for-all [kvs1 tu/gen-int-map-entries
+                 kvs2 tu/gen-int-map-entries]
+    (let [m1 (tu/->om kvs1)
+          m2 (tu/->om kvs2)
+          add (fn [k a b] (+ a b))]
+      (= (ordered-merge-with add m1 m2)
+         (ordered-merge-with add m2 m1)))))
+
+(defspec prop-merge-with-last-wins-equals-merge 100
+  (prop/for-all [kvs1 tu/gen-int-map-entries
+                 kvs2 tu/gen-int-map-entries]
+    (let [m1 (tu/->om kvs1)
+          m2 (tu/->om kvs2)]
+      (= (into m1 m2)
+         (ordered-merge-with (fn [k a b] b) m1 m2)))))
diff --git a/test/ordered_collections/ordered_multiset_test.clj b/test/ordered_collections/ordered_multiset_test.clj
new file mode 100644
index 0000000..4a69264
--- /dev/null
+++ b/test/ordered_collections/ordered_multiset_test.clj
@@ -0,0 +1,165 @@
+(ns ordered-collections.ordered-multiset-test
+  (:require [clojure.test :refer :all]
+            [clojure.core.reducers :as r]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.test-utils :as tu]
+            [ordered-collections.core :as oc]))
+
+(deftest ordered-multiset-basic
+  (testing "Empty multiset"
+    (let [ms (oc/ordered-multiset [])]
+      (is (= 0 (count ms)))
+      (is (nil? (seq ms)))))
+
+  (testing "Single element"
+    (let [ms (oc/ordered-multiset [42])]
+      (is (= 1 (count ms)))
+      (is (= [42] (seq ms)))))
+
+  (testing "Multiple distinct elements"
+    (let [ms (oc/ordered-multiset [3 1 4 5 2])]
+      (is (= 5 (count ms)))
+      (is (= [1 2 3 4 5] (seq ms)))))
+
+  (testing "Duplicate elements"
+    (let [ms (oc/ordered-multiset [3 1 4 1 5 9 2 6 5 3 5])]
+      (is (= 11 (count ms)))
+      (is (= [1 1 2 3 3 4 5 5 5 6 9] (seq ms))))))
+
+(deftest ordered-multiset-with-comparator
+  (testing "Descending order"
+    (let [ms (oc/ordered-multiset-by > [3 1 4 1 5])]
+      (is (= [5 4 3 1 1] (seq ms))))))
+
+(deftest ordered-multiset-conj-disj
+  (testing "conj adds element"
+    (let [ms (-> (oc/ordered-multiset [1 2 3])
+                 (conj 2)
+                 (conj 2))]
+      (is (= 5 (count ms)))
+      (is (= [1 2 2 2 3] (seq ms)))))
+
+  (testing "disj-one removes one occurrence"
+    (let [ms (oc/ordered-multiset [1 2 2 2 3])]
+      (let [ms2 (oc/disj-one ms 2)]
+        (is (= 4 (count ms2)))
+        (is (= [1 2 2 3] (seq ms2))))))
+
+  (testing "disj-one on non-existent"
+    (let [ms (oc/ordered-multiset [1 2 3])]
+      (is (= ms (oc/disj-one ms 99)))))
+
+  (testing "disj-all removes all occurrences"
+    (let [ms (oc/ordered-multiset [1 2 2 2 3])]
+      (let [ms2 (oc/disj-all ms 2)]
+        (is (= 2 (count ms2)))
+        (is (= [1 3] (seq ms2)))))))
+
+(deftest ordered-multiset-multiplicity
+  (testing "multiplicity"
+    (let [ms (oc/ordered-multiset [1 2 2 3 3 3 4])]
+      (is (= 1 (oc/multiplicity ms 1)))
+      (is (= 2 (oc/multiplicity ms 2)))
+      (is (= 3 (oc/multiplicity ms 3)))
+      (is (= 1 (oc/multiplicity ms 4)))
+      (is (= 0 (oc/multiplicity ms 99))))))
+
+(deftest ordered-multiset-distinct-elements
+  (testing "distinct-elements"
+    (let [ms (oc/ordered-multiset [3 1 4 1 5 9 2 6 5 3 5])]
+      (is (= [1 2 3 4 5 6 9] (oc/distinct-elements ms))))))
+
+(deftest ordered-multiset-frequencies
+  (testing "element-frequencies"
+    (let [ms (oc/ordered-multiset [1 2 2 3 3 3])]
+      (is (= {1 1, 2 2, 3 3} (oc/element-frequencies ms))))))
+
+(deftest ordered-multiset-lookup
+  (testing "contains?"
+    (let [^java.util.Collection ms (oc/ordered-multiset [1 2 3])]
+      (is (.contains ms 1))
+      (is (.contains ms 2))
+      (is (not (.contains ms 99)))))
+
+  (testing "get"
+    (let [ms (oc/ordered-multiset [1 2 3])]
+      (is (= 2 (ms 2)))
+      (is (= 2 (get ms 2)))
+      (is (nil? (ms 99)))
+      (is (= :default (get ms 99 :default))))))
+
+(deftest ordered-multiset-nth
+  (testing "nth access"
+    (let [ms (oc/ordered-multiset [3 1 4 1 5])]
+      (is (= 1 (nth ms 0)))
+      (is (= 1 (nth ms 1)))
+      (is (= 3 (nth ms 2)))
+      (is (= 4 (nth ms 3)))
+      (is (= 5 (nth ms 4))))))
+
+(deftest ordered-multiset-reduce
+  (testing "reduce"
+    (let [ms (oc/ordered-multiset [1 2 2 3])]
+      (is (= 8 (reduce + ms)))))
+
+  (testing "r/fold"
+    (let [ms (oc/ordered-multiset (range 1000))]
+      (is (= (reduce + (range 1000)) (r/fold + ms))))))
+
+(deftest ordered-multiset-seq-operations
+  (testing "seq"
+    (let [ms (oc/ordered-multiset [3 1 2])]
+      (is (= [1 2 3] (seq ms)))))
+
+  (testing "rseq"
+    (let [ms (oc/ordered-multiset [3 1 2])]
+      (is (= [3 2 1] (rseq ms))))))
+
+(deftest ordered-multiset-equality
+  (testing "equality - same elements"
+    (let [ms1 (oc/ordered-multiset [1 2 2 3])
+          ms2 (oc/ordered-multiset [3 2 1 2])]
+      (is (= ms1 ms2))))
+
+  (testing "inequality - different multiplicities"
+    (let [ms1 (oc/ordered-multiset [1 2 2 3])
+          ms2 (oc/ordered-multiset [1 2 3])]
+      (is (not= ms1 ms2)))))
+
+(deftest ordered-multiset-empty
+  (testing "empty"
+    (let [ms (oc/ordered-multiset [1 2 3])]
+      (is (= 0 (count (empty ms)))))))
+
+(deftest ordered-multiset-collection-interface
+  (testing "Collection methods"
+    (let [^java.util.Collection ms (oc/ordered-multiset [1 2 3])]
+      (is (not (.isEmpty ms)))
+      (is (= 3 (.size ms)))
+      (is (.contains ms 2))
+      (is (.containsAll ms [1 2]))
+      (is (not (.containsAll ms [1 2 99]))))))
+
+(defspec prop-ordered-multiset-frequencies 100
+  (prop/for-all [xs tu/gen-multiset-elems]
+    (let [ms (oc/ordered-multiset xs)]
+      (= (frequencies xs)
+         (oc/element-frequencies ms)))))
+
+(defspec prop-ordered-multiset-disj-one 100
+  (prop/for-all [xs tu/gen-multiset-elems
+                 x  gen/small-integer]
+    (let [ms (oc/ordered-multiset xs)
+          ms' (oc/disj-one ms x)
+          expected-freqs (tu/multiset-disj-one-frequencies xs x)]
+      (= expected-freqs (oc/element-frequencies ms')))))
+
+(defspec prop-ordered-multiset-disj-all 100
+  (prop/for-all [xs tu/gen-multiset-elems
+                 x  gen/small-integer]
+    (let [ms (oc/ordered-multiset xs)
+          ms' (oc/disj-all ms x)
+          expected (vec (sort (remove #(= x %) xs)))]
+      (= expected (vec (seq ms'))))))
diff --git a/test/ordered_collections/ordered_set_test.clj b/test/ordered_collections/ordered_set_test.clj
new file mode 100644
index 0000000..c6f3b30
--- /dev/null
+++ b/test/ordered_collections/ordered_set_test.clj
@@ -0,0 +1,447 @@
+(ns ordered-collections.ordered-set-test
+  (:refer-clojure :exclude [split-at])
+  (:require [clojure.core.reducers        :as r]
+            [clojure.math.combinatorics   :as combo]
+            [clojure.set                  :as set]
+            [clojure.string               :as str]
+            [clojure.test                 :refer :all]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.core  :refer :all]
+            [ordered-collections.test-utils :as tu]))
+
+
+;; TODO: more coverage
+
+(deftest simple-checks
+  (let [x (ordered-set (shuffle (range 8)))
+        y (ordered-set (shuffle (range 20)))
+        z (ordered-set (shuffle (range 0 20 2)))]
+    (is (= #{} (ordered-set)))
+    (is (= #{} (disj (ordered-set) 1)))
+    (is (= #{} (disj (ordered-set [1]) 1)))
+    (is (set? (ordered-set)))
+    (is (= #{0 1 2 3 4 5 6 7}     (conj x 5)))
+    (is (= #{0 1 2 3 4 5 6 7 9}   (conj x 9)))
+    (is (= #{-1 0 1 2 3 4 5 6 7}  (conj x -1)))
+    (is (= #{1 2 3 4 5 6 7}       (disj x 0)))
+    (is (= [9 0 1 2 3 4 5 6 7]    (cons 9 x)))
+    (is (= 0 (first x)))
+    (is (= 7 (last x)))
+    (doseq [i (range 20)]
+      (is (= i (nth y i)))
+      (is (= i (y i)))
+      (is (= i (get y i)))
+      (is (= ::nope (get y (+ 100 i) ::nope)))
+      (is (= i (.ceiling ^java.util.NavigableSet y i)))
+      (is (= i (.floor ^java.util.NavigableSet y i)))
+      (is (= (if (even? i) i (dec i)) (.floor ^java.util.NavigableSet z i)))
+      (is (= i (->> y (drop i) first))))
+    ;; subSet(from, to) returns elements >= from and < to (standard SortedSet semantics)
+    (is (= #{3 4 5 6}  (.subSet ^java.util.SortedSet x 3 7)))))
+
+(deftest set-algebra-checks
+  (doseq [size [10 100 1000 10000 100000]]
+    (let [x   (ordered-set (rest (shuffle (range size))))    ;; rest randomizes among runs
+          y   (ordered-set (rest (shuffle (range (* 2 size)))))
+          v   (ordered-set (rest (shuffle (range 0 (* 2 size) 7))))
+          w   (ordered-set (rest (shuffle (range 0 size 3))))
+          z   (ordered-set (rest (shuffle (range 0 size 2))))
+          chk (fn [x y]
+                (doseq [[theirs ours] [[set/intersection intersection]
+                                       [set/union        union]
+                                       [set/difference   difference]
+                                       [set/subset?      subset?]
+                                       [set/superset?    superset?]]]
+                  (is (= (theirs (set x) (set y)) (ours x y)))
+                  (is (= (theirs (set y) (set x)) (ours y x)))
+                  (is (= (theirs (set x) (set y)) (ours x (set y))))
+                  (is (= (theirs (set y) (set x)) (ours y (set x))))))]
+      (doseq [xy (combo/combinations [x y v w z] 2)]
+        (apply chk xy)))))
+
+(deftest set-equivalence-checks
+  (doseq [size [1 10 100 1000 10000 100000]]
+    (is (= (range size)
+           (seq (ordered-set (shuffle (range size))))))
+    (is (= (range size)
+           (seq (ordered-set-by < (shuffle (range size))))))
+    (is (= (reverse (range size))
+           (seq (ordered-set-by > (shuffle (range size))))))
+    (is (not= (range (inc size))
+              (seq (ordered-set (shuffle (range size))))))
+    (is (= (range size)
+           (ordered-set (shuffle (range size)))))
+    (is (not= (range size)
+              (ordered-set (shuffle (range (inc size))))))
+    (is (= (ordered-set (shuffle (range size)))
+           (set (range size))))
+    (is (= (set (range size))
+           (ordered-set (shuffle (range size)))))
+    (is (not= (set (range 100000))
+              (ordered-set (shuffle (range (inc size))))))
+    (is (= (ordered-set (shuffle (range size)))
+           (ordered-set (shuffle (range size)))))
+    (is (not= (ordered-set (shuffle (range 1 (inc size))))
+              (ordered-set (shuffle (range size)))))))
+
+(deftest sets-of-various-size-and-element-types
+  (doseq [size [1 10 100 1000 10000 100000 250000 500000]
+          f    [identity str gensym
+                #(java.util.Date. (long %))
+                (fn [_] (java.util.UUID/randomUUID))]]
+    (let [data (mapv f (shuffle (range size)))
+          this (ordered-set data)
+          that (apply sorted-set data)
+          afew (take 1000 data)]
+      (is (= that this))
+      (is (= that (into this afew)))
+      (is (= (apply disj that afew) (apply disj this afew)))
+      (is (= (seq this) (seq that)))
+      (is (= (count this) (count that)))
+      (is (every? #(= (nth this %) (->> that (drop %) first))
+                  (take 10 (repeatedly #(rand-int size)))))
+      (is (every? #(= (this %) (that %)) afew)))))
+
+(deftest foldable-reducible-collection-check
+  (doseq [size  [1 10 100 1000 10000 100000 250000 500000 1000000]
+          chunk [1 10 100 1000]]
+    (let [data (shuffle (range size))
+          sum  (reduce + data)
+          this (ordered-set data)]
+      (is (= sum (r/fold chunk + + this)))
+      (is (= sum (reduce + this))))))
+
+(deftest general-comparator-supports-common-non-comparable-values
+  (require 'clojure.edn 'clojure.string)
+  (testing "ordered-set-with general-compare accepts namespaces, including (all-ns)"
+    (let [nss (vec (all-ns))
+          os  (ordered-set-with general-compare nss)]
+      (is (= (set nss) os))
+      (is (= (sort-by str (distinct nss)) (seq os)))))
+
+  (testing "ordered-set-with general-compare accepts vars"
+    (let [vars [#'clojure.core/map
+                #'clojure.core/filter
+                #'clojure.core/reduce]
+          os   (ordered-set-with general-compare (reverse vars))]
+      (is (= (set vars) os))
+      (is (= (sort-by str vars) (seq os))))))
+
+(deftest general-compare-lookup-and-membership
+  (let [nss (vec (all-ns))
+        os  (ordered-set-with general-compare nss)]
+    (testing "contains? finds every element"
+      (doseq [ns nss]
+        (is (contains? os ns))))
+    (testing "contains? rejects absent element"
+      (is (not (contains? os :not-a-namespace))))
+    (testing "get returns element when present"
+      (let [ns1 (first nss)]
+        (is (= ns1 (get os ns1)))
+        (is (= ns1 (os ns1)))))
+    (testing "get returns not-found when absent"
+      (is (= ::miss (get os :nope ::miss))))))
+
+(deftest general-compare-deletion
+  (let [nss (vec (all-ns))
+        os  (ordered-set-with general-compare nss)
+        ns1 (first (seq os))]
+    (testing "disj removes element"
+      (let [os' (disj os ns1)]
+        (is (not (contains? os' ns1)))
+        (is (= (dec (count os)) (count os')))))
+    (testing "disj of absent element is identity"
+      (is (= os (disj os :not-a-namespace))))))
+
+(deftest general-compare-set-algebra
+  (let [nss  (vec (all-ns))
+        half (quot (count nss) 2)
+        os1  (ordered-set-with general-compare (take half nss))
+        os2  (ordered-set-with general-compare (drop (quot half 2) nss))]
+    (testing "union contains all elements from both"
+      (let [u (union os1 os2)]
+        (is (= (count u) (count (into #{} (concat (seq os1) (seq os2))))))))
+    (testing "intersection contains only shared elements"
+      (let [i (intersection os1 os2)]
+        (is (every? #(and (contains? os1 %) (contains? os2 %)) i))))
+    (testing "difference removes second set's elements"
+      (let [d (difference os1 os2)]
+        (is (every? #(not (contains? os2 %)) d))
+        (is (every? #(contains? os1 %) d))))))
+
+(deftest general-compare-comparable-values-match-normal
+  (testing "integers via general-compare have same order as normal-compare"
+    (let [xs   (shuffle (range 1000))
+          os   (ordered-set xs)
+          osg  (ordered-set-with general-compare xs)]
+      (is (= (seq os) (seq osg)))))
+  (testing "strings via general-compare have same order as normal-compare"
+    (let [xs (mapv str (shuffle (range 1000)))
+          os  (ordered-set xs)
+          osg (ordered-set-with general-compare xs)]
+      (is (= (seq os) (seq osg))))))
+
+(deftest general-compare-nil-handling
+  (let [os (ordered-set-with general-compare [3 nil 1 2])]
+    (is (= 4 (count os)))
+    (is (contains? os nil))
+    (is (= nil (first os)))
+    (is (= [nil 1 2 3] (vec os)))))
+
+(deftest general-compare-hash-and-equality
+  (let [nss (vec (all-ns))
+        os1 (ordered-set-with general-compare nss)
+        os2 (ordered-set-with general-compare (shuffle nss))]
+    (testing "hash is consistent across construction order"
+      (is (= (hash os1) (hash os2))))
+    (testing "equal to itself"
+      (is (= os1 os2)))
+    (testing "equal to plain set of same elements"
+      (is (= (set nss) os1)))))
+
+(deftest general-compare-positional-ops
+  (let [xs  (shuffle (range 100))
+        osg (ordered-set-with general-compare xs)]
+    (testing "nth matches sorted order"
+      (is (= 0 (nth osg 0)))
+      (is (= 50 (nth osg 50)))
+      (is (= 99 (nth osg 99))))
+    (testing "rank matches nth"
+      (is (= 0 (rank osg 0)))
+      (is (= 50 (rank osg 50)))
+      (is (nil? (rank osg 999))))
+    (testing "nearest works"
+      (is (= 49 (nearest osg :< 50)))
+      (is (= 51 (nearest osg :> 50))))))
+
+(deftest general-compare-prints-opaque
+  (let [os (ordered-set-with general-compare [1 2 3])]
+    (is (str/starts-with? (pr-str os) "#<OrderedSet"))))
+
+(deftest general-compare-deterministic-order
+  (testing "same elements produce same order across multiple constructions"
+    (let [nss (vec (all-ns))]
+      (is (= (vec (ordered-set-with general-compare nss))
+             (vec (ordered-set-with general-compare (shuffle nss)))
+             (vec (ordered-set-with general-compare (reverse nss))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Split and Range Operations (data.avl compatible)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest split-key-test
+  (testing "split-key on ordered-set"
+    (let [s (ordered-set [1 2 3 4 5])]
+      ;; Split at existing key
+      (let [[left entry right] (split-key 3 s)]
+        (is (= #{1 2} left))
+        (is (= 3 entry))
+        (is (= #{4 5} right)))
+      ;; Split at non-existing key
+      (let [[left entry right] (split-key 2.5 s)]
+        (is (= #{1 2} left))
+        (is (nil? entry))
+        (is (= #{3 4 5} right)))
+      ;; Split at first element
+      (let [[left entry right] (split-key 1 s)]
+        (is (= #{} left))
+        (is (= 1 entry))
+        (is (= #{2 3 4 5} right)))
+      ;; Split at last element
+      (let [[left entry right] (split-key 5 s)]
+        (is (= #{1 2 3 4} left))
+        (is (= 5 entry))
+        (is (= #{} right)))))
+
+  (testing "split-key on ordered-map"
+    (let [m (ordered-map [[1 :a] [2 :b] [3 :c] [4 :d] [5 :e]])]
+      ;; Split at existing key
+      (let [[left entry right] (split-key 3 m)]
+        (is (= {1 :a 2 :b} left))
+        (is (= [3 :c] entry))
+        (is (= {4 :d 5 :e} right)))
+      ;; Split at non-existing key
+      (let [[left entry right] (split-key 2.5 m)]
+        (is (= {1 :a 2 :b} left))
+        (is (nil? entry))
+        (is (= {3 :c 4 :d 5 :e} right))))))
+
+(deftest split-at-test
+  (testing "split-at on ordered-set"
+    (let [s (ordered-set [1 2 3 4 5])]
+      ;; Split at middle
+      (let [[left right] (split-at 2 s)]
+        (is (= #{1 2} left))
+        (is (= #{3 4 5} right)))
+      ;; Split at 0
+      (let [[left right] (split-at 0 s)]
+        (is (= #{} left))
+        (is (= #{1 2 3 4 5} right)))
+      ;; Split at end
+      (let [[left right] (split-at 5 s)]
+        (is (= #{1 2 3 4 5} left))
+        (is (= #{} right)))
+      ;; Split at 1
+      (let [[left right] (split-at 1 s)]
+        (is (= #{1} left))
+        (is (= #{2 3 4 5} right)))))
+
+  (testing "split-at on ordered-map"
+    (let [m (ordered-map [[1 :a] [2 :b] [3 :c] [4 :d] [5 :e]])]
+      (let [[left right] (split-at 2 m)]
+        (is (= {1 :a 2 :b} left))
+        (is (= {3 :c 4 :d 5 :e} right))))))
+
+(deftest subrange-test
+  (testing "subrange with single test"
+    (let [s (ordered-set (range 10))]
+      (is (= #{0 1 2 3 4} (subrange s :< 5)))
+      (is (= #{0 1 2 3 4 5} (subrange s :<= 5)))
+      (is (= #{6 7 8 9} (subrange s :> 5)))
+      (is (= #{5 6 7 8 9} (subrange s :>= 5)))))
+
+  (testing "subrange with two tests"
+    (let [s (ordered-set (range 10))]
+      (is (= #{3 4 5 6} (subrange s :>= 3 :< 7)))
+      (is (= #{3 4 5 6 7} (subrange s :>= 3 :<= 7)))
+      (is (= #{4 5 6} (subrange s :> 3 :< 7)))
+      (is (= #{4 5 6 7} (subrange s :> 3 :<= 7)))))
+
+  (testing "subrange on ordered-map"
+    (let [m (ordered-map (for [i (range 10)] [i (keyword (str i))]))]
+      (is (= {3 :3 4 :4 5 :5 6 :6} (subrange m :>= 3 :< 7)))))
+
+  (testing "subrange with strings"
+    (let [s (ordered-set ["apple" "banana" "cherry" "date" "elderberry" "fig"])]
+      (is (= #{"cherry" "date"} (subrange s :>= "cherry" :< "elderberry")))
+      (is (= #{"apple" "banana"} (subrange s :< "cherry")))
+      (is (= #{"elderberry" "fig"} (subrange s :> "date")))))
+
+  (testing "subrange with keywords"
+    (let [s (ordered-set [:a :b :c :d :e :f])]
+      (is (= #{:b :c :d} (subrange s :> :a :<= :d)))
+      (is (= #{:e :f} (subrange s :>= :e)))))
+
+  (testing "subrange with java.time.LocalDate"
+    (let [dates (ordered-set [(java.time.LocalDate/of 2024 1 1)
+                              (java.time.LocalDate/of 2024 3 15)
+                              (java.time.LocalDate/of 2024 6 30)
+                              (java.time.LocalDate/of 2024 9 15)
+                              (java.time.LocalDate/of 2024 12 31)])
+          q2-start (java.time.LocalDate/of 2024 4 1)
+          q3-end (java.time.LocalDate/of 2024 9 30)]
+      (is (= #{(java.time.LocalDate/of 2024 6 30)
+               (java.time.LocalDate/of 2024 9 15)}
+             (subrange dates :>= q2-start :<= q3-end))))))
+
+(deftest nearest-test
+  (testing "nearest on ordered-set"
+    (let [s (ordered-set [1 3 5 7 9])]
+      ;; :< - greatest less than
+      (is (= 5 (nearest s :< 6)))
+      (is (= 5 (nearest s :< 5.5)))
+      (is (nil? (nearest s :< 1)))
+      ;; :< when key exists (predecessor test)
+      (is (= 3 (nearest s :< 5)))   ; predecessor of 5 is 3
+      (is (= 7 (nearest s :< 9)))   ; predecessor of 9 is 7
+      ;; :<= - greatest less than or equal
+      (is (= 5 (nearest s :<= 5)))
+      (is (= 5 (nearest s :<= 6)))
+      (is (= 1 (nearest s :<= 1)))
+      ;; :> - least greater than
+      (is (= 7 (nearest s :> 6)))
+      (is (nil? (nearest s :> 9)))
+      ;; :> when key exists (successor test)
+      (is (= 7 (nearest s :> 5)))   ; successor of 5 is 7
+      (is (= 3 (nearest s :> 1)))   ; successor of 1 is 3
+      ;; :>= - least greater than or equal
+      (is (= 5 (nearest s :>= 5)))
+      (is (= 7 (nearest s :>= 6)))
+      (is (= 9 (nearest s :>= 9)))))
+
+  (testing "nearest on ordered-map"
+    (let [m (ordered-map [[1 :a] [3 :b] [5 :c] [7 :d] [9 :e]])]
+      (is (= [5 :c] (nearest m :< 6)))
+      (is (= [3 :b] (nearest m :< 5)))   ; predecessor test
+      (is (= [5 :c] (nearest m :<= 5)))
+      (is (= [7 :d] (nearest m :> 6)))
+      (is (= [7 :d] (nearest m :> 5)))   ; successor test
+      (is (= [5 :c] (nearest m :>= 5)))))
+
+  (testing "nearest with strings"
+    (let [s (ordered-set ["apple" "banana" "cherry" "date" "elderberry"])]
+      (is (= "cherry" (nearest s :< "coconut")))
+      (is (= "cherry" (nearest s :<= "cherry")))
+      (is (= "date" (nearest s :> "cherry")))
+      (is (= "cherry" (nearest s :>= "cherry")))
+      (is (= "banana" (nearest s :<= "blueberry")))
+      (is (nil? (nearest s :< "apple")))
+      (is (nil? (nearest s :> "elderberry")))))
+
+  (testing "nearest with keywords"
+    (let [s (ordered-set [:alpha :beta :gamma :delta :epsilon])]
+      (is (= :delta (nearest s :< :epsilon)))
+      (is (= :beta (nearest s :<= :beta)))
+      (is (= :gamma (nearest s :>= :gamma)))))
+
+  (testing "nearest with java.time.LocalDate"
+    (let [dates (ordered-set [(java.time.LocalDate/of 2024 1 1)
+                              (java.time.LocalDate/of 2024 3 15)
+                              (java.time.LocalDate/of 2024 6 30)
+                              (java.time.LocalDate/of 2024 12 31)])]
+      (is (= (java.time.LocalDate/of 2024 3 15)
+             (nearest dates :<= (java.time.LocalDate/of 2024 4 1))))
+      (is (= (java.time.LocalDate/of 2024 6 30)
+             (nearest dates :>= (java.time.LocalDate/of 2024 4 1))))))
+
+  (testing "nearest with vectors (lexicographic)"
+    (let [s (ordered-set [[1 1] [1 2] [2 1] [2 2] [3 1]])]
+      (is (= [1 2] (nearest s :< [2 1])))
+      (is (= [2 1] (nearest s :<= [2 1])))
+      (is (= [2 2] (nearest s :> [2 1]))))))
+
+(deftest rank-test
+  (testing "rank on ordered-set"
+    (let [s (ordered-set [10 20 30 40 50])]
+      (is (= 0 (rank s 10)))
+      (is (= 2 (rank s 30)))
+      (is (= 4 (rank s 50)))
+      (is (nil? (rank s 25)))
+      (is (nil? (rank s 5)))
+      (is (nil? (rank s 100)))))
+
+  (testing "rank on ordered-map"
+    (let [m (ordered-map [[1 :a] [3 :b] [5 :c] [7 :d] [9 :e]])]
+      (is (= 0 (rank m 1)))
+      (is (= 2 (rank m 5)))
+      (is (= 4 (rank m 9)))
+      (is (nil? (rank m 2)))
+      (is (nil? (rank m 10))))))
+
+(deftest disjoint?-test
+  (testing "disjoint sets"
+    (is (disjoint? (ordered-set [1 2 3]) (ordered-set [4 5 6])))
+    (is (disjoint? (ordered-set [1 3 5]) (ordered-set [2 4 6]))))
+
+  (testing "overlapping sets"
+    (is (not (disjoint? (ordered-set [1 2 3]) (ordered-set [3 4 5]))))
+    (is (not (disjoint? (ordered-set [1 2 3]) (ordered-set [1 2 3])))))
+
+  (testing "empty sets"
+    (is (disjoint? (ordered-set) (ordered-set)))
+    (is (disjoint? (ordered-set) (ordered-set [1 2 3])))
+    (is (disjoint? (ordered-set [1 2 3]) (ordered-set))))
+
+  (testing "single element"
+    (is (not (disjoint? (ordered-set [5]) (ordered-set [5]))))
+    (is (disjoint? (ordered-set [5]) (ordered-set [6])))))
+
+(defspec prop-disjoint-iff-empty-intersection 100
+  (prop/for-all [xs tu/gen-int-set
+                 ys tu/gen-int-set]
+    (let [os1 (tu/->os xs)
+          os2 (tu/->os ys)]
+      (= (disjoint? os1 os2)
+         (empty? (intersection os1 os2))))))
diff --git a/test/ordered_collections/parallel_threshold_bench.clj b/test/ordered_collections/parallel_threshold_bench.clj
new file mode 100644
index 0000000..aa2a329
--- /dev/null
+++ b/test/ordered_collections/parallel_threshold_bench.clj
@@ -0,0 +1,627 @@
+(ns ordered-collections.parallel-threshold-bench
+  "Benchmark production-style threshold dispatch for shared parallel operations.
+
+   Usage:
+     lein bench-parallel           ; Full benchmark
+     lein bench-parallel --quick   ; Quick mode
+
+   Measures:
+     1. Forced sequential execution
+     2. Production-style dispatch using candidate thresholds
+     3. Ordered-map merge under the same shared threshold
+
+   This is intentionally different from directly benchmarking the
+   `*-parallel` functions in isolation: production never pays pool-entry
+   overhead below the configured threshold."
+  (:require [ordered-collections.bench-utils :refer [has-flag?]]
+            [ordered-collections.core :as oc]
+            [ordered-collections.parallel :as parallel]
+            [ordered-collections.kernel.tree :as tree]
+            [ordered-collections.kernel.node :as node]
+            [ordered-collections.kernel.order :as order]
+            [ordered-collections.bench-utils :as bu])
+  (:import [ordered_collections.kernel.root INodeCollection IOrderedCollection]))
+
+
+(defn warmup
+  "JIT warmup - run operation multiple times."
+  [f n]
+  (dotimes [_ n] (f)))
+
+(defn bench-op
+  "Benchmark an operation, returning mean time in microseconds."
+  [f warmup-iters bench-iters]
+  (warmup f warmup-iters)
+  (let [start (System/nanoTime)]
+    (dotimes [_ bench-iters] (f))
+    (let [elapsed (- (System/nanoTime) start)]
+      (/ elapsed (* bench-iters 1000.0)))))
+
+(defn stats
+  "Compute simple descriptive stats for repeated benchmark samples."
+  [samples]
+  (let [sorted (sort samples)
+        n      (count sorted)
+        median (nth sorted (quot n 2))
+        mean   (/ (reduce + sorted) n)
+        low    (first sorted)
+        high   (last sorted)]
+    {:samples samples
+     :median  median
+     :mean    mean
+     :low     low
+     :high    high}))
+
+(defn bench-op-samples
+  "Benchmark f multiple times and return summary stats.
+
+   The median is used for threshold comparisons to reduce noise from
+   occasional scheduling hiccups."
+  [f warmup-iters bench-iters sample-runs]
+  (stats (vec (repeatedly sample-runs #(bench-op f warmup-iters bench-iters)))))
+
+(defn- make-keys
+  [n key-profile]
+  (case key-profile
+    :string (bu/generate-string-keys n)
+    :long   (vec (range n))
+    (throw (ex-info "unsupported key profile" {:key-profile key-profile}))))
+
+(defn make-test-sets
+  "Create two ordered-sets with given sizes and overlap ratio."
+  [size1 size2 overlap-ratio key-profile]
+  (let [overlap-size (int (* (min size1 size2) overlap-ratio))
+        ;; Elements: set1 has [0, size1), set2 has [offset, offset+size2)
+        ;; where offset determines overlap
+        offset (- size1 overlap-size)
+        keys1  (make-keys size1 key-profile)
+        keys2  (subvec (make-keys (+ offset size2) key-profile) offset (+ offset size2))
+        [s1 s2]
+        (case key-profile
+          :string [(oc/string-ordered-set (shuffle keys1))
+                   (oc/string-ordered-set (shuffle keys2))]
+          :long   [(oc/ordered-set (shuffle keys1))
+                   (oc/ordered-set (shuffle keys2))]
+          (throw (ex-info "unsupported key profile" {:key-profile key-profile})))]
+    [s1 s2]))
+
+(defn make-test-maps
+  "Create two ordered-maps with given sizes and overlap ratio."
+  [size1 size2 overlap-ratio key-profile]
+  (let [overlap-size (int (* (min size1 size2) overlap-ratio))
+        offset       (- size1 overlap-size)
+        keys1        (make-keys size1 key-profile)
+        keys2        (subvec (make-keys (+ offset size2) key-profile) offset (+ offset size2))
+        pairs1       (map-indexed (fn [idx k] [k idx]) (shuffle keys1))
+        pairs2       (map-indexed (fn [idx k] [k (+ idx size1)]) (shuffle keys2))]
+    (case key-profile
+      :string [(oc/string-ordered-map pairs1)
+               (oc/string-ordered-map pairs2)]
+      :long   [(oc/ordered-map pairs1)
+               (oc/ordered-map pairs2)]
+      (throw (ex-info "unsupported key profile" {:key-profile key-profile})))))
+
+(defn get-roots
+  "Extract roots from two compatible ordered collections."
+  [c1 c2]
+  [(.getRoot ^INodeCollection c1)
+   (.getRoot ^INodeCollection c2)])
+
+(defn- production-dispatch
+  "Mimic the production top-level dispatch decision at a given threshold."
+  [threshold seq-f par-f total]
+  (if (>= total threshold)
+    (par-f)
+    (seq-f)))
+
+(def ^:private default-threshold-candidates
+  [4096 8192 16384 32768 65536 131072 210000 262144 524288])
+
+(def ^:private default-recursive-threshold-candidates
+  [4096 16384 32768 65536])
+
+(defn- current-thresholds
+  []
+  {:union tree/+parallel-union-root-threshold+
+   :intersect tree/+parallel-intersection-root-threshold+
+   :diff tree/+parallel-difference-root-threshold+
+   :merge tree/+parallel-merge-root-threshold+})
+
+(defn- current-recursive-thresholds
+  []
+  {:union tree/+parallel-union-recursive-threshold+
+   :intersect tree/+parallel-intersection-recursive-threshold+
+   :diff tree/+parallel-difference-recursive-threshold+
+   :merge tree/+parallel-merge-recursive-threshold+})
+
+(def ^:private union-parallel-kernel
+  (ns-resolve 'ordered-collections.kernel.tree 'node-set-union-parallel*))
+
+(def ^:private intersect-parallel-kernel
+  (ns-resolve 'ordered-collections.kernel.tree 'node-set-intersection-parallel*))
+
+(def ^:private diff-parallel-kernel
+  (ns-resolve 'ordered-collections.kernel.tree 'node-set-difference-parallel*))
+
+(def ^:private merge-parallel-kernel
+  (ns-resolve 'ordered-collections.kernel.tree 'node-map-merge-parallel*))
+
+(defn bench-threshold-for-size
+  "Benchmark production-style dispatch at a given combined size."
+  [size & {:keys [warmup-iters bench-iters sample-runs overlap-ratio thresholds key-profile]
+           :or {warmup-iters 5
+                bench-iters 20
+                sample-runs 9
+                overlap-ratio 0.5
+                thresholds default-threshold-candidates
+                key-profile :long}}]
+  (let [half-size (quot size 2)
+        [s1 s2] (make-test-sets half-size half-size overlap-ratio key-profile)
+        [m1 m2] (make-test-maps half-size half-size overlap-ratio key-profile)
+        [r1 r2] (get-roots s1 s2)
+        [mr1 mr2] (get-roots m1 m2)
+        set-cmp (.getCmp ^IOrderedCollection s1)
+        map-cmp (.getCmp ^IOrderedCollection m1)
+        total   (+ (tree/node-size r1) (tree/node-size r2))
+        union-seq-f     #(tree/node-set-union r1 r2)
+        union-par-f     #(tree/node-set-union-parallel r1 r2)
+        intersect-seq-f #(tree/node-set-intersection r1 r2)
+        intersect-par-f #(tree/node-set-intersection-parallel r1 r2)
+        diff-seq-f      #(tree/node-set-difference r1 r2)
+        diff-par-f      #(tree/node-set-difference-parallel r1 r2)
+        merge-fn        (fn [_ left _] left)
+        merge-seq-f     #(tree/node-map-merge mr1 mr2 merge-fn)
+        merge-par-f     #(tree/node-map-merge-parallel mr1 mr2 merge-fn)
+
+        ;; Benchmark each operation using production-style threshold dispatch.
+        set-results
+        (binding [order/*compare* set-cmp]
+          {:union-seq     (bench-op-samples union-seq-f warmup-iters bench-iters sample-runs)
+           :intersect-seq (bench-op-samples intersect-seq-f warmup-iters bench-iters sample-runs)
+           :diff-seq      (bench-op-samples diff-seq-f warmup-iters bench-iters sample-runs)
+           :thresholds
+           (into {}
+                 (for [threshold thresholds]
+                   [threshold
+                    {:union
+                     (bench-op-samples
+                       #(production-dispatch threshold union-seq-f union-par-f total)
+                       warmup-iters bench-iters sample-runs)
+                     :intersect
+                     (bench-op-samples
+                       #(production-dispatch threshold intersect-seq-f intersect-par-f total)
+                       warmup-iters bench-iters sample-runs)
+                     :diff
+                     (bench-op-samples
+                       #(production-dispatch threshold diff-seq-f diff-par-f total)
+                       warmup-iters bench-iters sample-runs)}]))})
+        merge-results
+        (binding [order/*compare* map-cmp]
+          {:merge-seq
+           (bench-op-samples merge-seq-f warmup-iters bench-iters sample-runs)
+           :merge-thresholds
+           (into {}
+                 (for [threshold thresholds]
+                   [threshold
+                    (bench-op-samples
+                      #(production-dispatch threshold merge-seq-f merge-par-f total)
+                      warmup-iters bench-iters sample-runs)]))})
+        results
+        (assoc set-results
+               :merge-seq (:merge-seq merge-results)
+               :thresholds
+               (reduce (fn [acc threshold]
+                         (assoc acc threshold
+                                (assoc (get acc threshold)
+                                       :merge (get-in merge-results [:merge-thresholds threshold]))))
+                       (:thresholds set-results)
+                       thresholds))]
+
+    (assoc results :size size :total total :key-profile key-profile)))
+
+(defn bench-recursive-threshold-for-size
+  "Benchmark explicit recursive-threshold choices once an operation has already
+   entered the parallel path at the root."
+  [size & {:keys [warmup-iters bench-iters sample-runs overlap-ratio recursive-thresholds key-profile]
+           :or {warmup-iters 5
+                bench-iters 20
+                sample-runs 9
+                overlap-ratio 0.5
+                recursive-thresholds default-recursive-threshold-candidates
+                key-profile :long}}]
+  (let [recursive-thresholds (sort (distinct (concat recursive-thresholds
+                                                      (vals (current-recursive-thresholds)))))
+        half-size (quot size 2)
+        [s1 s2]   (make-test-sets half-size half-size overlap-ratio key-profile)
+        [m1 m2]   (make-test-maps half-size half-size overlap-ratio key-profile)
+        [r1 r2]   (get-roots s1 s2)
+        [mr1 mr2] (get-roots m1 m2)
+        set-cmp   (.getCmp ^IOrderedCollection s1)
+        map-cmp   (.getCmp ^IOrderedCollection m1)
+        join      tree/*t-join*
+        merge-fn  (fn [_ left _] left)
+
+        union-seq-f     #(tree/node-set-union r1 r2)
+        intersect-seq-f #(tree/node-set-intersection r1 r2)
+        diff-seq-f      #(tree/node-set-difference r1 r2)
+        merge-seq-f     #(tree/node-map-merge mr1 mr2 merge-fn)
+
+        union-par-f     (fn [recursive-threshold]
+                          #(parallel/invoke-root
+                             (fn []
+                               (union-parallel-kernel r1 r2 set-cmp join recursive-threshold))))
+        intersect-par-f (fn [recursive-threshold]
+                          #(parallel/invoke-root
+                             (fn []
+                               (intersect-parallel-kernel r1 r2 set-cmp join recursive-threshold))))
+        diff-par-f      (fn [recursive-threshold]
+                          #(parallel/invoke-root
+                             (fn []
+                               (diff-parallel-kernel r1 r2 set-cmp join recursive-threshold))))
+        merge-par-f     (fn [recursive-threshold]
+                          #(parallel/invoke-root
+                             (fn []
+                               (merge-parallel-kernel mr1 mr2 merge-fn map-cmp join recursive-threshold))))
+
+        set-results
+        {:union-seq     (binding [order/*compare* set-cmp]
+                         (bench-op-samples union-seq-f warmup-iters bench-iters sample-runs))
+         :intersect-seq (binding [order/*compare* set-cmp]
+                         (bench-op-samples intersect-seq-f warmup-iters bench-iters sample-runs))
+         :diff-seq      (binding [order/*compare* set-cmp]
+                         (bench-op-samples diff-seq-f warmup-iters bench-iters sample-runs))
+         :recursive-thresholds
+         (into {}
+               (for [threshold recursive-thresholds]
+                 [threshold
+                   {:union
+                   (binding [order/*compare* set-cmp]
+                     (bench-op-samples (union-par-f threshold) warmup-iters bench-iters sample-runs))
+                   :intersect
+                   (binding [order/*compare* set-cmp]
+                     (bench-op-samples (intersect-par-f threshold) warmup-iters bench-iters sample-runs))
+                   :diff
+                   (binding [order/*compare* set-cmp]
+                     (bench-op-samples (diff-par-f threshold) warmup-iters bench-iters sample-runs))}]))}
+
+        merge-results
+        {:merge-seq (binding [order/*compare* map-cmp]
+                     (bench-op-samples merge-seq-f warmup-iters bench-iters sample-runs))
+         :merge-recursive-thresholds
+         (into {}
+               (for [threshold recursive-thresholds]
+                 [threshold
+                  (binding [order/*compare* map-cmp]
+                    (bench-op-samples (merge-par-f threshold) warmup-iters bench-iters sample-runs))]))}
+
+        results
+        (assoc set-results
+               :merge-seq (:merge-seq merge-results)
+               :recursive-thresholds
+               (reduce (fn [acc threshold]
+                         (assoc acc threshold
+                                (assoc (get acc threshold)
+                                       :merge (get-in merge-results [:merge-recursive-thresholds threshold]))))
+                       (:recursive-thresholds set-results)
+                       recursive-thresholds))]
+    (assoc results :size size :key-profile key-profile)))
+
+(defn- best-threshold
+  [threshold-results op]
+  (apply min-key #(get-in threshold-results [% op :median]) (keys threshold-results)))
+
+(defn- speedup
+  [seq-stats candidate-stats]
+  (/ (:median seq-stats) (:median candidate-stats)))
+
+(defn print-results-table
+  "Print results in a formatted table."
+  [key-profile results]
+  (println)
+  (println (str "Key profile: " (name key-profile)))
+  (println "╔══════════════════════════════════════════════════════════════════════════════════════════════════════════════╗")
+  (println "║                          PRODUCTION THRESHOLD BENCHMARK RESULTS                                              ║")
+  (println "╠══════════════════════════════════════════════════════════════════════════════════════════════════════════════╣")
+  (println "║  Size   │  Best Union         │ Best Intersect      │ Best Diff           │ Best Merge          │ Current     ║")
+  (println "║         │ thres   med   spd   │ thres   med   spd   │ thres   med   spd   │ thres   med   spd   │ U I D M     ║")
+  (println "╠══════════════════════════════════════════════════════════════════════════════════════════════════════════════╣")
+  (doseq [{:keys [size union-seq intersect-seq diff-seq merge-seq thresholds]} results]
+    (let [union-best-th      (best-threshold thresholds :union)
+          intersect-best-th  (best-threshold thresholds :intersect)
+          diff-best-th       (best-threshold thresholds :diff)
+          merge-best-th      (best-threshold thresholds :merge)
+          current-thresholds (current-thresholds)]
+      (printf "║ %6d  │ %6d %6.0f %5.2fx │ %6d %6.0f %5.2fx │ %6d %6.0f %5.2fx │ %6d %6.0f %5.2fx │ %4.0f %4.0f %4.0f %4.0f ║%n"
+              size
+              union-best-th
+              (get-in thresholds [union-best-th :union :median])
+              (speedup union-seq (get-in thresholds [union-best-th :union]))
+              intersect-best-th
+              (get-in thresholds [intersect-best-th :intersect :median])
+              (speedup intersect-seq (get-in thresholds [intersect-best-th :intersect]))
+              diff-best-th
+              (get-in thresholds [diff-best-th :diff :median])
+              (speedup diff-seq (get-in thresholds [diff-best-th :diff]))
+              merge-best-th
+              (get-in thresholds [merge-best-th :merge :median])
+              (speedup merge-seq (get-in thresholds [merge-best-th :merge]))
+              (get-in thresholds [(:union current-thresholds) :union :median])
+              (get-in thresholds [(:intersect current-thresholds) :intersect :median])
+              (get-in thresholds [(:diff current-thresholds) :diff :median])
+              (get-in thresholds [(:merge current-thresholds) :merge :median]))))
+  (println "╚══════════════════════════════════════════════════════════════════════════════════════════════════════════════╝")
+  (println)
+  (println "Speedup > 1.0 means the candidate threshold beat forced sequential on median time.")
+  (println (str "Current root thresholds:"
+                " union=" tree/+parallel-union-root-threshold+
+                " intersect=" tree/+parallel-intersection-root-threshold+
+                " diff=" tree/+parallel-difference-root-threshold+
+                " merge=" tree/+parallel-merge-root-threshold+))
+  (println (str "Current recursive thresholds:"
+                " union=" tree/+parallel-union-recursive-threshold+
+                " intersect=" tree/+parallel-intersection-recursive-threshold+
+                " diff=" tree/+parallel-difference-recursive-threshold+
+                " merge=" tree/+parallel-merge-recursive-threshold+)))
+
+(defn find-crossover
+  "Find best candidate threshold per operation at each tested size."
+  [results]
+  (let [current-thresholds (current-thresholds)]
+    (mapv (fn [{:keys [size union-seq intersect-seq diff-seq merge-seq thresholds]}]
+            {:size size
+             :union-threshold (best-threshold thresholds :union)
+             :union-speedup (speedup union-seq (get-in thresholds [(best-threshold thresholds :union) :union]))
+             :intersect-threshold (best-threshold thresholds :intersect)
+             :intersect-speedup (speedup intersect-seq (get-in thresholds [(best-threshold thresholds :intersect) :intersect]))
+             :diff-threshold (best-threshold thresholds :diff)
+             :diff-speedup (speedup diff-seq (get-in thresholds [(best-threshold thresholds :diff) :diff]))
+             :merge-threshold (best-threshold thresholds :merge)
+             :merge-speedup (speedup merge-seq (get-in thresholds [(best-threshold thresholds :merge) :merge]))
+             :current-thresholds current-thresholds
+             :current-union-speedup (speedup union-seq (get-in thresholds [(:union current-thresholds) :union]))
+             :current-intersect-speedup (speedup intersect-seq (get-in thresholds [(:intersect current-thresholds) :intersect]))
+             :current-diff-speedup (speedup diff-seq (get-in thresholds [(:diff current-thresholds) :diff]))
+             :current-merge-speedup (speedup merge-seq (get-in thresholds [(:merge current-thresholds) :merge]))})
+          results)))
+
+(defn run-benchmark
+  "Run the full threshold benchmark."
+  [& {:keys [sizes warmup-iters bench-iters sample-runs thresholds key-profiles]
+      :or {sizes [4096 16384 65536 131072 262144 524288 1048576]
+           warmup-iters 5
+           bench-iters 20
+           sample-runs 9
+           thresholds default-threshold-candidates
+           key-profiles [:long :string]}}]
+  (println "Running parallel threshold benchmark...")
+  (println "Testing sizes:" sizes)
+  (println "Warmup iterations:" warmup-iters)
+  (println "Benchmark iterations:" bench-iters)
+  (println "Sample runs:" sample-runs)
+  (println "Threshold candidates:" thresholds)
+  (println "Key profiles:" key-profiles)
+  (println)
+
+  (let [results-by-profile
+        (into {}
+              (for [key-profile key-profiles]
+                [key-profile
+                 (vec (for [size sizes]
+                        (do
+                          (print (str "  Testing " (name key-profile) " size " size "... "))
+                          (flush)
+                          (let [r (bench-threshold-for-size size
+                                    :warmup-iters warmup-iters
+                                    :bench-iters bench-iters
+                                    :sample-runs sample-runs
+                                    :thresholds thresholds
+                                    :key-profile key-profile)]
+                            (println "done")
+                            r))))]))
+        summaries-by-profile
+        (into {}
+              (map (fn [[key-profile results]]
+                     [key-profile (find-crossover results)])
+                   results-by-profile))]
+
+    (doseq [key-profile key-profiles]
+      (let [results   (get results-by-profile key-profile)
+            summaries (get summaries-by-profile key-profile)]
+        (print-results-table key-profile results)
+        (println)
+        (println "Per-size threshold analysis:")
+        (doseq [{:keys [size union-threshold union-speedup
+                        intersect-threshold intersect-speedup
+                        diff-threshold diff-speedup
+                        merge-threshold merge-speedup
+                        current-thresholds current-union-speedup
+                        current-intersect-speedup current-diff-speedup
+                        current-merge-speedup]} summaries]
+          (printf "  size=%d  union=%d (%4.2fx)  intersect=%d (%4.2fx)  diff=%d (%4.2fx)  merge=%d (%4.2fx)  current=[%d %d %d %d] [%4.2fx %4.2fx %4.2fx %4.2fx]%n"
+                  size
+                  union-threshold union-speedup
+                  intersect-threshold intersect-speedup
+                  diff-threshold diff-speedup
+                  merge-threshold merge-speedup
+                  (:union current-thresholds)
+                  (:intersect current-thresholds)
+                  (:diff current-thresholds)
+                  (:merge current-thresholds)
+                  current-union-speedup current-intersect-speedup current-diff-speedup current-merge-speedup))
+        (println)))
+
+    {:results-by-profile results-by-profile
+     :summaries-by-profile summaries-by-profile}))
+
+(defn print-recursive-results-table
+  [key-profile results]
+  (println)
+  (println (str "Key profile: " (name key-profile)))
+  (println "╔══════════════════════════════════════════════════════════════════════════════════════════════════════════════╗")
+  (println "║                         RECURSIVE THRESHOLD BENCHMARK RESULTS                                                ║")
+  (println "╠══════════════════════════════════════════════════════════════════════════════════════════════════════════════╣")
+  (println "║  Size   │  Best Union         │ Best Intersect      │ Best Diff           │ Best Merge          │ Current     ║")
+  (println "║         │ recur   med   spd   │ recur   med   spd   │ recur   med   spd   │ recur   med   spd   │ U I D M     ║")
+  (println "╠══════════════════════════════════════════════════════════════════════════════════════════════════════════════╣")
+  (doseq [{:keys [size union-seq intersect-seq diff-seq merge-seq recursive-thresholds]} results]
+    (let [union-best-th      (best-threshold recursive-thresholds :union)
+          intersect-best-th  (best-threshold recursive-thresholds :intersect)
+          diff-best-th       (best-threshold recursive-thresholds :diff)
+          merge-best-th      (best-threshold recursive-thresholds :merge)
+          current-thresholds (current-recursive-thresholds)]
+      (printf "║ %6d  │ %6d %6.0f %5.2fx │ %6d %6.0f %5.2fx │ %6d %6.0f %5.2fx │ %6d %6.0f %5.2fx │ %4.0f %4.0f %4.0f %4.0f ║%n"
+              size
+              union-best-th
+              (get-in recursive-thresholds [union-best-th :union :median])
+              (speedup union-seq (get-in recursive-thresholds [union-best-th :union]))
+              intersect-best-th
+              (get-in recursive-thresholds [intersect-best-th :intersect :median])
+              (speedup intersect-seq (get-in recursive-thresholds [intersect-best-th :intersect]))
+              diff-best-th
+              (get-in recursive-thresholds [diff-best-th :diff :median])
+              (speedup diff-seq (get-in recursive-thresholds [diff-best-th :diff]))
+              merge-best-th
+              (get-in recursive-thresholds [merge-best-th :merge :median])
+              (speedup merge-seq (get-in recursive-thresholds [merge-best-th :merge]))
+              (get-in recursive-thresholds [(:union current-thresholds) :union :median])
+              (get-in recursive-thresholds [(:intersect current-thresholds) :intersect :median])
+              (get-in recursive-thresholds [(:diff current-thresholds) :diff :median])
+              (get-in recursive-thresholds [(:merge current-thresholds) :merge :median]))))
+  (println "╚══════════════════════════════════════════════════════════════════════════════════════════════════════════════╝")
+  (println)
+  (println "Current root thresholds stay fixed during this benchmark.")
+  (println (str "Current recursive thresholds:"
+                " union=" tree/+parallel-union-recursive-threshold+
+                " intersect=" tree/+parallel-intersection-recursive-threshold+
+                " diff=" tree/+parallel-difference-recursive-threshold+
+                " merge=" tree/+parallel-merge-recursive-threshold+)))
+
+(defn find-recursive-crossover
+  [results]
+  (let [current-thresholds (current-recursive-thresholds)]
+    (mapv (fn [{:keys [size union-seq intersect-seq diff-seq merge-seq recursive-thresholds]}]
+            {:size size
+             :union-threshold (best-threshold recursive-thresholds :union)
+             :union-speedup (speedup union-seq (get-in recursive-thresholds [(best-threshold recursive-thresholds :union) :union]))
+             :intersect-threshold (best-threshold recursive-thresholds :intersect)
+             :intersect-speedup (speedup intersect-seq (get-in recursive-thresholds [(best-threshold recursive-thresholds :intersect) :intersect]))
+             :diff-threshold (best-threshold recursive-thresholds :diff)
+             :diff-speedup (speedup diff-seq (get-in recursive-thresholds [(best-threshold recursive-thresholds :diff) :diff]))
+             :merge-threshold (best-threshold recursive-thresholds :merge)
+             :merge-speedup (speedup merge-seq (get-in recursive-thresholds [(best-threshold recursive-thresholds :merge) :merge]))
+             :current-thresholds current-thresholds
+             :current-union-speedup (speedup union-seq (get-in recursive-thresholds [(:union current-thresholds) :union]))
+             :current-intersect-speedup (speedup intersect-seq (get-in recursive-thresholds [(:intersect current-thresholds) :intersect]))
+             :current-diff-speedup (speedup diff-seq (get-in recursive-thresholds [(:diff current-thresholds) :diff]))
+             :current-merge-speedup (speedup merge-seq (get-in recursive-thresholds [(:merge current-thresholds) :merge]))})
+          results)))
+
+(defn run-recursive-benchmark
+  [& {:keys [sizes warmup-iters bench-iters sample-runs recursive-thresholds key-profiles]
+      :or {sizes [4096 16384 65536 131072 262144 524288 1048576]
+           warmup-iters 5
+           bench-iters 20
+           sample-runs 9
+           recursive-thresholds default-recursive-threshold-candidates
+           key-profiles [:long :string]}}]
+  (println "Running recursive threshold benchmark...")
+  (println "Testing sizes:" sizes)
+  (println "Warmup iterations:" warmup-iters)
+  (println "Benchmark iterations:" bench-iters)
+  (println "Sample runs:" sample-runs)
+  (println "Recursive threshold candidates:" recursive-thresholds)
+  (println "Key profiles:" key-profiles)
+  (println)
+
+  (let [results-by-profile
+        (into {}
+              (for [key-profile key-profiles]
+                [key-profile
+                 (vec (for [size sizes]
+                        (do
+                          (print (str "  Testing " (name key-profile) " size " size "... "))
+                          (flush)
+                          (let [r (bench-recursive-threshold-for-size size
+                                    :warmup-iters warmup-iters
+                                    :bench-iters bench-iters
+                                    :sample-runs sample-runs
+                                    :recursive-thresholds recursive-thresholds
+                                    :key-profile key-profile)]
+                            (println "done")
+                            r))))]))
+        summaries-by-profile
+        (into {}
+              (map (fn [[key-profile results]]
+                     [key-profile (find-recursive-crossover results)])
+                   results-by-profile))]
+    (doseq [key-profile key-profiles]
+      (let [results   (get results-by-profile key-profile)
+            summaries (get summaries-by-profile key-profile)]
+        (print-recursive-results-table key-profile results)
+        (println)
+        (println "Per-size recursive-threshold analysis:")
+        (doseq [{:keys [size union-threshold union-speedup
+                        intersect-threshold intersect-speedup
+                        diff-threshold diff-speedup
+                        merge-threshold merge-speedup
+                        current-thresholds current-union-speedup
+                        current-intersect-speedup current-diff-speedup
+                        current-merge-speedup]} summaries]
+          (printf "  size=%d  union=%d (%4.2fx)  intersect=%d (%4.2fx)  diff=%d (%4.2fx)  merge=%d (%4.2fx)  current=[%d %d %d %d] [%4.2fx %4.2fx %4.2fx %4.2fx]%n"
+                  size
+                  union-threshold union-speedup
+                  intersect-threshold intersect-speedup
+                  diff-threshold diff-speedup
+                  merge-threshold merge-speedup
+                  (:union current-thresholds)
+                  (:intersect current-thresholds)
+                  (:diff current-thresholds)
+                  (:merge current-thresholds)
+                  current-union-speedup current-intersect-speedup current-diff-speedup current-merge-speedup))
+        (println)))
+    {:results-by-profile results-by-profile
+     :summaries-by-profile summaries-by-profile}))
+
+(defn quick-bench
+  "Quick benchmark with fewer iterations for fast feedback."
+  []
+  (run-benchmark :sizes [4096 16384 65536 131072 262144]
+                 :warmup-iters 3
+                 :bench-iters 10
+                 :sample-runs 5))
+
+(defn quick-recursive-bench
+  []
+  (run-recursive-benchmark :sizes [65536 131072 262144 524288 1048576]
+                           :warmup-iters 3
+                           :bench-iters 10
+                           :sample-runs 5))
+
+(defn -main
+  "Entry point for lein bench-parallel."
+  [& args]
+  (cond
+    (has-flag? args "--recursive")
+    (if (has-flag? args "--quick" "-q")
+      (quick-recursive-bench)
+      (run-recursive-benchmark))
+
+    (has-flag? args "--quick" "-q")
+    (quick-bench)
+    :else
+    (run-benchmark))
+  (shutdown-agents))
+
+(comment
+  ;; Quick test
+  (quick-bench)
+
+  ;; Full benchmark
+  (run-benchmark)
+
+  ;; Fine-grained around and above current threshold
+  (run-benchmark :sizes [131072 196608 262144 393216 524288 786432 1048576])
+
+  ;; Recursive-threshold sweep with current root thresholds held fixed
+  (run-recursive-benchmark)
+  )
diff --git a/test/ordered_collections/priority_queue_test.clj b/test/ordered_collections/priority_queue_test.clj
new file mode 100644
index 0000000..4223e2f
--- /dev/null
+++ b/test/ordered_collections/priority_queue_test.clj
@@ -0,0 +1,278 @@
+(ns ordered-collections.priority-queue-test
+  (:require [clojure.string :as str]
+            [clojure.test :refer :all]
+            [clojure.core.reducers :as r]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.test-utils :as tu]
+            [ordered-collections.core :as oc]))
+
+(defn- pop-all
+  [pq]
+  (loop [pq pq, acc []]
+    (if-let [x (peek pq)]
+      (recur (pop pq) (conj acc x))
+      acc)))
+
+(deftest priority-queue-basic
+  (testing "Empty queue"
+    (let [pq (oc/priority-queue [])]
+      (is (= 0 (count pq)))
+      (is (nil? (peek pq)))
+      (is (thrown? IllegalStateException (pop pq)))))
+
+  (testing "Single element"
+    (let [pq (oc/priority-queue [[42 :val]])]
+      (is (= 1 (count pq)))
+      (is (= [42 :val] (peek pq)))
+      (is (= :val (oc/peek-min-val pq)))
+      (is (= 0 (count (pop pq))))))
+
+  (testing "Multiple elements - min heap"
+    (let [pq (oc/priority-queue [[3 :c] [1 :a] [4 :d] [1 :a2] [5 :e]])]
+      (is (= 5 (count pq)))
+      (is (= [1 :a] (peek pq)))
+      (is (= :a (oc/peek-min-val pq)))
+      ;; seq returns [priority value] pairs in order
+      (is (= [[1 :a] [1 :a2] [3 :c] [4 :d] [5 :e]] (vec (seq pq))))))
+
+  (testing "Multiple elements - max heap via priority-queue-by"
+    (let [pq (oc/priority-queue-by > [[3 :c] [1 :a] [5 :e]])]
+      (is (= [5 :e] (oc/peek-min pq)))
+      (is (= [5 :e] (peek pq)))
+      (is (= [[5 :e] [3 :c] [1 :a]] (vec (seq pq)))))))
+
+(deftest priority-queue-push-pop
+  (testing "Push with priority"
+    (let [pq (-> (oc/priority-queue [])
+                 (oc/push 5 :five)
+                 (oc/push 2 :two)
+                 (oc/push 8 :eight)
+                 (oc/push 1 :one))]
+      (is (= 4 (count pq)))
+      (is (= [1 :one] (peek pq)))
+      (is (= :one (oc/peek-min-val pq)))))
+
+  (testing "Pop sequence"
+    (let [pq (oc/priority-queue [[5 :e] [2 :b] [8 :h] [1 :a] [3 :c]])]
+      (is (= [1 :a] (peek pq)))
+      (let [pq2 (pop pq)]
+        (is (= [2 :b] (peek pq2)))
+        (let [pq3 (pop pq2)]
+          (is (= [3 :c] (peek pq3)))))))
+
+  (testing "Push-all"
+    (let [pq (oc/push-all (oc/priority-queue [])
+                          [[3 :c] [1 :a] [2 :b]])]
+      (is (= 3 (count pq)))
+      (is (= [1 :a] (peek pq)))
+      (is (= :a (oc/peek-min-val pq))))))
+
+(deftest priority-queue-max-operations
+  (testing "peek-max and pop-max"
+    (let [pq (oc/priority-queue [[3 :c] [1 :a] [9 :i] [6 :f]])]
+      (is (= [9 :i] (oc/peek-max pq)))
+      (is (= :i (oc/peek-max-val pq)))
+      (let [pq2 (oc/pop-max pq)]
+        (is (= 3 (count pq2)))
+        (is (= [6 :f] (oc/peek-max pq2)))))))
+
+(deftest priority-queue-comparator-semantics
+  (testing "peek-min/peek-max are relative to queue order, not numeric names"
+    (let [pq (oc/priority-queue-by > [[1 :low] [3 :high] [2 :mid]])]
+      (is (= [3 :high] (peek pq)))
+      (is (= [3 :high] (oc/peek-min pq)))
+      (is (= [1 :low] (oc/peek-max pq)))
+      (is (= [[3 :high] [2 :mid] [1 :low]] (vec (seq pq)))))))
+
+(deftest priority-queue-equal-priority-endpoints
+  (testing "equal priorities are stable in forward queue order"
+    (let [pq (oc/priority-queue [[1 :first] [1 :second] [1 :third]])]
+      (is (= [1 :first] (peek pq)))
+      (is (= [1 :first] (oc/peek-min pq)))
+      (is (= [1 :third] (oc/peek-max pq)))
+      (is (= [[1 :first] [1 :second] [1 :third]] (vec (seq pq))))
+      (is (= [[1 :third] [1 :second] [1 :first]] (vec (rseq pq)))))))
+
+(deftest priority-queue-reduce
+  (testing "reduce over [priority value] pairs"
+    (let [pq (oc/priority-queue [[1 10] [2 20] [3 30]])]
+      ;; reduce receives [priority value] pairs
+      (is (= 60 (reduce (fn [acc [_ v]] (+ acc v)) 0 pq)))
+      (is (= 6 (reduce (fn [acc [p _]] (+ acc p)) 0 pq)))))
+
+  (testing "reduce with r/fold"
+    (let [pairs (vec (for [i (range 100)] [i (* i 10)]))
+          pq (oc/priority-queue pairs)]
+      (is (= (reduce + (map second pairs))
+             (r/fold + (fn [acc [_ v]] (+ acc v)) pq))))))
+
+(deftest priority-queue-nth
+  (testing "nth access returns [priority value]"
+    (let [pq (oc/priority-queue [[5 :e] [2 :b] [8 :h] [1 :a] [3 :c]])]
+      (is (= [1 :a] (nth pq 0)))
+      (is (= [2 :b] (nth pq 1)))
+      (is (= [3 :c] (nth pq 2)))
+      (is (= [5 :e] (nth pq 3)))
+      (is (= [8 :h] (nth pq 4)))
+      (is (= :nf (nth pq 5 :nf))))))
+
+(deftest priority-queue-conj
+  (testing "conj takes [priority value] pair"
+    (let [pq (-> (oc/priority-queue [])
+                 (conj [3 :c])
+                 (conj [1 :a])
+                 (conj [4 :d]))]
+      (is (= 3 (count pq)))
+      (is (= [1 :a] (peek pq))))))
+
+(deftest priority-queue-equality
+  (testing "equality"
+    (let [pq1 (oc/priority-queue [[1 :a] [2 :b] [3 :c]])
+          pq2 (oc/priority-queue [[3 :c] [1 :a] [2 :b]])]
+      (is (= pq1 pq2))
+      (is (= pq1 [[1 :a] [2 :b] [3 :c]])))))
+
+(deftest priority-queue-stability
+  (testing "stable ordering for equal priorities"
+    (let [pq (oc/priority-queue [[1 :first] [1 :second] [1 :third]])]
+      ;; Elements with same priority should maintain insertion order
+      (is (= [[1 :first] [1 :second] [1 :third]] (vec (seq pq)))))))
+
+(deftest priority-queue-ordering-through-pop
+  (testing "repeated pop returns elements in queue order"
+    (doseq [pairs [[[3 :c] [1 :a] [4 :d] [1 :a2] [2 :b]]
+                   [[5 :e] [5 :e2] [1 :a] [3 :c] [3 :c2] [2 :b]]
+                   [[9 :i] [7 :g] [8 :h] [1 :a] [2 :b] [6 :f]]]]
+      (let [pq (oc/priority-queue pairs)
+            expected (tu/priority-queue-order pairs)]
+        (is (= expected (pop-all pq)))))))
+
+(deftest priority-queue-meta
+  (testing "metadata round-trips through with-meta and empty"
+    (let [pq (with-meta (oc/priority-queue [[1 :a] [2 :b]]) {:tag :pq})]
+      (is (= {:tag :pq} (meta pq)))
+      (is (= {:tag :pq} (meta (empty pq)))))))
+
+(defspec prop-priority-queue-pop-order 100
+  (prop/for-all [pairs tu/gen-priority-pairs]
+    (let [pq (oc/priority-queue pairs)
+          expected (tu/priority-queue-order pairs)]
+      (= expected (pop-all pq)))))
+
+(defspec prop-priority-queue-pop-order-descending 100
+  (prop/for-all [pairs tu/gen-priority-pairs]
+    (let [pq (oc/priority-queue-by > pairs)
+          expected (tu/priority-queue-order pairs true)]
+      (= expected (pop-all pq)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Constructor Variants
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest priority-queue-by-test
+  (testing "priority-queue-by with predicate"
+    (let [pq (oc/priority-queue-by > [[1 :a] [3 :c] [2 :b]])]
+      (is (= [3 :c] (peek pq)))
+      (is (= [[3 :c] [2 :b] [1 :a]] (vec (seq pq))))))
+  (testing "priority-queue-by with empty pairs"
+    (let [pq (oc/priority-queue-by > [])]
+      (is (= 0 (count pq)))
+      (is (nil? (peek pq))))))
+
+(deftest priority-queue-with-test
+  (testing "priority-queue-with explicit Comparator"
+    (let [pq (oc/priority-queue-with oc/long-compare [[3 :c] [1 :a] [2 :b]])]
+      (is (= [1 :a] (peek pq)))
+      (is (= [[1 :a] [2 :b] [3 :c]] (vec (seq pq))))))
+  (testing "empty priority-queue-with"
+    (let [pq (oc/priority-queue-with oc/string-compare)]
+      (is (= 0 (count pq)))
+      (is (nil? (peek pq)))))
+  (testing "priority-queue-with prints opaque for non-default comparator"
+    (let [cmp (oc/compare-by >)
+          pq  (oc/priority-queue-with cmp [[1 :a]])]
+      (is (str/starts-with? (pr-str pq) "#<PriorityQueue")))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Non-Numeric Priorities
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest priority-queue-string-priorities
+  (let [pq (oc/priority-queue [["beta" :b] ["alpha" :a] ["gamma" :g]])]
+    (testing "construction and seq"
+      (is (= [["alpha" :a] ["beta" :b] ["gamma" :g]] (vec (seq pq)))))
+    (testing "peek/pop cycle"
+      (is (= ["alpha" :a] (peek pq)))
+      (is (= ["beta" :b] (peek (pop pq))))
+      (is (= ["gamma" :g] (oc/peek-max pq))))
+    (testing "rseq"
+      (is (= [["gamma" :g] ["beta" :b] ["alpha" :a]] (vec (rseq pq)))))
+    (testing "push"
+      (let [pq2 (oc/push pq "aardvark" :aa)]
+        (is (= ["aardvark" :aa] (peek pq2)))
+        (is (= 4 (count pq2)))))
+    (testing "reduce"
+      (is (= #{"alpha" "beta" "gamma"}
+             (reduce (fn [acc [p _]] (conj acc p)) #{} pq)))))
+  (testing "duplicate string priorities preserve insertion order"
+    (let [pq (oc/priority-queue [["x" :first] ["x" :second] ["x" :third]])]
+      (is (= 3 (count pq)))
+      (is (= [["x" :first] ["x" :second] ["x" :third]] (vec (seq pq))))
+      (is (= ["x" :first] (oc/peek-min pq)))
+      (is (= ["x" :third] (oc/peek-max pq)))
+      (is (= [["x" :second] ["x" :third]] (vec (seq (oc/pop-min pq))))))))
+
+(deftest priority-queue-keyword-priorities
+  (let [pq (oc/priority-queue [[:b 2] [:a 1] [:c 3]])]
+    (testing "construction and seq"
+      (is (= [[:a 1] [:b 2] [:c 3]] (vec (seq pq)))))
+    (testing "pop-min/pop-max"
+      (is (= [:b 2] (peek (pop pq))))
+      (is (= [:b 2] (oc/peek-max (oc/pop-max pq)))))
+    (testing "duplicate keyword priorities"
+      (let [pq2 (oc/push-all (oc/priority-queue)
+                              [[:p :first] [:p :second] [:q :only]])]
+        (is (= 3 (count pq2)))
+        (is (= [:p :first] (peek pq2)))
+        (is (= [:q :only] (oc/peek-max pq2)))))))
+
+(deftest priority-queue-date-priorities
+  (let [t1 (java.time.Instant/parse "2024-01-01T00:00:00Z")
+        t2 (java.time.Instant/parse "2024-06-15T00:00:00Z")
+        t3 (java.time.Instant/parse "2024-12-31T00:00:00Z")
+        pq (oc/priority-queue [[t2 :mid] [t3 :late] [t1 :early]])]
+    (testing "construction and ordering"
+      (is (= [t1 :early] (peek pq)))
+      (is (= [t3 :late] (oc/peek-max pq)))
+      (is (= [[t1 :early] [t2 :mid] [t3 :late]] (vec (seq pq)))))
+    (testing "pop cycle"
+      (is (= [t2 :mid] (peek (pop pq))))
+      (is (= [t2 :mid] (oc/peek-max (oc/pop-max pq)))))
+    (testing "push and count"
+      (let [t0 (java.time.Instant/parse "2023-01-01T00:00:00Z")
+            pq2 (oc/push pq t0 :earliest)]
+        (is (= 4 (count pq2)))
+        (is (= [t0 :earliest] (peek pq2)))))
+    (testing "duplicate date priorities"
+      (let [pq2 (oc/priority-queue [[t1 :a] [t1 :b] [t2 :c]])]
+        (is (= 3 (count pq2)))
+        (is (= [t1 :a] (oc/peek-min pq2)))
+        (is (= [t1 :b] (peek (pop pq2))))))))
+
+(deftest priority-queue-tostring
+  (testing "toString uses pr-str"
+    (let [pq (oc/priority-queue [[1 :a] [2 :b]])]
+      (is (= (pr-str pq) (str pq))))))
+
+(deftest priority-queue-count-tracks-elements
+  (testing "count is total elements, not distinct priorities"
+    (let [pq (oc/priority-queue [[1 :a] [1 :b] [1 :c] [2 :d]])]
+      (is (= 4 (count pq)))
+      (is (= 3 (count (oc/pop-min pq))))
+      (is (= 3 (count (oc/pop-max pq))))))
+  (testing "count after push to existing priority"
+    (let [pq (-> (oc/priority-queue [[1 :a]])
+                 (oc/push 1 :b)
+                 (oc/push 1 :c))]
+      (is (= 3 (count pq))))))
diff --git a/test/ordered_collections/range_map_bench.clj b/test/ordered_collections/range_map_bench.clj
new file mode 100644
index 0000000..01c430d
--- /dev/null
+++ b/test/ordered_collections/range_map_bench.clj
@@ -0,0 +1,503 @@
+(ns ordered-collections.range-map-bench
+  "Benchmark comparing our range-map against Google Guava's TreeRangeMap.
+
+   Usage:
+     lein bench-range-map           ; Full suite
+     lein bench-range-map --quick   ; Quick mode
+
+   Note: Our range-map is persistent (immutable) while Guava's is mutable.
+   This means every modification creates a new structure via path-copying,
+   which has inherent overhead but enables safe concurrent reads, undo/history,
+   and structural sharing."
+  (:require [ordered-collections.bench-utils :refer [has-flag?]]
+            [ordered-collections.core :as oc])
+  (:import [com.google.common.collect TreeRangeMap Range]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Guava Helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn ^TreeRangeMap guava-range-map []
+  (TreeRangeMap/create))
+
+(defn guava-put! [^TreeRangeMap grm ^long lo ^long hi v]
+  (.put grm (Range/closedOpen lo hi) v)
+  grm)
+
+(defn guava-put-coalescing! [^TreeRangeMap grm ^long lo ^long hi v]
+  (.putCoalescing grm (Range/closedOpen lo hi) v)
+  grm)
+
+(defn guava-remove! [^TreeRangeMap grm ^long lo ^long hi]
+  (.remove grm (Range/closedOpen lo hi))
+  grm)
+
+(defn guava-get [^TreeRangeMap grm ^long x]
+  (.get grm x))
+
+(defn guava-get-entry [^TreeRangeMap grm ^long x]
+  (.getEntry grm x))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Benchmark Infrastructure
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmacro bench
+  "Run f for warmup-iters, then measure actual-iters. Returns [total-ms per-op-ms]."
+  [warmup-iters actual-iters & body]
+  `(do
+     ;; Warmup
+     (dotimes [_# ~warmup-iters]
+       ~@body)
+     ;; GC before measurement
+     (System/gc)
+     (Thread/sleep 50)
+     ;; Measure
+     (let [start# (System/nanoTime)]
+       (dotimes [_# ~actual-iters]
+         ~@body)
+       (let [end# (System/nanoTime)
+             total-ms# (/ (- end# start#) 1e6)
+             per-op# (/ total-ms# ~actual-iters)]
+         [total-ms# per-op#]))))
+
+(defn format-result [label [total-ms per-op]]
+  (printf "  %-35s %8.2f ms total  %8.3f ms/op%n" label total-ms per-op)
+  (flush))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Test Data Generators
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn gen-non-overlapping-ranges
+  "Generate n non-overlapping ranges [lo, hi) with values."
+  ([n] (gen-non-overlapping-ranges n 100))
+  ([n spacing]
+   (vec (for [i (range n)]
+          (let [lo (* i spacing)
+                hi (+ lo (quot spacing 2) (rand-int (quot spacing 2)))]
+            [lo hi (keyword (str "v" i))])))))
+
+(defn gen-overlapping-ranges
+  "Generate n potentially overlapping ranges."
+  [n max-coord]
+  (vec (for [i (range n)]
+         (let [lo (rand-int max-coord)
+               hi (+ lo 100 (rand-int 500))]
+           [lo hi (keyword (str "v" i))]))))
+
+(defn gen-lookup-points
+  "Generate n random lookup points in [0, max-coord)."
+  [n max-coord]
+  (vec (repeatedly n #(rand-int max-coord))))
+
+(defn gen-coalescing-ranges
+  "Generate n adjacent ranges with the same value."
+  [n]
+  (vec (for [i (range n)]
+         [(* i 100) (* (inc i) 100) :same-value])))
+
+(defn gen-remove-ranges
+  "Generate n ranges for removal operations."
+  [n max-coord]
+  (vec (for [i (range n)]
+         (let [lo (+ 50 (* i (quot max-coord n)))
+               hi (+ lo 100)]
+           [lo hi]))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Benchmarks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-construction-non-overlapping
+  "Benchmark inserting non-overlapping ranges."
+  [n iterations]
+  (println (str "\n=== Construction: " n " non-overlapping ranges ==="))
+  (let [ranges (gen-non-overlapping-ranges n)]
+
+    (format-result "Guava TreeRangeMap"
+      (bench 100 iterations
+        (let [grm (guava-range-map)]
+          (doseq [[lo hi v] ranges]
+            (guava-put! grm lo hi v))
+          grm)))
+
+    (format-result "Our range-map"
+      (bench 100 iterations
+        (reduce (fn [rm [lo hi v]]
+                  (assoc rm [lo hi] v))
+                (oc/range-map)
+                ranges)))))
+
+(defn bench-construction-overlapping
+  "Benchmark inserting overlapping ranges (requires carving)."
+  [n iterations]
+  (println (str "\n=== Construction: " n " overlapping ranges ==="))
+  (let [ranges (gen-overlapping-ranges n 5000)]
+
+    (format-result "Guava TreeRangeMap"
+      (bench 100 iterations
+        (let [grm (guava-range-map)]
+          (doseq [[lo hi v] ranges]
+            (guava-put! grm lo hi v))
+          grm)))
+
+    (format-result "Our range-map"
+      (bench 100 iterations
+        (reduce (fn [rm [lo hi v]]
+                  (assoc rm [lo hi] v))
+                (oc/range-map)
+                ranges)))))
+
+(defn bench-point-lookups
+  "Benchmark point lookup operations."
+  [num-ranges num-lookups iterations]
+  (println (str "\n=== Point Lookups: " num-lookups " lookups on " num-ranges "-range map ==="))
+  (let [ranges (gen-non-overlapping-ranges num-ranges)
+        points (gen-lookup-points num-lookups 10000)
+        guava-built (reduce (fn [grm [lo hi v]] (guava-put! grm lo hi v))
+                            (guava-range-map)
+                            ranges)
+        ours-built (reduce (fn [rm [lo hi v]] (assoc rm [lo hi] v))
+                           (oc/range-map)
+                           ranges)]
+
+    (format-result "Guava TreeRangeMap"
+      (bench 100 iterations
+        (doseq [x points]
+          (guava-get guava-built x))))
+
+    (format-result "Our range-map"
+      (bench 100 iterations
+        (doseq [x points]
+          (ours-built x))))))
+
+(defn bench-get-entry
+  "Benchmark get-entry operations."
+  [num-ranges num-lookups iterations]
+  (println (str "\n=== Get-Entry: " num-lookups " get-entry calls on " num-ranges "-range map ==="))
+  (let [ranges (gen-non-overlapping-ranges num-ranges)
+        points (gen-lookup-points num-lookups 10000)
+        guava-built (reduce (fn [grm [lo hi v]] (guava-put! grm lo hi v))
+                            (guava-range-map)
+                            ranges)
+        ours-built (reduce (fn [rm [lo hi v]] (assoc rm [lo hi] v))
+                           (oc/range-map)
+                           ranges)]
+
+    (format-result "Guava getEntry"
+      (bench 100 iterations
+        (doseq [x points]
+          (guava-get-entry guava-built x))))
+
+    (format-result "Our get-entry"
+      (bench 100 iterations
+        (doseq [x points]
+          (oc/get-entry ours-built x))))))
+
+(defn bench-coalescing
+  "Benchmark coalescing insert operations."
+  [n iterations]
+  (println (str "\n=== Coalescing: " n " adjacent same-value ranges ==="))
+  (let [ranges (gen-coalescing-ranges n)]
+
+    (format-result "Guava putCoalescing"
+      (bench 100 iterations
+        (let [grm (guava-range-map)]
+          (doseq [[lo hi v] ranges]
+            (guava-put-coalescing! grm lo hi v))
+          grm)))
+
+    (format-result "Our assoc-coalescing"
+      (bench 100 iterations
+        (reduce (fn [rm [lo hi v]]
+                  (oc/assoc-coalescing rm [lo hi] v))
+                (oc/range-map)
+                ranges)))))
+
+(defn bench-range-removal
+  "Benchmark range removal operations."
+  [num-ranges num-removes iterations]
+  (println (str "\n=== Range Removal: " num-removes " removes from " num-ranges "-range map ==="))
+  (let [insert-ranges (gen-non-overlapping-ranges num-ranges)
+        remove-ranges (gen-remove-ranges num-removes (* num-ranges 100))]
+
+    (format-result "Guava remove"
+      (bench 100 iterations
+        (let [grm (reduce (fn [g [lo hi v]] (guava-put! g lo hi v))
+                          (guava-range-map)
+                          insert-ranges)]
+          (doseq [[lo hi] remove-ranges]
+            (guava-remove! grm lo hi))
+          grm)))
+
+    (format-result "Our range-remove"
+      (bench 100 iterations
+        (let [rm (reduce (fn [r [lo hi v]] (assoc r [lo hi] v))
+                         (oc/range-map)
+                         insert-ranges)]
+          (reduce (fn [r [lo hi]]
+                    (oc/range-remove r [lo hi]))
+                  rm
+                  remove-ranges))))))
+
+(defn bench-iteration
+  "Benchmark iterating over all entries."
+  [num-ranges iterations]
+  (println (str "\n=== Iteration: traverse all " num-ranges " ranges ==="))
+  (let [ranges (gen-non-overlapping-ranges num-ranges)
+        guava-built (reduce (fn [grm [lo hi v]] (guava-put! grm lo hi v))
+                            (guava-range-map)
+                            ranges)
+        ours-built (reduce (fn [rm [lo hi v]] (assoc rm [lo hi] v))
+                           (oc/range-map)
+                           ranges)]
+
+    (format-result "Guava asMapOfRanges iteration"
+      (bench 100 iterations
+        (let [^java.util.Map m (.asMapOfRanges ^TreeRangeMap guava-built)]
+          (reduce (fn [acc ^java.util.Map$Entry e]
+                    (+ acc (hash (.getValue e))))
+                  0
+                  (.entrySet m)))))
+
+    (format-result "Our seq iteration"
+      (bench 100 iterations
+        (reduce (fn [acc [_ v]]
+                  (+ acc (hash v)))
+                0
+                ours-built)))))
+
+(defn bench-snapshot-modify
+  "Benchmark creating snapshots while modifying - persistence advantage.
+   Guava must copy the entire map for each snapshot."
+  [num-ranges num-snapshots iterations]
+  (println (str "\n=== Snapshot + Modify: " num-snapshots " snapshots from " num-ranges "-range map ==="))
+  (let [ranges (gen-non-overlapping-ranges num-ranges)
+        max-coord (* num-ranges 100)]
+
+    (format-result "Guava (must copy each snapshot)"
+      (bench 50 iterations
+        (let [grm (reduce (fn [g [lo hi v]] (guava-put! g lo hi v))
+                          (guava-range-map)
+                          ranges)]
+          (loop [i 0 snapshots []]
+            (if (< i num-snapshots)
+              (let [copy (TreeRangeMap/create)]
+                (.putAll copy grm)
+                (guava-put! grm (rand-int max-coord) (+ max-coord (rand-int 1000)) :new)
+                (recur (inc i) (conj snapshots copy)))
+              snapshots)))))
+
+    (format-result "Our (structural sharing)"
+      (bench 50 iterations
+        (let [rm (reduce (fn [r [lo hi v]] (assoc r [lo hi] v))
+                         (oc/range-map)
+                         ranges)]
+          (loop [i 0 current rm snapshots []]
+            (if (< i num-snapshots)
+              (let [new-rm (assoc current
+                                  [(rand-int max-coord) (+ max-coord (rand-int 1000))]
+                                  :new)]
+                (recur (inc i) new-rm (conj snapshots current)))
+              snapshots)))))))
+
+(defn bench-reduce
+  "Benchmark reduce over the collection."
+  [num-ranges iterations]
+  (println (str "\n=== Reduce: sum values over " num-ranges " ranges ==="))
+  (let [ranges (vec (for [i (range num-ranges)]
+                      [(* i 100) (+ (* i 100) 50 (rand-int 50)) i]))
+        guava-built (reduce (fn [grm [lo hi v]] (guava-put! grm lo hi v))
+                            (guava-range-map)
+                            ranges)
+        ours-built (reduce (fn [rm [lo hi v]] (assoc rm [lo hi] v))
+                           (oc/range-map)
+                           ranges)]
+
+    (format-result "Guava reduce via entrySet"
+      (bench 100 iterations
+        (let [^java.util.Map m (.asMapOfRanges ^TreeRangeMap guava-built)]
+          (reduce (fn [^long acc ^java.util.Map$Entry e]
+                    (+ acc (long (.getValue e))))
+                  0
+                  (.entrySet m)))))
+
+    (format-result "Our reduce"
+      (bench 100 iterations
+        (reduce (fn [^long acc [_ v]]
+                  (+ acc (long v)))
+                0
+                ours-built)))))
+
+(defn bench-heavy-versioning
+  "Benchmark creating many versions with modifications between each.
+   This is where persistence provides massive advantage."
+  [num-ranges num-versions iterations]
+  (println (str "\n=== Heavy Versioning: " num-versions " versions of " num-ranges "-range map ==="))
+  (let [ranges (gen-non-overlapping-ranges num-ranges)
+        max-coord (* num-ranges 100)]
+
+    (format-result "Guava (copy for each version)"
+      (bench 20 iterations
+        (let [grm (reduce (fn [g [lo hi v]] (guava-put! g lo hi v))
+                          (guava-range-map)
+                          ranges)]
+          (loop [i 0 versions (transient [])]
+            (if (< i num-versions)
+              (let [copy (TreeRangeMap/create)
+                    lo (rand-int max-coord)
+                    rm-lo (rand-int max-coord)]
+                (.putAll copy grm)
+                ;; Modify original after copy
+                (guava-put! grm lo (+ lo 100 (rand-int 1000)) :new)
+                (guava-remove! grm rm-lo (+ rm-lo 10))
+                (recur (inc i) (conj! versions copy)))
+              (persistent! versions))))))
+
+    (format-result "Our (structural sharing)"
+      (bench 20 iterations
+        (let [rm (reduce (fn [r [lo hi v]] (assoc r [lo hi] v))
+                         (oc/range-map)
+                         ranges)]
+          (loop [i 0 current rm versions (transient [])]
+            (if (< i num-versions)
+              (let [lo (rand-int max-coord)
+                    rm-lo (rand-int max-coord)
+                    new-rm (-> current
+                               (assoc [lo (+ lo 100 (rand-int 1000))] :new)
+                               (oc/range-remove [rm-lo (+ rm-lo 10)]))]
+                (recur (inc i) new-rm (conj! versions current)))
+              (persistent! versions))))))))
+
+(defn bench-lookup-after-versions
+  "After creating N versions, lookup in all of them.
+   Guava copies are independent; ours share structure."
+  [num-ranges num-versions num-lookups iterations]
+  (println (str "\n=== Lookup Across " num-versions " Versions ==="))
+  (let [ranges (gen-non-overlapping-ranges num-ranges)
+        max-coord (* num-ranges 100)
+        points (gen-lookup-points num-lookups max-coord)
+
+        ;; Build Guava versions
+        guava-base (reduce (fn [g [lo hi v]] (guava-put! g lo hi v))
+                           (guava-range-map)
+                           ranges)
+        guava-versions (loop [i 0 grm guava-base versions []]
+                         (if (< i num-versions)
+                           (let [copy (TreeRangeMap/create)]
+                             (.putAll copy grm)
+                             (guava-put! grm (rand-int max-coord) (+ max-coord (rand-int 1000)) :new)
+                             (recur (inc i) grm (conj versions copy)))
+                           versions))
+
+        ;; Build our versions
+        ours-base (reduce (fn [r [lo hi v]] (assoc r [lo hi] v))
+                          (oc/range-map)
+                          ranges)
+        ours-versions (loop [i 0 current ours-base versions []]
+                        (if (< i num-versions)
+                          (let [new-rm (assoc current
+                                              [(rand-int max-coord) (+ max-coord (rand-int 1000))]
+                                              :new)]
+                            (recur (inc i) new-rm (conj versions current)))
+                          versions))]
+
+    (format-result (str "Guava lookup across " num-versions " versions")
+      (bench 50 iterations
+        (doseq [grm guava-versions
+                x points]
+          (guava-get grm x))))
+
+    (format-result (str "Our lookup across " num-versions " versions")
+      (bench 50 iterations
+        (doseq [rm ours-versions
+                x points]
+          (rm x))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Entry Points
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn run-quick
+  "Run a quick benchmark suite."
+  []
+  (println)
+  (println "========================================================================")
+  (println "  Range-Map Performance: ordered-collections vs Guava TreeRangeMap")
+  (println "  JVM:" (System/getProperty "java.version")
+           " Clojure:" (clojure-version))
+  (println "========================================================================")
+  (println)
+  (println "Note: Our range-map is PERSISTENT (immutable), Guava's is MUTABLE.")
+  (println "      Persistence enables safe sharing, undo, concurrent reads.")
+
+  (bench-construction-non-overlapping 100 500)
+  (bench-construction-overlapping 100 500)
+  (bench-point-lookups 100 1000 500)
+  (bench-get-entry 100 1000 500)
+  (bench-coalescing 50 500)
+  (bench-range-removal 100 20 500)
+
+  (println)
+  (println "========================================================================")
+  (println))
+
+(defn run-all
+  "Run the full benchmark suite with more iterations."
+  []
+  (println)
+  (println "========================================================================")
+  (println "  Range-Map Performance: ordered-collections vs Guava TreeRangeMap")
+  (println "  JVM:" (System/getProperty "java.version")
+           " Clojure:" (clojure-version))
+  (println (java.util.Date.))
+  (println "========================================================================")
+  (println)
+  (println "Note: Our range-map is PERSISTENT (immutable), Guava's is MUTABLE.")
+  (println "      Persistence enables safe sharing, undo, concurrent reads.")
+
+  ;; Small scale (original tests)
+  (println)
+  (println "--- Small Scale (100 ranges) ---")
+  (bench-construction-non-overlapping 100 1000)
+  (bench-construction-overlapping 100 1000)
+  (bench-point-lookups 100 1000 1000)
+  (bench-get-entry 100 1000 1000)
+  (bench-coalescing 50 1000)
+  (bench-range-removal 100 20 1000)
+
+  ;; Medium scale
+  (println)
+  (println "--- Medium Scale (1,000 ranges) ---")
+  (bench-construction-non-overlapping 1000 500)
+  (bench-point-lookups 1000 10000 500)
+  (bench-iteration 1000 500)
+  (bench-reduce 1000 500)
+
+  ;; Large scale
+  (println)
+  (println "--- Large Scale (10,000 ranges) ---")
+  (bench-construction-non-overlapping 10000 100)
+  (bench-point-lookups 10000 50000 100)
+  (bench-iteration 10000 200)
+  (bench-reduce 10000 200)
+
+  ;; Persistence advantage scenarios
+  (println)
+  (println "--- Persistence Advantage Scenarios ---")
+  (bench-snapshot-modify 1000 50 200)
+  (bench-snapshot-modify 5000 100 100)
+  (bench-heavy-versioning 1000 200 50)
+  (bench-heavy-versioning 5000 500 20)
+  (bench-lookup-after-versions 1000 50 100 100)
+
+  (println)
+  (println "========================================================================")
+  (println))
+
+(defn -main [& args]
+  (if (has-flag? args "--quick" "-q")
+    (run-quick)
+    (run-all)))
diff --git a/test/ordered_collections/range_map_equivalence_test.clj b/test/ordered_collections/range_map_equivalence_test.clj
new file mode 100644
index 0000000..597c308
--- /dev/null
+++ b/test/ordered_collections/range_map_equivalence_test.clj
@@ -0,0 +1,377 @@
+(ns ordered-collections.range-map-equivalence-test
+  "Randomized equivalence tests comparing our range-map implementation
+   against Google Guava's TreeRangeMap.
+
+   These tests verify that our range-map has identical semantics to Guava's
+   TreeRangeMap for all operations:
+   - assoc (put): insert range, carving out overlaps
+   - assoc-coalescing (putCoalescing): insert and merge adjacent same-value ranges
+   - get: point lookup
+   - get-entry (getEntry): point lookup returning [range value]
+   - range-remove (remove): remove all mappings in a range
+
+   Reference: https://guava.dev/releases/33.0.0-jre/api/docs/com/google/common/collect/TreeRangeMap.html"
+  (:require [clojure.test :refer [deftest testing is]]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.core :as oc]
+            [ordered-collections.test-utils :as tu])
+  (:import [com.google.common.collect TreeRangeMap Range]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Guava Interop Helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn guava-range-map
+  "Create a Guava TreeRangeMap."
+  ^TreeRangeMap []
+  (TreeRangeMap/create))
+
+(defn guava-put!
+  "Put a range into a Guava TreeRangeMap (mutates in place).
+   Range is half-open [lo, hi)."
+  [^TreeRangeMap grm lo hi v]
+  (.put grm (Range/closedOpen (long lo) (long hi)) v)
+  grm)
+
+(defn guava-put-coalescing!
+  "Put a range with coalescing into a Guava TreeRangeMap (mutates in place)."
+  [^TreeRangeMap grm lo hi v]
+  (.putCoalescing grm (Range/closedOpen (long lo) (long hi)) v)
+  grm)
+
+(defn guava-remove!
+  "Remove a range from a Guava TreeRangeMap (mutates in place)."
+  [^TreeRangeMap grm lo hi]
+  (.remove grm (Range/closedOpen (long lo) (long hi)))
+  grm)
+
+(defn guava-get
+  "Get the value for a point in a Guava TreeRangeMap."
+  [^TreeRangeMap grm x]
+  (.get grm (long x)))
+
+(defn guava-get-entry
+  "Get [range value] for a point in a Guava TreeRangeMap.
+   Returns nil if no mapping exists."
+  [^TreeRangeMap grm x]
+  (when-let [entry (.getEntry grm (long x))]
+    (let [^Range range (.getKey entry)
+          value (.getValue entry)]
+      ;; Convert Guava Range to our [lo hi] format
+      [[(.. range lowerEndpoint) (.. range upperEndpoint)] value])))
+
+(defn guava->seq
+  "Convert Guava TreeRangeMap to seq of [[lo hi] value] pairs."
+  [^TreeRangeMap grm]
+  (for [entry (.asMapOfRanges grm)]
+    (let [^Range range (key entry)
+          value (val entry)]
+      [[(.. range lowerEndpoint) (.. range upperEndpoint)] value])))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Generators
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def gen-range
+  "Generate a valid range [lo hi) where lo < hi."
+  tu/gen-range)
+
+(def gen-range-value-pair
+  "Generate a [[lo hi] value] pair."
+  (gen/tuple gen-range gen/small-integer))
+
+(def gen-range-value-pairs
+  "Generate a vector of [[lo hi] value] pairs."
+  (gen/vector gen-range-value-pair 0 20))
+
+(def gen-point
+  "Generate a point for lookup."
+  gen/small-integer)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Comparison Helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn apply-ops-to-guava
+  "Apply a sequence of range-value pairs to a Guava TreeRangeMap."
+  [pairs]
+  (reduce (fn [grm [[lo hi] v]]
+            (guava-put! grm lo hi v))
+          (guava-range-map)
+          pairs))
+
+(defn apply-ops-to-ours
+  "Apply a sequence of range-value pairs to our range-map."
+  [pairs]
+  (reduce (fn [rm [[lo hi] v]]
+            (assoc rm [lo hi] v))
+          (oc/range-map)
+          pairs))
+
+(defn apply-coalescing-ops-to-guava
+  "Apply a sequence of range-value pairs to Guava with coalescing."
+  [pairs]
+  (reduce (fn [grm [[lo hi] v]]
+            (guava-put-coalescing! grm lo hi v))
+          (guava-range-map)
+          pairs))
+
+(defn apply-coalescing-ops-to-ours
+  "Apply a sequence of range-value pairs to our range-map with coalescing."
+  [pairs]
+  (reduce (fn [rm [[lo hi] v]]
+            (oc/assoc-coalescing rm [lo hi] v))
+          (oc/range-map)
+          pairs))
+
+(defn maps-equivalent?
+  "Check if our range-map and Guava's TreeRangeMap have identical contents."
+  [rm ^TreeRangeMap grm]
+  (= (vec (seq rm)) (vec (guava->seq grm))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Deterministic Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest basic-put-equivalence
+  (testing "Single range insertion"
+    (let [grm (-> (guava-range-map) (guava-put! 0 10 :a))
+          rm  (assoc (oc/range-map) [0 10] :a)]
+      (is (maps-equivalent? rm grm) "Single range")
+      (is (= :a (guava-get grm 5) (rm 5)) "Point lookup")
+      (is (= nil (guava-get grm 10) (rm 10)) "Point at upper bound (exclusive)")))
+
+  (testing "Non-overlapping ranges"
+    (let [grm (-> (guava-range-map)
+                  (guava-put! 0 10 :a)
+                  (guava-put! 20 30 :b))
+          rm  (-> (oc/range-map)
+                  (assoc [0 10] :a)
+                  (assoc [20 30] :b))]
+      (is (maps-equivalent? rm grm) "Non-overlapping")
+      (is (= :a (guava-get grm 5) (rm 5)))
+      (is (= nil (guava-get grm 15) (rm 15)) "Gap")
+      (is (= :b (guava-get grm 25) (rm 25)))))
+
+  (testing "Overlapping ranges - full containment"
+    (let [grm (-> (guava-range-map)
+                  (guava-put! 0 100 :a)
+                  (guava-put! 25 75 :b))
+          rm  (-> (oc/range-map)
+                  (assoc [0 100] :a)
+                  (assoc [25 75] :b))]
+      (is (maps-equivalent? rm grm) "Full containment")
+      (is (= :a (guava-get grm 10) (rm 10)) "Left portion")
+      (is (= :b (guava-get grm 50) (rm 50)) "Middle")
+      (is (= :a (guava-get grm 80) (rm 80)) "Right portion")))
+
+  (testing "Overlapping ranges - partial overlap"
+    (let [grm (-> (guava-range-map)
+                  (guava-put! 0 50 :a)
+                  (guava-put! 25 75 :b))
+          rm  (-> (oc/range-map)
+                  (assoc [0 50] :a)
+                  (assoc [25 75] :b))]
+      (is (maps-equivalent? rm grm) "Partial overlap")
+      (is (= :a (guava-get grm 10) (rm 10)))
+      (is (= :b (guava-get grm 30) (rm 30)))
+      (is (= :b (guava-get grm 60) (rm 60))))))
+
+(deftest get-entry-equivalence
+  (testing "get-entry returns correct range and value"
+    (let [grm (-> (guava-range-map)
+                  (guava-put! 0 10 :a)
+                  (guava-put! 20 30 :b))
+          rm  (-> (oc/range-map)
+                  (assoc [0 10] :a)
+                  (assoc [20 30] :b))]
+      (is (= [[0 10] :a] (guava-get-entry grm 5) (oc/get-entry rm 5)))
+      (is (= [[20 30] :b] (guava-get-entry grm 25) (oc/get-entry rm 25)))
+      (is (= nil (guava-get-entry grm 15) (oc/get-entry rm 15)) "Gap"))))
+
+(deftest range-remove-equivalence
+  (testing "Remove middle portion of range"
+    (let [grm (-> (guava-range-map)
+                  (guava-put! 0 100 :a)
+                  (guava-remove! 25 75))
+          rm  (-> (oc/range-map)
+                  (assoc [0 100] :a)
+                  (oc/range-remove [25 75]))]
+      (is (maps-equivalent? rm grm) "Remove middle")
+      (is (= :a (guava-get grm 10) (rm 10)) "Left intact")
+      (is (= nil (guava-get grm 50) (rm 50)) "Removed")
+      (is (= :a (guava-get grm 80) (rm 80)) "Right intact")))
+
+  (testing "Remove spanning multiple ranges"
+    (let [grm (-> (guava-range-map)
+                  (guava-put! 0 20 :a)
+                  (guava-put! 30 50 :b)
+                  (guava-put! 60 80 :c)
+                  (guava-remove! 10 70))
+          rm  (-> (oc/range-map)
+                  (assoc [0 20] :a)
+                  (assoc [30 50] :b)
+                  (assoc [60 80] :c)
+                  (oc/range-remove [10 70]))]
+      (is (maps-equivalent? rm grm) "Remove spanning")
+      (is (= :a (guava-get grm 5) (rm 5)) "[0,10) remains")
+      (is (= nil (guava-get grm 15) (rm 15)))
+      (is (= nil (guava-get grm 40) (rm 40)))
+      (is (= nil (guava-get grm 65) (rm 65)))
+      (is (= :c (guava-get grm 75) (rm 75)) "[70,80) remains"))))
+
+(deftest coalescing-equivalence
+  (testing "Adjacent same-value ranges coalesce"
+    (let [grm (-> (guava-range-map)
+                  (guava-put-coalescing! 0 50 :a)
+                  (guava-put-coalescing! 50 100 :a))
+          rm  (-> (oc/range-map)
+                  (oc/assoc-coalescing [0 50] :a)
+                  (oc/assoc-coalescing [50 100] :a))]
+      (is (maps-equivalent? rm grm) "Adjacent coalesce")
+      (is (= 1 (count (guava->seq grm)) (count rm)) "Single range")))
+
+  (testing "Adjacent different-value ranges don't coalesce"
+    (let [grm (-> (guava-range-map)
+                  (guava-put-coalescing! 0 50 :a)
+                  (guava-put-coalescing! 50 100 :b))
+          rm  (-> (oc/range-map)
+                  (oc/assoc-coalescing [0 50] :a)
+                  (oc/assoc-coalescing [50 100] :b))]
+      (is (maps-equivalent? rm grm) "Different values")
+      (is (= 2 (count (guava->seq grm)) (count rm)) "Two ranges")))
+
+  (testing "Coalescing with gap - no coalesce"
+    (let [grm (-> (guava-range-map)
+                  (guava-put-coalescing! 0 40 :a)
+                  (guava-put-coalescing! 60 100 :a))
+          rm  (-> (oc/range-map)
+                  (oc/assoc-coalescing [0 40] :a)
+                  (oc/assoc-coalescing [60 100] :a))]
+      (is (maps-equivalent? rm grm) "Gap - no coalesce")
+      (is (= 2 (count (guava->seq grm)) (count rm)) "Two ranges"))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Randomized Property-Based Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-put-equivalence 100
+  (prop/for-all [pairs gen-range-value-pairs]
+    (let [grm (apply-ops-to-guava pairs)
+          rm  (apply-ops-to-ours pairs)]
+      (maps-equivalent? rm grm))))
+
+(defspec prop-coalescing-put-equivalence 100
+  (prop/for-all [pairs gen-range-value-pairs]
+    (let [grm (apply-coalescing-ops-to-guava pairs)
+          rm  (apply-coalescing-ops-to-ours pairs)]
+      (maps-equivalent? rm grm))))
+
+(defspec prop-point-lookup-equivalence 100
+  (prop/for-all [pairs gen-range-value-pairs
+                 points (gen/vector gen-point 0 20)]
+    (let [grm (apply-ops-to-guava pairs)
+          rm  (apply-ops-to-ours pairs)]
+      (every? (fn [x]
+                (= (guava-get grm x) (rm x)))
+              points))))
+
+(defspec prop-get-entry-equivalence 100
+  (prop/for-all [pairs gen-range-value-pairs
+                 points (gen/vector gen-point 0 20)]
+    (let [grm (apply-ops-to-guava pairs)
+          rm  (apply-ops-to-ours pairs)]
+      (every? (fn [x]
+                (= (guava-get-entry grm x) (oc/get-entry rm x)))
+              points))))
+
+(defspec prop-remove-equivalence 100
+  (prop/for-all [pairs gen-range-value-pairs
+                 remove-range gen-range]
+    (let [[lo hi] remove-range
+          grm (-> (apply-ops-to-guava pairs)
+                  (guava-remove! lo hi))
+          rm  (-> (apply-ops-to-ours pairs)
+                  (oc/range-remove [lo hi]))]
+      (maps-equivalent? rm grm))))
+
+(defspec prop-mixed-operations 100
+  (prop/for-all [initial-pairs gen-range-value-pairs
+                 more-pairs gen-range-value-pairs
+                 remove-ranges (gen/vector gen-range 0 5)]
+    (let [;; Apply initial, then more puts, then removes
+          grm (reduce (fn [g [lo hi]]
+                        (guava-remove! g lo hi))
+                      (reduce (fn [g [[lo hi] v]]
+                                (guava-put! g lo hi v))
+                              (apply-ops-to-guava initial-pairs)
+                              more-pairs)
+                      remove-ranges)
+          rm (reduce (fn [r [lo hi]]
+                       (oc/range-remove r [lo hi]))
+                     (reduce (fn [r [[lo hi] v]]
+                               (assoc r [lo hi] v))
+                             (apply-ops-to-ours initial-pairs)
+                             more-pairs)
+                     remove-ranges)]
+      (maps-equivalent? rm grm))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Stress Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest stress-many-ranges
+  (testing "Many random ranges"
+    (dotimes [_ 10]
+      (let [n 100
+            ranges (for [_ (range n)]
+                     (let [a (rand-int 10000)
+                           b (rand-int 10000)
+                           lo (min a b)
+                           hi (max a b)
+                           hi (if (= lo hi) (inc hi) hi)]
+                       [[lo hi] (rand-int 1000)]))
+            grm (reduce (fn [g [[lo hi] v]] (guava-put! g lo hi v))
+                        (guava-range-map)
+                        ranges)
+            rm (reduce (fn [r [[lo hi] v]] (assoc r [lo hi] v))
+                       (oc/range-map)
+                       ranges)]
+        (is (maps-equivalent? rm grm) "Many ranges")
+        ;; Spot check some lookups
+        (dotimes [_ 50]
+          (let [x (rand-int 10000)]
+            (is (= (guava-get grm x) (rm x)) (str "Lookup at " x))))))))
+
+(deftest stress-many-removes
+  (testing "Many inserts followed by many removes"
+    (dotimes [_ 10]
+      (let [n 50
+            insert-ranges (for [_ (range n)]
+                            (let [a (rand-int 1000)
+                                  b (rand-int 1000)
+                                  lo (min a b)
+                                  hi (max a b)
+                                  hi (if (= lo hi) (inc hi) hi)]
+                              [[lo hi] (rand-int 100)]))
+            remove-ranges (for [_ (range (quot n 2))]
+                            (let [a (rand-int 1000)
+                                  b (rand-int 1000)
+                                  lo (min a b)
+                                  hi (max a b)
+                                  hi (if (= lo hi) (inc hi) hi)]
+                              [lo hi]))
+            grm (reduce (fn [g [lo hi]] (guava-remove! g lo hi))
+                        (reduce (fn [g [[lo hi] v]] (guava-put! g lo hi v))
+                                (guava-range-map)
+                                insert-ranges)
+                        remove-ranges)
+            rm (reduce (fn [r [lo hi]] (oc/range-remove r [lo hi]))
+                       (reduce (fn [r [[lo hi] v]] (assoc r [lo hi] v))
+                               (oc/range-map)
+                               insert-ranges)
+                       remove-ranges)]
+        (is (maps-equivalent? rm grm) "Many removes")))))
diff --git a/test/ordered_collections/range_map_test.clj b/test/ordered_collections/range_map_test.clj
new file mode 100644
index 0000000..a859bcf
--- /dev/null
+++ b/test/ordered_collections/range_map_test.clj
@@ -0,0 +1,1383 @@
+(ns ordered-collections.range-map-test
+  "Rigorous tests for RangeMap - non-overlapping range mappings with half-open intervals."
+  (:require [clojure.test :refer [deftest testing is]]
+            [ordered-collections.core :as oc]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Reference implementation for testing
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- ref-lookup
+  "Reference implementation: linear scan through ranges."
+  [ranges x]
+  (some (fn [[[lo hi] v]]
+          (when (and (<= lo x) (< x hi))
+            v))
+        ranges))
+
+(defn- ref-range-map
+  "Build reference: sorted list of non-overlapping ranges."
+  [range-pairs]
+  (sort-by (comp first first) range-pairs))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Construction
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest construction-empty
+  (let [rm (oc/range-map)]
+    (is (zero? (count rm)))
+    (is (nil? (seq rm)))
+    (is (nil? (rm 0)))
+    (is (nil? (oc/span rm)))))
+
+(deftest construction-various-sizes
+  (doseq [n [1 2 10 50 100 500 1000]]
+    (testing (str "N=" n " non-overlapping ranges")
+      (let [;; Create n non-overlapping ranges of width 5, spaced by 10
+            ranges (for [i (range n)]
+                     [[(* i 10) (+ (* i 10) 5)] (keyword (str "r" i))])
+            rm     (oc/range-map ranges)]
+        (is (= n (count rm)))
+        ;; Check all ranges present
+        (doseq [[[lo hi] v] ranges]
+          (is (= v (rm lo)) (str "Failed at lo=" lo))
+          (is (= v (rm (dec hi))) (str "Failed at hi-1=" (dec hi))))))))
+
+(deftest construction-from-map
+  (doseq [n [10 50 100]]
+    (let [m  (into {} (for [i (range n)] [[(* i 10) (+ (* i 10) 5)] i]))
+          rm (oc/range-map m)]
+      (is (= n (count rm))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Half-open interval semantics [lo, hi)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest half-open-semantics
+  (doseq [n [10 100 1000]]
+    (testing (str "N=" n " ranges")
+      (let [ranges (for [i (range n)]
+                     [[(* i 10) (+ (* i 10) 5)] i])
+            rm     (oc/range-map ranges)]
+        ;; Check boundary behavior for each range
+        (doseq [i (range n)]
+          (let [lo (* i 10)
+                hi (+ lo 5)]
+            ;; lo is included
+            (is (= i (rm lo)) (str "lo=" lo " should be in range"))
+            ;; hi-1 is included
+            (is (= i (rm (dec hi))) (str "hi-1=" (dec hi) " should be in range"))
+            ;; hi is excluded
+            (is (nil? (rm hi)) (str "hi=" hi " should be outside range"))
+            ;; Just before lo is excluded (except for first range)
+            (when (pos? lo)
+              (is (nil? (rm (dec lo))) (str "lo-1=" (dec lo) " should be outside")))))))))
+
+(deftest adjacent-ranges
+  (doseq [n [10 100 500]]
+    (testing (str "N=" n " adjacent ranges")
+      (let [;; Ranges [0,10), [10,20), [20,30), ...
+            ranges (for [i (range n)]
+                     [[(* i 10) (* (inc i) 10)] i])
+            rm     (oc/range-map ranges)]
+        (is (= n (count rm)))
+        ;; Each boundary point belongs to exactly one range
+        (doseq [i (range n)]
+          (let [boundary (* (inc i) 10)]
+            (when (< i (dec n))
+              (is (= (inc i) (rm boundary)) (str "Boundary " boundary)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Random point lookups
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest random-lookups-vs-reference
+  (doseq [n [10 50 100 500]]
+    (testing (str "N=" n " ranges, 1000 random lookups")
+      (let [;; Random non-overlapping ranges
+            ranges (for [i (range n)]
+                     [[(* i 10) (+ (* i 10) (+ 1 (rand-int 9)))]
+                      (keyword (str "v" i))])
+            rm     (oc/range-map ranges)
+            ref    (ref-range-map ranges)]
+        ;; Random lookups
+        (dotimes [_ 1000]
+          (let [x (rand-int (* n 10))]
+            (is (= (ref-lookup ref x) (rm x))
+                (str "Mismatch at x=" x))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Assoc without overlap
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest assoc-disjoint-ranges
+  (doseq [n [10 50 100 500]]
+    (testing (str "Building N=" n " disjoint ranges via assoc")
+      (let [rm (reduce
+                 (fn [m i]
+                   (assoc m [(* i 20) (+ (* i 20) 10)] i))
+                 (oc/range-map)
+                 (shuffle (range n)))]
+        (is (= n (count rm)))
+        ;; All values accessible
+        (doseq [i (range n)]
+          (is (= i (rm (+ (* i 20) 5)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Assoc with overlap - splitting behavior
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest assoc-complete-override
+  (doseq [n [10 50 100]]
+    (testing (str "Complete override, N=" n)
+      (let [;; Start with ranges [0,10), [20,30), [40,50), ...
+            rm (oc/range-map (for [i (range n)]
+                               [[(* i 20) (+ (* i 20) 10)] :old]))
+            ;; Override with one huge range
+            rm' (assoc rm [0 (* n 20)] :new)]
+        (is (= 1 (count rm')))
+        ;; Everything maps to :new
+        (doseq [x (take 100 (repeatedly #(rand-int (* n 20))))]
+          (is (= :new (rm' x))))))))
+
+(deftest assoc-partial-overlap-left
+  (let [rm  (oc/range-map {[100 200] :a})
+        rm' (assoc rm [50 150] :b)]
+    ;; Should have [50,150):b, [150,200):a
+    (is (= 2 (count rm')))
+    (is (= :b (rm' 75)))
+    (is (= :b (rm' 100)))
+    (is (= :b (rm' 149)))
+    (is (= :a (rm' 150)))
+    (is (= :a (rm' 175)))))
+
+(deftest assoc-partial-overlap-right
+  (let [rm  (oc/range-map {[100 200] :a})
+        rm' (assoc rm [150 250] :b)]
+    ;; Should have [100,150):a, [150,250):b
+    (is (= 2 (count rm')))
+    (is (= :a (rm' 100)))
+    (is (= :a (rm' 125)))
+    (is (= :b (rm' 150)))
+    (is (= :b (rm' 200)))
+    (is (= :b (rm' 249)))))
+
+(deftest assoc-split-in-middle
+  (doseq [outer-size [100 500 1000]]
+    (testing (str "Splitting [0," outer-size ") in middle")
+      (let [rm    (oc/range-map {[0 outer-size] :outer})
+            lo    (quot outer-size 4)
+            hi    (* 3 (quot outer-size 4))
+            rm'   (assoc rm [lo hi] :inner)]
+        ;; Should have 3 ranges: [0,lo), [lo,hi), [hi,outer-size)
+        (is (= 3 (count rm')))
+        (is (= :outer (rm' 0)))
+        (is (= :outer (rm' (dec lo))))
+        (is (= :inner (rm' lo)))
+        (is (= :inner (rm' (dec hi))))
+        (is (= :outer (rm' hi)))
+        (is (= :outer (rm' (dec outer-size))))))))
+
+(deftest assoc-spanning-multiple-ranges
+  (doseq [n [5 10 20 50]]
+    (testing (str "Spanning " n " ranges")
+      (let [;; Ranges [0,10), [20,30), [40,50), ...
+            ranges (for [i (range n)]
+                     [[(* i 20) (+ (* i 20) 10)] (keyword (str "r" i))])
+            rm     (oc/range-map ranges)
+            ;; Insert range that spans middle portion
+            lo     15
+            hi     (- (* n 20) 15)
+            rm'    (assoc rm [lo hi] :spanning)]
+        ;; First range should be untouched (ends at 10, before lo=15)
+        (is (= :r0 (rm' 5)))
+        ;; Spanning range covers the middle
+        (is (= :spanning (rm' lo)))
+        (is (= :spanning (rm' (dec hi))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Invalid range handling
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest invalid-range-throws
+  (let [rm (oc/range-map)]
+    (is (thrown? Exception (assoc rm [10 10] :bad)))
+    (is (thrown? Exception (assoc rm [20 10] :bad)))
+    (is (thrown? Exception (assoc rm [100 50] :bad)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; ranges and span functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ranges-function
+  (doseq [n [1 10 50 100]]
+    (testing (str "N=" n " ranges")
+      (let [ranges (for [i (range n)]
+                     [[(* i 10) (+ (* i 10) 5)] i])
+            rm     (oc/range-map ranges)
+            result (oc/ranges rm)]
+        (is (= n (count result)))
+        ;; Ranges are sorted by lower bound
+        (is (= (sort-by (comp first first) ranges)
+               result))))))
+
+(deftest span-function
+  (doseq [n [1 10 50 100]]
+    (testing (str "N=" n " ranges")
+      (let [rm     (oc/range-map (for [i (range n)]
+                                   [[(* i 10) (+ (* i 10) 5)] i]))
+            [lo hi] (oc/span rm)]
+        (is (= 0 lo))
+        (is (= (+ (* (dec n) 10) 5) hi))))))
+
+(deftest span-with-gaps
+  (let [rm (oc/range-map {[100 200] :a [500 600] :b [300 400] :c})]
+    (is (= [100 600] (oc/span rm)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Collection operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest collection-operations
+  (doseq [n [10 50 100]]
+    (let [rm (oc/range-map (for [i (range n)]
+                             [[(* i 10) (+ (* i 10) 5)] i]))]
+      (testing "count"
+        (is (= n (count rm))))
+
+      (testing "seq returns sorted range-value pairs"
+        (let [pairs (seq rm)]
+          (is (= n (count pairs)))
+          (is (= (range n) (map second pairs)))))
+
+      (testing "empty"
+        (let [e (empty rm)]
+          (is (zero? (count e)))))
+
+      (testing "cons/conj"
+        (let [rm' (conj rm [[1000 2000] :extra])]
+          (is (= (inc n) (count rm'))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Randomized stress tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest randomized-construction-and-lookup
+  (dotimes [_ 50]
+    (let [n       (+ 5 (rand-int 100))
+          ;; Generate random non-overlapping ranges
+          bounds  (sort (distinct (repeatedly (* n 3) #(rand-int 10000))))
+          pairs   (map vector (partition 2 1 bounds) (range))
+          ranges  (take n pairs)
+          rm      (oc/range-map ranges)
+          ref     (ref-range-map ranges)]
+      (testing (str "Random construction, n=" (count rm))
+        ;; Random lookups
+        (dotimes [_ 500]
+          (let [x (rand-int 10000)]
+            (is (= (ref-lookup ref x) (rm x))
+                (str "Mismatch at x=" x))))))))
+
+(deftest randomized-incremental-construction
+  (dotimes [_ 20]
+    (let [n (+ 10 (rand-int 50))]
+      (testing (str "Incremental construction, n=" n)
+        (let [;; Build incrementally in random order
+              final-rm (reduce
+                         (fn [rm i]
+                           (let [lo (* i 20)
+                                 hi (+ lo 10)]
+                             (assoc rm [lo hi] i)))
+                         (oc/range-map)
+                         (shuffle (range n)))]
+          (is (= n (count final-rm)))
+          ;; All values accessible
+          (doseq [i (range n)]
+            (is (= i (final-rm (+ (* i 20) 5))))))))))
+
+(deftest randomized-overlap-resolution
+  (dotimes [_ 30]
+    (let [;; Start with a base range
+          base-hi (+ 100 (rand-int 900))
+          rm0     (oc/range-map {[0 base-hi] :base})
+          ;; Insert random overlapping range
+          lo      (rand-int (quot base-hi 2))
+          hi      (+ lo 10 (rand-int (- base-hi lo 10)))
+          rm1     (assoc rm0 [lo hi] :overlay)]
+      (testing (str "Overlap [" lo "," hi ") within [0," base-hi ")")
+        ;; Points in overlay range should return :overlay
+        (dotimes [_ 50]
+          (let [x (+ lo (rand-int (- hi lo)))]
+            (is (= :overlay (rm1 x)) (str "x=" x " should be :overlay"))))
+        ;; Points outside overlay but inside base should return :base
+        (when (pos? lo)
+          (dotimes [_ 20]
+            (let [x (rand-int lo)]
+              (is (= :base (rm1 x)) (str "x=" x " should be :base")))))
+        (when (< hi base-hi)
+          (dotimes [_ 20]
+            (let [x (+ hi (rand-int (- base-hi hi)))]
+              (is (= :base (rm1 x)) (str "x=" x " should be :base")))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Property-based tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest property-no-overlaps-after-construction
+  (dotimes [_ 50]
+    (let [n      (+ 5 (rand-int 50))
+          ranges (for [i (range n)]
+                   [[(* i 20) (+ (* i 20) 10 (rand-int 5))] i])
+          rm     (oc/range-map ranges)
+          result (oc/ranges rm)]
+      (testing "No overlapping ranges in result"
+        ;; Check consecutive pairs - each range's hi should be <= next range's lo
+        (doseq [[[[_ h1] _] [[l2 _] _]] (partition 2 1 result)]
+          (is (<= h1 l2)
+              (str "Overlap: range ending at " h1 " overlaps range starting at " l2)))))))
+
+(deftest property-lookup-consistency
+  (dotimes [_ 30]
+    (let [n  (+ 10 (rand-int 100))
+          rm (oc/range-map (for [i (range n)]
+                             [[(* i 10) (+ (* i 10) 5)] i]))]
+      (testing "Lookup is consistent with ranges"
+        (doseq [[[lo hi] v] (oc/ranges rm)]
+          ;; All points in [lo, hi) should return v
+          (doseq [x (range lo hi)]
+            (is (= v (rm x)) (str "x=" x " in [" lo "," hi ")"))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Large Map Tests
+;;
+;; Verify RangeMap scales correctly with large numbers of ranges. Tests
+;; construction and lookup performance with 1000, 5000, and 10000 non-overlapping
+;; ranges. Also tests incremental construction (building via repeated assoc in
+;; random order) and heavy overlap scenarios where many small ranges are inserted
+;; into one large base range, creating complex fragmentation patterns.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest large-map-construction
+  (testing "1000 ranges"
+    (let [rm (oc/range-map (for [i (range 1000)]
+                             [[(* i 100) (+ (* i 100) 50)] i]))]
+      (is (= 1000 (count rm)))
+      ;; Spot check
+      (is (= 0 (rm 25)))
+      (is (= 500 (rm 50025)))
+      (is (= 999 (rm 99925)))))
+
+  (testing "5000 ranges"
+    (let [rm (oc/range-map (for [i (range 5000)]
+                             [[(* i 20) (+ (* i 20) 10)] i]))]
+      (is (= 5000 (count rm)))
+      ;; Random lookups
+      (dotimes [_ 1000]
+        (let [i (rand-int 5000)
+              x (+ (* i 20) (rand-int 10))]
+          (is (= i (rm x)))))))
+
+  (testing "10000 ranges"
+    (let [rm (oc/range-map (for [i (range 10000)]
+                             [[(* i 10) (+ (* i 10) 5)] i]))]
+      (is (= 10000 (count rm)))
+      ;; Verify spanning range
+      (is (= [0 99995] (oc/span rm))))))
+
+(deftest large-map-incremental-construction
+  (testing "Build 2000 ranges incrementally in random order"
+    (let [indices (shuffle (range 2000))
+          rm (reduce
+               (fn [m i]
+                 (assoc m [(* i 50) (+ (* i 50) 25)] i))
+               (oc/range-map)
+               indices)]
+      (is (= 2000 (count rm)))
+      ;; All values accessible
+      (doseq [i (range 2000)]
+        (is (= i (rm (+ (* i 50) 12))))))))
+
+(deftest large-map-heavy-overlap
+  (testing "Insert 1000 overlapping ranges"
+    (let [;; Start with one big range
+          rm0 (oc/range-map {[0 100000] :base})
+          ;; Insert 1000 small overlapping ranges
+          rm (reduce
+               (fn [m i]
+                 (let [lo (* i 100)
+                       hi (+ lo 50)]
+                   (assoc m [lo hi] i)))
+               rm0
+               (range 1000))]
+      ;; Should have many fragments
+      (is (> (count rm) 1000))
+      ;; Check some overlaid values
+      (is (= 0 (rm 25)))
+      (is (= 500 (rm 50025)))
+      ;; Check base values in gaps
+      (is (= :base (rm 75)))     ; gap between [0,50) and [100,150)
+      (is (= :base (rm 175))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Edge Cases
+;;
+;; Exercise boundary conditions and unusual range configurations:
+;; - Single-point ranges (width 1, e.g. [100,101))
+;; - Very wide ranges spanning millions of units
+;; - Negative range values and ranges spanning negative to positive
+;; - Floating-point boundaries with precise boundary behavior
+;; - Exact boundary touching (adjacent vs overlapping)
+;; - Minimal overlap (single unit)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest edge-case-single-point-range
+  (testing "Range of width 1"
+    (let [rm (oc/range-map {[100 101] :point})]
+      (is (= 1 (count rm)))
+      (is (nil? (rm 99)))
+      (is (= :point (rm 100)))
+      (is (nil? (rm 101))))))
+
+(deftest edge-case-very-wide-range
+  (testing "Range spanning millions"
+    (let [rm (oc/range-map {[0 10000000] :wide})]
+      (is (= 1 (count rm)))
+      (is (= :wide (rm 0)))
+      (is (= :wide (rm 5000000)))
+      (is (= :wide (rm 9999999)))
+      (is (nil? (rm 10000000))))))
+
+(deftest edge-case-negative-ranges
+  (testing "Negative range values"
+    (let [rm (oc/range-map {[-100 -50] :neg1
+                            [-25 25] :span
+                            [50 100] :pos})]
+      (is (= 3 (count rm)))
+      (is (= :neg1 (rm -75)))
+      (is (= :span (rm 0)))
+      (is (= :pos (rm 75)))
+      (is (nil? (rm -30)))  ; gap
+      (is (nil? (rm 30))))) ; gap
+
+  (testing "Negative to positive spanning"
+    (let [rm (oc/range-map {[-1000 1000] :all})]
+      (is (= :all (rm -500)))
+      (is (= :all (rm 0)))
+      (is (= :all (rm 500))))))
+
+(deftest edge-case-floating-point-ranges
+  (testing "Floating point boundaries"
+    (let [rm (oc/range-map {[0.0 1.5] :a
+                            [2.5 3.5] :b
+                            [4.0 5.0] :c})]
+      (is (= 3 (count rm)))
+      (is (= :a (rm 0.0)))
+      (is (= :a (rm 0.75)))
+      (is (= :a (rm 1.499)))
+      (is (nil? (rm 1.5)))
+      (is (nil? (rm 2.0)))
+      (is (= :b (rm 2.5)))
+      (is (= :b (rm 3.0)))))
+
+  (testing "Floating point overlap"
+    (let [rm0 (oc/range-map {[0.0 10.0] :base})
+          rm1 (assoc rm0 [2.5 7.5] :inner)]
+      (is (= 3 (count rm1)))
+      (is (= :base (rm1 1.0)))
+      (is (= :inner (rm1 5.0)))
+      (is (= :base (rm1 8.0))))))
+
+(deftest edge-case-boundary-precision
+  (testing "Adjacent ranges at exact boundaries"
+    (let [rm (oc/range-map {[0 100] :a
+                            [100 200] :b
+                            [200 300] :c})]
+      (is (= :a (rm 99)))
+      (is (= :b (rm 100)))
+      (is (= :b (rm 199)))
+      (is (= :c (rm 200)))
+      (is (= :c (rm 299)))
+      (is (nil? (rm 300))))))
+
+(deftest edge-case-minimal-overlap
+  (testing "Overlap by single unit"
+    (let [rm0 (oc/range-map {[0 100] :a})
+          rm1 (assoc rm0 [99 150] :b)]
+      ;; [0,99) :a, [99,150) :b
+      (is (= 2 (count rm1)))
+      (is (= :a (rm1 98)))
+      (is (= :b (rm1 99)))
+      (is (= :b (rm1 100)))))
+
+  (testing "Exact boundary touch (no overlap)"
+    (let [rm0 (oc/range-map {[0 100] :a})
+          rm1 (assoc rm0 [100 200] :b)]
+      ;; Should have both ranges intact
+      (is (= 2 (count rm1)))
+      (is (= :a (rm1 99)))
+      (is (= :b (rm1 100))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Multiple Successive Operations
+;;
+;; Test sequences of operations that build on each other:
+;; - Repeated binary splitting (subdividing ranges recursively)
+;; - Cascading overlaps (wave patterns where each insert splits multiple ranges)
+;; - Consolidation (overlaying fragmented ranges to merge them)
+;; - Build-up then tear-down (construct many ranges, then consolidate to few)
+;; These tests verify the range-map maintains consistency through complex
+;; sequences of mutations.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest successive-split-operations
+  (testing "Repeated binary splitting"
+    (let [;; Start with [0, 1024)
+          rm0 (oc/range-map {[0 1024] 0})
+          ;; Split into [0,512), [512,1024)
+          rm1 (assoc rm0 [512 1024] 1)
+          ;; Split [0,512) into [0,256), [256,512)
+          rm2 (assoc rm1 [256 512] 2)
+          ;; Split [512,1024) into [512,768), [768,1024)
+          rm3 (assoc rm2 [768 1024] 3)
+          ;; Continue splitting
+          rm4 (assoc rm3 [128 256] 4)
+          rm5 (assoc rm4 [640 768] 5)]
+      (is (= 6 (count rm5)))
+      (is (= 0 (rm5 64)))    ; [0, 128)
+      (is (= 4 (rm5 192)))   ; [128, 256)
+      (is (= 2 (rm5 384)))   ; [256, 512)
+      (is (= 1 (rm5 576)))   ; [512, 640)
+      (is (= 5 (rm5 704)))   ; [640, 768)
+      (is (= 3 (rm5 896))))) ; [768, 1024)
+
+  (testing "Cascading overlaps - wave pattern"
+    (let [;; Start with alternating ranges
+          rm0 (oc/range-map (for [i (range 10)]
+                              [[(* i 100) (+ (* i 100) 50)] i]))
+          ;; Wave: each new range overlaps two old ones
+          rm1 (reduce
+                (fn [m i]
+                  (assoc m [(+ (* i 100) 25) (+ (* i 100) 125)] (+ i 100)))
+                rm0
+                (range 9))]
+      ;; Each wave splits existing ranges
+      (is (> (count rm1) 10))
+      ;; Verify structure by sampling
+      (is (= 0 (rm1 10)))      ; untouched start of first range
+      (is (= 100 (rm1 50)))    ; first wave covers this
+      (is (= 100 (rm1 100)))   ; first wave continues
+      )))
+
+(deftest successive-merge-operations
+  (testing "Build fragmented then consolidate"
+    (let [;; Create 20 small ranges with gaps
+          rm0 (oc/range-map (for [i (range 20)]
+                              [[(* i 50) (+ (* i 50) 25)] i]))
+          ;; Now overlay one big range
+          rm1 (assoc rm0 [0 1000] :all)]
+      (is (= 1 (count rm1)))
+      (is (= :all (rm1 500)))))
+
+  (testing "Incremental consolidation"
+    (let [;; Start with 10 separate ranges
+          rm0 (oc/range-map (for [i (range 10)]
+                              [[(* i 20) (+ (* i 20) 10)] i]))
+          ;; Gradually fill gaps
+          rm1 (assoc rm0 [10 20] :gap1)   ; fill first gap
+          rm2 (assoc rm1 [30 40] :gap2)   ; fill second gap
+          rm3 (assoc rm2 [50 60] :gap3)]  ; fill third gap
+      (is (= 13 (count rm3)))
+      (is (= :gap1 (rm3 15)))
+      (is (= :gap2 (rm3 35)))
+      (is (= :gap3 (rm3 55))))))
+
+(deftest build-up-tear-down
+  (testing "Build 100 ranges then overlay to reduce"
+    (let [;; Build up
+          rm0 (oc/range-map (for [i (range 100)]
+                              [[(* i 10) (+ (* i 10) 5)] i]))
+          _ (is (= 100 (count rm0)))
+          ;; Overlay to reduce - cover first half
+          rm1 (assoc rm0 [0 500] :first-half)
+          _ (is (< (count rm1) 100))
+          ;; Overlay second half
+          rm2 (assoc rm1 [500 1000] :second-half)
+          _ (is (= 2 (count rm2)))
+          ;; Finally, one big range
+          rm3 (assoc rm2 [0 1000] :all)]
+      (is (= 1 (count rm3)))
+      (is (= :all (rm3 500))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Gaps Function Tests
+;;
+;; Verify the `gaps` function correctly identifies unmapped regions between
+;; mapped ranges. Tests simple gaps between ranges, adjacent ranges (no gaps),
+;; single-range maps, empty maps, and complex scenarios with many small gaps
+;; or variable gap sizes.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest gaps-function-basic
+  (testing "Simple gaps"
+    (let [rm (oc/range-map {[0 10] :a [20 30] :b [40 50] :c})
+          gs (oc/gaps rm)]
+      (is (= [[10 20] [30 40]] gs))))
+
+  (testing "No gaps (adjacent ranges)"
+    (let [rm (oc/range-map {[0 10] :a [10 20] :b [20 30] :c})
+          gs (oc/gaps rm)]
+      (is (empty? gs))))
+
+  (testing "Single range has no gaps"
+    (let [rm (oc/range-map {[0 100] :only})
+          gs (oc/gaps rm)]
+      (is (empty? gs))))
+
+  (testing "Empty map has no gaps"
+    (is (nil? (oc/gaps (oc/range-map))))))
+
+(deftest gaps-function-complex
+  (testing "Many small gaps"
+    (let [;; Ranges of width 5 with gaps of 5
+          rm (oc/range-map (for [i (range 100)]
+                             [[(* i 10) (+ (* i 10) 5)] i]))
+          gs (oc/gaps rm)]
+      (is (= 99 (count gs)))
+      ;; Each gap should be [i*10+5, (i+1)*10)
+      (doseq [[i [lo hi]] (map-indexed vector gs)]
+        (is (= (+ (* i 10) 5) lo))
+        (is (= (* (inc i) 10) hi)))))
+
+  (testing "Variable gap sizes"
+    (let [rm (oc/range-map {[0 10] :a
+                            [100 110] :b
+                            [200 210] :c
+                            [205 215] :d})  ; overlaps with :c
+          gs (oc/gaps rm)]
+      ;; After overlap resolution, gaps should be consistent
+      (is (every? (fn [[lo hi]] (< lo hi)) gs)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Use Case Scenarios
+;;
+;; Real-world use cases demonstrating RangeMap applicability:
+;; - IP address block allocation (private network ranges, subnet allocation)
+;; - Time slot scheduling (non-overlapping calendar bookings with gaps)
+;; - Memory region management (allocation, fragmentation, defragmentation)
+;; - Version range resolution (semantic versioning with deprecation markers)
+;; - Coverage-then-fragment (systematic subdivision of complete coverage)
+;; Each scenario tests multiple operations in a coherent domain context.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest scenario-ip-address-ranges
+  (testing "IP address block allocation simulation"
+    (let [;; Simulate IP blocks as integers
+          ;; 10.0.0.0/8 = 167772160 to 184549375
+          block-10 [167772160 184549376]
+          ;; 192.168.0.0/16 = 3232235520 to 3232301055
+          block-192 [3232235520 3232301056]
+          ;; 172.16.0.0/12 = 2886729728 to 2887778303
+          block-172 [2886729728 2887778304]
+
+          rm0 (oc/range-map {block-10 :private-a
+                             block-172 :private-b
+                             block-192 :private-c})
+
+          ;; Allocate a subnet within 10.x.x.x
+          ;; 10.1.0.0/16 = 167837696 to 167903231
+          subnet-10-1 [167837696 167903232]
+          rm1 (assoc rm0 subnet-10-1 :allocated-subnet)]
+
+      ;; Should have: [10.0.0.0 to 10.1.0.0), [10.1.0.0 to 10.1.255.255), [10.2.0.0 to end), plus 172 and 192 blocks
+      (is (= 5 (count rm1)))
+      (is (= :private-a (rm1 167772160)))  ; start of 10.0.0.0
+      (is (= :allocated-subnet (rm1 167837700)))  ; in 10.1.x.x
+      (is (= :private-a (rm1 167903300)))  ; after 10.1.x.x but still in 10.x
+      (is (= :private-b (rm1 2886729730)))
+      (is (= :private-c (rm1 3232235525))))))
+
+(deftest scenario-time-slot-scheduling
+  (testing "Non-overlapping time slot booking"
+    (let [;; Times as minutes from midnight
+          rm0 (oc/range-map)
+          ;; Book meeting 9:00-10:00 (540-600)
+          rm1 (assoc rm0 [540 600] {:event "standup"})
+          ;; Book 10:30-12:00 (630-720)
+          rm2 (assoc rm1 [630 720] {:event "planning"})
+          ;; Book 14:00-15:30 (840-930)
+          rm3 (assoc rm2 [840 930] {:event "review"})
+          ;; Try to book 9:30-10:15 - should split standup, extends past it
+          rm4 (assoc rm3 [570 615] {:event "urgent"})]
+
+      ;; standup [540-570), urgent [570-615), planning [630-720), review [840-930)
+      (is (= 4 (count rm4)))
+      (is (= {:event "standup"} (rm4 545)))
+      (is (= {:event "urgent"} (rm4 580)))
+      (is (= {:event "urgent"} (rm4 610)))
+      (is (= {:event "planning"} (rm4 650)))
+
+      ;; Verify gaps show free time
+      (let [gs (oc/gaps rm4)]
+        (is (some #(= [615 630] %) gs))   ; gap between urgent and planning
+        (is (some #(= [720 840] %) gs)))))) ; gap between planning and review
+
+(deftest scenario-memory-regions
+  (testing "Memory allocation simulation"
+    (let [;; Start with entire address space free
+          rm0 (oc/range-map {[0 65536] :free})
+          ;; Allocate kernel: 0-4096
+          rm1 (assoc rm0 [0 4096] :kernel)
+          ;; Allocate heap: 8192-32768
+          rm2 (assoc rm1 [8192 32768] :heap)
+          ;; Allocate stack: 61440-65536
+          rm3 (assoc rm2 [61440 65536] :stack)]
+
+      (is (= 5 (count rm3)))  ; kernel, free, heap, free, stack
+      (is (= :kernel (rm3 1000)))
+      (is (= :free (rm3 5000)))
+      (is (= :heap (rm3 20000)))
+      (is (= :free (rm3 40000)))
+      (is (= :stack (rm3 63000)))
+
+      ;; Allocate more from free regions
+      (let [rm4 (assoc rm3 [4096 6144] :bss)
+            rm5 (assoc rm4 [50000 60000] :shared)]
+        ;; kernel, bss, free [6144-8192), heap, free [32768-50000), shared, free [60000-61440), stack
+        (is (= 8 (count rm5)))
+        (is (= :bss (rm5 5000)))
+        (is (= :shared (rm5 55000))))))
+
+  (testing "Fragmentation and defragmentation"
+    (let [;; Create fragmented memory
+          rm0 (oc/range-map (for [i (range 64)]
+                              [[(* i 1024) (+ (* i 1024) 512)]
+                               (if (even? i) :used :free)]))
+          ;; Count used vs free
+          used-count (count (filter #(= :used (second %)) (oc/ranges rm0)))
+          free-count (count (filter #(= :free (second %)) (oc/ranges rm0)))
+          _ (is (= 32 used-count))
+          _ (is (= 32 free-count))
+
+          ;; "Defragment" by consolidating all used to beginning
+          rm1 (assoc rm0 [0 32768] :used)
+          rm2 (assoc rm1 [32768 65536] :free)]
+      (is (= 2 (count rm2))))))
+
+(deftest scenario-version-ranges
+  (testing "Dependency version resolution"
+    (let [;; Version numbers as integers (major * 10000 + minor * 100 + patch)
+          ;; e.g., 2.3.4 = 20304
+          rm0 (oc/range-map {[10000 20000] :v1  ; 1.x.x
+                             [20000 30000] :v2  ; 2.x.x
+                             [30000 40000] :v3}) ; 3.x.x
+
+          ;; Mark 2.5.0+ as deprecated
+          rm1 (assoc rm0 [20500 30000] :deprecated)
+
+          ;; Mark 1.9.x as security-patched
+          rm2 (assoc rm1 [10900 11000] :security-patch)]
+
+      ;; v1 [10000-10900), security-patch [10900-11000), v1 [11000-20000), v2 [20000-20500), deprecated [20500-30000), v3
+      (is (= 6 (count rm2)))
+      (is (= :v1 (rm2 10500)))           ; 1.5.0
+      (is (= :security-patch (rm2 10950))) ; 1.9.50
+      (is (= :v2 (rm2 20300)))           ; 2.3.0
+      (is (= :deprecated (rm2 20800)))   ; 2.8.0
+      (is (= :v3 (rm2 30500))))))        ; 3.5.0
+
+(deftest scenario-coverage-then-fragment
+  (testing "Full coverage then systematic fragmentation"
+    (let [;; Start with complete coverage
+          rm0 (oc/range-map {[0 10000] :base})
+          _ (is (= 1 (count rm0)))
+
+          ;; Fragment by inserting every 100th range
+          rm1 (reduce
+                (fn [m i]
+                  (assoc m [(* i 100) (+ (* i 100) 50)] i))
+                rm0
+                (range 100))
+          ;; 100 new ranges + 100 :base fragments between them (including one at end)
+          _ (is (= 200 (count rm1)))
+
+          ;; Fragment further
+          rm2 (reduce
+                (fn [m i]
+                  (assoc m [(+ (* i 100) 25) (+ (* i 100) 75)] (+ i 1000)))
+                rm1
+                (range 99))]
+      (is (> (count rm2) 200))
+      ;; Verify some samples
+      (is (= 0 (rm2 10)))        ; start of first inserted range
+      (is (= 1000 (rm2 50)))     ; first sub-fragment
+      (is (= :base (rm2 85))))))  ; gap filled by base
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Stress Tests
+;;
+;; Push RangeMap to its limits with adversarial patterns:
+;; - 1000 random insert/lookup operations with varying range sizes
+;; - Worst-case patterns: all ranges overlapping at single point, reverse-order
+;;   insertion (worst for some tree structures)
+;; - 5000 single-unit ranges (minimal width)
+;; - Deep nesting (matryoshka pattern: each range contains the next)
+;; - Alternating overlap patterns
+;; These tests verify structural integrity and correct behavior under stress.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest stress-random-operations
+  (testing "1000 random insert/lookup operations"
+    (let [rm (atom (oc/range-map))
+          ref (atom {})  ; reference as sorted map of ranges
+          ops (for [i (range 1000)]
+                (let [lo (rand-int 50000)
+                      width (+ 1 (rand-int 500))
+                      hi (+ lo width)]
+                  {:lo lo :hi hi :val i}))]
+      ;; Apply operations
+      (doseq [{:keys [lo hi val]} ops]
+        (swap! rm assoc [lo hi] val))
+
+      ;; Verify no overlaps
+      (let [ranges (oc/ranges @rm)]
+        (doseq [[[[_ h1] _] [[l2 _] _]] (partition 2 1 ranges)]
+          (is (<= h1 l2) "No overlaps allowed")))
+
+      ;; Random lookups should return values from inserted ranges
+      (dotimes [_ 500]
+        (let [x (rand-int 50000)
+              result (@rm x)]
+          ;; Result should be either nil (in gap) or a value from our ops
+          (when result
+            (is (integer? result))))))))
+
+(deftest stress-worst-case-patterns
+  (testing "All ranges overlap at same point"
+    (let [;; Every range includes point 500, each one completely contains the next
+          ;; Range 0: [499, 501), Range 1: [498, 502), ..., Range 99: [400, 600)
+          rm (oc/range-map (for [i (range 100)]
+                             [[(- 500 i 1) (+ 501 i)] i]))]
+      ;; Last insertion (i=99) covers [400, 600) and overwrites everything
+      (is (= 99 (rm 500)))
+      ;; Due to complete overlap, only 1 range survives
+      (is (= 1 (count rm)))))
+
+  (testing "Reverse order insertion (worst for some tree structures)"
+    (let [rm (reduce
+               (fn [m i]
+                 (assoc m [(- 10000 (* i 10) 10) (- 10000 (* i 10))] i))
+               (oc/range-map)
+               (range 1000))]
+      (is (= 1000 (count rm)))
+      ;; Verify ordering
+      (let [ranges (oc/ranges rm)]
+        (is (apply < (map (comp first first) ranges)))))))
+
+(deftest stress-tiny-ranges
+  (testing "Many single-unit ranges"
+    (let [rm (oc/range-map (for [i (range 5000)]
+                             [[i (inc i)] i]))]
+      (is (= 5000 (count rm)))
+      (doseq [i (range 5000)]
+        (is (= i (rm i))))))
+
+  (testing "Interleaved tiny and large ranges"
+    (let [;; Tiny ranges at even positions
+          tiny (for [i (range 0 1000 2)]
+                 [[i (inc i)] :tiny])
+          ;; Large ranges that span odd gaps
+          rm0 (oc/range-map tiny)
+          rm1 (reduce
+                (fn [m i]
+                  (assoc m [(dec i) (+ i 2)] :large))
+                rm0
+                (range 1 1000 2))]
+      ;; Large ranges should dominate
+      (doseq [i (range 1 999 2)]
+        (is (= :large (rm1 i)))))))
+
+(deftest stress-deep-nesting
+  (testing "Deeply nested ranges (matryoshka pattern)"
+    (let [;; Each range contains the next
+          rm (reduce
+               (fn [m i]
+                 (assoc m [i (- 1000 i)] i))
+               (oc/range-map)
+               (range 500))]
+      ;; Innermost range wins
+      (is (= 499 (rm 500)))
+      ;; Outermost layer at boundaries
+      (is (= 0 (rm 0)))
+      (is (= 0 (rm 999)))))
+
+  (testing "Alternating overlap pattern"
+    (let [;; Odd ranges overlap with neighbors
+          rm (reduce
+               (fn [m i]
+                 (if (even? i)
+                   (assoc m [(* i 10) (+ (* i 10) 10)] i)
+                   (assoc m [(- (* i 10) 5) (+ (* i 10) 15)] i)))
+               (oc/range-map)
+               (range 100))]
+      ;; Verify structure is valid
+      (let [ranges (oc/ranges rm)]
+        (doseq [[[[_ h1] _] [[l2 _] _]] (partition 2 1 ranges)]
+          (is (<= h1 l2))))
+      ;; Odd numbers should dominate due to overlap
+      (is (= 1 (rm 10))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Coalescing Tests
+;;
+;; Verify that adjacent ranges with the same value are automatically merged:
+;; - Basic left/right coalescing when inserting adjacent ranges
+;; - Three-way coalescing when a range bridges two same-value neighbors
+;; - Coalescing during overlap resolution (trimmed portions merge with new range)
+;; - Non-coalescing when values differ
+;; - Coalescing with various value types (keywords, maps, vectors)
+;; - Coalescing preserves correct boundaries after complex operations
+;; - Stress tests with many coalescing operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest coalesce-basic-right
+  (testing "New range coalesces with existing range on right"
+    (let [rm0 (oc/range-map {[100 200] :a})
+          rm1 (oc/assoc-coalescing rm0 [50 100] :a)]
+      (is (= 1 (count rm1)))
+      (is (= [[50 200]] (map first (oc/ranges rm1))))
+      (is (= :a (rm1 75)))
+      (is (= :a (rm1 150))))))
+
+(deftest coalesce-basic-left
+  (testing "New range coalesces with existing range on left"
+    (let [rm0 (oc/range-map {[0 100] :a})
+          rm1 (oc/assoc-coalescing rm0 [100 200] :a)]
+      (is (= 1 (count rm1)))
+      (is (= [[0 200]] (map first (oc/ranges rm1))))
+      (is (= :a (rm1 50)))
+      (is (= :a (rm1 150))))))
+
+(deftest coalesce-three-way
+  (testing "New range bridges two same-value ranges, coalesces all three"
+    (let [rm0 (oc/range-map {[0 100] :a [200 300] :a})
+          rm1 (oc/assoc-coalescing rm0 [100 200] :a)]
+      (is (= 1 (count rm1)))
+      (is (= [[0 300]] (map first (oc/ranges rm1))))
+      (is (= :a (rm1 50)))
+      (is (= :a (rm1 150)))
+      (is (= :a (rm1 250))))))
+
+(deftest coalesce-no-merge-different-values
+  (testing "Adjacent ranges with different values do NOT coalesce"
+    (let [rm0 (oc/range-map {[0 100] :a})
+          rm1 (oc/assoc-coalescing rm0 [100 200] :b)]
+      (is (= 2 (count rm1)))
+      (is (= :a (rm1 50)))
+      (is (= :b (rm1 150)))))
+
+  (testing "Three adjacent ranges with different values stay separate"
+    (let [rm (oc/range-map {[0 100] :a [100 200] :b [200 300] :c})]
+      (is (= 3 (count rm))))))
+
+(deftest coalesce-only-matching-side
+  (testing "Coalesce left but not right (different right value)"
+    ;; Start: [0, 100) :a, gap, [200, 300) :b
+    ;; Insert: [100, 200) :a (fills gap)
+    ;; [100, 200) :a is adjacent to [0, 100) :a → coalesce to [0, 200) :a
+    ;; [100, 200) :a is adjacent to [200, 300) :b → no coalesce (different values)
+    ;; Result: [0, 200) :a, [200, 300) :b
+    (let [rm0 (oc/range-map {[0 100] :a [200 300] :b})
+          rm1 (oc/assoc-coalescing rm0 [100 200] :a)]
+      (is (= 2 (count rm1)))
+      (is (= [[0 200] [200 300]] (map first (oc/ranges rm1))))
+      (is (= :a (rm1 150)))
+      (is (= :b (rm1 250)))))
+
+  (testing "Coalesce right but not left (different left value)"
+    ;; Start: [0, 100) :a, gap, [200, 300) :b
+    ;; Insert: [100, 200) :b (fills gap)
+    ;; [100, 200) :b is adjacent to [0, 100) :a → no coalesce (different values)
+    ;; [100, 200) :b is adjacent to [200, 300) :b → coalesce to [100, 300) :b
+    ;; Result: [0, 100) :a, [100, 300) :b
+    (let [rm0 (oc/range-map {[0 100] :a [200 300] :b})
+          rm1 (oc/assoc-coalescing rm0 [100 200] :b)]
+      (is (= 2 (count rm1)))
+      (is (= [[0 100] [100 300]] (map first (oc/ranges rm1))))
+      (is (= :a (rm1 50)))
+      (is (= :b (rm1 150))))))
+
+(deftest coalesce-with-overlap-resolution
+  (testing "Overlap creates trimmed portion that coalesces with new range"
+    ;; Start: [0, 100) :a, [100, 200) :b
+    ;; Insert: [50, 150) :a
+    ;; Step 1: Remove overlapping portions, add back trimmed:
+    ;;         [0, 50) :a (trimmed left of [0,100))
+    ;;         [150, 200) :b (trimmed right of [100,200))
+    ;; Step 2: Add [50, 150) :a
+    ;; Step 3: Coalesce [0, 50) :a with [50, 150) :a → [0, 150) :a
+    ;; Result: [0, 150) :a, [150, 200) :b
+    (let [rm0 (oc/range-map {[0 100] :a [100 200] :b})
+          rm1 (oc/assoc-coalescing rm0 [50 150] :a)]
+      (is (= 2 (count rm1)))
+      (is (= :a (rm1 25)))   ; in [0, 50) originally, now part of [0, 150)
+      (is (= :a (rm1 75)))   ; in overlap [50, 100), now part of [0, 150)
+      (is (= :a (rm1 125)))  ; in new [50, 150), now part of [0, 150)
+      (is (= :b (rm1 175)))))  ; in trimmed [150, 200)
+
+  (testing "Split creates two fragments that both coalesce"
+    ;; Start: [0, 300) :a
+    ;; Insert: [100, 200) :a (same value)
+    ;; Result: [0, 300) :a (everything merges back together)
+    (let [rm0 (oc/range-map {[0 300] :a})
+          rm1 (oc/assoc-coalescing rm0 [100 200] :a)]
+      (is (= 1 (count rm1)))
+      (is (= [[0 300]] (map first (oc/ranges rm1)))))))
+
+(deftest coalesce-chain-building
+  (testing "Build chain of coalescing ranges left to right"
+    (let [rm (reduce
+               (fn [m i]
+                 (oc/assoc-coalescing m [(* i 100) (* (inc i) 100)] :chain))
+               (oc/range-map)
+               (range 10))]
+      (is (= 1 (count rm)))
+      (is (= [[0 1000]] (map first (oc/ranges rm))))))
+
+  (testing "Build chain of coalescing ranges right to left"
+    (let [rm (reduce
+               (fn [m i]
+                 (oc/assoc-coalescing m [(* i 100) (* (inc i) 100)] :chain))
+               (oc/range-map)
+               (reverse (range 10)))]
+      (is (= 1 (count rm)))
+      (is (= [[0 1000]] (map first (oc/ranges rm))))))
+
+  (testing "Build chain in random order"
+    (let [rm (reduce
+               (fn [m i]
+                 (oc/assoc-coalescing m [(* i 100) (* (inc i) 100)] :chain))
+               (oc/range-map)
+               (shuffle (range 10)))]
+      (is (= 1 (count rm)))
+      (is (= [[0 1000]] (map first (oc/ranges rm)))))))
+
+(deftest coalesce-with-various-value-types
+  (testing "Coalesce with keyword values"
+    (let [rm (-> (oc/range-map)
+                 (oc/assoc-coalescing [0 100] :same)
+                 (oc/assoc-coalescing [100 200] :same))]
+      (is (= 1 (count rm)))))
+
+  (testing "Coalesce with map values"
+    (let [v {:type :config :id 42}
+          rm (-> (oc/range-map)
+                 (oc/assoc-coalescing [0 100] v)
+                 (oc/assoc-coalescing [100 200] v))]
+      (is (= 1 (count rm)))
+      (is (= v (rm 50)))
+      (is (= v (rm 150)))))
+
+  (testing "Coalesce with vector values"
+    (let [v [1 2 3]
+          rm (-> (oc/range-map)
+                 (oc/assoc-coalescing [0 100] v)
+                 (oc/assoc-coalescing [100 200] v))]
+      (is (= 1 (count rm)))))
+
+  (testing "Coalesce with integer values"
+    (let [rm (-> (oc/range-map)
+                 (oc/assoc-coalescing [0 100] 42)
+                 (oc/assoc-coalescing [100 200] 42))]
+      (is (= 1 (count rm)))))
+
+  (testing "Equal but not identical maps still coalesce"
+    ;; Equal maps SHOULD coalesce (= returns true)
+    (let [rm (-> (oc/range-map)
+                 (oc/assoc-coalescing [0 100] {:a 1})
+                 (oc/assoc-coalescing [100 200] {:a 1}))]
+      (is (= 1 (count rm))))))
+
+(deftest coalesce-interleaved-values
+  (testing "Alternating values don't coalesce"
+    (let [rm (reduce
+               (fn [m i]
+                 (oc/assoc-coalescing m [(* i 100) (* (inc i) 100)]
+                        (if (even? i) :even :odd)))
+               (oc/range-map)
+               (range 10))]
+      (is (= 10 (count rm)))))
+
+  (testing "Same values at both ends, different in middle"
+    ;; [0,100):a [100,200):b [200,300):a - should stay as 3 ranges
+    (let [rm (oc/range-map {[0 100] :a [100 200] :b [200 300] :a})]
+      (is (= 3 (count rm))))
+
+    ;; Now insert [100,200):a - should coalesce all three
+    (let [rm0 (oc/range-map {[0 100] :a [100 200] :b [200 300] :a})
+          rm1 (oc/assoc-coalescing rm0 [100 200] :a)]
+      (is (= 1 (count rm1)))
+      (is (= [[0 300]] (map first (oc/ranges rm1)))))))
+
+(deftest coalesce-stress-random
+  (testing "Random coalescing operations maintain invariants"
+    (dotimes [_ 20]
+      (let [;; Create ranges with only 3 possible values to encourage coalescing
+            values [:a :b :c]
+            ops (for [i (range 100)]
+                  {:lo (* i 10)
+                   :hi (+ (* i 10) 10)
+                   :val (rand-nth values)})
+            rm (reduce
+                 (fn [m {:keys [lo hi val]}]
+                   (oc/assoc-coalescing m [lo hi] val))
+                 (oc/range-map)
+                 ops)]
+        ;; Verify no overlaps
+        (let [ranges (oc/ranges rm)]
+          (doseq [[[[_ h1] _] [[l2 _] _]] (partition 2 1 ranges)]
+            (is (<= h1 l2))))
+        ;; Verify no adjacent same-value ranges (coalescing worked)
+        (let [ranges (oc/ranges rm)]
+          (doseq [[[_ v1] [_ v2]] (partition 2 1 ranges)]
+            (is (not= v1 v2) "Adjacent ranges should have different values")))))))
+
+(deftest coalesce-stress-many-same-value
+  (testing "1000 adjacent ranges with same value coalesce to one"
+    (let [rm (reduce
+               (fn [m i]
+                 (oc/assoc-coalescing m [(* i 10) (* (inc i) 10)] :unified))
+               (oc/range-map)
+               (shuffle (range 1000)))]
+      (is (= 1 (count rm)))
+      (is (= [[0 10000]] (map first (oc/ranges rm))))))
+
+  (testing "Insert in worst-case order (reverse) still coalesces"
+    (let [rm (reduce
+               (fn [m i]
+                 (oc/assoc-coalescing m [(* i 10) (* (inc i) 10)] :unified))
+               (oc/range-map)
+               (reverse (range 500)))]
+      (is (= 1 (count rm))))))
+
+(deftest coalesce-with-gaps
+  (testing "Coalescing doesn't bridge gaps"
+    ;; [0,100):a gap [200,300):a - should stay as 2 ranges
+    (let [rm (oc/range-map {[0 100] :a [200 300] :a})]
+      (is (= 2 (count rm))))
+
+    ;; Fill the gap with same value - now coalesces
+    (let [rm0 (oc/range-map {[0 100] :a [200 300] :a})
+          rm1 (oc/assoc-coalescing rm0 [100 200] :a)]
+      (is (= 1 (count rm1)))))
+
+  (testing "Coalescing doesn't bridge gaps with different values"
+    (let [rm0 (oc/range-map {[0 100] :a [200 300] :a})
+          rm1 (oc/assoc-coalescing rm0 [100 200] :b)]
+      (is (= 3 (count rm1))))))
+
+(deftest coalesce-ip-address-scenario
+  (testing "IP allocation coalescing (from zorp-example)"
+    (let [;; Helper: IP to int (simplified)
+          ip (fn [a b c d] (+ (* a 16777216) (* b 65536) (* c 256) d))
+
+          ;; Start with kevin-iot block
+          rm0 (oc/range-map {[(ip 10 10 4 0) (ip 10 10 8 0)] :kevin-iot})
+
+          ;; Add adjacent block with same owner - should coalesce
+          rm1 (oc/assoc-coalescing rm0 [(ip 10 10 8 0) (ip 10 10 12 0)] :kevin-iot)]
+
+      (is (= 1 (count rm1)))
+      (let [[[lo hi] v] (first (oc/ranges rm1))]
+        (is (= (ip 10 10 4 0) lo))
+        (is (= (ip 10 10 12 0) hi))
+        (is (= :kevin-iot v))))))
+
+(deftest coalesce-time-slot-scenario
+  (testing "Time slot coalescing"
+    (let [;; Book consecutive hours with same event
+          rm (-> (oc/range-map)
+                 (oc/assoc-coalescing [540 600] {:event "workshop"})   ; 9:00-10:00
+                 (oc/assoc-coalescing [600 660] {:event "workshop"})   ; 10:00-11:00
+                 (oc/assoc-coalescing [660 720] {:event "workshop"}))] ; 11:00-12:00
+      ;; Should coalesce into one 3-hour block
+      (is (= 1 (count rm)))
+      (is (= [[540 720]] (map first (oc/ranges rm)))))))
+
+(deftest coalesce-preserves-correct-value
+  (testing "Coalesced range has correct value"
+    (let [rm (-> (oc/range-map)
+                 (oc/assoc-coalescing [0 100] :value)
+                 (oc/assoc-coalescing [100 200] :value)
+                 (oc/assoc-coalescing [200 300] :value))]
+      (is (= 1 (count rm)))
+      (doseq [x (range 0 300 10)]
+        (is (= :value (rm x))))))
+
+  (testing "Non-coalescing preserves distinct values"
+    (let [rm (-> (oc/range-map)
+                 (assoc [0 100] :a)
+                 (assoc [100 200] :b)
+                 (assoc [200 300] :c))]
+      (is (= :a (rm 50)))
+      (is (= :b (rm 150)))
+      (is (= :c (rm 250))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Regression Tests
+;;
+;; Guard against specific edge cases that could cause bugs:
+;; - Inserting a range with exact same boundaries (complete replacement)
+;; - Inserting identical range multiple times (should collapse to one)
+;; - Overlaying entire content (reduces to single range)
+;; - Sequential complete overlays (last one wins)
+;; These tests prevent regressions in overlap resolution logic.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest regression-exact-boundary-overlap
+  (testing "Inserting range with exact same boundaries"
+    (let [rm0 (oc/range-map {[0 100] :old})
+          rm1 (assoc rm0 [0 100] :new)]
+      (is (= 1 (count rm1)))
+      (is (= :new (rm1 50)))))
+
+  (testing "Inserting identical range multiple times"
+    (let [rm (reduce
+               (fn [m _] (assoc m [0 100] :value))
+               (oc/range-map)
+               (range 100))]
+      (is (= 1 (count rm))))))
+
+(deftest regression-empty-result
+  (testing "Overlaying entire content"
+    (let [rm0 (oc/range-map {[0 50] :a [50 100] :b})
+          rm1 (assoc rm0 [0 100] :c)]
+      (is (= 1 (count rm1)))
+      (is (= :c (rm1 25)))
+      (is (= :c (rm1 75)))))
+
+  (testing "Sequential complete overlays"
+    (let [rm (reduce
+               (fn [m i]
+                 (assoc m [0 1000] i))
+               (oc/range-map)
+               (range 100))]
+      (is (= 1 (count rm)))
+      (is (= 99 (rm 500))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; get-entry Tests (Guava getEntry equivalent)
+;;
+;; Return [range value] for the range containing a point
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest get-entry-basic
+  (testing "Returns [range value] for point in range"
+    (let [rm (oc/range-map {[0 100] :a [200 300] :b})]
+      (is (= [[0 100] :a] (oc/get-entry rm 50)))
+      (is (= [[0 100] :a] (oc/get-entry rm 0)))
+      (is (= [[0 100] :a] (oc/get-entry rm 99)))
+      (is (= [[200 300] :b] (oc/get-entry rm 250)))))
+
+  (testing "Returns nil for point in gap"
+    (let [rm (oc/range-map {[0 100] :a [200 300] :b})]
+      (is (nil? (oc/get-entry rm 150)))
+      (is (nil? (oc/get-entry rm 100)))  ; exclusive upper bound
+      (is (nil? (oc/get-entry rm -10)))))
+
+  (testing "Empty range-map returns nil"
+    (is (nil? (oc/get-entry (oc/range-map) 50)))))
+
+(deftest get-entry-complex-values
+  (testing "Works with complex map values"
+    (let [rm (oc/range-map {[0 100] {:id 1 :name "first"}
+                             [100 200] {:id 2 :name "second"}})]
+      (is (= [[0 100] {:id 1 :name "first"}] (oc/get-entry rm 50)))
+      (is (= [[100 200] {:id 2 :name "second"}] (oc/get-entry rm 150))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; range-remove Tests (Guava remove equivalent)
+;;
+;; Remove all mappings in a range, trimming overlapping ranges
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest range-remove-basic
+  (testing "Remove entire range"
+    (let [rm0 (oc/range-map {[0 100] :a [200 300] :b})
+          rm1 (oc/range-remove rm0 [0 100])]
+      (is (= 1 (count rm1)))
+      (is (nil? (rm1 50)))
+      (is (= :b (rm1 250)))))
+
+  (testing "Remove middle of range - splits it"
+    (let [rm0 (oc/range-map {[0 100] :a})
+          rm1 (oc/range-remove rm0 [25 75])]
+      (is (= 2 (count rm1)))
+      (is (= :a (rm1 10)))
+      (is (nil? (rm1 50)))
+      (is (= :a (rm1 80)))))
+
+  (testing "Remove left portion of range"
+    (let [rm0 (oc/range-map {[0 100] :a})
+          rm1 (oc/range-remove rm0 [0 50])]
+      (is (= 1 (count rm1)))
+      (is (nil? (rm1 25)))
+      (is (= :a (rm1 75)))))
+
+  (testing "Remove right portion of range"
+    (let [rm0 (oc/range-map {[0 100] :a})
+          rm1 (oc/range-remove rm0 [50 100])]
+      (is (= 1 (count rm1)))
+      (is (= :a (rm1 25)))
+      (is (nil? (rm1 75))))))
+
+(deftest range-remove-spanning-multiple
+  (testing "Remove spanning multiple ranges"
+    (let [rm0 (oc/range-map {[0 100] :a [100 200] :b [200 300] :c})
+          rm1 (oc/range-remove rm0 [50 250])]
+      (is (= 2 (count rm1)))
+      (is (= :a (rm1 25)))
+      (is (nil? (rm1 150)))
+      (is (= :c (rm1 275)))))
+
+  (testing "Remove all ranges"
+    (let [rm0 (oc/range-map {[0 100] :a [100 200] :b})
+          rm1 (oc/range-remove rm0 [0 200])]
+      (is (= 0 (count rm1))))))
+
+(deftest range-remove-no-overlap
+  (testing "Remove range in gap - no effect"
+    (let [rm0 (oc/range-map {[0 100] :a [200 300] :b})
+          rm1 (oc/range-remove rm0 [120 180])]
+      (is (= 2 (count rm1)))
+      (is (= :a (rm1 50)))
+      (is (= :b (rm1 250)))))
+
+  (testing "Remove range before all ranges"
+    (let [rm0 (oc/range-map {[100 200] :a})
+          rm1 (oc/range-remove rm0 [0 50])]
+      (is (= 1 (count rm1)))
+      (is (= :a (rm1 150)))))
+
+  (testing "Remove range after all ranges"
+    (let [rm0 (oc/range-map {[0 100] :a})
+          rm1 (oc/range-remove rm0 [200 300])]
+      (is (= 1 (count rm1)))
+      (is (= :a (rm1 50))))))
+
+(deftest range-remove-stress
+  (testing "Remove many small ranges from large range"
+    (let [rm0 (oc/range-map {[0 1000] :base})
+          ;; Remove every other segment
+          rm1 (reduce
+                (fn [rm i]
+                  (oc/range-remove rm [(* i 20) (+ (* i 20) 10)]))
+                rm0
+                (range 50))]
+      ;; Should have 50 fragments of :base
+      (is (= 50 (count rm1)))
+      ;; Check some fragments
+      (is (= :base (rm1 15)))   ; in [10, 20)
+      (is (nil? (rm1 5)))       ; removed [0, 10)
+      (is (= :base (rm1 35)))))); in [30, 40)
diff --git a/test/ordered_collections/ranked_set_test.clj b/test/ordered_collections/ranked_set_test.clj
new file mode 100644
index 0000000..1b68647
--- /dev/null
+++ b/test/ordered_collections/ranked_set_test.clj
@@ -0,0 +1,309 @@
+(ns ordered-collections.ranked-set-test
+  "Tests for PRanked protocol operations on ordered-set."
+  (:require [clojure.test :refer [deftest testing is]]
+            [clojure.core.reducers :as r]
+            [ordered-collections.core :as oc]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Construction at various sizes
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest construction-various-sizes
+  (doseq [size [0 1 2 10 100 1000 10000 100000]]
+    (testing (str "Size " size)
+      (let [data (shuffle (range size))
+            rs   (oc/ordered-set data)
+            ss   (apply sorted-set data)]
+        (is (= size (count rs)))
+        (is (= (vec (seq ss)) (vec (seq rs))))
+        (is (= rs ss))))))
+
+(deftest construction-with-duplicates
+  (doseq [size [10 100 1000 10000]]
+    (testing (str "Size " size " with duplicates")
+      (let [;; Create data with ~50% duplicates
+            data (shuffle (concat (range size) (take (quot size 2) (shuffle (range size)))))
+            rs   (oc/ordered-set data)
+            ss   (apply sorted-set data)]
+        (is (= size (count rs)))
+        (is (= (seq ss) (seq rs)))))))
+
+(deftest construction-with-comparator
+  (doseq [size [10 100 1000 10000]]
+    (testing (str "Descending order, size " size)
+      (let [data (shuffle (range size))
+            rs   (oc/ordered-set-by > data)]
+        (is (= (reverse (range size)) (seq rs)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; nth: positional access
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest nth-correctness
+  (doseq [size [10 100 1000 10000 100000]]
+    (testing (str "Size " size)
+      (let [data   (shuffle (range size))
+            rs     (oc/ordered-set data)
+            sorted (vec (sort data))]
+        ;; Check all elements match
+        (doseq [i (range size)]
+          (is (= (sorted i) (nth rs i))
+              (str "Mismatch at index " i)))))))
+
+(deftest nth-random-access
+  (doseq [size [1000 10000 100000 500000]]
+    (testing (str "Random access, size " size)
+      (let [data   (shuffle (range size))
+            rs     (oc/ordered-set data)
+            sorted (vec (sort data))
+            ;; Test 1000 random indices
+            indices (repeatedly 1000 #(rand-int size))]
+        (is (every? #(= (sorted %) (nth rs %)) indices))))))
+
+(deftest nth-boundaries
+  (doseq [size [1 10 100 1000]]
+    (testing (str "Boundary cases, size " size)
+      (let [rs (oc/ordered-set (shuffle (range size)))]
+        ;; First and last
+        (is (= 0 (nth rs 0)))
+        (is (= (dec size) (nth rs (dec size))))
+        ;; Out of bounds with not-found
+        (is (= :nope (nth rs -1 :nope)))
+        (is (= :nope (nth rs size :nope)))
+        (is (= :nope (nth rs (* size 10) :nope)))))))
+
+(deftest nth-with-comparator
+  (doseq [size [100 1000 10000]]
+    (testing (str "Descending, size " size)
+      (let [rs     (oc/ordered-set-by > (shuffle (range size)))
+            sorted (vec (reverse (range size)))]
+        (doseq [i (take 100 (repeatedly #(rand-int size)))]
+          (is (= (sorted i) (nth rs i))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; rank: inverse of nth
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rank-correctness
+  (doseq [size [10 100 1000 10000 100000]]
+    (testing (str "Size " size)
+      (let [data (shuffle (range size))
+            rs   (oc/ordered-set data)]
+        ;; Rank of each element equals its sorted position
+        (doseq [x (range size)]
+          (is (= x (oc/rank rs x))
+              (str "Rank mismatch for element " x)))))))
+
+(deftest rank-is-inverse-of-nth
+  (doseq [size [100 1000 10000 100000]]
+    (testing (str "Inverse property, size " size)
+      (let [rs (oc/ordered-set (shuffle (range size)))]
+        ;; For all i: rank(nth(i)) == i
+        (doseq [i (take 500 (repeatedly #(rand-int size)))]
+          (is (= i (oc/rank rs (nth rs i)))))
+        ;; For all x in set: nth(rank(x)) == x
+        (doseq [x (take 500 (repeatedly #(rand-int size)))]
+          (is (= x (nth rs (oc/rank rs x)))))))))
+
+(deftest rank-non-existent
+  (doseq [size [100 1000 10000]]
+    (testing (str "Non-existent elements, size " size)
+      (let [;; Only even numbers
+            rs (oc/ordered-set (range 0 size 2))]
+        ;; Odd numbers should have nil rank
+        (doseq [x (range 1 size 2)]
+          (is (nil? (oc/rank rs x))))
+        ;; Elements outside range
+        (is (nil? (oc/rank rs -1)))
+        (is (nil? (oc/rank rs size)))
+        (is (nil? (oc/rank rs (* size 10))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; slice: range extraction
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest slice-correctness
+  (doseq [size [100 1000 10000]]
+    (testing (str "Size " size)
+      (let [rs     (oc/ordered-set (shuffle (range size)))
+            sorted (vec (range size))]
+        ;; Random slices
+        (dotimes [_ 100]
+          (let [start (rand-int size)
+                end   (+ start (rand-int (- size start)))]
+            (is (= (subvec sorted start end)
+                   (vec (oc/slice rs start end))))))))))
+
+(deftest slice-edge-cases
+  (doseq [size [10 100 1000]]
+    (testing (str "Edge cases, size " size)
+      (let [rs (oc/ordered-set (shuffle (range size)))]
+        ;; Empty slice
+        (is (empty? (oc/slice rs 0 0)))
+        (is (empty? (oc/slice rs 5 5)))
+        ;; Full slice
+        (is (= (range size) (oc/slice rs 0 size)))
+        ;; Single element slices
+        (doseq [i (range (min 10 size))]
+          (is (= (list i) (oc/slice rs i (inc i)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; median: middle element
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest median-correctness
+  (doseq [size [1 2 3 10 11 100 101 1000 1001 10000 10001]]
+    (testing (str "Size " size)
+      (let [rs       (oc/ordered-set (shuffle (range size)))
+            expected (quot (dec size) 2)]
+        (is (= expected (oc/median rs)))))))
+
+(deftest median-empty
+  (is (nil? (oc/median (oc/ordered-set)))))
+
+(deftest median-random-data
+  (dotimes [_ 100]
+    (let [size (+ 1 (rand-int 1000))
+          data (repeatedly size #(rand-int 10000))
+          rs   (oc/ordered-set data)
+          n    (count rs)
+          expected (nth rs (quot (dec n) 2))]
+      (is (= expected (oc/median rs))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; percentile: position by percentage
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest percentile-boundaries
+  (doseq [size [10 100 1000 10000]]
+    (testing (str "Size " size)
+      (let [rs (oc/ordered-set (shuffle (range size)))]
+        ;; 0th percentile is minimum
+        (is (= 0 (oc/percentile rs 0)))
+        ;; 100th percentile is maximum
+        (is (= (dec size) (oc/percentile rs 100)))))))
+
+(deftest percentile-various
+  (let [rs (oc/ordered-set (range 100))]
+    ;; For 100 elements: percentile p should give index close to p
+    (doseq [p [0 10 25 50 75 90 100]]
+      (let [result (oc/percentile rs p)]
+        (is (<= (- p 1) result (+ p 1))
+            (str "Percentile " p " gave " result))))))
+
+(deftest percentile-empty
+  (is (nil? (oc/percentile (oc/ordered-set) 50))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Underlying set operations still work
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest set-operations-integrity
+  (doseq [size [100 1000 10000]]
+    (testing (str "Size " size)
+      (let [data (shuffle (range size))
+            rs   (oc/ordered-set data)
+            ss   (apply sorted-set data)]
+        ;; contains?
+        (doseq [x (take 100 (repeatedly #(rand-int (* 2 size))))]
+          (is (= (contains? ss x) (contains? rs x))))
+        ;; subseq
+        (dotimes [_ 20]
+          (let [lo (rand-int size)
+                hi (+ lo (rand-int (- size lo)))]
+            (is (= (vec (subseq ss >= lo < hi))
+                   (vec (subseq rs >= lo < hi))))))))))
+
+(deftest set-mutation-operations
+  (doseq [size [100 1000 10000]]
+    (testing (str "Size " size)
+      (let [rs (oc/ordered-set (shuffle (range size)))]
+        ;; conj new element
+        (let [rs' (conj rs size)]
+          (is (= (inc size) (count rs')))
+          (is (contains? rs' size))
+          (is (= size (nth rs' size))))
+        ;; disj existing element
+        (let [to-remove (rand-int size)
+              rs'       (disj rs to-remove)]
+          (is (= (dec size) (count rs')))
+          (is (not (contains? rs' to-remove))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Stress tests with various element types
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest various-element-types
+  (doseq [size [100 1000 10000]
+          [name f] [["integers" identity]
+                    ["strings" str]
+                    ["keywords" #(keyword (str "k" %))]]]
+    (testing (str name ", size " size)
+      (let [data   (mapv f (shuffle (range size)))
+            rs     (oc/ordered-set data)
+            sorted (vec (sort data))]
+        (is (= size (count rs)))
+        ;; Random nth checks
+        (doseq [i (take 50 (repeatedly #(rand-int size)))]
+          (is (= (sorted i) (nth rs i))))
+        ;; Random rank checks
+        (doseq [i (take 50 (repeatedly #(rand-int size)))]
+          (let [elem (sorted i)]
+            (is (= i (oc/rank rs elem)))))))))
+
+(deftest reducible-and-foldable
+  (doseq [size [100 1000 10000 100000 500000]]
+    (testing (str "Size " size)
+      (let [data (shuffle (range size))
+            rs   (oc/ordered-set data)
+            expected (reduce + (range size))]
+        ;; reduce
+        (is (= expected (reduce + rs)))
+        ;; r/fold
+        (is (= expected (r/fold + rs)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Randomized property tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest randomized-properties
+  (dotimes [_ 50]
+    (let [size (+ 10 (rand-int 10000))
+          ;; Random data with possible duplicates and gaps
+          data (repeatedly size #(rand-int (* size 2)))
+          rs   (oc/ordered-set data)
+          n    (count rs)]
+      (testing (str "Random data, n=" n)
+        ;; Property: seq is sorted
+        (let [s (seq rs)]
+          (is (= s (sort s))))
+        ;; Property: all indices valid
+        (doseq [i (take 20 (repeatedly #(rand-int n)))]
+          (is (some? (nth rs i))))
+        ;; Property: rank/nth are inverses
+        (doseq [i (take 20 (repeatedly #(rand-int n)))]
+          (let [elem (nth rs i)]
+            (is (= i (oc/rank rs elem)))))
+        ;; Property: median is in the middle
+        (when (pos? n)
+          (let [med (oc/median rs)
+                idx (oc/rank rs med)]
+            (is (= (quot (dec n) 2) idx))))))))
+
+(deftest randomized-slice-properties
+  (dotimes [_ 50]
+    (let [size (+ 10 (rand-int 5000))
+          rs   (oc/ordered-set (shuffle (range size)))]
+      ;; Property: slice(i, j) has length j - i
+      (dotimes [_ 10]
+        (let [i (rand-int size)
+              j (+ i (rand-int (- size i)))]
+          (is (= (- j i) (count (oc/slice rs i j))))))
+      ;; Property: slice elements are consecutive in rank
+      (dotimes [_ 10]
+        (let [i     (rand-int size)
+              j     (+ i 1 (rand-int (min 100 (- size i))))
+              slice (vec (oc/slice rs i j))]
+          (doseq [k (range (count slice))]
+            (is (= (+ i k) (oc/rank rs (slice k))))))))))
diff --git a/test/ordered_collections/rope_fold_bench.clj b/test/ordered_collections/rope_fold_bench.clj
new file mode 100644
index 0000000..644da92
--- /dev/null
+++ b/test/ordered_collections/rope_fold_bench.clj
@@ -0,0 +1,184 @@
+(ns ordered-collections.rope-fold-bench
+  "Dedicated benchmark for rope fold strategies.
+
+   Compares:
+   - rope reduce
+   - current tree-native rope fold
+   - prior split-based rope fold
+   - vector reduce
+   - vector fold
+
+   Usage:
+     lein bench-rope-fold
+     lein bench-rope-fold --quick"
+  (:require [clojure.core.reducers :as r]
+            [ordered-collections.bench-utils :as bu :refer [has-flag?]]
+            [ordered-collections.core :as oc]
+            [ordered-collections.parallel :as par]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Benchmark Infrastructure
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-op
+  [f warmup-iters bench-iters]
+  (dotimes [_ warmup-iters] (f))
+  (let [start (System/nanoTime)]
+    (dotimes [_ bench-iters] (f))
+    (/ (- (System/nanoTime) start) (* bench-iters 1000.0))))
+
+(defn bench-op-samples
+  [f warmup-iters bench-iters sample-runs]
+  (let [samples (vec (repeatedly sample-runs #(bench-op f warmup-iters bench-iters)))
+        sorted  (sort samples)
+        n       (count sorted)]
+    {:median  (nth sorted (quot n 2))
+     :mean    (/ (reduce + sorted) n)
+     :low     (first sorted)
+     :high    (last sorted)
+     :samples samples}))
+
+(defn- fmt-us [stats]
+  (bu/format-ns (* 1000 (:median stats))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Workloads
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- split-based-fold
+  "Previous Rope CollFold strategy, retained here for benchmark comparison."
+  [coll ^long n combinef reducef]
+  (letfn [(fold* [child]
+            (let [csz (count child)]
+              (if (<= csz n)
+                (reduce reducef (combinef) child)
+                (let [cmid   (quot csz 2)
+                      [cl cr] (oc/rope-split child cmid)]
+                  (par/fork-join
+                    [lv (fold* cl) rv (fold* cr)]
+                    (combinef lv rv))))))]
+    (if (par/in-fork-join-pool?)
+      (fold* coll)
+      (par/invoke-root #(fold* coll)))))
+
+(defn- freq-combine
+  ([] {})
+  ([m1 m2] (merge-with + m1 m2)))
+
+(defn- freq-reduce [m x]
+  (update m (mod (long x) 100) (fnil inc 0)))
+
+(def workloads
+  [{:key :sum
+    :label "sum"
+    :combinef +
+    :reducef +}
+   {:key :into
+    :label "into"
+    :combinef into
+    :reducef conj}
+   {:key :freq
+    :label "freq"
+    :combinef freq-combine
+    :reducef freq-reduce}])
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Bench
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def default-sizes [100000 500000 1000000])
+(def quick-sizes [100000 500000])
+(def default-thresholds [1024 4096 16384 65536])
+(def quick-thresholds [1024 16384])
+
+(defn bench-fold-workload
+  [n threshold {:keys [combinef reducef]} opts]
+  (let [data (range n)
+        r    (oc/rope data)
+        v    (vec data)]
+    {:rope-reduce    (bench-op-samples
+                       #(reduce reducef (combinef) r)
+                       (:warmup opts) (:iters opts) (:samples opts))
+     :rope-fold      (bench-op-samples
+                       #(r/fold threshold combinef reducef r)
+                       (:warmup opts) (:iters opts) (:samples opts))
+     :rope-fold-old  (bench-op-samples
+                       #(split-based-fold r threshold combinef reducef)
+                       (:warmup opts) (:iters opts) (:samples opts))
+     :vector-reduce  (bench-op-samples
+                       #(reduce reducef (combinef) v)
+                       (:warmup opts) (:iters opts) (:samples opts))
+     :vector-fold    (bench-op-samples
+                       #(r/fold threshold combinef reducef v)
+                       (:warmup opts) (:iters opts) (:samples opts))}))
+
+(defn- print-results
+  [results]
+  (println)
+  (println "═══════════════════════════════════════════════════════════════════════════════════════════")
+  (println "  ROPE FOLD BENCHMARK")
+  (println "  Median time for each workload / threshold")
+  (println "═══════════════════════════════════════════════════════════════════════════════════════════")
+  (doseq [[wk rs] (sort-by key (group-by :workload results))]
+    (println)
+    (println (format "  Workload: %s" (name wk)))
+    (doseq [[n size-results] (sort-by key (group-by :n rs))]
+      (println)
+      (printf "  N = %,d%n" n)
+      (println "  ┌───────────┬────────────┬────────────┬──────────────┬──────────────┬─────────────┐")
+      (println "  │ threshold │ rope fold  │ rope old   │ rope reduce  │ vector fold  │ vector red. │")
+      (println "  ├───────────┼────────────┼────────────┼──────────────┼──────────────┼─────────────┤")
+      (doseq [{:keys [threshold bench]} (sort-by :threshold size-results)]
+        (printf "  │ %7d   │ %10s │ %10s │ %12s │ %12s │ %11s │%n"
+                threshold
+                (fmt-us (:rope-fold bench))
+                (fmt-us (:rope-fold-old bench))
+                (fmt-us (:rope-reduce bench))
+                (fmt-us (:vector-fold bench))
+                (fmt-us (:vector-reduce bench))))
+      (println "  └───────────┴────────────┴────────────┴──────────────┴──────────────┴─────────────┘"))))
+
+(defn run-benchmark
+  [& {:keys [sizes thresholds warmup iters samples]
+      :or {sizes default-sizes
+           thresholds default-thresholds
+           warmup 10
+           iters 30
+           samples 7}}]
+  (let [opts {:warmup warmup :iters iters :samples samples}]
+    (println "Rope fold benchmark")
+    (println "Sizes:" sizes)
+    (println "Thresholds:" thresholds)
+    (println "Workloads:" (mapv :label workloads))
+    (println (format "Per-measurement: %d warmup, %d iters, %d samples" warmup iters samples))
+    (println)
+    (let [results
+          (vec
+            (for [{:keys [key] :as workload} workloads
+                  n sizes
+                  threshold thresholds]
+              (do
+                (print (format "  workload=%s N=%,d threshold=%d " (name key) n threshold))
+                (flush)
+                (let [bench (bench-fold-workload n threshold workload opts)]
+                  (println)
+                  {:workload key
+                   :n n
+                   :threshold threshold
+                   :bench bench}))))]
+      (print-results results)
+      results)))
+
+(defn quick-bench []
+  (run-benchmark :sizes quick-sizes
+                 :thresholds quick-thresholds
+                 :warmup 5 :iters 15 :samples 5))
+
+(defn -main [& args]
+  (if (has-flag? args "--quick" "-q")
+    (quick-bench)
+    (run-benchmark))
+  (shutdown-agents))
diff --git a/test/ordered_collections/rope_test.clj b/test/ordered_collections/rope_test.clj
new file mode 100644
index 0000000..02ef6a8
--- /dev/null
+++ b/test/ordered_collections/rope_test.clj
@@ -0,0 +1,1212 @@
+(ns ordered-collections.rope-test
+  (:require [clojure.test :refer :all]
+            [clojure.core.reducers :as r]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.core :as oc]
+            [ordered-collections.kernel.rope :as ropetree]
+            [ordered-collections.test-utils :as tu]))
+
+
+(deftest rope-basic-semantics
+  (let [r (oc/rope [0 1 2 3 4])]
+    (is (vector? r))
+    (is (= 5 (count r)))
+    (is (= [0 1 2 3 4] r))
+    (is (= 0 (nth r 0)))
+    (is (= 4 (nth r 4)))
+    (is (= :nope (nth r 9 :nope)))
+    (is (= 2 (get r 2)))
+    (is (= :nope (get r 9 :nope)))
+    (is (= [4 3 2 1 0] (vec (rseq r))))
+    (is (= 10 (reduce + r)))
+    (is (= [0 1 2 3 4 5] (vec (conj r 5))))
+    (is (= [0 1 9 3 4] (vec (assoc r 2 9))))
+    (is (= 4 (peek r)))
+    (is (= [0 1 2 3] (vec (pop r))))
+    (is (= [0 1 2 3 4] (seq r)))
+    (is (= r [0 1 2 3 4]))
+    (is (= [0 1 2 3 4] r))))
+
+(deftest rope-indexed-associative-semantics
+  (let [r (oc/rope [:a :b :c])]
+    (is (contains? r 0))
+    (is (contains? r 2))
+    (is (not (contains? r 3)))
+    (let [e (.entryAt ^clojure.lang.Associative r 1)]
+      (is (= 1 (key e)))
+      (is (= :b (val e))))
+    (is (= [:a :b :c :d] (vec (assoc r 3 :d))))
+    (is (thrown? IndexOutOfBoundsException (assoc r 4 :e)))))
+
+(deftest rope-metadata-and-structural-ops
+  (let [r (with-meta (oc/rope [0 1 2 3 4 5]) {:tag :rope})]
+    (is (= {:tag :rope} (meta r)))
+    (is (= {:tag :rope} (meta (empty r))))
+    (let [[l rr] (oc/rope-split r 3)]
+      (is (= [0 1 2] (vec l)))
+      (is (= [3 4 5] (vec rr)))
+      (is (= {:tag :rope} (meta l)))
+      (is (= {:tag :rope} (meta rr))))
+    (let [sv (oc/rope-sub r 2 5)]
+      (is (= [2 3 4] (vec sv)))
+      (is (= {:tag :rope} (meta sv))))
+    (let [c (oc/rope-concat (oc/rope [0 1 2]) (oc/rope [3 4 5]))]
+      (is (= [0 1 2 3 4 5] (vec c))))))
+
+(deftest rope-empty-edge-cases
+  (let [r (oc/rope)]
+    (is (= [] (vec r)))
+    (is (nil? (seq r)))
+    (is (nil? (rseq r)))
+    (is (nil? (peek r)))
+    (is (thrown? IllegalStateException (pop r)))
+    (is (= :nope (get r 0 :nope)))
+    (is (thrown? IndexOutOfBoundsException (assoc r 1 :x)))))
+
+(deftest rope-large-structural-operations
+  (let [r (oc/rope (range 100000))]
+    (is (= :x (nth (assoc r 75000 :x) 75000)))
+    (let [[l rr] (oc/rope-split r 50000)]
+      (is (= 50000 (count l)))
+      (is (= 50000 (count rr)))
+      (is (= 0 (nth l 0)))
+      (is (= 50000 (nth rr 0))))
+    (is (= 99999 (peek r)))
+    (is (= 99998 (peek (pop r))))
+    (is (= 12345 (nth r 12345)))
+    (is (= :y (nth (assoc r 32768 :y) 32768)))
+    (is (= (range 49990 50010) (vec (oc/rope-sub r 49990 50010))))))
+
+(deftest rope-chunk-boundary-behavior
+  (let [n    (+ ropetree/+min-chunk-size+ 2)
+        r    (oc/rope (range n))
+        mid  (quot n 2)]
+    (is (= n (count r)))
+    (is (= (range n) (vec r)))
+    (is (= 1 (oc/rope-chunk-count r)))
+    (is (= (range mid (+ mid 10)) (vec (oc/rope-sub r mid (+ mid 10)))))
+    (let [split mid]
+      (let [[l rr] (oc/rope-split r split)]
+        (is (= (range split) (vec l)))
+        (is (= (range split n) (vec rr))))
+      (let [[l rr] (oc/rope-split r (inc split))]
+        (is (= (range (inc split)) (vec l)))
+        (is (= (range (inc split) n) (vec rr)))))
+    (is (= (range (+ n 10))
+          (vec (reduce conj r (range n (+ n 10))))))))
+
+(deftest rope-editing-operations
+  (let [r (oc/rope (range 10))]
+    (is (= [0 1 :a :b 2 3 4 5 6 7 8 9]
+          (vec (oc/rope-insert r 2 [:a :b]))))
+    (is (= [:a :b 0 1 2 3 4 5 6 7 8 9]
+          (vec (oc/rope-insert r 0 (oc/rope [:a :b])))))
+    (is (= [0 1 2 3 7 8 9]
+          (vec (oc/rope-remove r 4 7))))
+    (is (= [0 1 :x :y 5 6 7 8 9]
+          (vec (oc/rope-splice r 2 5 [:x :y]))))
+    (is (= (range 10) (vec (oc/rope-remove r 3 3))))
+    (is (thrown? IndexOutOfBoundsException (oc/rope-insert r 11 [:x])))
+    (is (thrown? IndexOutOfBoundsException (oc/rope-insert r 1.5 [:x])))
+    (is (thrown? IndexOutOfBoundsException (oc/rope-remove r -1 2)))
+    (is (thrown? IndexOutOfBoundsException (oc/rope-remove r 1.2 3)))
+    (is (thrown? IndexOutOfBoundsException (oc/rope-splice r 4 2 [:x])))
+    (is (thrown? IndexOutOfBoundsException (oc/rope-splice r 2 4.1 [:x])))
+    (is (thrown? IndexOutOfBoundsException (oc/rope-split r 2.2)))
+    (is (thrown? IndexOutOfBoundsException (oc/rope-sub r 1 3.5)))))
+
+(deftest rope-concat-coercion
+  (is (= [0 1 2 3]
+        (vec (oc/rope-concat [0 1] (oc/rope [2 3])))))
+  (is (= [0 1 2 3]
+        (vec (oc/rope-concat (oc/rope [0 1]) [2 3]))))
+  (let [left (with-meta (oc/rope [0 1]) {:tag :left})]
+    (is (= {:tag :left}
+          (meta (oc/rope-concat left [2 3]))))))
+
+(deftest rope-normalization-and-chunk-iteration
+  (let [tiny (reduce oc/rope-concat (map #(oc/rope [%]) (range 130)))]
+    (is (= (range 130) (vec tiny)))
+    (is (= [130] (mapv count (oc/rope-chunks tiny))))
+    (is (= [130] (mapv count (oc/rope-chunks-reverse tiny))))))
+
+(deftest rope-sub-view
+  (let [r  (oc/rope (range 20))
+        sv (oc/rope-sub r 5 15)]
+    (is (= 10 (count sv)))
+    (is (= (range 5 15) (vec sv)))
+    (is (= 5 (nth sv 0)))
+    (is (= 14 (nth sv 9)))
+    (is (= :nope (nth sv 20 :nope)))
+    (is (= [14 13 12 11 10 9 8 7 6 5] (vec (rseq sv))))
+    (is (= 95 (reduce + sv)))
+    (is (= {:tag :slice} (meta (with-meta sv {:tag :slice}))))
+    (is (= [5 6 :x 8 9 10 11 12 13 14]
+          (vec (assoc (oc/rope (vec sv)) 2 :x))))
+    (is (= (range 5 15)
+          (vec (oc/rope-concat sv (oc/rope [])))))
+    (is (= [0 1 2 3 4 5 6 7 8 9 10 11]
+          (vec (oc/rope-concat (oc/rope (range 5))
+                 (oc/rope-sub (oc/rope (range 20)) 5 12)))))
+    (is (= [5 6 :a :b 10 11 12 13 14]
+          (vec (oc/rope-splice sv 2 5 [:a :b]))))
+    (is (= (range 7 12)
+          (vec (oc/rope-sub sv 2 7)))))) 
+
+(deftest rope-chunk-shape-invariants
+  (let [tiny  (reduce oc/rope-concat (map #(oc/rope [%]) (range 1000)))
+        sizes (mapv count (oc/rope-chunks tiny))]
+    (is (= (range 1000) (vec tiny)))
+    (is (ropetree/invariant-valid? (.-root ^ordered_collections.types.rope.Rope tiny))
+      "CSI must hold after 1000 single-element concats")
+    ;; All chunks except the last must be >= min
+    (is (every? #(>= % ropetree/+min-chunk-size+) (butlast sizes)))
+    ;; No chunk exceeds target
+    (is (every? #(<= % ropetree/+target-chunk-size+) sizes))
+    ;; Reasonable chunk count: at most ceil(n/min) chunks
+    (is (<= (count sizes) (inc (quot 1000 ropetree/+min-chunk-size+))))))
+
+(defn- clamp-index
+  [n i]
+  (min n (max 0 i)))
+
+(defn- apply-rope-op
+  [r [op a b c]]
+  (case op
+    :insert
+    (let [i (clamp-index (count r) a)]
+      (oc/rope-insert r i b))
+
+    :insert-many
+    (let [i (clamp-index (count r) a)]
+      (oc/rope-insert r i b))
+
+    :remove
+    (let [n (count r)
+          lo (clamp-index n a)
+          hi (clamp-index n b)]
+      (oc/rope-remove r lo hi))
+
+    :splice
+    (let [n (count r)
+          lo (clamp-index n a)
+          hi (clamp-index n b)]
+      (oc/rope-splice r lo hi c))
+
+    :subrope
+    (let [n (count r)
+          lo (clamp-index n a)
+          hi (clamp-index n b)]
+      (oc/rope-sub r lo hi))))
+
+(defn- apply-vector-op
+  [v [op a b c]]
+  (case op
+    :insert
+    (let [i (clamp-index (count v) a)]
+      (vec (concat (subvec v 0 i) b (subvec v i))))
+
+    :insert-many
+    (let [i (clamp-index (count v) a)]
+      (vec (concat (subvec v 0 i) b (subvec v i))))
+
+    :remove
+    (let [n  (count v)
+          lo (clamp-index n a)
+          hi (clamp-index n b)]
+      (vec (concat (subvec v 0 lo) (subvec v hi))))
+
+    :splice
+    (let [n  (count v)
+          lo (clamp-index n a)
+          hi (clamp-index n b)]
+      (vec (concat (subvec v 0 lo) c (subvec v hi))))
+
+    :subrope
+    (let [n  (count v)
+          lo (clamp-index n a)
+          hi (clamp-index n b)]
+      (subvec v lo hi))))
+
+(defn gen-rope-op
+  "Generate a rope operation with index range [0, max-idx].
+  Callers control the index range to match collection scale."
+  [max-idx]
+  (gen/one-of
+    [;; Structural ops
+     (gen/fmap (fn [[i x]] [:insert i [x] nil])
+       (gen/tuple (gen/choose 0 max-idx) gen/small-integer))
+     (gen/fmap (fn [[i xs]] [:insert-many i xs nil])
+       (gen/tuple (gen/choose 0 max-idx) (gen/vector gen/small-integer 0 8)))
+     (gen/fmap (fn [[a b]] [:remove (min a b) (max a b) nil])
+       (gen/tuple (gen/choose 0 max-idx) (gen/choose 0 max-idx)))
+     (gen/fmap (fn [[a b xs]] [:splice (min a b) (max a b) xs])
+       (gen/tuple (gen/choose 0 max-idx) (gen/choose 0 max-idx)
+         (gen/vector gen/small-integer 0 8)))
+     (gen/fmap (fn [[a b]] [:subrope (min a b) (max a b) nil])
+       (gen/tuple (gen/choose 0 max-idx) (gen/choose 0 max-idx)))
+     ;; Vector-like ops
+     (gen/fmap (fn [x] [:conj x nil nil]) gen/small-integer)
+     (gen/return [:pop nil nil nil])
+     (gen/fmap (fn [[i x]] [:assoc i x nil])
+       (gen/tuple (gen/choose 0 max-idx) gen/small-integer))]))
+
+(defn gen-rope-ops
+  "Generate 0-n rope operations with index range [0, max-idx]."
+  [n max-idx]
+  (gen/vector (gen-rope-op max-idx) 0 n))
+
+(defn- apply-full-rope-op
+  [r [op a b c]]
+  (case op
+    :conj    (conj r a)
+    :pop     (if (pos? (count r)) (pop r) r)
+    :assoc   (let [n (count r)]
+               (if (and (pos? n) (< a n)) (assoc r (rem a n) b) r))
+    (apply-rope-op r [op a b c])))
+
+(defn- apply-full-vector-op
+  [v [op a b c]]
+  (case op
+    :conj    (conj v a)
+    :pop     (if (pos? (count v)) (pop v) v)
+    :assoc   (let [n (count v)]
+               (if (and (pos? n) (< a n)) (assoc v (rem a n) b) v))
+    (apply-vector-op v [op a b c])))
+
+(defspec prop-rope-random-edit-sequences 100
+  (prop/for-all [xs  (gen/vector gen/small-integer 0 100)
+                 ops (gen-rope-ops 60 100)]
+    (= (reduce apply-full-vector-op (vec xs) ops)
+       (vec (reduce apply-full-rope-op (oc/rope xs) ops)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Reduced Handling
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-reduce-early-termination
+  (testing "2-arity reduce with reduced"
+    (let [r (oc/rope (range 1000))]
+      (is (= 10
+            (reduce (fn [acc x]
+                      (if (>= acc 10)
+                        (reduced acc)
+                        (inc acc)))
+              0 r)))))
+  (testing "1-arity reduce with reduced"
+    (let [r (oc/rope (range 1 1000))]
+      (is (= 10
+            (reduce (fn [acc x]
+                      (if (>= (long acc) 10)
+                        (reduced acc)
+                        (+ (long acc) (long x))))
+              r)))))
+  (testing "reduced across chunk boundaries"
+    (let [r (oc/rope (range 10000))
+          stop-at 500]
+      (is (= stop-at
+            (reduce (fn [^long acc x]
+                      (if (>= acc stop-at)
+                        (reduced acc)
+                        (unchecked-inc acc)))
+              (long 0) r))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Java Interop
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-java-list-interface
+  (let [^java.util.List r (oc/rope [10 20 30 40 50])]
+    (is (instance? java.util.List r))
+    (is (instance? java.util.Collection r))
+    (is (= 5 (.size r)))
+    (is (not (.isEmpty r)))
+    (is (.isEmpty ^java.util.Collection (oc/rope)))
+    (is (= 30 (.get r 2)))
+    (is (thrown? IndexOutOfBoundsException (.get r 5)))
+    (is (= 0 (.indexOf r 10)))
+    (is (= 4 (.indexOf r 50)))
+    (is (= -1 (.indexOf r 99)))
+    (is (= 4 (.lastIndexOf r 50)))
+    (is (.contains r 30))
+    (is (not (.contains r 99)))
+    (is (.containsAll r [10 30 50]))
+    (is (not (.containsAll r [10 99])))
+    (is (= [10 20 30 40 50] (vec (.toArray r))))
+    (is (thrown? UnsupportedOperationException (.add r 60)))
+    (is (thrown? UnsupportedOperationException (.clear r)))))
+
+(deftest rope-sublist
+  (let [^java.util.List r (oc/rope (range 20))
+        sl (.subList r 5 10)]
+    (is (= [5 6 7 8 9] (vec sl)))
+    (is (instance? java.util.List sl))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Comparable
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-comparable
+  (let [a (oc/rope [1 2 3])
+        b (oc/rope [1 2 4])
+        c (oc/rope [1 2 3])
+        d (oc/rope [1 2])
+        e (oc/rope [1 2 3 4])]
+    (is (zero? (compare a c)))
+    (is (neg? (compare a b)))
+    (is (pos? (compare b a)))
+    (is (pos? (compare a d)))
+    (is (neg? (compare d a)))
+    (is (neg? (compare a e)))
+    (is (pos? (compare e a)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Hash and Equality Consistency
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-hash-equality-consistency
+  (let [r (oc/rope [1 2 3 4 5])
+        v [1 2 3 4 5]]
+    (is (= r v))
+    (is (= v r))
+    (is (= (hash r) (hash v))))
+  (let [r1 (oc/rope (range 100))
+        r2 (oc/rope (range 100))]
+    (is (= r1 r2))
+    (is (= (hash r1) (hash r2))))
+  (testing "empty rope hash matches empty vector"
+    (is (= (hash (oc/rope)) (hash [])))))
+
+(deftest rope-sub-hash-equality
+  (let [r  (oc/rope (range 20))
+        sv (oc/rope-sub r 5 10)
+        v  [5 6 7 8 9]]
+    (is (= sv v))
+    (is (= v sv))
+    (is (= (hash sv) (hash v)))))
+
+(deftest rope-sequential-equality-and-ordering-contract
+  (let [r (oc/rope [1 2 3])
+        v [1 2 3]
+        l '(1 2 3)
+        a (oc/rope [1 2 3])
+        b (oc/rope [1 2 4])]
+    (is (= r v))
+    (is (= r l))
+    (is (zero? (compare r v)))
+    (is (zero? (compare r l)))
+    (is (neg? (compare a b)))
+    (is (pos? (compare b a)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Parallel Fold
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-parallel-fold
+  (let [r (oc/rope (range 100000))
+        expected (reduce + (range 100000))]
+    (is (= expected
+          (r/fold + r)))
+    (is (= expected
+          (r/fold 1024 + + r)))))
+
+(deftest rope-parallel-fold-edge-cases
+  (testing "empty rope"
+    (let [r (oc/rope)]
+      (is (= 0 (r/fold + r)))
+      (is (= [] (r/fold 1 into conj r)))
+      (is (= {} (r/fold 1
+                 (fn ([] {}) ([m1 m2] (merge-with + m1 m2)))
+                 (fn [m x] (update m x (fnil inc 0)))
+                 r)))))
+  (testing "singleton rope"
+    (let [r (oc/rope [42])]
+      (is (= 42 (r/fold + r)))
+      (is (= [42] (r/fold 1 into conj r)))
+      (is (= "x" (r/fold 1 str (fn [s ch] (str s ch)) (oc/rope "x"))))))
+  (testing "threshold boundaries preserve order"
+    (let [r (oc/rope (range 300))]
+      (doseq [threshold [1 2 3 7 31 63 64 65 127 128 129 255 256 257 1024]]
+        (is (= (vec (range 300))
+              (r/fold threshold into conj r)))
+        (is (= (reduce + (range 300))
+              (r/fold threshold + + r)))))))
+
+(deftest rope-parallel-fold-after-structural-edits
+  (let [r0 (oc/rope (range 1000))
+        r1 (oc/rope-insert r0 200 [:a :b :c])
+        r2 (oc/rope-remove r1 500 700)
+        r3 (oc/rope-splice r2 20 40 (range 10))
+        expected (vec r3)
+        freq-combine (fn ([] {}) ([m1 m2] (merge-with + m1 m2)))
+        freq-reduce  (fn [m x] (update m (class x) (fnil inc 0)))]
+    (doseq [threshold [1 8 64 256 1024]]
+      (is (= expected (r/fold threshold into conj r3)))
+      (is (= (reduce freq-reduce {} r3)
+            (r/fold threshold freq-combine freq-reduce r3))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Print Methods
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-print-method
+  (is (= "#ordered/rope [1 2 3]" (pr-str (oc/rope [1 2 3]))))
+  (is (= "#ordered/rope []" (pr-str (oc/rope))))
+  (is (= "#ordered/rope [5 6 7]"
+        (pr-str (oc/rope-sub (oc/rope (range 10)) 5 8)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interop: String, Vector, Sequence
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-str-conversion
+  (is (= "hello" (oc/rope-str (oc/rope "hello"))))
+  (is (= "" (oc/rope-str (oc/rope))))
+  (is (= "The quick brown fox"
+        (oc/rope-str (oc/rope-concat (oc/rope "The quick ")
+                                     (oc/rope "brown fox")))))
+  (testing "rope-str on slice"
+    (is (= "quick"
+          (oc/rope-str (oc/rope-sub (oc/rope "The quick brown") 4 9))))))
+
+(deftest rope-to-vec-conversion
+  (testing "vec on rope preserves content"
+    (let [r (oc/rope [1 2 3 4 5])]
+      (is (= [1 2 3 4 5] (vec r)))))
+  (testing "into [] materializes to PersistentVector"
+    (let [r (oc/rope [1 2 3 4 5])
+          v (into [] r)]
+      (is (= [1 2 3 4 5] v))
+      (is (instance? clojure.lang.PersistentVector v))))
+  (testing "empty rope"
+    (is (= [] (into [] (oc/rope))))))
+
+(deftest rope-sequence-interop
+  (testing "rope from various seqable sources"
+    (is (= [1 2 3] (vec (oc/rope [1 2 3]))))
+    (is (= [0 1 2] (vec (oc/rope (range 3)))))
+    (is (= [\h \e \l \l \o] (vec (oc/rope "hello"))))
+    (is (= [1 2 3] (vec (oc/rope '(1 2 3))))))
+  (testing "rope operations accept non-rope collections"
+    (is (= [1 2 3] (vec (oc/rope-concat (oc/rope [1 2]) [3]))))
+    (is (= [1 2 :x 3] (vec (oc/rope-insert (oc/rope [1 2 3]) 2 [:x]))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Bounds Checking
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-bounds-checking
+  (let [r (oc/rope [0 1 2])]
+    (is (thrown? IndexOutOfBoundsException (nth r 3)))
+    (is (thrown? IndexOutOfBoundsException (nth r -1)))
+    (is (= :nope (nth r 3 :nope)))
+    (is (= :nope (nth r -1 :nope)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Transient
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-transient-basic
+  (let [r (persistent! (reduce conj! (transient (oc/rope)) (range 1000)))]
+    (is (= (range 1000) (vec (into [] r))))
+    (is (= 1000 (count r)))
+    (is (ropetree/invariant-valid? (.-root ^ordered_collections.types.rope.Rope r)))))
+
+(deftest rope-transient-from-existing
+  (let [base (oc/rope (range 500))
+        r    (persistent! (reduce conj! (transient base) (range 500 1000)))]
+    (is (= (range 1000) (into [] r)))
+    (is (= 1000 (count r)))))
+
+(deftest rope-transient-empty
+  (let [r (persistent! (transient (oc/rope)))]
+    (is (= [] (into [] r)))
+    (is (= 0 (count r)))))
+
+(deftest rope-transient-small
+  (let [r (persistent! (reduce conj! (transient (oc/rope)) [1 2 3]))]
+    (is (= [1 2 3] (into [] r)))))
+
+(deftest rope-transient-invalidation
+  (let [t (transient (oc/rope))]
+    (persistent! t)
+    (is (thrown? IllegalAccessError (conj! t 1)))
+    (is (thrown? IllegalAccessError (persistent! t)))))
+
+(deftest rope-transient-count
+  (let [t (reduce conj! (transient (oc/rope)) (range 100))]
+    (is (= 100 (count t)))))
+
+(deftest rope-transient-nth
+  (let [t (reduce conj! (transient (oc/rope)) (range 500))]
+    (is (= 0 (nth t 0)))
+    (is (= 255 (nth t 255)))
+    (is (= 256 (nth t 256)))
+    (is (= 499 (nth t 499)))
+    (is (= :nope (nth t 500 :nope)))))
+
+(deftest rope-transient-live-boundaries
+  (let [target ropetree/+target-chunk-size+
+        base   (oc/rope (range 100))
+        t      (transient base)]
+    (doseq [x (range 100 (+ 100 (* 2 target) 17))]
+      (conj! t x))
+    (is (= (+ 100 (* 2 target) 17) (count t)))
+    (is (= 0 (nth t 0)))
+    (is (= 99 (nth t 99)))
+    (is (= 100 (nth t 100)))
+    (is (= (+ 100 target -1) (nth t (+ 100 target -1))))
+    (is (= (+ 100 target) (nth t (+ 100 target))))
+    (is (= (+ 100 (* 2 target) -1) (nth t (+ 100 (* 2 target) -1))))
+    (is (= (+ 100 (* 2 target)) (nth t (+ 100 (* 2 target)))))
+    (is (= (+ 100 (* 2 target) 16) (nth t (+ 100 (* 2 target) 16))))
+    (is (= :nope (nth t (+ 100 (* 2 target) 17) :nope)))))
+
+
+(defn- rope-root-of [^ordered_collections.types.rope.Rope r]
+  (.-root r))
+
+(defspec prop-chunk-shape-after-edits 50
+  (prop/for-all [xs  (gen/vector gen/small-integer 0 200)
+                 ops tu/gen-rope-ops]
+    (let [r    (reduce apply-rope-op (oc/rope xs) ops)
+          root (rope-root-of r)]
+      (ropetree/invariant-valid? root))))
+
+(defspec prop-csi-after-individual-ops 100
+  (prop/for-all [xs (gen/vector gen/small-integer 10 100)]
+    (let [r (oc/rope xs)
+          root (rope-root-of r)]
+      (and
+        ;; Construction
+        (ropetree/invariant-valid? root)
+        ;; Concat
+        (ropetree/invariant-valid?
+          (rope-root-of (oc/rope-concat r (oc/rope (take 5 xs)))))
+        ;; Split
+        (let [[l rr] (oc/rope-split r (quot (count xs) 2))]
+          (and (ropetree/invariant-valid? (rope-root-of l))
+               (ropetree/invariant-valid? (rope-root-of rr))))
+        ;; Subrope
+        (ropetree/invariant-valid?
+          (rope-root-of (oc/rope-sub r 1 (dec (count xs)))))
+        ;; Insert
+        (ropetree/invariant-valid?
+          (rope-root-of (oc/rope-insert r 3 [:x :y :z])))
+        ;; Splice
+        (ropetree/invariant-valid?
+          (rope-root-of (oc/rope-splice r 2 5 [:a :b])))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Large-Scale Property Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-large-edit-sequences 50
+  (prop/for-all [xs  (gen/vector gen/small-integer 200 600)
+                 ops (gen-rope-ops 100 600)]
+    (let [r (reduce apply-full-rope-op (oc/rope xs) ops)
+          v (reduce apply-full-vector-op (vec xs) ops)]
+      (and (= v (into [] r))
+           (ropetree/invariant-valid? (rope-root-of r))))))
+
+(defspec prop-hash-equality-with-vector 100
+  (prop/for-all [xs (gen/vector gen/small-integer 0 500)]
+    (let [r (oc/rope xs)]
+      (and (= r (vec xs))
+           (= (vec xs) r)
+           (= (hash r) (hash (vec xs)))))))
+
+(defspec prop-reduce-matches-vector 100
+  (prop/for-all [xs (gen/vector gen/small-integer 1 500)]
+    (let [r (oc/rope xs)
+          v (vec xs)]
+      (and (= (reduce + 0 r) (reduce + 0 v))
+           (= (reduce conj [] r) (reduce conj [] v))))))
+
+(defspec prop-seq-reduce-consistency 100
+  (prop/for-all [xs (gen/vector gen/small-integer 1 2000)]
+    (let [r (oc/rope xs)]
+      ;; seq and reduce must agree with each other
+      (= (reduce conj [] r)
+         (into [] (seq r))))))
+
+(defspec prop-seq-walk-matches-vector 100
+  (prop/for-all [xs (gen/vector gen/small-integer 1 2000)]
+    (let [r (oc/rope xs)]
+      ;; Walk the RopeSeq via .next chain, element by element
+      (loop [s (seq r), v (seq xs)]
+        (cond
+          (and (nil? s) (nil? v)) true
+          (or (nil? s) (nil? v))  false
+          (not= (first s) (first v)) false
+          :else (recur (next s) (next v)))))))
+
+(defspec prop-rseq-walk-matches-vector 100
+  (prop/for-all [xs (gen/vector gen/small-integer 1 2000)]
+    (let [r (oc/rope xs)
+          v (vec xs)]
+      ;; Walk the RopeSeqReverse via .next chain
+      (loop [s (rseq r), v (rseq v)]
+        (cond
+          (and (nil? s) (nil? v)) true
+          (or (nil? s) (nil? v))  false
+          (not= (first s) (first v)) false
+          :else (recur (next s) (next v)))))))
+
+(defspec prop-conj-pop-round-trip 100
+  (prop/for-all [xs (gen/vector gen/small-integer 0 300)]
+    (let [r (reduce conj (oc/rope) xs)
+          popped (reduce (fn [r _] (pop r)) r (range (min 10 (count xs))))]
+      (and (= (vec r) xs)
+           (= (count popped) (max 0 (- (count xs) (min 10 (count xs)))))))))
+
+(defspec prop-transient-round-trip 100
+  (prop/for-all [xs (gen/vector gen/small-integer 0 1000)]
+    (let [r (persistent! (reduce conj! (transient (oc/rope)) xs))]
+      (and (= (vec xs) (into [] r))
+           (= (count xs) (count r))
+           (ropetree/invariant-valid? (rope-root-of r))))))
+
+(defspec prop-transient-live-nth-matches-vector 50
+  (prop/for-all [base  (gen/vector gen/small-integer 0 300)
+                 extra (gen/vector gen/small-integer 0 2000)]
+    (let [t    (reduce conj! (transient (oc/rope base)) extra)
+          v    (vec (concat base extra))
+          n    (count v)
+          idxs (if (zero? n)
+                 []
+                 (distinct (concat [0 (dec n)]
+                             (range 0 n (max 1 (quot n 25))))))]
+      (and (= n (count t))
+           (every? #(= (nth t %) (nth v %)) idxs)
+           (= :nope (nth t n :nope))))))
+
+(defspec prop-concat-all-matches-into 50
+  ;; Mix of tiny (1-5), undersized (<min), valid (min-target), and
+  ;; target-sized chunks to exercise chunks->root-csi boundary merging
+  (prop/for-all [chunks (gen/vector
+                          (gen/one-of
+                            [(gen/vector gen/small-integer 1 5)      ;; tiny
+                             (gen/vector gen/small-integer 0 100)    ;; undersized
+                             (gen/vector gen/small-integer 128 256)  ;; valid
+                             (gen/vector gen/small-integer 256 256)]);; exactly target
+                          1 30)]
+    (let [ropes  (mapv oc/rope chunks)
+          result (apply oc/rope-concat ropes)
+          expected (vec (apply concat chunks))]
+      (and (= expected (into [] result))
+           (ropetree/invariant-valid? (rope-root-of result))))))
+
+(defspec prop-fold-matches-reduce 50
+  (prop/for-all [xs (gen/vector gen/small-integer 0 4000)
+                 threshold (gen/elements [1 2 3 4 8 16 31 32 63 64 65 127 128 129 255 256 257 511 512 1024 4096])]
+    (let [r (oc/rope xs)]
+      (and
+        ;; Commutative: sum
+        (= (reduce + 0 r)
+           (r/fold threshold + + r))
+        ;; Non-commutative: ordered collection into vector
+        ;; fold with into must produce the same ordered result
+        (= (reduce conj [] r)
+           (r/fold threshold into conj r))
+        ;; Map-building workload with nontrivial combine/reduce
+        (= (reduce (fn [m x] (update m (mod (long x) 17) (fnil inc 0))) {} r)
+           (r/fold threshold
+             (fn ([] {}) ([m1 m2] (merge-with + m1 m2)))
+             (fn [m x] (update m (mod (long x) 17) (fnil inc 0)))
+             r))))))
+
+(defspec prop-metadata-preserved 100
+  (prop/for-all [xs (gen/vector gen/small-integer 10 100)]
+    (let [m {:tag :test}
+          r (with-meta (oc/rope xs) m)]
+      (and (= m (meta r))
+           (= m (meta (oc/rope-concat r (oc/rope [99]))))
+           (= m (meta (first (oc/rope-split r 5))))
+           (= m (meta (oc/rope-sub r 2 8)))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Multi-Chunk Scale and Structural Integrity
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- rope-tree-healthy?
+  "Check that the rope root satisfies both CSI and WBT balance."
+  [root]
+  (and (ropetree/invariant-valid? root)
+       (or (nil? root)
+           (ordered-collections.kernel.tree/node-healthy? root))))
+
+(defspec prop-multi-chunk-edit-sequences 50
+  ;; Inputs large enough to span many chunks; indices scale to full range
+  (prop/for-all [xs  (gen/vector gen/small-integer 2000 4000)
+                 ops (gen-rope-ops 120 4000)]
+    (let [r (reduce apply-full-rope-op (oc/rope xs) ops)
+          v (reduce apply-full-vector-op (vec xs) ops)]
+      (and (= v (into [] r))
+           (rope-tree-healthy? (rope-root-of r))))))
+
+(defspec prop-nth-matches-vector 100
+  (prop/for-all [xs (gen/vector gen/small-integer 1 2000)]
+    (let [r (oc/rope xs)
+          v (vec xs)
+          n (count xs)
+          ;; Check every 50th index plus first and last
+          idxs (distinct (concat [0 (dec n)]
+                           (range 0 n (max 1 (quot n 20)))))]
+      (every? #(= (nth r %) (nth v %)) idxs))))
+
+(defspec prop-assoc-matches-vector 100
+  (prop/for-all [xs (gen/vector gen/small-integer 1 500)
+                 i  (gen/choose 0 499)
+                 v  gen/small-integer]
+    (let [n (count xs)]
+      (if (< i n)
+        (= (assoc (vec xs) i v)
+           (vec (assoc (oc/rope xs) i v)))
+        true))))
+
+(defspec prop-rope-str-matches-apply-str 100
+  (prop/for-all [xs (gen/vector (gen/elements (seq "abcdefghij ")) 0 500)]
+    (let [r (oc/rope xs)]
+      (= (apply str xs)
+         (oc/rope-str r)))))
+
+(defspec prop-into-vec-materializes 100
+  (prop/for-all [xs (gen/vector gen/small-integer 0 2000)]
+    (let [r (oc/rope xs)
+          v (into [] r)]
+      (and (instance? clojure.lang.PersistentVector v)
+           (= xs v)))))
+
+(defspec prop-concat-mixed-sizes 50
+  (prop/for-all [left  (gen/vector gen/small-integer 0 2000)
+                 right (gen/vector gen/small-integer 0 2000)]
+    (let [result (oc/rope-concat (oc/rope left) (oc/rope right))
+          root   (rope-root-of result)]
+      (and (= (into (vec left) right) (into [] result))
+           (rope-tree-healthy? root)))))
+
+(defspec prop-transient-many-flushes 50
+  ;; Large enough to exercise many chunk flushes
+  (prop/for-all [xs (gen/vector gen/small-integer 5000 10000)]
+    (let [r (persistent! (reduce conj! (transient (oc/rope)) xs))]
+      (and (= (vec xs) (into [] r))
+           (rope-tree-healthy? (rope-root-of r))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; IFn Invocation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-ifn-invocation
+  (let [r (oc/rope [10 20 30 40 50])]
+    (is (= 10 (r 0)))
+    (is (= 30 (r 2)))
+    (is (= 50 (r 4)))
+    (is (= :nope (r 5 :nope)))
+    (is (nil? (r 99)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Persistent Sharing
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-persistent-sharing
+  (testing "split halves are independent"
+    (let [r (oc/rope (range 100))
+          [left right] (oc/rope-split r 50)
+          left'  (oc/rope-splice left 10 20 [:x])
+          right' (oc/rope-insert right 0 [:y])]
+      ;; Originals unchanged
+      (is (= (vec (range 100)) (vec r)))
+      (is (= (vec (range 50)) (vec left)))
+      (is (= (vec (range 50 100)) (vec right)))
+      ;; Edits only affect their target
+      (is (= 41 (count left')))
+      (is (= 51 (count right')))))
+  (testing "sub shares structure but edits are independent"
+    (let [r   (oc/rope (range 1000))
+          sub (oc/rope-sub r 100 200)
+          sub' (assoc sub 50 :replaced)]
+      (is (= 500 (nth r 500)))
+      (is (= :replaced (nth sub' 50)))
+      (is (= 150 (nth sub 50))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Empty Edge Cases
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest rope-empty-operations
+  (let [e (oc/rope)]
+    (testing "concat with empty"
+      (is (= [1 2 3] (vec (oc/rope-concat e (oc/rope [1 2 3])))))
+      (is (= [1 2 3] (vec (oc/rope-concat (oc/rope [1 2 3]) e)))))
+    (testing "split empty"
+      (let [[l r] (oc/rope-split e 0)]
+        (is (= [] (vec l)))
+        (is (= [] (vec r)))))
+    (testing "sub of empty"
+      (is (= [] (vec (oc/rope-sub e 0 0)))))
+    (testing "insert into empty"
+      (is (= [:a] (vec (oc/rope-insert e 0 [:a])))))
+    (testing "empty from empty"
+      (is (= [] (vec (empty e)))))
+    (testing "conj to empty"
+      (is (= [42] (vec (conj e 42)))))))
+
+(deftest rope-single-element
+  (let [r (oc/rope [42])]
+    (is (= 1 (count r)))
+    (is (= 42 (nth r 0)))
+    (is (= 42 (peek r)))
+    (is (= [] (vec (pop r))))
+    (let [[l rr] (oc/rope-split r 0)]
+      (is (= [] (vec l)))
+      (is (= [42] (vec rr))))
+    (let [[l rr] (oc/rope-split r 1)]
+      (is (= [42] (vec l)))
+      (is (= [] (vec rr))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Mixed Element Types
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-mixed-element-types 100
+  (prop/for-all [xs (gen/vector gen/any-printable-equatable 0 200)]
+    (let [r (oc/rope xs)]
+      (and (= (count xs) (count r))
+           (= (vec xs) (vec r))
+           (= (hash (vec xs)) (hash r))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; EDN Round-Trip Property
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-edn-round-trip 100
+  (prop/for-all [xs (gen/vector gen/small-integer 0 500)]
+    (let [r  (oc/rope xs)
+          rt (clojure.edn/read-string
+               {:readers {'ordered/rope oc/rope}}
+               (pr-str r))]
+      (and (= (vec r) (vec rt))
+           (= (count r) (count rt))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Conj/Pop CSI and WBT Health
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defspec prop-conj-pop-preserves-health 50
+  (prop/for-all [xs (gen/vector gen/small-integer 0 2000)]
+    (let [r (reduce conj (oc/rope) xs)
+          popped (reduce (fn [r _] (if (pos? (count r)) (pop r) r))
+                   r (range (min 500 (count xs))))]
+      (and (rope-tree-healthy? (rope-root-of r))
+           (rope-tree-healthy? (rope-root-of popped))))))
+
+(defspec prop-adversarial-chunk-boundaries 50
+  ;; Build ropes at CSI boundary sizes — mostly multi-chunk (1K+)
+  ;; with a few small edge cases
+  (prop/for-all [size (gen/frequency
+                        [[1 (gen/return 1)]
+                         [1 (gen/return ropetree/+min-chunk-size+)]
+                         [1 (gen/return ropetree/+target-chunk-size+)]
+                         [2 (gen/return (inc ropetree/+target-chunk-size+))]
+                         [3 (gen/return (* 3 ropetree/+target-chunk-size+))]
+                         [3 (gen/return (* 5 ropetree/+target-chunk-size+))]
+                         [4 (gen/return (inc (* 4 ropetree/+target-chunk-size+)))]
+                         [5 (gen/return (* 10 ropetree/+target-chunk-size+))]])]
+    (let [r   (oc/rope (range size))
+          mid (quot size 2)
+          v   (vec (range size))]
+      (and
+        ;; Construction
+        (rope-tree-healthy? (rope-root-of r))
+        (= v (vec r))
+        ;; Split at midpoint
+        (let [[l rr] (oc/rope-split r mid)]
+          (and (= (subvec v 0 mid) (vec l))
+               (= (subvec v mid) (vec rr))
+               (rope-tree-healthy? (rope-root-of l))
+               (rope-tree-healthy? (rope-root-of rr))))
+        ;; Concat two boundary-sized ropes
+        (let [c (oc/rope-concat r (oc/rope (range size)))]
+          (and (= (into v (range size)) (vec c))
+               (rope-tree-healthy? (rope-root-of c))))
+        ;; Sub at boundary positions
+        (let [s (oc/rope-sub r (min 1 mid) (max mid (dec size)))]
+          (rope-tree-healthy? (rope-root-of s)))
+        ;; Splice at midpoint
+        (or (<= size 2)
+            (let [sp (oc/rope-splice r (min 1 mid) (max mid (dec size)) [:x])]
+              (rope-tree-healthy? (rope-root-of sp))))))))
+
+(defspec prop-large-adversarial-edits 30
+  ;; Large ropes (5K-50K) with many operations hitting the full index range.
+  ;; Verifies correctness AND structural health after a long edit sequence.
+  (prop/for-all [size (gen/frequency
+                        [[3 (gen/choose 5000 10000)]
+                         [4 (gen/choose 10000 25000)]
+                         [3 (gen/choose 25000 50000)]])
+                 ops  (gen/vector (gen-rope-op 50000) 100 200)]
+    (let [r (reduce apply-full-rope-op (oc/rope (range size)) ops)
+          v (reduce apply-full-vector-op (vec (range size)) ops)]
+      (and (= v (vec r))
+           (rope-tree-healthy? (rope-root-of r))))))
+
+(defspec prop-split-at-every-chunk-boundary 30
+  ;; Build a large rope, then split at positions that land exactly on
+  ;; chunk boundaries (multiples of target) and verify both halves.
+  (prop/for-all [nchunks (gen/choose 4 40)]
+    (let [size (* nchunks ropetree/+target-chunk-size+)
+          r    (oc/rope (range size))
+          v    (vec (range size))]
+      (every? identity
+        (for [i (range 1 nchunks)]
+          (let [pos (* i ropetree/+target-chunk-size+)
+                [l rr] (oc/rope-split r pos)]
+            (and (= (subvec v 0 pos) (vec l))
+                 (= (subvec v pos) (vec rr))
+                 (rope-tree-healthy? (rope-root-of l))
+                 (rope-tree-healthy? (rope-root-of rr)))))))))
+
+(defspec prop-repeated-split-concat-round-trip 50
+  ;; Split a large rope into many pieces, then concat them back.
+  ;; The result must equal the original.
+  (prop/for-all [size (gen/choose 2000 20000)
+                 nsplits (gen/choose 3 15)]
+    (let [r    (oc/rope (range size))
+          ;; Split into nsplits pieces at evenly spaced positions
+          positions (mapv #(long (* size (/ (double (inc %)) (inc nsplits))))
+                     (range nsplits))
+          pieces (loop [remaining r, positions positions, acc []]
+                   (if (empty? positions)
+                     (conj acc remaining)
+                     (let [[l rr] (oc/rope-split remaining (first positions))]
+                       (recur rr
+                         (mapv #(- % (first positions)) (rest positions))
+                         (conj acc l)))))
+          ;; Concat all pieces back together
+          reassembled (reduce oc/rope-concat pieces)]
+      (and (= (vec (range size)) (vec reassembled))
+           (rope-tree-healthy? (rope-root-of reassembled))))))
+
+(defspec prop-nested-sub-correctness 50
+  ;; Take a large rope, sub a window, sub a sub-window, verify at each step
+  (prop/for-all [size (gen/choose 5000 20000)]
+    (let [r  (oc/rope (range size))
+          v  (vec (range size))
+          q1 (quot size 4)
+          q3 (* 3 q1)
+          s1 (oc/rope-sub r q1 q3)
+          v1 (subvec v q1 q3)
+          inner-size (- q3 q1)
+          iq1 (quot inner-size 4)
+          iq3 (* 3 iq1)
+          s2 (oc/rope-sub s1 iq1 iq3)
+          v2 (subvec v1 iq1 iq3)]
+      (and (= v1 (vec s1))
+           (= v2 (vec s2))
+           (rope-tree-healthy? (rope-root-of s1))
+           (rope-tree-healthy? (rope-root-of s2))))))
+
+(defspec prop-interleaved-insert-remove 50
+  ;; Alternating inserts and removes at random positions on a large rope.
+  ;; This stresses CSI normalization under mixed growth/shrinkage.
+  (prop/for-all [size (gen/choose 3000 10000)
+                 ops  (gen/vector
+                        (gen/one-of
+                          [(gen/fmap (fn [[i x]] [:insert i [x]])
+                             (gen/tuple (gen/choose 0 10000) gen/small-integer))
+                           (gen/fmap (fn [[a b]] [:remove (min a b) (max a b)])
+                             (gen/tuple (gen/choose 0 10000) (gen/choose 0 10000)))])
+                        100 200)]
+    (let [apply-op (fn [[coll-r coll-v] [op a b]]
+                     (let [n (count coll-r)]
+                       (case op
+                         :insert
+                         (let [i (min a n)]
+                           [(oc/rope-insert coll-r i b)
+                            (vec (concat (subvec coll-v 0 i) b (subvec coll-v i)))])
+                         :remove
+                         (let [lo (min a n)
+                               hi (min b n)
+                               lo (min lo hi)
+                               hi (max lo hi)]
+                           [(oc/rope-remove coll-r lo hi)
+                            (vec (concat (subvec coll-v 0 lo) (subvec coll-v hi)))]))))
+          [r v] (reduce apply-op [(oc/rope (range size)) (vec (range size))] ops)]
+      (and (= v (vec r))
+           (rope-tree-healthy? (rope-root-of r))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Coverage Gap Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; splice-root edge cases: empty mid, empty left, empty right
+(deftest rope-splice-root-edge-cases
+  (let [r (oc/rope (range 100))]
+    (testing "remove-only splice (empty mid)"
+      (is (= (vec (concat (range 10) (range 50 100)))
+            (vec (oc/rope-remove r 10 50)))))
+    (testing "splice at start (left is empty)"
+      (is (= (into [:x :y] (range 10 100))
+            (vec (oc/rope-splice r 0 10 [:x :y])))))
+    (testing "splice at end (right is empty)"
+      (is (= (into (vec (range 90)) [:x :y])
+            (vec (oc/rope-splice r 90 100 [:x :y])))))
+    (testing "remove everything"
+      (is (= [] (vec (oc/rope-remove r 0 100)))))
+    (testing "insert into empty"
+      (is (= [:a :b] (vec (oc/rope-insert (oc/rope) 0 [:a :b])))))
+    (testing "splice replacing everything"
+      (is (= [:z] (vec (oc/rope-splice r 0 100 [:z])))))))
+
+;; merge-boundary cascade: concatenating tiny ropes forces one-more-neighbor pull
+(deftest rope-merge-boundary-cascade
+  (testing "concatenating many single-element ropes"
+    (let [r (reduce oc/rope-concat (map #(oc/rope [%]) (range 50)))]
+      (is (= (range 50) (vec r)))
+      (is (ropetree/invariant-valid? (rope-root-of r)))))
+  (testing "concat two very small ropes"
+    (let [a (oc/rope [1 2])
+          b (oc/rope [3 4])
+          c (oc/rope-concat a b)]
+      (is (= [1 2 3 4] (vec c)))
+      (is (ropetree/invariant-valid? (rope-root-of c)))))
+  (testing "concat where boundary chunks are both undersized"
+    ;; Build a rope, split to get a runt, then concat with another runt
+    (let [r   (oc/rope (range 1000))
+          [l _] (oc/rope-split r 3)    ;; l has 3 elements (runt)
+          [_ rr] (oc/rope-split r 997) ;; rr has 3 elements (runt)
+          c   (oc/rope-concat l rr)]
+      (is (= (into (vec (range 3)) (range 997 1000)) (vec c)))
+      (is (ropetree/invariant-valid? (rope-root-of c))))))
+
+;; rope-concat with mixed Rope and non-Rope collections
+(deftest rope-concat-mixed-types
+  (is (= [1 2 3 4 5 6]
+        (vec (oc/rope-concat (oc/rope [1 2]) [3 4] (oc/rope [5 6])))))
+  (is (= (range 100)
+        (vec (apply oc/rope-concat
+               (map #(if (even? %)
+                       (oc/rope (range (* % 10) (* (inc %) 10)))
+                       (vec (range (* % 10) (* (inc %) 10))))
+                 (range 10)))))))
+
+;; rope-chunks-reverse property test
+(defspec prop-chunks-reverse-matches-forward 100
+  (prop/for-all [xs (gen/vector gen/small-integer 1 2000)]
+    (let [r (oc/rope xs)]
+      (= (reverse (map vec (oc/rope-chunks r)))
+         (map vec (oc/rope-chunks-reverse r))))))
+
+;; rope-chunk-count property test
+(defspec prop-chunk-count-matches-chunks 100
+  (prop/for-all [xs (gen/vector gen/small-integer 0 2000)]
+    (let [r (oc/rope xs)]
+      (= (oc/rope-chunk-count r)
+         (count (vec (oc/rope-chunks r)))))))
+
+;; normalize-root: full rechunk produces valid CSI
+(deftest rope-normalize-root
+  (testing "normalize-root on a well-formed rope is idempotent"
+    (let [root (rope-root-of (oc/rope (range 1000)))
+          normalized (ropetree/normalize-root root)]
+      (is (= (vec (range 1000))
+            (vec (oc/rope (range 1000)))))
+      (is (ropetree/invariant-valid? normalized))))
+  (testing "normalize-root on an artificially degraded root restores CSI"
+    ;; Build a root with many tiny chunks by raw construction
+    (let [tiny-chunks (mapv vector (range 50))
+          bad-root    (ropetree/chunks->root tiny-chunks)
+          fixed       (ropetree/normalize-root bad-root)]
+      (is (= (range 50) (vec (map first (ropetree/root->chunks bad-root)))))
+      (is (ropetree/invariant-valid? fixed))
+      (is (= (range 50)
+            (reduce into [] (ropetree/root->chunks fixed))))))
+  (testing "normalize-root on nil returns nil"
+    (is (nil? (ropetree/normalize-root nil)))))
+
+;; RopeSeqReverse count fallback (cnt is nil after .next chains)
+(deftest rope-seq-reverse-count-after-next
+  (let [r  (oc/rope (range 20))
+        rs (rseq r)
+        rs2 (next rs)
+        rs5 (nth (iterate next rs) 5)]
+    (is (= 20 (count rs)))
+    (is (= 19 (count rs2)))
+    (is (= 15 (count rs5)))))
+
+;; RopeSeq count after .next chains
+(deftest rope-seq-count-after-next
+  (let [r (oc/rope (range 100))
+        s (seq r)
+        s5 (nth (iterate next s) 5)
+        s50 (nth (iterate next s) 50)]
+    (is (= 100 (count s)))
+    (is (= 95 (count s5)))
+    (is (= 50 (count s50)))))
+
+;; RopeSeq reduce via .next-obtained seq
+(deftest rope-seq-reduce-from-mid
+  (let [r (oc/rope (range 100))
+        s (nth (iterate next (seq r)) 10)]
+    (is (= (reduce + (range 10 100))
+          (reduce + s)))))
+
+;; ensure-right-fringe actually fires
+(deftest rope-fringe-repair
+  (testing "split inside a chunk creates undersized fringe that gets repaired"
+    (let [r (oc/rope (range 1000))
+          ;; Split at a position inside a chunk, not at a chunk boundary
+          [l rr] (oc/rope-split r 5)]
+      (is (= (range 5) (vec l)))
+      (is (= (range 5 1000) (vec rr)))
+      (is (ropetree/invariant-valid? (rope-root-of l)))
+      (is (ropetree/invariant-valid? (rope-root-of rr)))))
+  (testing "subrope creating small fringes on both sides"
+    (let [r (oc/rope (range 2000))
+          s (oc/rope-sub r 3 1997)]
+      (is (= (vec (range 3 1997)) (vec s)))
+      (is (ropetree/invariant-valid? (rope-root-of s))))))
+
+;; rope-peek-right and rope-pop-right coverage
+(deftest rope-peek-pop-coverage
+  (let [r (oc/rope (range 500))]
+    (is (= 499 (peek r)))
+    (is (= 498 (peek (pop r))))
+    (is (= 499 (count (pop r))))
+    ;; Pop down to a single element
+    (let [single (reduce (fn [r _] (pop r)) (oc/rope [1 2 3]) (range 2))]
+      (is (= [1] (vec single)))
+      (is (= 1 (peek single))))))
+
+;; rope-remove-root is just splice-root with nil mid
+(deftest rope-remove-root-delegation
+  (let [r (oc/rope (range 100))]
+    (is (= (vec (oc/rope-remove r 10 20))
+          (vec (concat (range 10) (range 20 100)))))))
+
+;; rope-fold kernel function directly
+(deftest rope-fold-kernel
+  (let [root (rope-root-of (oc/rope (range 10000)))]
+    (is (= (reduce + (range 10000))
+          (ropetree/rope-fold root 512 + +)))))
diff --git a/test/ordered_collections/rope_tuning_bench.clj b/test/ordered_collections/rope_tuning_bench.clj
new file mode 100644
index 0000000..d71287b
--- /dev/null
+++ b/test/ordered_collections/rope_tuning_bench.clj
@@ -0,0 +1,307 @@
+(ns ordered-collections.rope-tuning-bench
+  "Systematic benchmark for rope chunk-size tuning.
+
+   Measures every rope operation across candidate chunk sizes to find the
+   optimal target/min pair. Each candidate rebuilds the test data at that
+   chunk size, then benchmarks all key operations against PersistentVector.
+
+   Usage:
+     lein bench-rope-tuning           ; Default sizes
+     lein bench-rope-tuning --quick   ; Fast feedback
+
+   This is the rope analogue of bench-parallel: it finds the chunk size
+   that gives the best overall profile rather than guessing."
+  (:require [ordered-collections.bench-utils :as bu :refer [has-flag?]]
+            [ordered-collections.kernel.rope :as ropetree]
+            [ordered-collections.kernel.node :as node :refer [leaf leaf?]]
+            [ordered-collections.kernel.tree :as tree]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Benchmark Infrastructure
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-op
+  "Benchmark f, returning mean time in microseconds."
+  [f warmup-iters bench-iters]
+  (dotimes [_ warmup-iters] (f))
+  (let [start (System/nanoTime)]
+    (dotimes [_ bench-iters] (f))
+    (/ (- (System/nanoTime) start) (* bench-iters 1000.0))))
+
+(defn bench-op-samples
+  "Benchmark f multiple times and return summary stats."
+  [f warmup-iters bench-iters sample-runs]
+  (let [samples (vec (repeatedly sample-runs #(bench-op f warmup-iters bench-iters)))
+        sorted  (sort samples)
+        n       (count sorted)]
+    {:median  (nth sorted (quot n 2))
+     :mean    (/ (reduce + sorted) n)
+     :low     (first sorted)
+     :high    (last sorted)
+     :samples samples}))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Rope Construction at Arbitrary Chunk Size
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- rope-node-create-fn
+  "Build a rope-node-create function for a given chunk size."
+  []
+  (fn [chunk _ l r]
+    (node/->SimpleNode chunk
+      (+ (count chunk) (ropetree/rope-size l) (ropetree/rope-size r))
+      l r
+      (+ 1 (tree/node-size l) (tree/node-size r)))))
+
+(defn build-rope-root
+  "Build a rope root from a collection using a specific target chunk size."
+  [coll ^long target]
+  (let [chunks (mapv vec (partition-all target coll))]
+    (ropetree/chunks->root chunks)))
+
+(defn build-vector
+  [coll]
+  (vec coll))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Individual Operation Benchmarks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-nth-for-chunk-size
+  "Benchmark 1000 random nth lookups."
+  [root v n opts]
+  (let [rng  (java.util.Random. 42)
+        idxs (vec (repeatedly 1000 #(.nextInt rng (int n))))]
+    {:rope   (bench-op-samples
+               #(dotimes [i 1000]
+                  (ropetree/rope-nth root (nth idxs i)))
+               (:warmup opts) (:iters opts) (:samples opts))
+     :vector (bench-op-samples
+               #(dotimes [i 1000]
+                  (nth v (nth idxs i)))
+               (:warmup opts) (:iters opts) (:samples opts))}))
+
+(defn bench-reduce-for-chunk-size
+  "Benchmark reduce + over all elements."
+  [root v opts]
+  {:rope   (bench-op-samples
+             #(ropetree/rope-reduce + 0 root)
+             (:warmup opts) (:iters opts) (:samples opts))
+   :vector (bench-op-samples
+             #(reduce + 0 v)
+             (:warmup opts) (:iters opts) (:samples opts))})
+
+(defn bench-split-for-chunk-size
+  "Benchmark split at midpoint."
+  [root v n opts]
+  (let [mid (quot n 2)]
+    {:rope   (bench-op-samples
+               #(ropetree/rope-split-at root mid)
+               (:warmup opts) (:iters opts) (:samples opts))
+     :vector (bench-op-samples
+               #(do [(subvec v 0 mid) (subvec v mid)] nil)
+               (:warmup opts) (:iters opts) (:samples opts))}))
+
+(defn bench-splice-for-chunk-size
+  "Benchmark splice at midpoint."
+  [root v n opts]
+  (let [mid   (quot n 2)
+        start (max 0 (- mid 16))
+        end   (min n (+ mid 16))
+        ins   (vec (range 32))
+        ins-root (build-rope-root ins ropetree/+target-chunk-size+)]
+    {:rope   (bench-op-samples
+               #(ropetree/rope-splice-root root start end ins-root)
+               (:warmup opts) (:iters opts) (:samples opts))
+     :vector (bench-op-samples
+               #(vec (concat (subvec v 0 start) ins (subvec v end)))
+               (:warmup opts) (:iters opts) (:samples opts))}))
+
+(defn bench-concat-for-chunk-size
+  "Benchmark bulk concat of pre-built pieces."
+  [pieces-root vec-pieces opts]
+  {:rope   (bench-op-samples
+             #(reduce ropetree/rope-concat nil pieces-root)
+             (:warmup opts) (:iters opts) (:samples opts))
+   :vector (bench-op-samples
+             #(reduce into [] vec-pieces)
+             (:warmup opts) (:iters opts) (:samples opts))})
+
+(defn bench-text-splice-for-chunk-size
+  "Benchmark splice of character data: rope vs String."
+  [root ^String s n opts]
+  (let [mid   (quot n 2)
+        start (max 0 (- mid 16))
+        end   (min n (+ mid 16))
+        ins   (vec (seq "REPLACED-CONTENT!!!!!!!!!!!!!!!!"))
+        ins-s "REPLACED-CONTENT!!!!!!!!!!!!!!!!"
+        ins-root (build-rope-root ins ropetree/+target-chunk-size+)]
+    {:rope   (bench-op-samples
+               #(ropetree/rope-splice-root root start end ins-root)
+               (:warmup opts) (:iters opts) (:samples opts))
+     :string (bench-op-samples
+               #(str (subs s 0 start) ins-s (subs s end))
+               (:warmup opts) (:iters opts) (:samples opts))}))
+
+(defn bench-text-split-for-chunk-size
+  "Benchmark split of character data: rope vs String."
+  [root ^String s n opts]
+  (let [mid (quot n 2)]
+    {:rope   (bench-op-samples
+               #(ropetree/rope-split-at root mid)
+               (:warmup opts) (:iters opts) (:samples opts))
+     :string (bench-op-samples
+               #(do [(subs s 0 mid) (subs s mid)] nil)
+               (:warmup opts) (:iters opts) (:samples opts))}))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Chunk Size Sweep
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def default-chunk-candidates [64 128 256 512 1024])
+(def default-sizes [10000 100000 500000])
+
+(defn- random-char-string ^String [^long n]
+  (let [alphabet "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+        sb (StringBuilder. n)]
+    (dotimes [_ n]
+      (.append sb (.charAt alphabet (rand-int (.length alphabet)))))
+    (.toString sb)))
+
+(defn bench-chunk-size-at-n
+  "Run all operations for a given chunk size and collection size."
+  [^long n ^long target opts]
+  (let [data       (range n)
+        root       (build-rope-root data target)
+        v          (build-vector data)
+        ;; Build pieces for concat bench
+        pieces     (->> data (partition-all target) (mapv vec))
+        piece-roots (mapv #(build-rope-root % target) pieces)
+        ;; Text data for string comparison
+        text       (random-char-string n)
+        text-root  (build-rope-root (vec (seq text)) target)]
+    (print ".")
+    (flush)
+    {:chunk-size   target
+     :n            n
+     :chunks       (count pieces)
+     :nth          (bench-nth-for-chunk-size root v n opts)
+     :reduce       (bench-reduce-for-chunk-size root v opts)
+     :split        (bench-split-for-chunk-size root v n opts)
+     :splice       (bench-splice-for-chunk-size root v n opts)
+     :concat       (bench-concat-for-chunk-size piece-roots pieces opts)
+     :text-splice  (bench-text-splice-for-chunk-size text-root text n opts)
+     :text-split   (bench-text-split-for-chunk-size text-root text n opts)}))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Reporting
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- ratio [rope-stats vec-stats]
+  (/ (:median vec-stats) (:median rope-stats)))
+
+(defn- fmt-ratio [r]
+  (if (>= r 1.0)
+    (format "%5.1fx" r)
+    (format "%5.2fx" r)))
+
+(defn- fmt-us [stats]
+  (bu/format-ns (* 1000 (:median stats))))
+
+(defn print-chunk-size-results
+  [results]
+  (println)
+  (println "═══════════════════════════════════════════════════════════════════════════════════════════")
+  (println "  ROPE CHUNK SIZE TUNING — vs Vector")
+  (println "  Each cell shows: rope median / ratio vs vector (>1x = rope wins)")
+  (println "═══════════════════════════════════════════════════════════════════════════════════════════")
+  (doseq [[n size-results] (sort-by key (group-by :n results))]
+    (println)
+    (printf "  N = %,d%n" n)
+    (println "  ┌────────────┬────────────────┬────────────────┬────────────────┬────────────────┬────────────────┐")
+    (println "  │ chunk size │     nth 1000   │     reduce     │     split      │     splice     │     concat     │")
+    (println "  ├────────────┼────────────────┼────────────────┼────────────────┼────────────────┼────────────────┤")
+    (doseq [{:keys [chunk-size nth reduce split splice concat]} (sort-by :chunk-size size-results)]
+      (printf "  │   %4d     │ %8s %5s │ %8s %5s │ %8s %5s │ %8s %5s │ %8s %5s │%n"
+        chunk-size
+        (fmt-us (:rope nth))       (fmt-ratio (ratio (:rope nth) (:vector nth)))
+        (fmt-us (:rope reduce))    (fmt-ratio (ratio (:rope reduce) (:vector reduce)))
+        (fmt-us (:rope split))     (fmt-ratio (ratio (:rope split) (:vector split)))
+        (fmt-us (:rope splice))    (fmt-ratio (ratio (:rope splice) (:vector splice)))
+        (fmt-us (:rope concat))    (fmt-ratio (ratio (:rope concat) (:vector concat)))))
+    (println "  └────────────┴────────────────┴────────────────┴────────────────┴────────────────┴────────────────┘")
+    (println (str "  vector baseline: nth=" (fmt-us (:vector (:nth (first size-results))))
+                  "  reduce=" (fmt-us (:vector (:reduce (first size-results))))
+                  "  split=" (fmt-us (:vector (:split (first size-results))))
+                  "  splice=" (fmt-us (:vector (:splice (first size-results))))
+                  "  concat=" (fmt-us (:vector (:concat (first size-results)))))))
+
+  (println)
+  (println "═══════════════════════════════════════════════════════════════════════════════════════════")
+  (println "  ROPE CHUNK SIZE TUNING — vs String (text workload)")
+  (println "  Each cell shows: rope median / ratio vs string (>1x = rope wins)")
+  (println "═══════════════════════════════════════════════════════════════════════════════════════════")
+  (doseq [[n size-results] (sort-by key (group-by :n results))]
+    (println)
+    (printf "  N = %,d chars%n" n)
+    (println "  ┌────────────┬────────────────┬────────────────┐")
+    (println "  │ chunk size │  text splice   │  text split    │")
+    (println "  ├────────────┼────────────────┼────────────────┤")
+    (doseq [{:keys [chunk-size text-splice text-split]} (sort-by :chunk-size size-results)]
+      (printf "  │   %4d     │ %8s %5s │ %8s %5s │%n"
+        chunk-size
+        (fmt-us (:rope text-splice))  (fmt-ratio (ratio (:rope text-splice) (:string text-splice)))
+        (fmt-us (:rope text-split))   (fmt-ratio (ratio (:rope text-split) (:string text-split)))))
+    (println "  └────────────┴────────────────┴────────────────┘")
+    (println (str "  string baseline: splice=" (fmt-us (:string (:text-splice (first size-results))))
+                  "  split=" (fmt-us (:string (:text-split (first size-results)))))))
+
+  (println)
+  (println "═══════════════════════════════════════════════════════════════════════════════════════════")
+  (printf "  Current chunk size: target=%d  min=%d%n"
+    ropetree/+target-chunk-size+ ropetree/+min-chunk-size+)
+  (println "═══════════════════════════════════════════════════════════════════════════════════════════"))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Runner
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn run-benchmark
+  [& {:keys [sizes chunk-candidates warmup iters samples]
+      :or {sizes default-sizes
+           chunk-candidates default-chunk-candidates
+           warmup 10
+           iters 30
+           samples 7}}]
+  (let [opts {:warmup warmup :iters iters :samples samples}]
+    (println "Rope chunk-size tuning benchmark")
+    (println "Chunk candidates:" chunk-candidates)
+    (println "Collection sizes:" sizes)
+    (println (format "Per-measurement: %d warmup, %d iters, %d samples" warmup iters samples))
+    (println)
+    (let [results (vec (for [n sizes, target chunk-candidates]
+                         (do
+                           (print (format "  chunk=%d N=%,d " target n))
+                           (flush)
+                           (let [r (bench-chunk-size-at-n n target opts)]
+                             (println)
+                             r))))]
+      (print-chunk-size-results results)
+      results)))
+
+(defn quick-bench []
+  (run-benchmark :sizes [10000 100000]
+                 :chunk-candidates [128 256 512]
+                 :warmup 5 :iters 15 :samples 5))
+
+(defn -main [& args]
+  (if (has-flag? args "--quick" "-q")
+    (quick-bench)
+    (run-benchmark))
+  (shutdown-agents))
diff --git a/test/ordered_collections/segment_tree_test.clj b/test/ordered_collections/segment_tree_test.clj
new file mode 100644
index 0000000..363c3e1
--- /dev/null
+++ b/test/ordered_collections/segment_tree_test.clj
@@ -0,0 +1,593 @@
+(ns ordered-collections.segment-tree-test
+  "Rigorous tests for SegmentTree - range aggregate queries with O(log n) updates."
+  (:require [clojure.test :refer [deftest testing is]]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [ordered-collections.test-utils :as tu]
+            [ordered-collections.core :as oc])
+  (:import [java.time Instant]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Reference implementations for testing
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- ref-range-sum
+  "Reference: sum values for keys in [lo, hi]."
+  [m lo hi]
+  (tu/ref-range-sum m lo hi))
+
+(defn- ref-range-min
+  "Reference: min value for keys in [lo, hi]."
+  [m lo hi]
+  (reduce min Long/MAX_VALUE (for [[k v] m :when (<= lo k hi)] v)))
+
+(defn- ref-range-max
+  "Reference: max value for keys in [lo, hi]."
+  [m lo hi]
+  (reduce max Long/MIN_VALUE (for [[k v] m :when (<= lo k hi)] v)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Construction
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest construction-empty
+  (let [st (oc/segment-tree + 0)]
+    (is (zero? (count st)))
+    (is (nil? (seq st)))
+    (is (= 0 (oc/aggregate st)))))
+
+(deftest construction-various-sizes
+  (doseq [n [1 2 10 100 1000 10000]]
+    (testing (str "N=" n)
+      (let [data (into {} (for [i (range n)] [i i]))
+            st   (oc/sum-tree data)]
+        (is (= n (count st)))
+        (is (= (reduce + (range n)) (oc/aggregate st)))))))
+
+(deftest construction-from-seq
+  (doseq [n [10 100 1000]]
+    (let [pairs (for [i (range n)] [i (* i 10)])
+          st    (oc/sum-tree pairs)]
+      (is (= n (count st)))
+      (is (= (* 10 (reduce + (range n))) (oc/aggregate st))))))
+
+(deftest construction-non-contiguous-indices
+  (doseq [n [10 100 1000]]
+    (testing (str "N=" n " sparse indices")
+      (let [;; Random indices with gaps
+            indices (sort (distinct (repeatedly n #(rand-int (* n 10)))))
+            data    (into {} (for [i indices] [i 1]))
+            st      (oc/sum-tree data)]
+        (is (= (count indices) (count st)))
+        (is (= (count indices) (oc/aggregate st)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Sum tree: range sum queries
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest sum-tree-aggregate
+  (doseq [n [10 100 1000 10000 100000]]
+    (testing (str "N=" n)
+      (let [data (into {} (for [i (range n)] [i i]))
+            st   (oc/sum-tree data)]
+        (is (= (reduce + (range n)) (oc/aggregate st)))))))
+
+(deftest sum-tree-range-queries
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n " random range queries")
+      (let [data (into {} (for [i (range n)] [i i]))
+            st   (oc/sum-tree data)]
+        ;; Random range queries
+        (dotimes [_ 500]
+          (let [lo (rand-int n)
+                hi (+ lo (rand-int (- n lo)))]
+            (is (= (ref-range-sum data lo hi)
+                   (oc/query st lo hi))
+                (str "Range [" lo ", " hi "]"))))))))
+
+(deftest sum-tree-single-element-queries
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n " single element queries")
+      (let [data (into {} (for [i (range n)] [i (* i 100)]))
+            st   (oc/sum-tree data)]
+        ;; Each single-element query should return the element
+        (doseq [i (take 100 (repeatedly #(rand-int n)))]
+          (is (= (* i 100) (oc/query st i i))))))))
+
+(deftest sum-tree-full-range
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n " full range")
+      (let [data (into {} (for [i (range n)] [i 1]))
+            st   (oc/sum-tree data)]
+        (is (= n (oc/query st 0 (dec n))))))))
+
+(deftest sum-tree-arithmetic-sequences
+  ;; Sum of i from a to b = (b-a+1)(a+b)/2
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n " arithmetic sequence")
+      (let [st (oc/sum-tree (into {} (for [i (range n)] [i i])))]
+        (dotimes [_ 100]
+          (let [lo (rand-int n)
+                hi (+ lo (rand-int (- n lo)))
+                expected (quot (* (- hi lo -1) (+ lo hi)) 2)]
+            (is (= expected (oc/query st lo hi)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Min tree: range minimum queries
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest min-tree-aggregate
+  (doseq [n [10 100 1000 10000]]
+    (testing (str "N=" n)
+      (let [data (into {} (for [i (range n)] [i (rand-int 10000)]))
+            st   (oc/min-tree data)]
+        (is (= (apply min (vals data)) (oc/aggregate st)))))))
+
+(deftest min-tree-range-queries
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n " random range queries")
+      (let [data (into {} (for [i (range n)] [i (rand-int 10000)]))
+            st   (oc/min-tree data)]
+        (dotimes [_ 500]
+          (let [lo (rand-int n)
+                hi (+ lo (rand-int (- n lo)))]
+            (is (= (ref-range-min data lo hi)
+                   (oc/query st lo hi))
+                (str "Range [" lo ", " hi "]"))))))))
+
+(deftest min-tree-with-known-minimum
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n " with known minimum location")
+      (let [min-idx (rand-int n)
+            data    (into {} (for [i (range n)]
+                               [i (if (= i min-idx) 0 1000)]))
+            st      (oc/min-tree data)]
+        ;; Full range should find 0
+        (is (= 0 (oc/query st 0 (dec n))))
+        ;; Range containing min-idx should find 0
+        (is (= 0 (oc/query st (max 0 (- min-idx 10)) (min (dec n) (+ min-idx 10)))))
+        ;; Range not containing min-idx should find 1000
+        (when (> min-idx 10)
+          (is (= 1000 (oc/query st 0 (- min-idx 5)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Max tree: range maximum queries
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest max-tree-aggregate
+  (doseq [n [10 100 1000 10000]]
+    (testing (str "N=" n)
+      (let [data (into {} (for [i (range n)] [i (rand-int 10000)]))
+            st   (oc/max-tree data)]
+        (is (= (apply max (vals data)) (oc/aggregate st)))))))
+
+(deftest max-tree-range-queries
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n " random range queries")
+      (let [data (into {} (for [i (range n)] [i (rand-int 10000)]))
+            st   (oc/max-tree data)]
+        (dotimes [_ 500]
+          (let [lo (rand-int n)
+                hi (+ lo (rand-int (- n lo)))]
+            (is (= (ref-range-max data lo hi)
+                   (oc/query st lo hi))
+                (str "Range [" lo ", " hi "]"))))))))
+
+(deftest max-tree-with-known-maximum
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n " with known maximum location")
+      (let [max-idx (rand-int n)
+            data    (into {} (for [i (range n)]
+                               [i (if (= i max-idx) 10000 0)]))
+            st      (oc/max-tree data)]
+        ;; Full range should find 10000
+        (is (= 10000 (oc/query st 0 (dec n))))
+        ;; Range containing max-idx should find 10000
+        (is (= 10000 (oc/query st (max 0 (- max-idx 10)) (min (dec n) (+ max-idx 10)))))
+        ;; Range not containing max-idx should find 0
+        (when (> max-idx 10)
+          (is (= 0 (oc/query st 0 (- max-idx 5)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Update operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest update-val-preserves-immutability
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n)
+      (let [data (into {} (for [i (range n)] [i i]))
+            st   (oc/sum-tree data)
+            orig-agg (oc/aggregate st)]
+        ;; Update random elements
+        (dotimes [_ 50]
+          (let [idx (rand-int n)
+                new-val (rand-int 10000)
+                st' (oc/update-val st idx new-val)]
+            ;; Original unchanged
+            (is (= orig-agg (oc/aggregate st)))
+            (is (= idx (st idx)))
+            ;; New tree updated
+            (is (= new-val (st' idx)))))))))
+
+(deftest update-val-aggregate-consistency
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n)
+      (let [st (oc/sum-tree (into {} (for [i (range n)] [i 1])))]
+        ;; Update one element and verify aggregate changes correctly
+        (dotimes [_ 50]
+          (let [idx     (rand-int n)
+                new-val (rand-int 100)
+                st'     (oc/update-val st idx new-val)]
+            ;; New aggregate = old aggregate - 1 + new-val
+            (is (= (+ (- n 1) new-val) (oc/aggregate st')))))))))
+
+(deftest update-val-range-query-consistency
+  (doseq [n [100 1000]]
+    (testing (str "N=" n)
+      (let [data (into {} (for [i (range n)] [i i]))
+            st   (oc/sum-tree data)]
+        (dotimes [_ 20]
+          (let [idx     (rand-int n)
+                new-val (rand-int 10000)
+                st'     (oc/update-val st idx new-val)
+                data'   (assoc data idx new-val)]
+            ;; Random range queries should match reference
+            (dotimes [_ 50]
+              (let [lo (rand-int n)
+                    hi (+ lo (rand-int (- n lo)))]
+                (is (= (ref-range-sum data' lo hi)
+                       (oc/query st' lo hi)))))))))))
+
+(deftest update-fn-test
+  (doseq [n [100 1000 10000]]
+    (testing (str "N=" n)
+      (let [st (oc/sum-tree (into {} (for [i (range n)] [i 1])))]
+        ;; Double a random element
+        (dotimes [_ 50]
+          (let [idx (rand-int n)
+                st' (oc/update-fn st idx #(* 2 %))]
+            (is (= 2 (st' idx)))
+            (is (= (inc n) (oc/aggregate st')))))))))
+
+(deftest multiple-updates
+  (doseq [n [100 1000]]
+    (testing (str "N=" n " sequential updates")
+      (let [st (oc/sum-tree (into {} (for [i (range n)] [i 0])))]
+        ;; Set all elements to 1
+        (let [st' (reduce #(oc/update-val %1 %2 1) st (range n))]
+          (is (= n (oc/aggregate st'))))
+        ;; Set random subset to 10
+        (let [indices (take 100 (shuffle (range n)))
+              st'     (reduce #(oc/update-val %1 %2 10) st indices)]
+          (is (= (* 10 100) (oc/aggregate st'))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Collection operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest collection-operations
+  (doseq [n [10 100 1000]]
+    (let [data (into {} (for [i (range n)] [i i]))
+          st   (oc/sum-tree data)]
+
+      (testing "count"
+        (is (= n (count st))))
+
+      (testing "seq"
+        (let [pairs (seq st)]
+          (is (= n (count pairs)))
+          (is (= (sort (keys data)) (map first pairs)))))
+
+      (testing "get/lookup"
+        (doseq [i (take 50 (repeatedly #(rand-int n)))]
+          (is (= i (get st i)))
+          (is (= i (st i))))
+        (is (nil? (st (+ n 100))))
+        (is (= :default (get st (+ n 100) :default))))
+
+      (testing "assoc (same as update-val)"
+        (let [st' (assoc st 0 999)]
+          (is (= 999 (st' 0)))))
+
+      (testing "empty"
+        (let [e (empty st)]
+          (is (zero? (count e)))
+          (is (= 0 (oc/aggregate e)))))
+
+      (testing "cons/conj"
+        (let [st' (conj st [(+ n 1) 100])]
+          (is (= (inc n) (count st')))
+          (is (= 100 (st' (+ n 1)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Custom monoid operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest custom-product-monoid
+  ;; Only test small n to avoid overflow (n! overflows long at n=21)
+  (doseq [n [5 10 15]]
+    (testing (str "N=" n " product monoid")
+      (let [;; Values 1-n to avoid zeros
+            data (into {} (for [i (range n)] [i (inc i)]))
+            st   (oc/segment-tree *' 1 data)]  ; use *' for arbitrary precision
+        ;; Just verify some range queries work
+        (is (= 1 (oc/query st 0 0)))     ; 1
+        (is (= 2 (oc/query st 0 1)))     ; 1 * 2
+        (is (= 6 (oc/query st 0 2)))     ; 1 * 2 * 3
+        (is (= 24 (oc/query st 0 3)))))) ; 1 * 2 * 3 * 4
+
+  (testing "Product with updates"
+    (let [st  (oc/segment-tree * 1 {0 2, 1 3, 2 5})
+          st' (oc/update-val st 1 7)]
+      (is (= 30 (oc/aggregate st)))     ; 2 * 3 * 5
+      (is (= 70 (oc/aggregate st'))))) ; 2 * 7 * 5
+)
+
+(deftest custom-bitwise-or-monoid
+  (testing "Bitwise OR"
+    (let [st (oc/segment-tree bit-or 0 {0 1, 1 2, 2 4, 3 8})]
+      (is (= 15 (oc/aggregate st)))     ; 1|2|4|8
+      (is (= 3 (oc/query st 0 1)))      ; 1|2
+      (is (= 12 (oc/query st 2 3)))     ; 4|8
+      (is (= 7 (oc/query st 0 2)))))    ; 1|2|4
+
+  (testing "Bitwise OR with random data"
+    (doseq [n [10 50 100]]
+      (let [data (into {} (for [i (range n)] [i (bit-shift-left 1 (mod i 20))]))
+            st   (oc/segment-tree bit-or 0 data)]
+        ;; Aggregate should have all bits set that appear in any element
+        (is (= (reduce bit-or (vals data)) (oc/aggregate st)))))))
+
+(deftest custom-gcd-monoid
+  (let [gcd (fn gcd [a b]
+              (if (zero? b) a (gcd b (mod a b))))]
+    (testing "GCD monoid"
+      (let [st (oc/segment-tree gcd 0 {0 12, 1 18, 2 24, 3 30})]
+        (is (= 6 (oc/aggregate st)))    ; gcd(12,18,24,30) = 6
+        (is (= 6 (oc/query st 0 1)))    ; gcd(12,18) = 6
+        (is (= 6 (oc/query st 1 2)))    ; gcd(18,24) = 6
+        (is (= 6 (oc/query st 2 3))))) ; gcd(24,30) = 6
+
+    (testing "GCD with primes"
+      (let [primes [2 3 5 7 11 13 17 19 23 29]
+            st     (oc/segment-tree gcd 0 (zipmap (range) primes))]
+        ;; All primes, so GCD of any range with >1 element is 1
+        (is (= 1 (oc/aggregate st)))
+        (doseq [i (range 9)]
+          (is (= 1 (oc/query st i (inc i)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Edge cases
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest edge-case-single-element
+  (let [st (oc/sum-tree {42 100})]
+    (is (= 1 (count st)))
+    (is (= 100 (oc/aggregate st)))
+    (is (= 100 (oc/query st 42 42)))
+    (is (= 100 (st 42)))))
+
+(deftest edge-case-two-elements
+  (let [st (oc/sum-tree {0 10, 100 20})]
+    (is (= 2 (count st)))
+    (is (= 30 (oc/aggregate st)))
+    (is (= 10 (oc/query st 0 0)))
+    (is (= 20 (oc/query st 100 100)))
+    (is (= 30 (oc/query st 0 100)))
+    ;; Range with no elements
+    (is (= 0 (oc/query st 1 99)))))
+
+(deftest edge-case-sparse-indices
+  (doseq [n [10 100 1000]]
+    (testing (str "N=" n " very sparse")
+      (let [;; Indices spaced far apart
+            data (into {} (for [i (range n)] [(* i 1000) i]))
+            st   (oc/sum-tree data)]
+        (is (= n (count st)))
+        (is (= (reduce + (range n)) (oc/aggregate st)))
+        ;; Query between indices should return 0
+        (is (= 0 (oc/query st 1 999)))
+        ;; Query spanning multiple indices
+        (is (= (+ 0 1 2) (oc/query st 0 2500)))))))
+
+(deftest edge-case-negative-indices
+  (let [st (oc/sum-tree {-100 10, -50 20, 0 30, 50 40, 100 50})]
+    (is (= 5 (count st)))
+    (is (= 150 (oc/aggregate st)))
+    (is (= 10 (oc/query st -100 -100)))
+    (is (= 30 (oc/query st -100 -50)))   ; 10 + 20
+    (is (= 50 (oc/query st -50 0)))      ; 20 + 30
+    (is (= 150 (oc/query st -100 100))))) ; all
+
+(deftest segment-tree-supports-generic-ordered-keys
+  (testing "string keys"
+    (let [st (oc/segment-tree + 0 {"a" 10, "b" 20, "c" 30, "d" 40})]
+      (is (= 100 (oc/aggregate st)))
+      (is (= 50 (oc/query st "b" "c")))
+      (is (= 90 (oc/query st "b" "z")))
+      (is (= 0 (oc/query st "x" "z")))
+      (is (= 15 (-> st
+                    (oc/update-val "a" 15)
+                    (get "a"))))))
+
+  (testing "long string keys with sparse misses"
+      (let [k1 "alpha/warehouse/zone/0001"
+          k2 "alpha/warehouse/zone/0100"
+          k3 "beta/warehouse/zone/0200"
+          st (oc/segment-tree + 0 {k1 5, k2 7, k3 11})]
+      (is (= 12 (oc/query st k1 k2)))
+      (is (= 23 (oc/query st "alpha" "beta/warehouse/zone/9999")))
+      (is (= 0 (oc/query st "gamma" "omega")))))
+
+  (testing "decimal keys"
+    (let [st (oc/segment-tree + 0 {1.5 10, 2.0 20, 2.5 30, 4.0 40})]
+      (is (= 60 (oc/query st 1.5 2.5)))
+      (is (= 50 (oc/query st 1.7 3.0)))
+      (is (= 0 (oc/query st 4.1 5.0)))))
+
+  (testing "Instant keys"
+    (let [t0 (Instant/parse "2026-01-01T00:00:00Z")
+          t1 (Instant/parse "2026-01-01T01:00:00Z")
+          t2 (Instant/parse "2026-01-01T02:00:00Z")
+          t3 (Instant/parse "2026-01-01T03:00:00Z")
+          t4 (Instant/parse "2026-01-01T04:00:00Z")
+          st (oc/segment-tree + 0 {t0 10, t1 20, t2 30, t3 40})]
+      (is (= 60 (oc/query st t0 t2)))
+      (is (= 90 (oc/query st t1 t4)))
+      (is (= 0 (oc/query st (Instant/parse "2026-01-02T00:00:00Z")
+                         (Instant/parse "2026-01-02T01:00:00Z"))))
+      (is (= 25 (-> st
+                    (oc/update-val t1 25)
+                    (get t1))))))
+
+  (testing "custom comparator via segment-tree-by"
+    (let [st (oc/segment-tree-by > + 0 [[4 40] [3 30] [2 20] [1 10]])]
+      (is (= 70 (oc/query st 4 3)))
+      (is (= 100 (oc/query st 4 1)))
+      (is (= 0 (oc/query st 0 -1)))))
+
+  (testing "empty range when lo > hi"
+    (let [st (oc/sum-tree {0 10, 1 20, 2 30})]
+      (is (= 0 (oc/query st 2 1))))))
+
+(deftest segment-tree-ordered-map-parity-on-generic-keys
+  (let [t0 (Instant/parse "2026-01-01T00:00:00Z")
+        t1 (Instant/parse "2026-01-01T01:00:00Z")
+        t2 (Instant/parse "2026-01-01T02:00:00Z")
+        t3 (Instant/parse "2026-01-01T03:00:00Z")
+        st (oc/segment-tree + 0 {t0 10, t1 20, t2 30, t3 40})]
+    (testing "ranked operations"
+      (is (= 0 (oc/rank st t0)))
+      (is (= 2 (oc/rank st t2)))
+      (is (nil? (oc/rank st (Instant/parse "2026-01-01T00:30:00Z"))))
+      (is (= [[t1 20] [t2 30]]
+             (mapv vec (oc/slice st 1 3))))
+      (is (= [t1 20] (vec (oc/median st))))
+      (is (= [t2 30] (vec (oc/percentile st 50)))))
+
+    (testing "split operations"
+      (let [[left entry right] (oc/split-key t1 st)
+            [front back]       (oc/split-at 2 st)]
+        (is (= [[t0 10]] (mapv vec left)))
+        (is (= [t1 20] (vec entry)))
+        (is (= [[t2 30] [t3 40]] (mapv vec right)))
+        (is (= [[t0 10] [t1 20]] (mapv vec front)))
+        (is (= [[t2 30] [t3 40]] (mapv vec back)))))
+
+    (testing "nearest and subrange"
+      (let [probe (Instant/parse "2026-01-01T01:30:00Z")]
+        (is (= [t1 20] (vec (oc/nearest st :<= probe))))
+        (is (= [t2 30] (vec (oc/nearest st :>= probe))))
+        (is (= [[t0 10] [t1 20]]
+               (mapv vec (oc/subrange st :<= t1))))
+        (is (= [[t2 30] [t3 40]]
+               (mapv vec (oc/subrange st :> t1))))))
+
+    (testing "sorted map behavior preserves aggregates"
+      (let [tail (.tailMap ^java.util.SortedMap st t1)
+            trimmed (dissoc st t1)
+            inserted (assoc st (Instant/parse "2026-01-01T04:00:00Z") 50)]
+        (is (= t0 (.firstKey ^java.util.SortedMap st)))
+        (is (= t3 (.lastKey ^java.util.SortedMap st)))
+        (is (= 90 (oc/aggregate tail)))
+        (is (= 80 (oc/aggregate trimmed)))
+        (is (= 150 (oc/aggregate inserted)))
+        (is (= 90 (oc/query tail t1 t3)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Stress tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest stress-large-tree
+  (doseq [n [10000 100000 500000]]
+    (testing (str "N=" n)
+      (let [st (oc/sum-tree (into {} (for [i (range n)] [i 1])))]
+        (is (= n (count st)))
+        (is (= n (oc/aggregate st)))
+        ;; Random range queries
+        (dotimes [_ 100]
+          (let [lo (rand-int n)
+                hi (+ lo (rand-int (- n lo)))]
+            (is (= (- hi lo -1) (oc/query st lo hi)))))))))
+
+(deftest stress-many-updates
+  (doseq [n [1000 10000]]
+    (testing (str "N=" n " with many updates")
+      (let [st (oc/sum-tree (into {} (for [i (range n)] [i 0])))]
+        ;; Apply 1000 random updates
+        (let [updates (for [_ (range 1000)]
+                        [(rand-int n) (rand-int 100)])
+              final-st (reduce (fn [t [i v]] (oc/update-val t i v)) st updates)
+              final-data (reduce (fn [m [i v]] (assoc m i v))
+                                 (into {} (for [i (range n)] [i 0]))
+                                 updates)]
+          ;; Aggregate should match
+          (is (= (reduce + (vals final-data)) (oc/aggregate final-st)))
+          ;; Random range queries should match
+          (dotimes [_ 100]
+            (let [lo (rand-int n)
+                  hi (+ lo (rand-int (- n lo)))]
+              (is (= (ref-range-sum final-data lo hi)
+                     (oc/query final-st lo hi))))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Randomized property tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest property-aggregate-equals-full-range-query
+  (dotimes [_ 50]
+    (let [n    (+ 10 (rand-int 1000))
+          data (into {} (for [i (range n)] [i (rand-int 1000)]))
+          st   (oc/sum-tree data)
+          lo   (apply min (keys data))
+          hi   (apply max (keys data))]
+      (is (= (oc/aggregate st) (oc/query st lo hi))))))
+
+(deftest property-update-then-query
+  (dotimes [_ 50]
+    (let [n    (+ 10 (rand-int 500))
+          data (into {} (for [i (range n)] [i (rand-int 100)]))
+          st   (oc/sum-tree data)
+          idx  (rand-int n)
+          new-val (rand-int 1000)
+          st'  (oc/update-val st idx new-val)
+          data' (assoc data idx new-val)]
+      ;; Aggregate should be correct
+      (is (= (reduce + (vals data')) (oc/aggregate st')))
+      ;; Query containing idx should reflect new value
+      (is (= (ref-range-sum data' 0 (dec n))
+             (oc/query st' 0 (dec n)))))))
+
+(deftest property-sum-tree-vs-reduce
+  (dotimes [_ 30]
+    (let [n    (+ 100 (rand-int 5000))
+          data (into {} (for [i (range n)] [i (rand-int 100)]))
+          st   (oc/sum-tree data)]
+      ;; Aggregate should equal reduce
+      (is (= (reduce + (vals data)) (oc/aggregate st)))
+      ;; Full range query should equal reduce
+      (is (= (reduce + (vals data)) (oc/query st 0 (dec n)))))))
+
+(defspec prop-segment-tree-query-equivalence 100
+  (prop/for-all [entries tu/gen-int-map-entries
+                 ranges  (gen/vector tu/gen-query-range 0 30)]
+    (let [m  (into (sorted-map) entries)
+          st (oc/sum-tree entries)]
+      (every? (fn [[lo hi]]
+                (= (tu/ref-range-sum m lo hi)
+                   (oc/query st lo hi)))
+              ranges))))
+
+(defspec prop-segment-tree-update-equivalence 100
+  (prop/for-all [entries  tu/gen-int-map-entries
+                 updates  tu/gen-segment-updates
+                 ranges   (gen/vector tu/gen-query-range 0 20)]
+    (let [m'  (reduce (fn [m [k v]] (assoc m k v)) (into (sorted-map) entries) updates)
+          st' (reduce (fn [st [k v]] (oc/update-val st k v)) (oc/sum-tree entries) updates)]
+      (and (= (reduce + 0 (vals m')) (oc/aggregate st'))
+           (every? (fn [[lo hi]]
+                     (= (tu/ref-range-sum m' lo hi)
+                        (oc/query st' lo hi)))
+                   ranges)))))
diff --git a/test/ordered_collections/serialization_test.clj b/test/ordered_collections/serialization_test.clj
new file mode 100644
index 0000000..9be9e96
--- /dev/null
+++ b/test/ordered_collections/serialization_test.clj
@@ -0,0 +1,446 @@
+(ns ordered-collections.serialization-test
+  "Randomized test suite for Java serialization of ordered-collections.
+   Tests round-trip serialization at various cardinalities with nontrivial datasets.
+
+   Types that implement java.io.Serializable and use built-in comparators:
+   - ordered-set, ordered-map
+   - ordered-multiset
+   - priority-queue
+   - fuzzy-set, fuzzy-map
+
+   - interval-set, interval-map
+   - segment-tree, range-map
+
+   Note: Collections created with custom comparators (via ordered-set-by, etc.)
+   will only be serializable if the custom comparator itself is serializable."
+  (:require [clojure.test :refer [deftest testing is]]
+            [ordered-collections.core :as oc]
+            [ordered-collections.test-utils :as tu
+             :refer [rand-longs rand-strings rand-map-entries]])
+  (:import [java.io ByteArrayInputStream ByteArrayOutputStream
+            ObjectInputStream ObjectOutputStream]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Serialization Helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn serialize
+  "Serialize an object to a byte array"
+  ^bytes [obj]
+  (let [baos (ByteArrayOutputStream.)
+        oos  (ObjectOutputStream. baos)]
+    (.writeObject oos obj)
+    (.close oos)
+    (.toByteArray baos)))
+
+(defn deserialize
+  "Deserialize an object from a byte array"
+  [^bytes bytes]
+  (let [bais (ByteArrayInputStream. bytes)
+        ois  (ObjectInputStream. bais)]
+    (.readObject ois)))
+
+(defn round-trip
+  "Serialize and deserialize an object"
+  [obj]
+  (-> obj serialize deserialize))
+
+(defn serializable?
+  "Test if an object can be serialized without throwing"
+  [obj]
+  (try
+    (serialize obj)
+    true
+    (catch java.io.NotSerializableException _
+      false)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Test Scales
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def cardinalities [10 100 1000 10000 50000])
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Set Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-set-serialization
+  (testing "ordered-set round-trip serialization"
+    (doseq [n cardinalities]
+      (testing (str "cardinality " n)
+        (let [data (rand-longs n (* n 10))
+              original (oc/ordered-set data)
+              restored (round-trip original)]
+          (is (= (count original) (count restored))
+              "count preserved")
+          (is (= (vec original) (vec restored))
+              "elements and order preserved")
+          (is (= (first original) (first restored))
+              "first preserved")
+          (is (= (last original) (last restored))
+              "last preserved")
+          ;; Verify it's still functional
+          (is (contains? restored (first data))
+              "contains? works after deserialization")
+          (is (= (nth original (quot n 2)) (nth restored (quot n 2)))
+              "nth works after deserialization"))))))
+
+(deftest ordered-set-with-keywords
+  (testing "ordered-set with keyword elements"
+    (doseq [n [10 100 1000]]
+      (testing (str "cardinality " n)
+        (let [data (mapv #(keyword (str "k" %)) (range n))
+              original (oc/ordered-set (shuffle data))
+              restored (round-trip original)]
+          (is (= (vec original) (vec restored))
+              "keyword elements preserved"))))))
+
+(deftest ordered-set-with-mixed-integers
+  (testing "ordered-set with negative and positive integers"
+    (doseq [n cardinalities]
+      (testing (str "cardinality " n)
+        (let [data (mapv #(- % (quot n 2)) (range n))
+              original (oc/ordered-set (shuffle data))
+              restored (round-trip original)]
+          (is (= (vec original) (vec restored))
+              "mixed integers preserved")
+          (is (< (first restored) 0)
+              "negative values at front"))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Map Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-map-serialization
+  (testing "ordered-map round-trip serialization"
+    (doseq [n cardinalities]
+      (testing (str "cardinality " n)
+        (let [data (rand-map-entries n (* n 10))
+              original (oc/ordered-map data)
+              restored (round-trip original)]
+          (is (= (count original) (count restored))
+              "count preserved")
+          (is (= (vec original) (vec restored))
+              "entries and order preserved")
+          (is (= (vec (keys original)) (vec (keys restored)))
+              "keys preserved")
+          (is (= (vec (vals original)) (vec (vals restored)))
+              "vals preserved")
+          ;; Verify it's still functional
+          (let [[k v] (first data)]
+            (is (= v (get restored k))
+                "get works after deserialization")))))))
+
+(deftest ordered-map-with-complex-values
+  (testing "ordered-map with complex nested values"
+    (doseq [n [10 100 1000]]
+      (testing (str "cardinality " n)
+        (let [data (mapv (fn [i] [i {:id i
+                                    :name (str "item-" i)
+                                    :tags [:a :b :c]
+                                    :nested {:x i :y (* i 2)}}])
+                         (range n))
+              original (oc/ordered-map (shuffle data))
+              restored (round-trip original)]
+          (is (= (vec original) (vec restored))
+              "complex values preserved"))))))
+
+(deftest ordered-map-with-string-keys
+  (testing "ordered-map with string keys"
+    (doseq [n [10 100 1000]]
+      (testing (str "cardinality " n)
+        (let [keys (rand-strings n)
+              data (mapv #(vector % (hash %)) keys)
+              original (oc/ordered-map data)
+              restored (round-trip original)]
+          (is (= (vec original) (vec restored))
+              "string keys preserved"))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ordered Multiset Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-multiset-serialization
+  (testing "ordered-multiset round-trip serialization"
+    (doseq [n cardinalities]
+      (testing (str "cardinality " n)
+        ;; Include duplicates - elements in range [0, n/2) so ~2 of each
+        (let [data (repeatedly n #(rand-int (quot n 2)))
+              original (oc/ordered-multiset data)
+              restored (round-trip original)]
+          (is (= (count original) (count restored))
+              "count preserved (including duplicates)")
+          (is (= (vec original) (vec restored))
+              "elements and order preserved")
+          ;; Verify multiplicities
+          (doseq [sample (take 10 (shuffle (vec (set data))))]
+            (is (= (oc/multiplicity original sample)
+                   (oc/multiplicity restored sample))
+                (str "multiplicity of " sample " preserved"))))))))
+
+(deftest ordered-multiset-high-multiplicity
+  (testing "ordered-multiset with high multiplicity elements"
+    (let [;; 1000 copies of each of 10 distinct elements
+          data (for [i (range 10) _ (range 1000)] i)
+          original (oc/ordered-multiset data)
+          restored (round-trip original)]
+      (is (= 10000 (count original) (count restored))
+          "total count preserved")
+      (doseq [i (range 10)]
+        (is (= 1000 (oc/multiplicity restored i))
+            (str "multiplicity of " i " is 1000"))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Priority Queue Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest priority-queue-serialization
+  (testing "priority-queue round-trip serialization"
+    (doseq [n cardinalities]
+      (testing (str "cardinality " n)
+        (let [data (mapv (fn [_] [(rand-int 100) {:id (rand-int 1000000)}]) (range n))
+              original (oc/priority-queue data)
+              restored (round-trip original)]
+          (is (= (count original) (count restored))
+              "count preserved")
+          (is (= (vec (seq original)) (vec (seq restored)))
+              "queue order preserved")
+          (is (= (peek original) (peek restored))
+              "front element preserved")
+          (is (= (oc/peek-max original) (oc/peek-max restored))
+              "back element preserved"))))))
+
+(deftest priority-queue-ordering-preserved
+  (testing "priority-queue maintains queue order after deserialization"
+    (let [data (mapv (fn [i] [i (str "priority-" i)]) (shuffle (range 1000)))
+          original (oc/priority-queue data)
+          restored (round-trip original)]
+      (loop [orig original, rest restored, i 0]
+        (when (and (seq orig) (< i 250))
+          (is (= (peek orig) (peek rest))
+              (str "element " i " matches after pop"))
+          (recur (pop orig) (pop rest) (inc i)))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fuzzy Set/Map Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest fuzzy-set-serialization
+  (testing "fuzzy-set round-trip serialization"
+    (doseq [n [10 100 1000]]
+      (testing (str "cardinality " n)
+        (let [data (rand-longs n (* n 10))
+              original (oc/fuzzy-set data)
+              restored (round-trip original)]
+          (is (= (count original) (count restored))
+              "count preserved")
+          (is (= (vec original) (vec restored))
+              "elements preserved")
+          ;; Verify fuzzy lookup works
+          (let [query (+ (apply max data) 5)]
+            (is (= (oc/fuzzy-nearest original query)
+                   (oc/fuzzy-nearest restored query))
+                "nearest lookup works")))))))
+
+(deftest fuzzy-map-serialization
+  (testing "fuzzy-map round-trip serialization"
+    (doseq [n [10 100 1000]]
+      (testing (str "cardinality " n)
+        (let [data (into {} (rand-map-entries n (* n 10)))
+              original (oc/fuzzy-map data)
+              restored (round-trip original)]
+          (is (= (count original) (count restored))
+              "count preserved")
+          (is (= (vec original) (vec restored))
+              "entries preserved")
+          ;; Verify fuzzy lookup works
+          (let [max-key (apply max (keys data))
+                query (+ max-key 5)]
+            (is (= (get original query)
+                   (get restored query))
+                "fuzzy get works")))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Edge Cases
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest empty-collections-serialization
+  (testing "empty collections serialize correctly"
+    (is (= [] (vec (round-trip (oc/ordered-set)))))
+    (is (= [] (vec (round-trip (oc/ordered-map)))))
+    (is (= [] (vec (round-trip (oc/ordered-multiset [])))))
+    (is (= [] (vec (round-trip (oc/fuzzy-set [])))))
+    (is (= [] (vec (round-trip (oc/interval-set)))))
+    (is (= [] (vec (round-trip (oc/interval-map)))))))
+
+(deftest single-element-serialization
+  (testing "single element collections serialize correctly"
+    (is (= [42] (vec (round-trip (oc/ordered-set [42])))))
+    (is (= [[1 :a]] (vec (round-trip (oc/ordered-map [[1 :a]])))))
+    (is (= [42] (vec (round-trip (oc/ordered-multiset [42])))))
+    (is (= [42] (vec (round-trip (oc/fuzzy-set [42])))))
+    (is (= [[1 5]] (vec (round-trip (oc/interval-set [[1 5]])))))
+    (is (= [[[1 5] :a]] (vec (round-trip (oc/interval-map [[[1 5] :a]])))))))
+
+(deftest large-values-serialization
+  (testing "collections with large/extreme values"
+    (let [data [Long/MIN_VALUE -1 0 1 Long/MAX_VALUE]
+          original (oc/ordered-set data)
+          restored (round-trip original)]
+      (is (= (vec original) (vec restored))
+          "extreme long values preserved")
+      (is (= Long/MIN_VALUE (first restored)))
+      (is (= Long/MAX_VALUE (last restored))))))
+
+(deftest serialized-size-reasonable
+  (testing "serialized size is reasonable"
+    (let [n 10000
+          data (rand-longs n (* n 10))
+          original (oc/ordered-set data)
+          bytes (serialize original)
+          ;; Each element needs storage for value + tree structure overhead.
+          ;; Allow up to 50 bytes per element for tree nodes with all metadata.
+          max-expected (* n 50)]
+      (is (< (count bytes) max-expected)
+          (str "serialized size " (count bytes) " should be < " max-expected)))))
+
+(deftest multiple-serialization-rounds
+  (testing "multiple serialization rounds produce identical results"
+    (let [data (rand-longs 1000 10000)
+          original (oc/ordered-set data)
+          round1 (round-trip original)
+          round2 (round-trip round1)
+          round3 (round-trip round2)]
+      (is (= (vec original) (vec round1) (vec round2) (vec round3))
+          "multiple round trips preserve data"))))
+
+(deftest concurrent-serialization
+  (testing "concurrent serialization works correctly"
+    (let [data (rand-longs 1000 10000)
+          original (oc/ordered-set data)
+          results (doall
+                    (pmap (fn [_] (vec (round-trip original)))
+                          (range 10)))]
+      (is (every? #(= (vec original) %) results)
+          "all concurrent serializations produce same result"))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Functional Verification After Deserialization
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ordered-set-operations-after-deserialization
+  (testing "ordered-set operations work after deserialization"
+    (let [data (rand-longs 1000 10000)
+          original (oc/ordered-set data)
+          restored (round-trip original)
+          new-elem (+ 10000 (rand-int 1000))]
+      ;; conj
+      (is (contains? (conj restored new-elem) new-elem)
+          "conj works")
+      ;; disj
+      (let [to-remove (first data)]
+        (is (not (contains? (disj restored to-remove) to-remove))
+            "disj works"))
+      ;; subseq
+      (let [mid (nth (vec (sort data)) 500)]
+        (is (= (vec (subseq original >= mid))
+               (vec (subseq restored >= mid)))
+            "subseq works"))
+      ;; set operations between original and restored should work
+      ;; because comparators implement equals
+      (let [other-data (rand-longs 500 10000)
+            other (oc/ordered-set other-data)]
+        (is (= (vec (oc/union original other))
+               (vec (oc/union restored other)))
+            "union works")
+        (is (= (vec (oc/intersection original other))
+               (vec (oc/intersection restored other)))
+            "intersection works")))))
+
+(deftest ordered-map-operations-after-deserialization
+  (testing "ordered-map operations work after deserialization"
+    (let [data (rand-map-entries 1000 10000)
+          original (oc/ordered-map data)
+          restored (round-trip original)
+          new-key (+ 10000 (rand-int 1000))]
+      ;; assoc
+      (is (= :new-val (get (assoc restored new-key :new-val) new-key))
+          "assoc works")
+      ;; dissoc
+      (let [[k _] (first data)]
+        (is (nil? (get (dissoc restored k) k))
+            "dissoc works"))
+      ;; update
+      (let [[k v] (first data)]
+        (is (= (inc v) (get (update restored k inc) k))
+            "update works")))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Set/Map Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest interval-set-serialization
+  (testing "interval-set round-trip serialization"
+    (doseq [n [10 100 1000]]
+      (testing (str "cardinality " n)
+        (let [intervals (mapv (fn [_] (let [a (rand-int (* n 10))
+                                            b (rand-int (* n 10))]
+                                        [(min a b) (max a b)]))
+                              (range n))
+              original (oc/interval-set intervals)
+              restored (round-trip original)]
+          (is (= (count original) (count restored))
+              "count preserved")
+          (is (= (vec original) (vec restored))
+              "intervals and order preserved")
+          ;; Verify interval lookup works (invoke as function)
+          (let [[lo hi] (first (seq original))
+                mid     (/ (+ lo hi) 2)]
+            (is (= (original mid) (restored mid))
+                "interval lookup works after deserialization")))))))
+
+(deftest interval-map-serialization
+  (testing "interval-map round-trip serialization"
+    (doseq [n [10 100 1000]]
+      (testing (str "cardinality " n)
+        (let [entries (mapv (fn [i] (let [a (rand-int (* n 10))
+                                          b (rand-int (* n 10))]
+                                      [[(min a b) (max a b)] i]))
+                            (range n))
+              original (oc/interval-map entries)
+              restored (round-trip original)]
+          (is (= (count original) (count restored))
+              "count preserved")
+          (is (= (vec original) (vec restored))
+              "entries and order preserved")
+          ;; Verify interval lookup works (invoke as function)
+          (let [[[lo hi] _] (first (seq original))
+                mid         (/ (+ lo hi) 2)]
+            (is (= (original mid) (restored mid))
+                "interval lookup works after deserialization")))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Range Map Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest range-map-serialization
+  (testing "range-map round-trip serialization"
+    (doseq [n [10 100 1000]]
+      (testing (str "cardinality " n)
+        ;; Build non-overlapping ranges
+        (let [points   (vec (sort (set (repeatedly (* n 2) #(rand-int (* n 20))))))
+              pairs    (->> points (partition 2) (take n))
+              entries  (mapv (fn [[a b]] [[a b] (str a "-" b)]) pairs)
+              original (oc/range-map entries)
+              restored (round-trip original)]
+          (is (= (count original) (count restored))
+              "count preserved")
+          (is (= (seq original) (seq restored))
+              "entries preserved")
+          ;; Verify point lookup works
+          (when-let [[[lo hi] v] (first (seq original))]
+            (let [mid (/ (+ lo hi) 2)]
+              (is (= (get original mid) (get restored mid))
+                  "point lookup works after deserialization"))))))))
diff --git a/test/ordered_collections/simple_bench.clj b/test/ordered_collections/simple_bench.clj
new file mode 100644
index 0000000..94d68e1
--- /dev/null
+++ b/test/ordered_collections/simple_bench.clj
@@ -0,0 +1,775 @@
+(ns ordered-collections.simple-bench
+  "Simple benchmark suite without Criterium dependency.
+
+   For quick iteration during development. Uses basic timing with
+   manual warmup. For rigorous benchmarks with EDN output, use
+   lein bench instead.
+
+   Usage:
+     lein bench-simple                    ; Default (100 to 100K)
+     lein bench-simple --quick            ; Fast iteration (100 to 10K)
+     lein bench-simple --full             ; Full suite (100 to 1M)
+     lein bench-simple --sizes 1000,10000 ; Custom sizes
+     lein bench-simple --only sets        ; Run only set benchmarks
+     lein bench-simple --only maps,sets   ; Run maps and sets
+
+   Categories for --only:
+     maps, sets, set-ops, intervals, specialty, strings, parallel, memory"
+  (:require [clojure.core.reducers :as r]
+            [clojure.data.avl :as avl]
+            [clojure.string :as str]
+            [ordered-collections.bench-utils :as bu
+             :refer [bench format-ns format-result print-header print-row
+                     has-flag? get-arg-value parse-sizes parse-standard-args
+                     build-map-variants build-set-variants overlapping-set-variants
+                     split-workload fold-frequency-workload
+                     set-comparison-workload]]
+            [ordered-collections.core :as core]
+            [ordered-collections.kernel.node :as node]
+            [ordered-collections.kernel.tree :as tree]
+            [ordered-collections.kernel.order :as order]
+            [ordered-collections.kernel.interval :as interval]))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Map Benchmarks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-map-construction
+  "Benchmark building a map from N random key-value pairs."
+  [sizes]
+  (print-header "MAP CONSTRUCTION: Build from N random key-value pairs"
+                ["sorted-map" "data.avl" "ordered-map"])
+  (doseq [n sizes]
+    (let [pairs (mapv (fn [k] [k (str k)]) (shuffle (range n)))]
+      (print-row n
+        [(bench 20 10 (into (sorted-map) pairs))
+         (bench 20 10 (into (avl/sorted-map) pairs))
+         (bench 20 10 (core/ordered-map pairs))]))))
+
+(defn bench-map-incremental-insert
+  "Benchmark assoc one element at a time from empty."
+  [sizes]
+  (print-header "MAP INSERT: assoc one element at a time from empty"
+                ["sorted-map" "data.avl" "ordered-map"])
+  (doseq [n sizes]
+    (let [ks (shuffle (range n))]
+      (print-row n
+        [(bench 20 10
+           (loop [m (sorted-map) xs (seq ks)]
+             (if xs (recur (assoc m (first xs) true) (next xs)) m)))
+         (bench 20 10
+           (loop [m (avl/sorted-map) xs (seq ks)]
+             (if xs (recur (assoc m (first xs) true) (next xs)) m)))
+         (bench 20 10
+           (loop [m (core/ordered-map) xs (seq ks)]
+             (if xs (recur (assoc m (first xs) true) (next xs)) m)))]))))
+
+(defn bench-map-incremental-delete
+  "Benchmark dissoc half the elements one at a time."
+  [sizes]
+  (print-header "MAP DELETE: dissoc half the elements one at a time"
+                ["sorted-map" "data.avl" "ordered-map"])
+  (doseq [n sizes]
+    (let [pairs  (map #(vector % true) (range n))
+          to-del (vec (take (quot n 2) (shuffle (range n))))
+          sm     (into (sorted-map) pairs)
+          am     (into (avl/sorted-map) pairs)
+          om     (core/ordered-map pairs)]
+      (print-row n
+        [(bench 20 10 (reduce (fn [m k] (dissoc m k)) sm to-del))
+         (bench 20 10 (reduce (fn [m k] (dissoc m k)) am to-del))
+         (bench 20 10 (reduce (fn [m k] (dissoc m k)) om to-del))]))))
+
+(defn bench-map-lookup
+  "Benchmark 10,000 random lookups on a map of size N."
+  [sizes]
+  (print-header "MAP LOOKUP: 10,000 random lookups on map of size N"
+                ["sorted-map" "data.avl" "ordered-map"])
+  (doseq [n sizes]
+    (let [pairs (mapv (fn [k] [k (str k)]) (shuffle (range n)))
+          {:keys [sorted-map data-avl ordered-map]} (build-map-variants pairs)
+          ks    (int-array (repeatedly 10000 #(rand-int n)))]
+      (print-row n
+        [(bench 20 10 (dotimes [i 10000] (get sorted-map (aget ks i))))
+         (bench 20 10 (dotimes [i 10000] (get data-avl (aget ks i))))
+         (bench 20 10 (dotimes [i 10000] (ordered-map (aget ks i))))]))))
+
+(defn bench-map-iteration
+  "Benchmark traversing all N entries via reduce."
+  [sizes]
+  (print-header "MAP ITERATION: reduce over all N entries"
+                ["sorted-map" "data.avl" "ordered-map"])
+  (doseq [n sizes]
+    (let [pairs (mapv (fn [k] [k (str k)]) (shuffle (range n)))
+          sm    (into (sorted-map) pairs)
+          am    (into (avl/sorted-map) pairs)
+          om    (core/ordered-map pairs)]
+      (print-row n
+        [(bench 20 10 (reduce (fn [^long acc [k _]] (+ acc (long k))) 0 sm))
+         (bench 20 10 (reduce (fn [^long acc [k _]] (+ acc (long k))) 0 am))
+         (bench 20 10 (reduce (fn [^long acc [k _]] (+ acc (long k))) 0 om))]))))
+
+(defn bench-map-seq-iteration
+  "Benchmark traversing all N entries via seq (lazy)."
+  [sizes]
+  (print-header "MAP SEQ ITERATION: traverse via (seq m)"
+                ["sorted-map" "data.avl" "ordered-map"])
+  (doseq [n sizes]
+    (let [pairs (mapv (fn [k] [k (str k)]) (shuffle (range n)))
+          sm    (into (sorted-map) pairs)
+          am    (into (avl/sorted-map) pairs)
+          om    (core/ordered-map pairs)]
+      (print-row n
+        [(bench 20 10 (reduce (fn [^long acc [k _]] (+ acc (long k))) 0 (seq sm)))
+         (bench 20 10 (reduce (fn [^long acc [k _]] (+ acc (long k))) 0 (seq am)))
+         (bench 20 10 (reduce (fn [^long acc [k _]] (+ acc (long k))) 0 (seq om)))]))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Set Benchmarks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-set-construction
+  "Benchmark building a set from N random elements."
+  [sizes]
+  (print-header "SET CONSTRUCTION: Build from N random elements"
+                ["sorted-set" "data.avl" "ordered-set"])
+  (doseq [n sizes]
+    (let [elems (shuffle (range n))]
+      (print-row n
+        [(bench 20 10 (into (sorted-set) elems))
+         (bench 20 10 (into (avl/sorted-set) elems))
+         (bench 20 10 (core/ordered-set elems))]))))
+
+(defn bench-set-incremental-insert
+  "Benchmark conj one element at a time from empty."
+  [sizes]
+  (print-header "SET INSERT: conj one element at a time from empty"
+                ["sorted-set" "data.avl" "ordered-set"])
+  (doseq [n sizes]
+    (let [elems (shuffle (range n))]
+      (print-row n
+        [(bench 20 10
+           (loop [s (sorted-set) xs (seq elems)]
+             (if xs (recur (conj s (first xs)) (next xs)) s)))
+         (bench 20 10
+           (loop [s (avl/sorted-set) xs (seq elems)]
+             (if xs (recur (conj s (first xs)) (next xs)) s)))
+         (bench 20 10
+           (loop [s (core/ordered-set) xs (seq elems)]
+             (if xs (recur (conj s (first xs)) (next xs)) s)))]))))
+
+(defn bench-set-incremental-delete
+  "Benchmark disj half the elements one at a time."
+  [sizes]
+  (print-header "SET DELETE: disj half the elements one at a time"
+                ["sorted-set" "data.avl" "ordered-set"])
+  (doseq [n sizes]
+    (let [elems  (range n)
+          to-del (take (quot n 2) (shuffle (range n)))
+          ss     (into (sorted-set) elems)
+          as     (into (avl/sorted-set) elems)
+          os     (core/ordered-set elems)]
+      (print-row n
+        [(bench 20 10 (reduce (fn [s x] (disj s x)) ss to-del))
+         (bench 20 10 (reduce (fn [s x] (disj s x)) as to-del))
+         (bench 20 10 (reduce (fn [s x] (disj s x)) os to-del))]))))
+
+(defn bench-set-lookup
+  "Benchmark 10,000 random contains? checks on a set of size N."
+  [sizes]
+  (print-header "SET LOOKUP: 10,000 random contains? checks"
+                ["sorted-set" "data.avl" "ordered-set"])
+  (doseq [n sizes]
+    (let [elems (shuffle (range n))
+          {:keys [sorted-set data-avl ordered-set]} (build-set-variants elems)
+          ks    (int-array (repeatedly 10000 #(rand-int n)))]
+      (print-row n
+        [(bench 20 10 (dotimes [i 10000] (contains? sorted-set (aget ks i))))
+         (bench 20 10 (dotimes [i 10000] (contains? data-avl (aget ks i))))
+         (bench 20 10 (dotimes [i 10000] (contains? ordered-set (aget ks i))))]))))
+
+(defn bench-set-iteration
+  "Benchmark traversing all N elements via reduce."
+  [sizes]
+  (print-header "SET ITERATION: reduce over all N elements"
+                ["sorted-set" "data.avl" "ordered-set"])
+  (doseq [n sizes]
+    (let [elems (shuffle (range n))
+          ss    (into (sorted-set) elems)
+          as    (into (avl/sorted-set) elems)
+          os    (core/ordered-set elems)]
+      (print-row n
+        [(bench 20 10 (reduce (fn [^long acc x] (+ acc (long x))) 0 ss))
+         (bench 20 10 (reduce (fn [^long acc x] (+ acc (long x))) 0 as))
+         (bench 20 10 (reduce (fn [^long acc x] (+ acc (long x))) 0 os))]))))
+
+(defn bench-set-comparison
+  "Benchmark set equality on same-content and near-miss workloads."
+  [sizes]
+  (doseq [[case-label workload-key title]
+          [["equal" :equal "SET EQUALITY: compare equal randomized sets"]
+           ["one-different" :different "SET EQUALITY: compare same-size sets differing in one element"]
+           ["size-different" :size-different "SET EQUALITY: compare sets differing in cardinality by one"]]]
+    (print-header title ["hash-set" "sorted-set" "data.avl" "ordered-set"])
+    (doseq [n sizes]
+      (let [{left :left right :right} (workload-key (set-comparison-workload n))
+            hs1 (:hash-set left), hs2 (:hash-set right)
+            ss1 (:sorted-set left), ss2 (:sorted-set right)
+            as1 (:data-avl left), as2 (:data-avl right)
+            os1 (:ordered-set left), os2 (:ordered-set right)]
+        (print-row n
+          [(bench 20 10 (= hs1 hs2))
+           (bench 20 10 (= ss1 ss2))
+           (bench 20 10 (= as1 as2))
+           (bench 20 10 (= os1 os2))])))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Ranked Access Benchmarks (data.avl specialty)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-rank-access
+  "Benchmark rank (index) access - a specialty of both data.avl and ordered-*."
+  [sizes]
+  (print-header "RANK ACCESS: nth element by index (10,000 lookups)"
+                ["data.avl" "ordered-set"])
+  (doseq [n sizes]
+    (let [elems (shuffle (range n))
+          as    (into (avl/sorted-set) elems)
+          os    (core/ordered-set elems)
+          idxs  (int-array (repeatedly 10000 #(rand-int n)))]
+      (print-row n
+        [(bench 20 10 (dotimes [i 10000] (nth as (aget idxs i))))
+         (bench 20 10 (dotimes [i 10000] (nth os (aget idxs i))))]))))
+
+(defn bench-rank-lookup
+  "Benchmark finding the rank of an element."
+  [sizes]
+  (print-header "RANK LOOKUP: rank-of element (10,000 lookups)"
+                ["data.avl" "ordered-set"])
+  (doseq [n sizes]
+    (let [elems (shuffle (range n))
+          as    (into (avl/sorted-set) elems)
+          os    (core/ordered-set elems)
+          ks    (int-array (repeatedly 10000 #(rand-int n)))]
+      (print-row n
+        [(bench 20 10 (dotimes [i 10000] (avl/rank-of as (aget ks i))))
+         (bench 20 10 (dotimes [i 10000] (core/rank os (aget ks i))))]))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Split Operations (data.avl specialty)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-split-operations
+  "Benchmark split-key operations."
+  [sizes]
+  (print-header "SPLIT-KEY: split set at random key (100 ops)"
+                ["data.avl" "ordered-set"])
+  (doseq [n sizes]
+    (let [{:keys [data-avl ordered-set keys]} (split-workload n 100)
+          ^ints ks keys]
+      (print-row n
+        [(bench 2 5 (dotimes [i 100] (avl/split-key (aget ks i) data-avl)))
+         (bench 2 5 (dotimes [i 100] (core/split-key (aget ks i) ordered-set)))]))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Parallel Fold Benchmarks (clojure.core.reducers/fold)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-set-parallel-fold
+  "Benchmark r/fold performance across implementations.
+   ordered-set implements CollFold for efficient tree-aware parallel reduction.
+   sorted-set and data.avl use the default reducers behavior."
+  [sizes]
+  (print-header "SET r/fold: Chunked fold performance comparison"
+                ["sorted-set" "data.avl" "ordered-set"])
+  (doseq [n sizes]
+    (let [elems (shuffle (range n))
+          {:keys [sorted-set data-avl ordered-set]} (build-set-variants elems)
+          fold-time (fn [coll]
+                      (first (bench 20 10
+                               (r/fold + (fn [^long acc x] (+ acc (long x)))
+                                       coll))))
+          ss-fold (fold-time sorted-set)
+          as-fold (fold-time data-avl)
+          os-fold (fold-time ordered-set)
+          speedup (if (pos? os-fold) (format "%.1fx" (/ (double ss-fold) os-fold)) "N/A")]
+      (print-row n
+        [[ss-fold 0] [as-fold 0] [os-fold 0]])
+      (println (format "           ordered-set is %s faster than sorted-set" speedup)))))
+
+(defn bench-fold-comparison
+  "Direct comparison of reduce vs fold for ordered-set."
+  [sizes]
+  (println)
+  (println "=== FOLD vs REDUCE: Direct comparison on ordered-set ===")
+  (println (format "%-12s %-18s %-18s %-12s"
+                   "N" "reduce" "fold" "speedup"))
+  (println (apply str (repeat 62 "-")))
+  (doseq [n sizes]
+    (let [elems (shuffle (range n))
+          os    (core/ordered-set elems)
+          [os-reduce _] (bench 20 10 (reduce (fn [^long acc x] (+ acc (long x))) 0 os))
+          [os-fold _]   (bench 20 10 (r/fold + (fn [^long acc x] (+ acc (long x))) os))
+          os-speedup (if (pos? os-fold) (/ (double os-reduce) os-fold) 0.0)]
+      (println (format "%-12d %-18s %-18s %-12.1fx"
+                       n
+                       (format-ns os-reduce)
+                       (format-ns os-fold)
+                       os-speedup)))))
+
+(defn bench-fold-freq-comparison
+  "Compare reduce vs fold on a non-trivial frequency-map workload."
+  [sizes]
+  (println)
+  (println "=== FOLD vs REDUCE: Frequency-map workload ===")
+  (println (format "%-10s %-20s %-20s %-20s %-20s %-20s %-20s %-20s"
+                   "N"
+                   "hs reduce"
+                   "ss reduce"
+                   "ss fold"
+                   "avl reduce"
+                   "avl fold"
+                   "os reduce"
+                   "os fold"))
+  (println (apply str (repeat 150 "-")))
+  (doseq [n sizes]
+    (let [elems (shuffle (range n))
+          {:keys [sets combinef reducef]} (fold-frequency-workload elems)
+          {:keys [hash-set sorted-set data-avl ordered-set]} sets
+          [hs-reduce _] (bench 20 10 (reduce reducef {} hash-set))
+          [ss-reduce _] (bench 20 10 (reduce reducef {} sorted-set))
+          [ss-fold _]   (bench 20 10 (r/fold combinef reducef sorted-set))
+          [as-reduce _] (bench 20 10 (reduce reducef {} data-avl))
+          [as-fold _]   (bench 20 10 (r/fold combinef reducef data-avl))
+          [os-reduce _] (bench 20 10 (reduce reducef {} ordered-set))
+          [os-fold _]   (bench 20 10 (r/fold combinef reducef ordered-set))]
+      (println (format "%-10d %-20s %-20s %-20s %-20s %-20s %-20s %-20s"
+                       n
+                       (format-ns hs-reduce)
+                       (format-ns ss-reduce)
+                       (format-ns ss-fold)
+                       (format-ns as-reduce)
+                       (format-ns as-fold)
+                       (format-ns os-reduce)
+                       (format-ns os-fold))))))
+
+(defn run-parallel-benchmarks
+  "Run parallel fold benchmarks."
+  [sizes]
+  (bench-set-parallel-fold sizes)
+  (bench-fold-comparison sizes)
+  (bench-fold-freq-comparison sizes))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; String Key Benchmarks (Custom Comparator)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def ^:private string-cmp (order/compare-by #(neg? (compare (str %1) (str %2)))))
+
+(defn- make-string-keys [n]
+  (mapv #(format "key-%08d" %) (shuffle (range n))))
+
+(defn bench-string-map-construction
+  "Benchmark map construction with string keys."
+  [sizes]
+  (print-header "STRING MAP CONSTRUCTION: Build from N string key-value pairs"
+                ["sorted-map-by" "data.avl" "ordered-map"])
+  (doseq [n sizes]
+    (let [ks    (make-string-keys n)
+          pairs (mapv (fn [k] [k k]) ks)
+          cmp   #(compare (str %1) (str %2))]
+      (print-row n
+        [(bench 20 10 (into (sorted-map-by cmp) pairs))
+         (bench 20 10 (into (avl/sorted-map-by cmp) pairs))
+         (bench 20 10 (core/ordered-map-with string-cmp pairs))]))))
+
+(defn bench-string-map-lookup
+  "Benchmark lookups with string keys."
+  [sizes]
+  (print-header "STRING MAP LOOKUP: 10,000 random lookups, string keys"
+                ["sorted-map-by" "data.avl" "ordered-map"])
+  (doseq [n sizes]
+    (let [ks    (make-string-keys n)
+          pairs (mapv (fn [k] [k k]) ks)
+          cmp   #(compare (str %1) (str %2))
+          sm    (into (sorted-map-by cmp) pairs)
+          am    (into (avl/sorted-map-by cmp) pairs)
+          om    (core/ordered-map-with string-cmp pairs)
+          look  (object-array (repeatedly 10000 #(nth ks (rand-int n))))]
+      (print-row n
+        [(bench 20 10 (dotimes [i 10000] (get sm (aget look i))))
+         (bench 20 10 (dotimes [i 10000] (get am (aget look i))))
+         (bench 20 10 (dotimes [i 10000] (om (aget look i))))]))))
+
+(defn bench-string-map-iteration
+  "Benchmark iteration with string keys."
+  [sizes]
+  (print-header "STRING MAP ITERATION: reduce over N entries, string keys"
+                ["sorted-map-by" "data.avl" "ordered-map"])
+  (doseq [n sizes]
+    (let [ks    (make-string-keys n)
+          pairs (mapv (fn [k] [k k]) ks)
+          cmp   #(compare (str %1) (str %2))
+          sm    (into (sorted-map-by cmp) pairs)
+          am    (into (avl/sorted-map-by cmp) pairs)
+          om    (core/ordered-map-with string-cmp pairs)]
+      (print-row n
+        [(bench 20 10 (reduce (fn [^long acc [k _]] (+ acc (long (hash k)))) 0 sm))
+         (bench 20 10 (reduce (fn [^long acc [k _]] (+ acc (long (hash k)))) 0 am))
+         (bench 20 10 (reduce (fn [^long acc [k _]] (+ acc (long (hash k)))) 0 om))]))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Memory Footprint (approximate)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn estimate-memory-footprint
+  "Estimate memory footprint by forcing GC and measuring heap delta."
+  [sizes]
+  (println)
+  (println "=== MEMORY FOOTPRINT: Approximate bytes per entry ===")
+  (println (format "%-10s %-20s %-20s %-20s %-20s" "N" "sorted-map" "data.avl" "ordered-map" "ordered-set"))
+  (println (apply str (repeat 94 "-")))
+  (doseq [n sizes]
+    (let [pairs (mapv (fn [k] [k (str k)]) (range n))
+          elems (range n)
+          measure (fn [create-fn]
+                    (let [rt    (Runtime/getRuntime)
+                          holder (volatile! nil)]
+                      ;; Measure baseline
+                      (System/gc) (Thread/sleep 200)
+                      (System/gc) (Thread/sleep 100)
+                      (let [used0 (- (.totalMemory rt) (.freeMemory rt))]
+                        ;; Create and retain collection
+                        (vreset! holder (create-fn))
+                        ;; Measure with collection alive — do NOT GC here
+                        ;; as that could collect internal structure
+                        (System/gc) (Thread/sleep 100)
+                        (let [used1 (- (.totalMemory rt) (.freeMemory rt))
+                              bpe   (/ (double (- used1 used0)) n)]
+                          ;; Keep strong reference alive past measurement
+                          (assert (some? @holder))
+                          bpe))))
+          sm-bpe  (measure #(into (sorted-map) pairs))
+          avl-bpe (measure #(into (avl/sorted-map) pairs))
+          om-bpe  (measure #(core/ordered-map pairs))
+          os-bpe  (measure #(core/ordered-set elems))]
+      (println (format "%-10d %-20.1f %-20.1f %-20.1f %-20.1f"
+                       n sm-bpe avl-bpe om-bpe os-bpe)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Main Entry Points
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn run-map-benchmarks
+  "Run all map-related benchmarks."
+  [sizes]
+  (bench-map-construction sizes)
+  (bench-map-incremental-insert sizes)
+  (bench-map-incremental-delete sizes)
+  (bench-map-lookup sizes)
+  (bench-map-iteration sizes)
+  (bench-map-seq-iteration sizes))
+
+(defn run-set-benchmarks
+  "Run all set-related benchmarks."
+  [sizes]
+  (bench-set-construction sizes)
+  (bench-set-incremental-insert sizes)
+  (bench-set-incremental-delete sizes)
+  (bench-set-lookup sizes)
+  (bench-set-iteration sizes)
+  (bench-set-comparison sizes))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Set Operations Benchmarks (union, intersection, difference)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-set-union
+  "Benchmark set union operations."
+  [sizes]
+  (print-header "SET UNION: union of two sets of size N (overlapping 50%)"
+                ["clojure.set/hash-set" "clojure.set/sorted-set" "ordered-set"])
+  (doseq [n sizes]
+    (let [{left :left right :right} (overlapping-set-variants n)
+          hs1 (:hash-set left)
+          hs2 (:hash-set right)
+          cs1 (:sorted-set left)
+          cs2 (:sorted-set right)
+          os1 (:ordered-set left)
+          os2 (:ordered-set right)]
+      (print-row n
+        [(bench 2 5 (clojure.set/union hs1 hs2))
+         (bench 2 5 (clojure.set/union cs1 cs2))
+         (bench 2 5 (core/union os1 os2))]))))
+
+(defn bench-set-intersection
+  "Benchmark set intersection operations."
+  [sizes]
+  (print-header "SET INTERSECTION: intersection of two sets of size N"
+                ["clojure.set/hash-set" "clojure.set/sorted-set" "ordered-set"])
+  (doseq [n sizes]
+    (let [{left :left right :right} (overlapping-set-variants n)
+          hs1 (:hash-set left)
+          hs2 (:hash-set right)
+          cs1 (:sorted-set left)
+          cs2 (:sorted-set right)
+          os1 (:ordered-set left)
+          os2 (:ordered-set right)]
+      (print-row n
+        [(bench 2 5 (clojure.set/intersection hs1 hs2))
+         (bench 2 5 (clojure.set/intersection cs1 cs2))
+         (bench 2 5 (core/intersection os1 os2))]))))
+
+(defn bench-set-difference
+  "Benchmark set difference operations."
+  [sizes]
+  (print-header "SET DIFFERENCE: difference of two sets of size N"
+                ["clojure.set/hash-set" "clojure.set/sorted-set" "ordered-set"])
+  (doseq [n sizes]
+    (let [{left :left right :right} (overlapping-set-variants n)
+          hs1 (:hash-set left)
+          hs2 (:hash-set right)
+          cs1 (:sorted-set left)
+          cs2 (:sorted-set right)
+          os1 (:ordered-set left)
+          os2 (:ordered-set right)]
+      (print-row n
+        [(bench 2 5 (clojure.set/difference hs1 hs2))
+         (bench 2 5 (clojure.set/difference cs1 cs2))
+         (bench 2 5 (core/difference os1 os2))]))))
+
+(defn run-set-operations-benchmarks
+  "Run set operation benchmarks (union, intersection, difference)."
+  [sizes]
+  (bench-set-union sizes)
+  (bench-set-intersection sizes)
+  (bench-set-difference sizes))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Interval Set/Map Benchmarks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-interval-set-construction
+  "Benchmark building an interval set from N random intervals."
+  [sizes]
+  (print-header "INTERVAL SET CONSTRUCTION: Build from N random intervals"
+                ["interval-set"])
+  (doseq [n sizes]
+    (let [intervals (mapv (fn [_]
+                            (let [a (rand-int 1000000)
+                                  b (+ a (rand-int 1000))]
+                              [a b]))
+                          (range n))]
+      (print-row n
+        [(bench 20 10 (core/interval-set intervals))]))))
+
+(defn bench-interval-set-query
+  "Benchmark interval overlap queries via get (returns overlapping intervals)."
+  [sizes]
+  (print-header "INTERVAL SET QUERY: 1,000 overlap queries on set of N intervals"
+                ["interval-set"])
+  (doseq [n sizes]
+    (let [intervals (mapv (fn [_]
+                            (let [a (rand-int 1000000)
+                                  b (+ a (rand-int 1000))]
+                              [a b]))
+                          (range n))
+          iset      (core/interval-set intervals)
+          ;; Create valid intervals for queries (a <= b)
+          queries   (vec (repeatedly 1000
+                           (fn [] (let [a (rand-int 1000000)] [a (+ a (rand-int 100))]))))]
+      (print-row n
+        [(bench 20 10 (doseq [q queries] (get iset q)))]))))
+
+(defn bench-interval-map-construction
+  "Benchmark building an interval map from N random intervals."
+  [sizes]
+  (print-header "INTERVAL MAP CONSTRUCTION: Build from N random interval key-value pairs"
+                ["interval-map"])
+  (doseq [n sizes]
+    (let [pairs (mapv (fn [i]
+                        (let [a (rand-int 1000000)
+                              b (+ a (rand-int 1000))]
+                          [[a b] i]))
+                      (range n))]
+      (print-row n
+        [(bench 20 10 (core/interval-map pairs))]))))
+
+(defn bench-interval-map-query
+  "Benchmark interval map overlap queries."
+  [sizes]
+  (print-header "INTERVAL MAP QUERY: 1,000 overlap queries on map of N intervals"
+                ["interval-map"])
+  (doseq [n sizes]
+    (let [pairs (mapv (fn [i]
+                        (let [a (rand-int 1000000)
+                              b (+ a (rand-int 1000))]
+                          [[a b] i]))
+                      (range n))
+          imap    (core/interval-map pairs)
+          ;; Create valid intervals for queries (a <= b)
+          queries (vec (repeatedly 1000
+                         (fn [] (let [a (rand-int 1000000)] [a (+ a (rand-int 100))]))))]
+      (print-row n
+        [(bench 20 10 (doseq [q queries] (get imap q)))]))))
+
+(defn run-interval-benchmarks
+  "Run interval set and map benchmarks."
+  [sizes]
+  (bench-interval-set-construction sizes)
+  (bench-interval-set-query sizes)
+  (bench-interval-map-construction sizes)
+  (bench-interval-map-query sizes))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; First/Last Element Access Benchmarks
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-first-last-access
+  "Benchmark accessing first and last elements via seq (clojure first/last)."
+  [sizes]
+  (print-header "FIRST/LAST ACCESS: 1,000 first/last calls"
+                ["sorted-set" "data.avl" "ordered-set"])
+  (doseq [n sizes]
+    (let [elems (shuffle (range n))
+          ss    (into (sorted-set) elems)
+          as    (into (avl/sorted-set) elems)
+          os    (core/ordered-set elems)]
+      (print-row n
+        [(bench 2 5 (dotimes [_ 1000] (first ss) (last ss)))
+         (bench 2 5 (dotimes [_ 1000] (first as) (last as)))
+         ;; Use SortedSet interface for ordered-set (optimized path)
+         (bench 2 5 (dotimes [_ 1000]
+                      (.first ^java.util.SortedSet os)
+                      (.last ^java.util.SortedSet os)))]))))
+
+(defn run-specialty-benchmarks
+  "Run benchmarks for specialty operations (rank, split)."
+  [sizes]
+  (bench-rank-access sizes)
+  (bench-rank-lookup sizes)
+  (bench-split-operations sizes))
+
+(defn run-string-benchmarks
+  "Run benchmarks with string keys (custom comparator)."
+  [sizes]
+  (bench-string-map-construction sizes)
+  (bench-string-map-lookup sizes)
+  (bench-string-map-iteration sizes))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Size Presets
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def sizes-quick   [100 1000 10000])
+(def sizes-default [100 1000 10000 100000])
+(def sizes-full    [100 1000 10000 100000 1000000])
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Benchmark Categories
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def categories
+  {:maps      {:title "MAP BENCHMARKS"
+               :fn    run-map-benchmarks}
+   :sets      {:title "SET BENCHMARKS"
+               :fn    run-set-benchmarks}
+   :set-ops   {:title "SET OPERATIONS (union, intersection, difference)"
+               :fn    run-set-operations-benchmarks}
+   :intervals {:title "INTERVAL TREE OPERATIONS"
+               :fn    run-interval-benchmarks}
+   :specialty {:title "SPECIALTY OPERATIONS (rank, split, first/last)"
+               :fn    (fn [sizes]
+                        (run-specialty-benchmarks sizes)
+                        (bench-first-last-access sizes))}
+   :strings   {:title "STRING KEYS (Custom Comparator)"
+               :fn    run-string-benchmarks}
+   :parallel  {:title "PARALLEL FOLD (r/fold)"
+               :fn    run-parallel-benchmarks}
+   :memory    {:title "MEMORY FOOTPRINT"
+               :fn    estimate-memory-footprint}})
+
+(def category-order [:maps :sets :set-ops :intervals :specialty :strings :parallel :memory])
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Main Entry Points
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn print-header-banner [sizes]
+  (println "========================================================================")
+  (println "  Performance Comparison: sorted-map vs data.avl vs ordered-map")
+  (println (str "  JVM: " (System/getProperty "java.version")
+                "  Clojure: " (clojure-version)))
+  (println (str "  " (java.util.Date.)))
+  (println (str "  Sizes: " (str/join ", " (map #(format "%,d" %) sizes))))
+  (println "========================================================================"))
+
+(defn run-categories
+  "Run specified benchmark categories with given sizes."
+  [sizes cats]
+  (print-header-banner sizes)
+  (doseq [cat-key cats
+          :let [{:keys [title fn]} (get categories cat-key)]
+          :when fn]
+    (println)
+    (println "------------------------------------------------------------------------")
+    (println (str "                    " title))
+    (println "------------------------------------------------------------------------")
+    (fn sizes))
+  (println)
+  (println "========================================================================")
+  (println "  Benchmark complete.")
+  (println "========================================================================"))
+
+(defn run-all
+  "Run the complete benchmark suite."
+  ([] (run-all sizes-default))
+  ([sizes] (run-categories sizes category-order)))
+
+(defn run-quick
+  "Run a quick benchmark with smaller sizes for development."
+  []
+  (run-all sizes-quick))
+
+(defn run-full
+  "Run full benchmark suite including 1M cardinality."
+  []
+  (run-all sizes-full))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; CLI
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn print-usage []
+  (println "Usage: lein bench-simple [options]")
+  (println)
+  (println "Options:")
+  (println "  --quick            Fast iteration (100 to 10K)")
+  (println "  --full             Full suite including 1M")
+  (println "  --sizes N,N,...    Custom sizes (comma-separated)")
+  (println "  --only CATS        Run only specified categories")
+  (println "  --help             Show this help")
+  (println)
+  (println "Categories for --only:")
+  (println "  maps, sets, set-ops, intervals, specialty, strings, parallel, memory")
+  (println)
+  (println "Examples:")
+  (println "  lein bench-simple --quick --only sets")
+  (println "  lein bench-simple --sizes 10000,100000 --only maps,sets")
+  (println "  lein bench-simple --full"))
+
+(defn- parse-categories [s]
+  (mapv keyword (str/split (str/lower-case s) #",")))
+
+(defn parse-args [args]
+  (let [base   (parse-standard-args args sizes-quick sizes-default sizes-full)
+        only   (get-arg-value (vec args) "--only")
+        cats   (if only (parse-categories only) category-order)]
+    (assoc base :categories cats)))
+
+(defn -main [& args]
+  (let [{:keys [sizes categories help]} (parse-args args)]
+    (if help
+      (print-usage)
+      (run-categories sizes categories)))
+  (shutdown-agents))
diff --git a/test/ordered_collections/test_utils.clj b/test/ordered_collections/test_utils.clj
new file mode 100644
index 0000000..633f405
--- /dev/null
+++ b/test/ordered_collections/test_utils.clj
@@ -0,0 +1,278 @@
+(ns ordered-collections.test-utils
+  "Shared test utilities: generators, constructors, assertion helpers.
+
+   Usage:
+     (:require [ordered-collections.test-utils :as tu])"
+  (:require [clojure.data.avl :as avl]
+            [clojure.test :refer [is]]
+            [clojure.test.check.generators :as gen]
+            [ordered-collections.core :as oc]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Test Scales
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def ^:const small   100)
+(def ^:const medium  1000)
+(def ^:const large   10000)
+(def ^:const huge    100000)
+(def ^:const massive 1000000)
+(def ^:const extreme 5000000)
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Random Data Generators (imperative)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn rand-longs
+  "Generate n unique random longs in [0, max-val)."
+  [n max-val]
+  (loop [s (transient #{})]
+    (if (>= (count s) n)
+      (vec (persistent! s))
+      (recur (conj! s (long (rand max-val)))))))
+
+(defn rand-ints
+  "Generate n unique random integers in [-range/2, range/2)."
+  [n range-size]
+  (let [half (quot range-size 2)]
+    (loop [s (transient #{})]
+      (if (>= (count s) n)
+        (vec (persistent! s))
+        (recur (conj! s (- (rand-int range-size) half)))))))
+
+(defn rand-strings
+  "Generate n unique random strings."
+  [n]
+  (let [chars "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"]
+    (loop [s (transient #{})]
+      (if (>= (count s) n)
+        (vec (persistent! s))
+        (recur (conj! s (apply str (repeatedly (+ 5 (rand-int 20)) #(rand-nth chars)))))))))
+
+(defn rand-map-entries
+  "Generate n unique [k v] pairs with integer keys and values."
+  [n max-key]
+  (let [keys (rand-longs n max-key)]
+    (mapv #(vector % (rand-int 1000000)) keys)))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; test.check Generators
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn distinct-by
+  "Return values from coll, deduplicated by (f x)."
+  [f coll]
+  (vals (reduce (fn [m x] (assoc m (f x) x)) {} coll)))
+
+(def gen-int-set
+  "Generator for vectors of distinct integers."
+  (gen/fmap #(vec (distinct %)) (gen/vector gen/small-integer 0 500)))
+
+(def gen-non-empty-int-set
+  "Generator for non-empty vectors of distinct integers."
+  (gen/fmap #(vec (distinct %))
+            (gen/such-that not-empty (gen/vector gen/small-integer 1 200))))
+
+(def gen-int-map-entries
+  "Generator for vectors of distinct [k v] pairs."
+  (gen/fmap #(vec (distinct-by first %))
+            (gen/vector (gen/tuple gen/small-integer gen/small-integer) 0 500)))
+
+(def gen-non-empty-int-map-entries
+  "Generator for non-empty vectors of distinct [k v] pairs."
+  (gen/fmap #(vec (distinct-by first %))
+            (gen/such-that not-empty
+                           (gen/vector (gen/tuple gen/small-integer gen/small-integer) 1 200))))
+
+(def gen-test-symbol
+  "Generator for nearest/subrange test symbols."
+  (gen/elements [:< :<= :> :>=]))
+
+(def gen-range
+  "Generate a valid range [lo hi) where lo < hi."
+  (gen/bind (gen/tuple gen/small-integer gen/small-integer)
+            (fn [[a b]]
+              (let [lo (min a b)
+                    hi (max a b)]
+                (if (= lo hi)
+                  (gen/return [lo (inc hi)])
+                  (gen/return [lo hi]))))))
+
+(def gen-query-range
+  "Generator for inclusive query ranges [lo hi] with lo <= hi."
+  (gen/let [a gen/small-integer
+            b gen/small-integer]
+    [(min a b) (max a b)]))
+
+(def gen-priority-pairs
+  "Generator for [priority value] pairs, allowing duplicate priorities."
+  (gen/vector (gen/tuple gen/small-integer gen/small-integer) 0 200))
+
+(def gen-multiset-elems
+  "Generator for duplicate-heavy multiset inputs."
+  (gen/vector gen/small-integer 0 300))
+
+(def gen-segment-updates
+  "Generator for segment-tree [k v] updates, allowing repeated keys."
+  (gen/vector (gen/tuple gen/small-integer gen/small-integer) 0 50))
+
+(def gen-rope-op
+  "Generator for rope edit operations over small integer payloads."
+  (gen/one-of
+    [(gen/fmap (fn [[i x]] [:insert i [x] nil])
+       (gen/tuple (gen/choose 0 40) gen/small-integer))
+     (gen/fmap (fn [[i xs]] [:insert-many i xs nil])
+       (gen/tuple (gen/choose 0 40)
+                  (gen/vector gen/small-integer 0 8)))
+     (gen/fmap (fn [[a b]] [:remove (min a b) (max a b) nil])
+       (gen/tuple (gen/choose 0 40) (gen/choose 0 40)))
+     (gen/fmap (fn [[a b xs]] [:splice (min a b) (max a b) xs])
+       (gen/tuple (gen/choose 0 40)
+                  (gen/choose 0 40)
+                  (gen/vector gen/small-integer 0 8)))
+     (gen/fmap (fn [[a b]] [:subrope (min a b) (max a b) nil])
+       (gen/tuple (gen/choose 0 40) (gen/choose 0 40)))]))
+
+(def gen-rope-ops
+  "Generator for rope edit sequences."
+  (gen/vector gen-rope-op 0 60))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Reference Models for Property Tests
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn priority-queue-order
+  "Reference queue order for [priority value] pairs.
+
+   Equal priorities are FIFO in forward queue order."
+  ([pairs]
+   (priority-queue-order pairs false))
+  ([pairs descending?]
+   (->> pairs
+        (map-indexed (fn [idx [p v]] [p idx v]))
+        (sort-by (juxt (if descending? (comp - first) first) second))
+        (mapv (fn [[p _ v]] [p v])))))
+
+(defn multiset-disj-one-frequencies
+  "Reference frequencies after removing one occurrence of x."
+  [xs x]
+  (let [freqs (frequencies xs)]
+    (if (pos? (get freqs x 0))
+      (let [next-n (dec (get freqs x))]
+        (if (zero? next-n)
+          (dissoc freqs x)
+          (assoc freqs x next-n)))
+      freqs)))
+
+(defn fuzzy-nearest-ref
+  "Reference nearest value for integer fuzzy structures."
+  [xs q tiebreak]
+  (when (seq xs)
+    (let [dist (fn [x] (Math/abs ^long (- (long q) (long x))))]
+      (first
+        (sort-by (fn [x]
+                   [(dist x)
+                    (case tiebreak
+                      :< (long x)
+                      :> (- (long x)))])
+                 xs)))))
+
+(defn fuzzy-nearest-map-ref
+  "Reference nearest [key value] pair for integer fuzzy maps."
+  [m q tiebreak]
+  (when (seq m)
+    (let [k (fuzzy-nearest-ref (keys m) q tiebreak)]
+      [k (get m k)])))
+
+(defn ref-range-sum
+  "Reference: sum values for keys in [lo, hi]."
+  [m lo hi]
+  (reduce + 0 (for [[k v] m :when (<= lo k hi)] v)))
+
+(defn absent-small-int
+  "Return a small integer not present in coll, or nil if none is found."
+  [coll]
+  (first (filter #(not (contains? coll %)) (range -1000 1000))))
+
+(defn nearest-ref
+  "Reference nearest result for ordered collections."
+  [coll test k]
+  (case test
+    :<  (first (rsubseq coll < k))
+    :<= (first (rsubseq coll <= k))
+    :>  (first (subseq coll > k))
+    :>= (first (subseq coll >= k))))
+
+(defn subrange-ref
+  "Reference subrange result for ordered collections."
+  [coll test k]
+  (case test
+    :<  (subseq coll < k)
+    :<= (subseq coll <= k)
+    :>  (subseq coll > k)
+    :>= (subseq coll >= k)))
+
+(defn slice-ref
+  "Reference slice by index over an ordered collection."
+  [coll start end]
+  (->> coll seq (drop start) (take (- end start))))
+
+(defn split-key-ref
+  "Reference split-key result over an ordered collection."
+  [coll k]
+  [(into (empty coll) (subrange-ref coll :< k))
+   (when-let [v (get coll k)]
+     (if (map? coll) [k v] v))
+   (into (empty coll) (subrange-ref coll :> k))])
+
+(defn split-at-ref
+  "Reference split-at result over an ordered collection."
+  [coll i]
+  [(into (empty coll) (slice-ref coll 0 i))
+   (into (empty coll) (slice-ref coll i (count coll)))])
+
+(defn percentile-index
+  "Reference percentile index used by ranked collection tests."
+  [n pct]
+  (min (dec n) (long (* (/ (double pct) 100.0) n))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Collection Constructors
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Sets
+(defn ->ss  [xs] (into (sorted-set) xs))
+(defn ->hs  [xs] (into #{} xs))
+(defn ->as  [xs] (into (avl/sorted-set) xs))
+(defn ->os  [xs] (oc/ordered-set xs))
+(defn ->los [xs] (oc/long-ordered-set xs))
+
+;; Maps
+(defn ->sm [xs] (into (sorted-map) xs))
+(defn ->am [xs] (into (avl/sorted-map) xs))
+(defn ->om [xs] (oc/ordered-map xs))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Assertion Helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn same-seq?
+  "True if all collections have identical element sequences."
+  [& colls]
+  (apply = (map vec colls)))
+
+(defn assert-eq
+  "Assert that all results are equal, with descriptive message."
+  [msg & vals]
+  (is (apply = vals) msg))
+
+(defmacro with-iterations
+  "Run body n times."
+  [n & body]
+  `(dotimes [_# ~n] ~@body))
diff --git a/test/ordered_collections/transient_rope_bench.clj b/test/ordered_collections/transient_rope_bench.clj
new file mode 100644
index 0000000..9adb41e
--- /dev/null
+++ b/test/ordered_collections/transient_rope_bench.clj
@@ -0,0 +1,166 @@
+(ns ordered-collections.transient-rope-bench
+  "Dedicated benchmark for rope construction strategies.
+
+   Focus:
+   - small ropes must not regress
+   - large append-heavy builds should improve
+
+   Compares:
+   - current TransientRope
+   - direct `(oc/rope coll)`
+   - old-style transient-like flush-via-concat builder
+   - repeated rope-concat assembly from chunks"
+  (:require [ordered-collections.bench-utils :as bu :refer [has-flag?]]
+            [ordered-collections.core :as oc]
+            [ordered-collections.kernel.rope :as ropetree]))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Benchmark Infrastructure
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn bench-op
+  [f warmup-iters bench-iters]
+  (dotimes [_ warmup-iters] (f))
+  (let [start (System/nanoTime)]
+    (dotimes [_ bench-iters] (f))
+    (/ (- (System/nanoTime) start) (* bench-iters 1000.0))))
+
+(defn bench-op-samples
+  [f warmup-iters bench-iters sample-runs]
+  (let [samples (vec (repeatedly sample-runs #(bench-op f warmup-iters bench-iters)))
+        sorted  (sort samples)
+        n       (count sorted)]
+    {:median  (nth sorted (quot n 2))
+     :mean    (/ (reduce + sorted) n)
+     :low     (first sorted)
+     :high    (last sorted)
+     :samples samples}))
+
+(defn- fmt-us [stats]
+  (bu/format-ns (* 1000 (:median stats))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Builders
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- old-transient-build
+  [base coll]
+  (let [target ropetree/+target-chunk-size+]
+    (loop [root (.-root ^ordered_collections.types.rope.Rope (oc/rope base))
+           tail []
+           xs   (seq coll)]
+      (if-let [s xs]
+        (let [tail' (conj tail (first s))]
+          (if (= (count tail') target)
+            (recur (ropetree/rope-concat root (ropetree/chunks->root [tail']))
+                   []
+                   (next s))
+            (recur root tail' (next s))))
+        (if (seq tail)
+          (ropetree/rope-concat root (ropetree/chunks->root [tail]))
+          root)))))
+
+(defn- concat-build
+  [base coll]
+  (let [target ropetree/+target-chunk-size+
+        parts  (map oc/rope (partition-all target coll))]
+    (reduce oc/rope-concat (oc/rope base) parts)))
+
+(defn- transient-build
+  [base coll]
+  (persistent! (reduce conj! (transient (oc/rope base)) coll)))
+
+(defn- force-old-build
+  [base coll]
+  (ropetree/rope-size (old-transient-build base coll)))
+
+(defn- force-rope
+  [r]
+  (count r))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Bench
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def default-sizes [64 256 4096 65536 1000000])
+(def quick-sizes [64 256 4096 65536])
+
+(defn- bench-size
+  [n opts]
+  (let [base-size (quot n 4)
+        append-n  n
+        base      (range base-size)
+        append    (range base-size (+ base-size append-n))]
+    {:n n
+     :empty
+     {:transient (bench-op-samples #(force-rope (transient-build [] (range n)))
+                   (:warmup opts) (:iters opts) (:samples opts))
+      :direct    (bench-op-samples #(force-rope (oc/rope (range n)))
+                   (:warmup opts) (:iters opts) (:samples opts))
+      :old       (bench-op-samples #(force-old-build [] (range n))
+                   (:warmup opts) (:iters opts) (:samples opts))
+      :concat    (bench-op-samples #(force-rope (concat-build [] (range n)))
+                   (:warmup opts) (:iters opts) (:samples opts))}
+     :append
+     {:transient (bench-op-samples #(force-rope (transient-build base append))
+                   (:warmup opts) (:iters opts) (:samples opts))
+      :direct    (bench-op-samples #(force-rope (oc/rope (concat base append)))
+                   (:warmup opts) (:iters opts) (:samples opts))
+      :old       (bench-op-samples #(force-old-build base append)
+                   (:warmup opts) (:iters opts) (:samples opts))
+      :concat    (bench-op-samples #(force-rope (concat-build base append))
+                   (:warmup opts) (:iters opts) (:samples opts))}}))
+
+(defn- print-table
+  [title rows k]
+  (println)
+  (println "═══════════════════════════════════════════════════════════════════════════════════════════")
+  (println (str "  " title))
+  (println "═══════════════════════════════════════════════════════════════════════════════════════════")
+  (println "  ┌──────────┬────────────┬────────────┬────────────┬────────────┐")
+  (println "  │ N        │ transient  │ old flush  │ direct     │ concat     │")
+  (println "  ├──────────┼────────────┼────────────┼────────────┼────────────┤")
+  (doseq [{:keys [n] :as row} rows]
+    (let [r (k row)]
+      (printf "  │ %7d  │ %10s │ %10s │ %10s │ %10s │%n"
+              n
+              (fmt-us (:transient r))
+              (fmt-us (:old r))
+              (fmt-us (:direct r))
+              (fmt-us (:concat r)))))
+  (println "  └──────────┴────────────┴────────────┴────────────┴────────────┘"))
+
+(defn run-benchmark
+  [& {:keys [sizes warmup iters samples]
+      :or {sizes default-sizes
+           warmup 10
+           iters 30
+           samples 7}}]
+  (let [opts {:warmup warmup :iters iters :samples samples}]
+    (println "Transient rope benchmark")
+    (println "Sizes:" sizes)
+    (println (format "Per-measurement: %d warmup, %d iters, %d samples" warmup iters samples))
+    (println)
+    (let [rows (vec (for [n sizes]
+                      (do
+                        (print (format "  N=%,d " n))
+                        (flush)
+                        (let [row (bench-size n opts)]
+                          (println)
+                          row))))]
+      (print-table "Build From Empty" rows :empty)
+      (print-table "Append To Existing Rope" rows :append)
+      rows)))
+
+(defn quick-bench []
+  (run-benchmark :sizes quick-sizes
+                 :warmup 5 :iters 15 :samples 5))
+
+(defn -main [& args]
+  (if (has-flag? args "--quick" "-q")
+    (quick-bench)
+    (run-benchmark))
+  (shutdown-agents))
diff --git a/test/com/dean/interval_tree/tree_test.clj b/test/ordered_collections/tree_test.clj
similarity index 65%
rename from test/com/dean/interval_tree/tree_test.clj
rename to test/ordered_collections/tree_test.clj
index 874618b..ef8e6d6 100644
--- a/test/com/dean/interval_tree/tree_test.clj
+++ b/test/ordered_collections/tree_test.clj
@@ -1,7 +1,11 @@
-(ns com.dean.interval-tree.tree-test
+(ns ordered-collections.tree-test
   (:require [clojure.test :refer :all]
-            [com.dean.interval-tree.tree.node :as node]
-            [com.dean.interval-tree.tree.tree :as tree]))
+            [ordered-collections.kernel.node :as node]
+            [ordered-collections.kernel.tree :as tree]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]))
+
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Fixtures
@@ -75,7 +79,7 @@
 
 (deftest rotation-check:single-left
   (let [node node/->SimpleNode]
-    (matches (tree/rotate-single-left :AK :AV
+    (matches (tree/rotate-single-left tree/node-create-weight-balanced :AK :AV
                   (node :XK :XV (node/leaf) (node/leaf) 1)
                   (node :BK :BV (node :YK :YV (node/leaf) (node/leaf) 1)
                                 (node :ZK :XZ (node/leaf) (node/leaf) 1) 3))
@@ -86,7 +90,7 @@
 
 (deftest rotation-check:double-left
   (let [node node/->SimpleNode]
-    (matches (tree/rotate-double-left :AK :AV
+    (matches (tree/rotate-double-left tree/node-create-weight-balanced :AK :AV
                  (node :XK :XV (node/leaf) (node/leaf) 1)
                  (node :CK :CV
                        (node :BK :BV (node :Y1K :Y1V (node/leaf) (node/leaf) 1)
@@ -101,7 +105,7 @@
 
 (deftest rotation-check:single-right
   (let [node node/->SimpleNode]
-    (matches (tree/rotate-single-right :BK :BV
+    (matches (tree/rotate-single-right tree/node-create-weight-balanced :BK :BV
                  (node :AK :AV (node :XK :XV (node/leaf) (node/leaf) 1)
                                (node :YK :YV (node/leaf) (node/leaf) 1) 3)
                  (node :ZK :XZ (node/leaf) (node/leaf) 1))
@@ -112,7 +116,7 @@
 
 (deftest rotation-check:double-right
   (let [node node/->SimpleNode]
-    (matches (tree/rotate-double-right :CK :CV
+    (matches (tree/rotate-double-right tree/node-create-weight-balanced :CK :CV
                  (node :AK :AV (node :XK :XV (node/leaf) (node/leaf) 1)
                                (node :BK :BV (node :Y1K :Y1V (node/leaf) (node/leaf) 1)
                                              (node :Y2K :Y2V (node/leaf) (node/leaf) 1) 3) 5)
@@ -270,10 +274,112 @@
     (let [tree (make-integer-tree size)
           sum  (reduce + (range size))]
       (is (= sum (reduce + (map node/-k (tree/node-seq tree)))))
+      (is (= (reverse (range size))
+             (tree/node-reduce-right (fn [acc n] (conj acc (node/-k n))) [] tree)))
+      (let [seen (volatile! [])]
+        (tree/node-run-kv! tree (fn [k v] (vswap! seen conj [k v])))
+        (is (= (mapv (fn [k] [k k]) (range size)) @seen)))
       (dotimes [_ 1000]
-        (is (= sum (tree/node-chunked-fold (inc (rand-int size))
+        (is (= sum (tree/node-fold (inc (rand-int size))
                      tree + (fn ([acc x] (+ acc (node/-k x)))))))))))
 
+(deftest node-traversal-api-check
+  (let [tree     (make-tree0 10)
+        forward  (mapv identity (range 10))
+        reverse  (vec (reverse forward))
+        forward-kv (mapv vector forward (map str forward))
+        reverse-kv (mapv vector reverse (map str reverse))
+        grow-seeded (fn [acc x]
+                      (conj (if (vector? acc) acc [acc]) x))
+        grow-seeded-entry (fn [acc e]
+                            (conj (if (instance? clojure.lang.IMapEntry acc)
+                                    [[(key acc) (val acc)]]
+                                    acc)
+                                  [(key e) (val e)]))
+        node-ks  (fn [n] (node/-k n))]
+    (let [seen (volatile! [])]
+      (tree/node-run! tree #(vswap! seen conj (node-ks %)))
+      (is (= forward @seen)))
+    (let [seen (volatile! [])]
+      (tree/node-run-reverse! tree #(vswap! seen conj (node-ks %)))
+      (is (= reverse @seen)))
+    (let [seen (volatile! [])]
+      (tree/node-run-kv! tree (fn [k v] (vswap! seen conj [k v])))
+      (is (= forward-kv @seen)))
+    (let [seen (volatile! [])]
+      (tree/node-run-kv-reverse! tree (fn [k v] (vswap! seen conj [k v])))
+      (is (= reverse-kv @seen)))
+    (is (= forward
+           (tree/node-reduce (fn [acc n] (conj acc (node-ks n))) [] tree)))
+    (is (= reverse
+           (tree/node-reduce-right (fn [acc n] (conj acc (node-ks n))) [] tree)))
+    (is (= forward
+           (tree/node-reduce-keys conj [] tree)))
+    (is (= reverse
+           (tree/node-reduce-keys-right conj [] tree)))
+    (is (= (mapv vector forward (map str forward))
+           (tree/node-reduce-kv (fn [acc k v] (conj acc [k v])) [] tree)))
+    (is (= (mapv vector reverse (map str reverse))
+           (tree/node-reduce-kv-right (fn [acc k v] (conj acc [k v])) [] tree)))
+    (is (= forward-kv
+           (tree/node-reduce-entries (fn [acc e] (conj acc [(key e) (val e)])) [] tree)))
+    (is (= reverse-kv
+           (tree/node-reduce-entries-right (fn [acc e] (conj acc [(key e) (val e)])) [] tree)))
+    (is (= 3
+           (tree/node-reduce (fn [acc n]
+                               (let [k (node-ks n)]
+                                 (if (= k 3) (reduced k) k)))
+                             nil tree)))
+    (is (= 3
+           (tree/node-reduce-right (fn [_ n]
+                                     (let [k (node-ks n)]
+                                       (if (= k 3) (reduced k) nil)))
+                                   nil tree)))
+    (is (= 3
+           (tree/node-reduce-keys (fn [_ k] (if (= k 3) (reduced k) nil))
+                                  nil tree)))
+    (is (= 3
+           (tree/node-reduce-keys-right (fn [_ k] (if (= k 3) (reduced k) nil))
+                                        nil tree)))
+    (is (= [3 "3"]
+           (tree/node-reduce-kv (fn [_ k v]
+                                  (if (= k 3) (reduced [k v]) nil))
+                                nil tree)))
+    (is (= [3 "3"]
+           (tree/node-reduce-kv-right (fn [_ k v]
+                                        (if (= k 3) (reduced [k v]) nil))
+                                      nil tree)))
+    (is (= [3 "3"]
+           (tree/node-reduce-entries (fn [_ e]
+                                       (if (= (key e) 3)
+                                         (reduced [(key e) (val e)])
+                                         nil))
+                                     nil tree)))
+    (is (= [3 "3"]
+           (tree/node-reduce-entries-right (fn [_ e]
+                                             (if (= (key e) 3)
+                                               (reduced [(key e) (val e)])
+                                               nil))
+                                           nil tree)))
+    (is (= [] (tree/node-reduce conj [] (node/leaf))))
+    (is (= [] (tree/node-reduce-right conj [] (node/leaf))))
+    (is (= [] (tree/node-reduce-keys conj [] (node/leaf))))
+    (is (= [] (tree/node-reduce-keys-right conj [] (node/leaf))))
+    (is (= [] (tree/node-reduce-kv (fn [acc k v] (conj acc [k v])) [] (node/leaf))))
+    (is (= [] (tree/node-reduce-kv-right (fn [acc k v] (conj acc [k v])) [] (node/leaf))))
+    (is (= [] (tree/node-reduce-entries (fn [acc e] (conj acc e)) [] (node/leaf))))
+    (is (= [] (tree/node-reduce-entries-right (fn [acc e] (conj acc e)) [] (node/leaf))))
+    (is (= forward
+           (tree/node-reduce-keys grow-seeded tree)))
+    (is (= reverse
+           (tree/node-reduce-keys-right grow-seeded tree)))
+    (is (= forward-kv
+           (tree/node-reduce-entries grow-seeded-entry tree)))
+    (is (= reverse-kv
+           (tree/node-reduce-entries-right grow-seeded-entry tree)))
+    (is (= nil (tree/node-run! (node/leaf) (constantly :impossible))))
+    (is (= nil (tree/node-run-kv! (node/leaf) (fn [_ _] :impossible))))))
+
 (deftest node-comparison-check
   (let [nums #(-> % (repeatedly (partial rand-int 1000000000)))
         tree #(->> % nums (reduce tree/node-add (node/leaf)))
@@ -288,3 +394,18 @@
                                    (tree/node-remove-least %2))))]
     (doseq [size [1 10 100 1000 10000 100000]]
       (chk (tree size) (tree size)))))
+
+(defspec prop-tree-health-after-random-edit 100
+  (prop/for-all [size  (gen/choose 1 500)
+                 extra gen/small-integer]
+    (let [t        (make-integer-tree size)
+          idx      (rand-int size)
+          victim   (-> t (tree/node-nth idx) node/-k)
+          added    (tree/node-add t extra)
+          removed  (tree/node-remove t victim)
+          trimmedl (tree/node-remove-least t)
+          trimmedr (tree/node-remove-greatest t)]
+      (and (tree/node-healthy? added)
+           (tree/node-healthy? removed)
+           (tree/node-healthy? trimmedl)
+           (tree/node-healthy? trimmedr)))))
diff --git a/test/ordered_collections/zorp_test.clj b/test/ordered_collections/zorp_test.clj
new file mode 100644
index 0000000..26e0a45
--- /dev/null
+++ b/test/ordered_collections/zorp_test.clj
@@ -0,0 +1,438 @@
+(ns ordered-collections.zorp-test
+  "Tests for examples in doc/zorp-example.md
+
+   Zorp's Sneaker Emporium: Advanced Patterns
+   Testing the 0.2.0 API features."
+  (:refer-clojure :exclude [split-at])
+  (:require [clojure.test :refer [deftest testing is are]]
+            [clojure.string :as str]
+            [ordered-collections.core :as oc]))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Chapter 1: The Subnet Allocation (range-map)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn ip
+  "Convert IP string to integer."
+  [s]
+  (let [[a b c d] (map parse-long (str/split s #"\."))]
+    (+ (* a 16777216) (* b 65536) (* c 256) d)))
+
+(defn int->ip
+  "Convert integer to IP string."
+  [n]
+  (format "%d.%d.%d.%d"
+    (bit-and (bit-shift-right n 24) 0xff)
+    (bit-and (bit-shift-right n 16) 0xff)
+    (bit-and (bit-shift-right n 8) 0xff)
+    (bit-and n 0xff)))
+
+(deftest chapter-1-subnet-allocation-test
+  (testing "IP helper functions"
+    (is (= 167772160 (ip "10.0.0.0")))
+    (is (= 167772161 (ip "10.0.0.1")))
+    (is (= "10.0.0.0" (int->ip 167772160)))
+    (is (= "10.1.0.4" (int->ip (ip "10.1.0.4")))))
+
+  (testing "Range-map creation and basic lookup"
+    (let [network (oc/range-map {[(ip "10.0.0.0") (inc (ip "10.255.255.255"))] :unallocated})]
+      (is (= :unallocated (network (ip "10.5.0.1"))))
+      (is (= :unallocated (network (ip "10.128.0.0"))))))
+
+  (testing "Subnet allocation carves out ranges"
+    (let [network (-> (oc/range-map {[(ip "10.0.0.0") (inc (ip "10.255.255.255"))] :unallocated})
+                      (assoc [(ip "10.1.0.0") (ip "10.2.0.0")] :point-of-sale)
+                      (assoc [(ip "10.2.0.0") (ip "10.3.0.0")] :inventory)
+                      (assoc [(ip "10.10.0.0") (ip "10.11.0.0")] :customer-wifi))]
+      ;; Look up which system owns an IP
+      (is (= :point-of-sale (network (ip "10.1.0.4"))))
+      (is (= :inventory (network (ip "10.2.0.68"))))
+      (is (= :customer-wifi (network (ip "10.10.5.42"))))
+      (is (= :unallocated (network (ip "10.5.0.1"))))))
+
+  (testing "Quarantine zone splits existing range"
+    (let [network (-> (oc/range-map {[(ip "10.10.0.0") (ip "10.11.0.0")] :customer-wifi})
+                      (assoc [(ip "10.10.4.0") (ip "10.10.8.0")] :kevin-quarantine))
+          ranges (for [[[lo hi] owner] (oc/ranges network)]
+                   {:lo (int->ip lo) :hi (int->ip hi) :owner owner})]
+      ;; customer-wifi should be split around quarantine
+      (is (= 3 (count ranges)))
+      (is (some #(= {:lo "10.10.0.0" :hi "10.10.4.0" :owner :customer-wifi} %) ranges))
+      (is (some #(= {:lo "10.10.4.0" :hi "10.10.8.0" :owner :kevin-quarantine} %) ranges))
+      (is (some #(= {:lo "10.10.8.0" :hi "10.11.0.0" :owner :customer-wifi} %) ranges))))
+
+  (testing "Adjacent ranges with same value coalesce (using assoc-coalescing)"
+    (let [network (-> (oc/range-map {[(ip "10.10.4.0") (ip "10.10.8.0")] :kevin-iot})
+                      (oc/assoc-coalescing [(ip "10.10.8.0") (ip "10.10.12.0")] :kevin-iot))
+          kevin-ranges (for [[[lo hi] owner] (oc/ranges network)
+                             :when (= owner :kevin-iot)]
+                         {:lo (int->ip lo) :hi (int->ip hi)})]
+      ;; Should coalesce into single range
+      (is (= 1 (count kevin-ranges)))
+      (is (= {:lo "10.10.4.0" :hi "10.10.12.0"} (first kevin-ranges))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Chapter 2: Big Toe Tony's Fitting (nearest)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def available-sizes
+  (oc/ordered-set
+    [6.0 6.5 7.0 7.5 8.0 8.5 9.0 9.5 10.0 10.5
+     11.0 11.5 12.0 12.5 13.0 13.5 14.0 14.5 15.0]))
+
+(deftest chapter-2-big-toe-tonys-fitting-test
+  (testing "nearest :<= finds floor (largest size that fits)"
+    (is (= 11.0 (oc/nearest available-sizes :<= 11.3)))
+    (is (= 10.5 (oc/nearest available-sizes :<= 10.8)))
+    (is (= 9.0 (oc/nearest available-sizes :<= 9.2))))
+
+  (testing "nearest :>= finds ceiling (smallest size with room)"
+    (is (= 11.5 (oc/nearest available-sizes :>= 11.3)))
+    (is (= 11.0 (oc/nearest available-sizes :>= 10.8)))
+    (is (= 9.5 (oc/nearest available-sizes :>= 9.2))))
+
+  (testing "nearest with strict bounds"
+    (is (= 10.5 (oc/nearest available-sizes :< 11.0)))
+    (is (= 13.5 (oc/nearest available-sizes :> 13.0))))
+
+  (testing "fit-foot function finds snug and roomy options"
+    (let [tonys-feet {:reginald 11.3 :gerald 10.8 :margaret 9.2
+                      :humphrey 13.7 :agnes 8.1 :bernard 12.0}
+          fit-foot (fn [[foot-name ideal-size]]
+                     {:foot foot-name
+                      :ideal ideal-size
+                      :snug (oc/nearest available-sizes :<= ideal-size)
+                      :roomy (oc/nearest available-sizes :>= ideal-size)})
+          fits (into {} (map (fn [f] [(:foot f) f]) (map fit-foot tonys-feet)))]
+      (is (= {:foot :reginald :ideal 11.3 :snug 11.0 :roomy 11.5}
+             (:reginald fits)))
+      (is (= {:foot :gerald :ideal 10.8 :snug 10.5 :roomy 11.0}
+             (:gerald fits)))
+      (is (= {:foot :margaret :ideal 9.2 :snug 9.0 :roomy 9.5}
+             (:margaret fits)))))
+
+  (testing "nearest at boundaries"
+    (is (nil? (oc/nearest available-sizes :< 6.0)))
+    (is (nil? (oc/nearest available-sizes :> 15.0)))
+    (is (= 6.0 (oc/nearest available-sizes :<= 6.0)))
+    (is (= 15.0 (oc/nearest available-sizes :>= 15.0)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Chapter 3: The Split Decision (split-at, split-key)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest chapter-3-split-decision-test
+  (testing "split-at partitions by position for percentiles"
+    (let [customer-spending (oc/ordered-map
+                              (for [id (range 1000)]
+                                [(+ 100 (* id 50)) {:id id}]))
+          n (count customer-spending)]
+      ;; Top 10%
+      (let [[_ top-10-pct] (oc/split-at (- n (quot n 10)) customer-spending)]
+        (is (= 100 (count top-10-pct))))
+      ;; Bottom 20%
+      (let [[bottom-20-pct _] (oc/split-at (quot n 5) customer-spending)]
+        (is (= 200 (count bottom-20-pct))))
+      ;; Median
+      (let [[lower upper] (oc/split-at (quot n 2) customer-spending)]
+        (is (= 500 (count lower)))
+        (is (= 500 (count upper))))))
+
+  (testing "split-key partitions by value at threshold"
+    (let [customer-spending (oc/ordered-map
+                              [[100 {:id 0}] [500 {:id 1}] [1000 {:id 2}]
+                               [5000 {:id 3}] [10000 {:id 4}] [25000 {:id 5}]])
+          [casual exact vip] (oc/split-key 10000 customer-spending)]
+      (is (= 4 (count casual)))       ; 100, 500, 1000, 5000
+      (is (some? exact))              ; exact match at 10000
+      (is (= 1 (count vip)))))        ; 25000
+
+  (testing "split-key with no exact match"
+    (let [spending (oc/ordered-map [[100 :a] [500 :b] [1000 :c]])
+          [below exact above] (oc/split-key 750 spending)]
+      (is (= 2 (count below)))        ; 100, 500
+      (is (nil? exact))               ; no 750
+      (is (= 1 (count above)))))      ; 1000
+
+  (testing "Results are full collections - can chain operations"
+    (let [customer-spending (oc/ordered-map
+                              [[100 :a] [500 :b] [1000 :c] [5000 :d]
+                               [10000 :e] [25000 :f] [50000 :g]])
+          [_ _ high-spenders] (oc/split-key 25000 customer-spending)]
+      ;; Can get last element of result
+      (is (= [50000 :g] (last high-spenders))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Chapter 4: Fuzzy Lookup (fuzzy-set, fuzzy-map)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def shipping-tiers
+  (oc/fuzzy-set [100 250 500 750 1000 1500 2000]))
+
+(def loyalty-tiers
+  (oc/fuzzy-map
+    {0     {:tier :bronze  :discount 0.05}
+     500   {:tier :silver  :discount 0.10}
+     1000  {:tier :gold    :discount 0.15}
+     2500  {:tier :platinum :discount 0.20}
+     5000  {:tier :diamond :discount 0.25}}))
+
+(deftest chapter-4-fuzzy-lookup-test
+  (testing "fuzzy-set snaps to nearest value"
+    (is (= 250 (shipping-tiers 350)))   ; closer to 250 than 500
+    (is (= 500 (shipping-tiers 450)))   ; closer to 500 than 250
+    (is (= 100 (shipping-tiers 50)))    ; below range, snaps to 100
+    (is (= 2000 (shipping-tiers 3000))) ; above range, snaps to 2000
+    (is (= 750 (shipping-tiers 750))))  ; exact match
+
+  (testing "fuzzy-nearest returns [value distance]"
+    (let [[value distance] (oc/fuzzy-nearest shipping-tiers 350)]
+      (is (= 250 value))
+      (is (= 100.0 distance)))
+    (let [[value distance] (oc/fuzzy-nearest shipping-tiers 750)]
+      (is (= 750 value))
+      (is (= 0.0 distance))))
+
+  (testing "fuzzy-map snaps to nearest key, returns value"
+    (is (= {:tier :silver :discount 0.10} (loyalty-tiers 523)))
+    (is (= {:tier :platinum :discount 0.20} (loyalty-tiers 2100)))
+    (is (= {:tier :bronze :discount 0.05} (loyalty-tiers 0)))
+    (is (= {:tier :diamond :discount 0.25} (loyalty-tiers 5000))))
+
+  (testing "fuzzy-nearest on fuzzy-map returns [key value distance]"
+    (let [[threshold tier distance] (oc/fuzzy-nearest loyalty-tiers 480)]
+      (is (= 500 threshold))
+      (is (= {:tier :silver :discount 0.10} tier))
+      (is (= 20.0 distance))))
+
+  (testing "Upsell pattern - points to next tier"
+    (let [tier-thresholds (oc/ordered-set [0 500 1000 2500 5000])
+          tier-status (fn [points]
+                        (let [[threshold tier _] (oc/fuzzy-nearest loyalty-tiers points)
+                              next-threshold (oc/nearest tier-thresholds :> threshold)]
+                          (cond-> tier
+                            next-threshold (assoc :points-to-next (- next-threshold points)))))
+          status (tier-status 480)]
+      (is (= :silver (:tier status)))
+      (is (= 520 (:points-to-next status))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Chapter 5: The Segment Tree (segment-tree, query)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def traffic-data
+  {0 12, 1 8, 2 5, 3 3, 4 2, 5 4,        ;; night (sparse)
+   6 15, 7 28, 8 45, 9 52, 10 48, 11 41, ;; morning rush
+   12 38, 13 42, 14 35, 15 31, 16 29, 17 44, ;; midday
+   18 67, 19 72, 20 58, 21 43, 22 31, 23 19}) ;; evening rush
+
+(def traffic-totals (oc/segment-tree + 0 traffic-data))
+(def traffic-peaks (oc/segment-tree max 0 traffic-data))
+
+(deftest chapter-5-segment-tree-test
+  (testing "Total customers during morning rush (hours 6-11)"
+    (is (= (+ 15 28 45 52 48 41) (oc/query traffic-totals 6 11))))
+
+  (testing "Total for evening rush (hours 18-22)"
+    (is (= (+ 67 72 58 43 31) (oc/query traffic-totals 18 22))))
+
+  (testing "Compare shifts"
+    (let [morning (oc/query traffic-totals 6 12)   ;; Glorm's shift
+          evening (oc/query traffic-totals 18 24)] ;; Zorp's shift
+      (is (= (+ 15 28 45 52 48 41 38) morning))
+      (is (= (+ 67 72 58 43 31 19) evening))
+      (is (> evening morning))))
+
+  (testing "Find peak hours"
+    (is (= 72 (oc/query traffic-peaks 0 24)))   ;; hour 19 was busiest
+    (is (= 52 (oc/query traffic-peaks 6 12))))  ;; morning peak at hour 9
+
+  (testing "Update when new data arrives - O(log n)"
+    (let [updated-totals (assoc traffic-totals 20 85)]  ;; busy night!
+      ;; Original was 58, now 85 - difference of 27
+      (is (= (+ 67 72 85 43 31) (oc/query updated-totals 18 22)))))
+
+  (testing "Sum tree for range aggregation"
+    (let [sum-tree (oc/sum-tree {0 10, 1 20, 2 30, 3 40, 4 50})]
+      (is (= 60 (oc/query sum-tree 0 2)))     ;; 10+20+30
+      (is (= 150 (oc/query sum-tree 0 4)))))) ;; all
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Chapter 6: The Clearance Audit (subrange)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def stale-inventory
+  (oc/ordered-map
+    {12  {:sku "VR-100" :name "Void Runner" :price 299.99 :markdown 0}
+     35  {:sku "SW-200" :name "Shadow Walker" :price 225.00 :markdown 0.10}
+     67  {:sku "EU-300" :name "Europa Ice" :price 175.00 :markdown 0.15}
+     91  {:sku "GW-400" :name "Gravity Well" :price 375.00 :markdown 0.25}
+     120 {:sku "DD-500" :name "Dark Side Dunk" :price 450.00 :markdown 0.30}
+     145 {:sku "OM-600" :name "Olympus Max" :price 599.00 :markdown 0.40}
+     203 {:sku "AG-700" :name "Anti-Gravity 3000" :price 899.00 :markdown 0.50}}))
+
+(deftest chapter-6-clearance-audit-test
+  (testing "Find items stale 90+ days - liquidation candidates"
+    (let [liquidation-candidates (oc/subrange stale-inventory :>= 90)]
+      (is (= 4 (count liquidation-candidates)))
+      (is (contains? liquidation-candidates 91))
+      (is (contains? liquidation-candidates 120))
+      (is (contains? liquidation-candidates 145))
+      (is (contains? liquidation-candidates 203))))
+
+  (testing "Calculate liquidation value"
+    (let [liquidation-candidates (oc/subrange stale-inventory :>= 90)
+          value (->> liquidation-candidates
+                     (map (fn [[_ item]]
+                            (* (:price item) (- 1 (:markdown item)))))
+                     (reduce +))]
+      ;; 375*0.75 + 450*0.70 + 599*0.60 + 899*0.50
+      ;; = 281.25 + 315 + 359.4 + 449.5 = 1405.15
+      (is (< (Math/abs (- 1405.15 value)) 0.01))))
+
+  (testing "Warning zone (60-90 days)"
+    (let [warning-zone (oc/subrange stale-inventory :>= 60 :< 90)]
+      (is (= 1 (count warning-zone)))
+      (let [[days item] (first warning-zone)]
+        (is (= 67 days))
+        (is (= "Europa Ice" (:name item))))))
+
+  (testing "Fresh items (under 30 days)"
+    (is (= 1 (count (oc/subrange stale-inventory :< 30)))))
+
+  (testing "Compare full-price vs discounted inventory"
+    (let [full-price (oc/subrange stale-inventory :< 60)
+          discounted (oc/subrange stale-inventory :>= 60)
+          liquidation (oc/subrange stale-inventory :>= 90)]
+      (is (= 2 (count full-price)))
+      (is (= 5 (count discounted)))
+      (is (= 4 (count liquidation))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Chapter 7: The Promotional Post-Mortem (interval-map + segment-tree)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def promotions
+  (oc/interval-map
+    {[1 15]   :new-year-clearance      ;; days 1-14
+     [20 35]  :jovian-appreciation     ;; days 20-34
+     [25 28]  :flash-sale              ;; days 25-27 (overlaps jovian)
+     [45 52]  :spring-preview          ;; days 45-51
+     [80 91]  :end-of-quarter-push}))  ;; days 80-90
+
+(def daily-revenue
+  (oc/segment-tree + 0
+    {1 2400, 2 2100, 3 2800, 4 3100, 5 2900,    ;; new-year surge
+     6 3400, 7 3200, 8 2800, 9 2600, 10 2500,
+     11 2300, 12 2400, 13 2200, 14 2100, 15 1800,
+     16 1200, 17 1100, 18 1300, 19 1250,         ;; post-promo slump
+     20 2800, 21 3200, 22 3500, 23 3100, 24 2900, ;; jovian starts
+     25 4200, 26 4800, 27 5100,                   ;; flash sale spike!
+     28 3400, 29 3100, 30 2800, 31 2600, 32 2400,
+     33 2300, 34 2200, 35 1900,
+     ;; middle of quarter omitted (baseline)
+     45 2100, 46 2400, 47 2600, 48 2300, 49 2200,
+     50 2100, 51 2000,                            ;; spring preview
+     80 3800, 81 4200, 82 4500, 83 4100, 84 3900,
+     85 4600, 86 5200, 87 4800, 88 4400, 89 4100, 90 3800}))
+
+(deftest chapter-7-promotional-post-mortem-test
+  (testing "Query promotions active on a given day"
+    (let [active-day-26 (promotions 26)]
+      ;; Both jovian-appreciation and flash-sale active
+      (is (some #{:jovian-appreciation} active-day-26))
+      (is (some #{:flash-sale} active-day-26)))
+    ;; Single promotion day
+    (let [active-day-10 (promotions 10)]
+      (is (some #{:new-year-clearance} active-day-10))
+      (is (not (some #{:flash-sale} active-day-10)))))
+
+  (testing "Query promotions touching a range"
+    (let [active-30-50 (promotions [30 50])]
+      (is (some #{:jovian-appreciation} active-30-50))
+      (is (some #{:spring-preview} active-30-50))
+      (is (not (some #{:flash-sale} active-30-50)))))
+
+  (testing "Revenue during promotional periods"
+    ;; Promo periods are half-open [start, end), but segment-tree query is inclusive
+    ;; So we query [start, end-1] to get the correct range
+    (let [promo-revenue (fn [[start end]]
+                          (oc/query daily-revenue start (dec end)))]
+      ;; New year clearance: days 1-14 (half-open [1,15))
+      (let [revenue (promo-revenue [1 15])]
+        (is (= (+ 2400 2100 2800 3100 2900 3400 3200 2800 2600 2500 2300 2400 2200 2100)
+               revenue)))
+      ;; Flash sale: days 25-27 (half-open [25,28))
+      (let [revenue (promo-revenue [25 28])]
+        (is (= (+ 4200 4800 5100) revenue))
+        (is (= 14100 revenue)))))
+
+  (testing "Per-day revenue analysis"
+    (let [promo-periods {:new-year-clearance [1 15]
+                         :jovian-appreciation [20 35]
+                         :flash-sale [25 28]
+                         :spring-preview [45 52]
+                         :end-of-quarter-push [80 91]}
+          analyze (fn [[name [start end]]]
+                    (let [days (- end start)
+                          ;; Query with (dec end) since segment-tree is inclusive
+                          revenue (oc/query daily-revenue start (dec end))]
+                      {:promo name
+                       :days days
+                       :revenue revenue
+                       :per-day (/ revenue days)}))
+          analysis (into {} (map (fn [r] [(:promo r) r]) (map analyze promo-periods)))]
+      ;; Flash sale has highest per-day
+      (is (= 4700 (:per-day (:flash-sale analysis))))
+      ;; End of quarter also strong
+      (is (> (:per-day (:end-of-quarter-push analysis)) 4000))))
+
+  (testing "Overlap analysis - Jovian with/without Flash Sale"
+    ;; Promo periods are half-open, segment-tree query is inclusive
+    ;; Jovian: [20,35) = days 20-34, Flash: [25,28) = days 25-27
+    (let [jovian-total (oc/query daily-revenue 20 34)
+          flash-overlap (oc/query daily-revenue 25 27)
+          jovian-alone (- jovian-total flash-overlap)]
+      ;; Jovian total includes flash sale days (days 20-34)
+      (is (= (+ 2800 3200 3500 3100 2900 4200 4800 5100 3400 3100 2800 2600 2400 2300 2200)
+             jovian-total))
+      ;; Flash contribution (days 25-27)
+      (is (= 14100 flash-overlap))
+      ;; Jovian baseline without flash
+      (is (= (- jovian-total 14100) jovian-alone))
+      ;; Flash lift percentage
+      (let [lift-pct (int (* 100 (/ flash-overlap jovian-alone)))]
+        (is (> lift-pct 40))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Epilogue: Integration Test
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest epilogue-integration-test
+  (testing "All chapter features work together"
+    ;; Chapter 1: range-map subnet allocation
+    (let [network (-> (oc/range-map {[(ip "10.0.0.0") (ip "10.1.0.0")] :available})
+                      (assoc [(ip "10.0.0.0") (ip "10.0.128.0")] :allocated))]
+      (is (= :allocated (network (ip "10.0.64.0"))))
+      (is (= :available (network (ip "10.0.200.0")))))
+
+    ;; Chapter 2: nearest for size fitting
+    (is (= 11.0 (oc/nearest available-sizes :<= 11.3)))
+
+    ;; Chapter 3: split-key for segmentation
+    (let [[small _ large] (oc/split-key 1000 (oc/ordered-set [100 500 1000 5000 10000]))]
+      (is (= [100 500] (vec small)))
+      (is (= [5000 10000] (vec large))))
+
+    ;; Chapter 4: fuzzy lookup for tier mapping
+    (is (= {:tier :silver :discount 0.10} (loyalty-tiers 600)))
+
+    ;; Chapter 5: segment-tree for range queries
+    (is (= (+ 67 72 58 43 31 19) (oc/query traffic-totals 18 24)))
+
+    ;; Chapter 6: subrange for filtering
+    (is (= 4 (count (oc/subrange stale-inventory :>= 90))))
+
+    ;; Chapter 7: interval-map + segment-tree for attribution
+    (is (some #{:flash-sale} (promotions 26)))
+    (is (= 14100 (oc/query daily-revenue 25 27)))))  ; days 25-27 inclusive