@@ -81,7 +81,10 @@ stack-profile = { path = "./packages/stack-profile", version = "0.43.0" }
 cts-common = { version = "0.43.0", default-features = false }
 zerokms-protocol = "0.12.31"
 recipher = "=0.3.1"
-cllw-ore = { version = "=0.5.0", default-features = false }
+# cllw-ore's `vitaminc` feature implements vitaminc-ore's `OrderScheme`,
+# which Stack Encrypt's order terms are encrypted through. It first ships
+# in a pre-release, and Cargo resolves a pre-release only when named.
+cllw-ore = { version = "=0.5.2-rc.1", default-features = false, features = ["vitaminc"] }
 
 # External dependencies, with the suite's feature lists.
 base64 = "0.22.0"
 
@@ -327,15 +327,16 @@ fn guest_terms_match_the_native_sem_derivations() {
     .expect("native");
     assert_eq!(eq_bytes, native_bytes.as_bytes());
 
-    // Variable-width CLLW output for strings.
+    // Variable-width CLLW output for strings: the text behind cllw-ore's
+    // one marker byte, eight bytes a plaintext byte.
     let ore_s = block_on(ops::term(
         &cipher.default_keyset(),
         &encode(s("alice")),
         &encode(s("users/name")),
         TERM_ORE,
     ))
     .expect("string ore");
-    assert_eq!(ore_s.len(), 5 * 8);
+    assert_eq!(ore_s.len(), 6 * 8);
 
     // No ZeroKMS traffic for any of it.
     assert_eq!(cipher.kms().generate_calls.load(Ordering::SeqCst), 0);
 
@@ -159,19 +159,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Breaking
 
-- **Text orders by its folded order key.** An ORE or OPE term over text is
-  derived over the system ADR-0002's fold (Unicode 16 NFC with case and
-  accents folded, from `vitaminc-ore`) in place of cllw-ore's own
-  collation, under a key framing that names the fold's frozen label. So
-  `Café`, `cafe`, `CAFÉ` and `cafe` with a combining accent are one term and
-  tie, `alice` orders before `Zoe`, and `é` orders with `e`, not after `z`.
-  Every text order term changes bytes; integer, float and bytes order terms
-  do not. None was deployed (ADR-0002). Text holding a code point Unicode 16
-  does not assign has no fold and no order term (`TermError::Normalize`),
-  on write and on query. The ordering operators are answered on text, on
-  the typed path (`op::Ordered` for `String`, whose `Between` judges an
-  inverted range on the folded keys: `("b", "A")` is inverted, `("A", "a")`
-  is one value) and on the data-plan path, so a binding generates them too.
+- **Order terms encrypt through cllw-ore's vitaminc schemes, and text is
+  ordered.** An ORE or OPE term is now cllw-ore 0.5.2-rc.1's
+  `vitaminc::Ore`/`vitaminc::Ope` encryption of the value's `vitaminc-ore`
+  order encoding: the engine passes the value through and names its type's
+  target (`sem::Orderable`: integers at their own width, `f32`/`f64` as
+  `F64`, text as `Text`, bytes as `Bytes`), and cllw-ore does the encoding.
+  Text is ordered by the system ADR-0002's fold (Unicode 16 NFC with case
+  and accents folded), so `Café`, `cafe`, `CAFÉ` and `cafe` with a
+  combining accent are one term and tie, `alice` orders before `Zoe`, and
+  `é` orders with `e`, not after `z`. Every order term changes bytes: the
+  key labels move to `/v2`, the column salt binds the scheme and the
+  target, and text and bytes go in behind cllw-ore's marker byte. None was
+  deployed (ADR-0002). Every source type's term is one ciphertext type,
+  `OreCllw8VariableV1` or `OpeCllw8VariableV1`; `OreTerm<T>` and
+  `OpeTerm<T>` keep `T` to name the source, and `new`, `inner` and
+  `into_inner`, `KeysetCipher::ore_term` and `ope_term` take or return those
+  types. `sem::CllwOreEncrypt` and `sem::CllwOpeEncrypt` are no longer
+  re-exported, and the term bounds are `Orderable`. Text holding a code
+  point Unicode 16 does not assign has no order term
+  (`TermError::Normalize`), on write and on query. The ordering operators
+  are answered on text, on the typed path (`op::Ordered` for `String`) and
+  on the data-plan path, so a binding generates them too. `Between` judges
+  an inverted range in the order the stored terms compare, by comparing the
+  bounds' encryptions: `("b", "A")` is inverted, `("A", "a")` is one value.
 
 - **A match value with no tokens is stored as the empty filter, so
   `KeysetCipher::match_terms` is no longer a query.** In 0.2.0 the same call
@@ -215,9 +226,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   way. Every equality and match term changes
   bytes (the domains move to `/v2`); ORE and OPE terms do not. No stored
   term existed to keep; the record fixture is regenerated. Text order
-  terms derive over the folded order key (see "Text orders by its folded
-  order key" above), so equality and ordering agree on two forms of
-  `café`.
+  terms are encoded in the same normal form, folded further (see "Order
+  terms encrypt through cllw-ore's vitaminc schemes" above), so equality
+  and ordering agree on two forms of `café`.
 - **`dynamic::Value` and `dynamic::Scalar` are gone.** A field lowered from
   data holds an `FfiValue`, which is now `Clone` (a deep copy into fresh
   `Protected` payloads, as `Value`'s was) and reads as a context label.
 
@@ -37,8 +37,8 @@ vitaminc-hmac = { workspace = true }
 # number whatever its width, text in Unicode 16 NFC. Match text is
 # normalized by the same crate before it is tokenized.
 vitaminc-normalize = { workspace = true }
-# Text order terms are derived over `vitaminc-ore`'s folded order key, not
-# cllw-ore's own text collation.
+# The order targets (`OrderTarget`) and the scheme traits cllw-ore's
+# `vitaminc` feature implements, which order terms encrypt through.
 vitaminc-ore = { workspace = true }
 vitaminc-prf = { workspace = true }
 vitaminc-protected = { workspace = true }
 
@@ -500,10 +500,10 @@ key tie; that is what the column declared, and an earlier draft of this ADR
 was wrong to call it a false positive and put the term under `Probabilistic`.
 Its use is ordering and cursor paging on names (`ORDER BY name`, "the page
 after Nguyen"), and EQL v4 carries `query_text_ord` and `query_text_ord_ore`
-for it. Stack Encrypt produces the term: the order key is vitaminc-ore's
-text order encoding, the system ADR-0002's fold pinned to Unicode 16, which
-vitaminc 0.6 ships, and the ORE and OPE indexes answer the orderings on text
-over it. `TextOrdOre` and `TextSearchOre` also need the block ORE scheme EQL
+for it. Stack Encrypt produces the term: it hands the text to cllw-ore's
+vitaminc schemes as the `Text` target, whose order key is vitaminc-ore's
+text order encoding, the system ADR-0002's fold pinned to Unicode 16, and
+the ORE and OPE indexes answer the orderings on text over it. `TextOrdOre` and `TextSearchOre` also need the block ORE scheme EQL
 stores (#1132).
 
 A `Ranked` term's `target_limit` applies the index's configured recall
 
@@ -77,6 +77,7 @@ use crate::op::{Limit, Stats};
 use crate::sem::{match_limit, MatchOptions, QueryTokens, TermError};
 use crate::target::IndexSpec;
 use crate::{KeysetCipher, Pending};
+use vitaminc_ore::OrderTarget;
 
 /// An operator, named at run time: the runtime form of the
 /// [`op`](crate::op) module's operator types, as [`IndexSpec`] is of the
@@ -582,7 +583,7 @@ fn check_input(index: &IndexSpec, input: &Input) -> Result<(), Error> {
         // derivation would refuse it after one.
         (IndexSpec::Ore | IndexSpec::Ope, Input::One(FfiValue::String(text))) => {
             if let Some(text) = utf8(text) {
-                crate::sem::text_order_key(text)
+                crate::sem::order_cmp_as(OrderTarget::Text, text, text)
                     .map(drop)
                     .map_err(refused)?;
             }
@@ -602,18 +603,15 @@ fn check_input(index: &IndexSpec, input: &Input) -> Result<(), Error> {
 }
 
 /// The order of a range's two bounds, as the server compares their terms:
-/// integers of one kind by value, text by its order key, so `("b", "A")` is
-/// inverted and `("A", "a")` is one value. `None` for anything else.
+/// integers of one kind by value, text in cllw-ore's order of its encoding
+/// (the system ADR-0002's fold), so `("b", "A")` is inverted and
+/// `("A", "a")` is one value. `None` for anything else.
 fn bound_order(lo: &FfiValue, hi: &FfiValue) -> Result<Option<Ordering>, TermError> {
     if let (FfiValue::String(lo), FfiValue::String(hi)) = (lo, hi) {
         let (Some(lo), Some(hi)) = (utf8(lo), utf8(hi)) else {
             return Ok(None);
         };
-        let (lo, hi) = (
-            crate::sem::text_order_key(lo)?,
-            crate::sem::text_order_key(hi)?,
-        );
-        return Ok(Some(lo.as_slice().cmp(hi.as_slice())));
+        return crate::sem::order_cmp_as(OrderTarget::Text, lo, hi).map(Some);
     }
     Ok(integer_order(lo, hi))
 }