@@ -131,5 +131,8 @@ vitaminc-hmac = "0.6.0"
 # Normalized equality terms (Unicode 16 NFC text, one integer encoding for
 # every width), which `vitaminc-prf`'s `normalize` feature derives over.
 vitaminc-normalize = "0.6.0"
+# The text order key: the system ADR-0002's fold, pinned to Unicode 16,
+# which text ORE and OPE terms are derived over (ADR-0009, #1234).
+vitaminc-ore = "0.6.0"
 vitaminc-prf = { version = "0.6.0", features = ["normalize"] }
 vitaminc-protected = "0.6.0"
@@ -41,9 +41,14 @@ listed under **Breaking**. Releases are tagged `languages/golang/vX.Y.Z`.
   NULL.
 - **`encrypt.Range`**: what `Between` returns, the low and high bound's
   terms.
+- **Ordering methods on text.** A string field with `index=ore` or
+  `index=ope` gets `Lt`, `Lte`, `Gt`, `Gte` and `Between`. Text orders by its
+  folded form (ADR-0002: case and accents folded, under Unicode 16), so
+  `Café` and `cafe` tie and `alice` orders before `Zoe`. Text order terms
+  change bytes from the alpha's; none was deployed.
 - **stashgen notices an index no generated method queries**: an `ore` or
-  `ope` index on text, bytes or a float (the engine answers the orderings
-  over integers only), or the second of two order indexes on an integer.
+  `ope` index on bytes or a float (the engine answers the orderings over
+  integers and text only), or the second of two order indexes on a field.
   The index is still stored; the notice is on stderr and in the file.
 
 ### Changed
 
@@ -124,7 +124,7 @@ For `-type User`, the file `user_stash.go` holds:
 - `Fields`, with one entry for each sealed field.
   An opaque struct, or a struct with no sealed field outside an opaque one, gets no `Fields`: nothing in it is sealed on its own, so nothing can be queried.
   An entry encrypts one value, and has one query method for each operator the engine answers on the field: `Eq`, `Lt`, `Lte`, `Gt`, `Gte`, `Between` or `Matches`.
-  stashgen asks the embedded engine which operators each field answers, and which index answers each one, so it holds no copy of those rules: an equality index answers `Eq`, a match index on a string `Matches`, and an ORE or OPE index on an integer the four orderings and `Between`, through ORE when the field declares both.
+  stashgen asks the embedded engine which operators each field answers, and which index answers each one, so it holds no copy of those rules: an equality index answers `Eq`, a match index on a string `Matches`, and an ORE or OPE index on an integer or a string the four orderings and `Between`, through ORE when the field declares both. A string orders by its folded form: case and accents folded, under Unicode 16.
   `encrypt_into=TextEq` answers `Eq`, which returns the type's query value, `eql.TextEqQuery`.
   `encrypt_into=TextMatch` answers `Matches`, which returns an `encrypt.EQLMatchQuery`: the `eql.TextMatchQuery` operand, with `Verify` and `TargetLimit`.
   The query of `Matches` carries `Verify` and `TargetLimit`, because its answer can hold rows that do not match; an exact operator's query carries neither.
 
@@ -243,17 +243,25 @@ rules.
 | The field declares | Methods | Each returns |
 |---|---|---|
 | `index=equality` | `Eq` | `encrypt.EqualityTerm` |
-| `index=ore` or `index=ope`, on an integer | `Lt`, `Lte`, `Gt`, `Gte` | `encrypt.OreTerm`, or `encrypt.OpeTerm` when the field declares no `ore` |
+| `index=ore` or `index=ope`, on an integer or a string | `Lt`, `Lte`, `Gt`, `Gte` | `encrypt.OreTerm`, or `encrypt.OpeTerm` when the field declares no `ore` |
 | the same | `Between(ctx, cipher, lo, hi)` | `encrypt.Range[encrypt.OreTerm]` or `encrypt.Range[encrypt.OpeTerm]`, the two bounds' terms |
 | `index=match`, on a string | `Matches` | `encrypt.MatchQuery[T]` |
 | `encrypt_into=TextEq` | `Eq` | `eql.TextEqQuery` |
 | `encrypt_into=TextMatch` | `Matches` | `encrypt.EQLMatchQuery[eql.TextMatchQuery, T]` |
 
 A method takes the field's own Go type, so `Fields.Age.Lt` on a `uint32`
-field takes a `uint32`. An order index on text, bytes or a float stores its
-term but answers no ordering operator yet, so such a field has no `Lt`; nor
-does the `ope` index of a field that declares `ore` too, since `ore` answers
-the orderings. stashgen prints a notice for each such index, on stderr and in
+field takes a `uint32`.
+
+Text orders by its folded form (ADR-0002): case and accents are folded and
+`ß` becomes `ss`, under Unicode 16. So `Café`, `cafe` and `CAFÉ` are one
+value and tie, `alice` orders before `Zoe`, and `é` orders with `e`, not
+after `z`. `Between("b", "A")` is refused as an inverted range, since `A`
+folds to `a`. Text holding a code point Unicode 16 does not assign has no
+fold, and its query or write is refused with `encrypt.ErrTerm`.
+
+An order index on bytes or a float stores its term but answers no ordering
+operator, so such a field has no `Lt`; nor does the `ope` index of a field
+that declares `ore` too, since `ore` answers the orderings. stashgen prints a notice for each such index, on stderr and in
 the generated file: the terms are stored, and only your own code can compare
 them. A match index on an index-only field (`index=match` with no `encrypt`)
 is refused, because `Verify` checks a match query's rows by decrypting them.
 
@@ -137,7 +137,10 @@
 //
 // Eq returns an [EqualityTerm] (or, for a field with encrypt_into, the EQL
 // type's query value), an ordering an [OreTerm] or [OpeTerm], and Between a
-// [Range] of two. Their answers are exact. Matches returns a [MatchQuery],
+// [Range] of two. Their answers are exact. The orderings are answered on
+// integers and on text, which orders by its folded form (case and accents
+// folded, under Unicode 16), so Café and cafe tie and alice orders before
+// Zoe. Matches returns a [MatchQuery],
 // whose answer can hold rows that do not match: size the fetch with
 // [MatchQuery.TargetLimit], then decrypt the rows and keep those
 // [MatchQuery.Verify] reports true, one call into the engine for the page.
 
@@ -4,8 +4,10 @@ import (
 	"bytes"
 	"cmp"
 	"context"
+	"errors"
 	"math/rand"
 	"reflect"
+	"slices"
 	"testing"
 	"testing/quick"
 
@@ -17,7 +19,7 @@ import (
 // stores for them through the generated Probe fields' Encrypt, comparison
 // in Go. A query method derives the same bytes, but only for the index
 // that answers its operator (ORE, where a field declares both), and only
-// over integers, so the stored terms reach every index and kind. ORE is
+// over integers and text, so the stored terms reach every index and kind. ORE is
 // probabilistic — a wrong comparator or a wrong derivation still agrees
 // with plaintext order on many pairs — so a fixed vector set says little;
 // hundreds of random pairs per type say more. The index key is the
@@ -121,24 +123,31 @@ func adjacentProperty[T any](t *testing.T, cipher *encrypt.Cipher, ope bool, der
 	}
 }
 
-// collatedAlphabet holds characters that the ORE and OPE string encodings
-// keep as they are. Before deriving a term, cllw-ore's orderize_string
-// decomposes each character canonically and drops anything that is not
-// alphanumeric, whitespace or ASCII punctuation. So two strings order by
-// their UTF-8 bytes only when that collation leaves both unchanged: a
-// private-use character is dropped, and a precomposed Hangul syllable or
-// an accented letter decomposes. The non-ASCII letters here have no
-// canonical decomposition, so multi-byte UTF-8 ordering is still covered.
-var collatedAlphabet = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ßжω中")
+// foldedAlphabet holds characters that text's order key keeps as they are.
+// Text orders by its fold (ADR-0002): NFD, full case folding, NFD again,
+// accents dropped, NFC. So two strings order by their UTF-8 bytes when the
+// fold leaves both unchanged: lower-case letters with no accent, digits,
+// space and ASCII punctuation. The non-ASCII letters here are already
+// folded and have no decomposition, so multi-byte UTF-8 ordering is still
+// covered. Upper case, accents and the sharp s are checked as ties below.
+var foldedAlphabet = []rune("abcdefghijklmnopqrstuvwxyz0123456789 !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\u0436\u03c9\u4e2d")
 
-func collatedString(r *rand.Rand) string {
+func foldedString(r *rand.Rand) string {
 	out := make([]rune, r.Intn(24))
 	for i := range out {
-		out[i] = collatedAlphabet[r.Intn(len(collatedAlphabet))]
+		out[i] = foldedAlphabet[r.Intn(len(foldedAlphabet))]
 	}
 	return string(out)
 }
 
+// inOrder orders strings by their place in values, for a list written in
+// the order the fold gives it.
+func inOrder(values []string) func(a, b string) int {
+	return func(a, b string) int {
+		return cmp.Compare(slices.Index(values, a), slices.Index(values, b))
+	}
+}
+
 func TestTermOrderIsPlaintextOrder(t *testing.T) {
 	c := deterministicClient(t)
 	cipher := c.DefaultKeyset()
@@ -176,16 +185,20 @@ func TestTermOrderIsPlaintextOrder(t *testing.T) {
 				d := storedTerm(f.S.Encrypt, ope,
 					func(e testusers.EncryptedProbeS) []byte { return e.Ore },
 					func(e testusers.EncryptedProbeS) []byte { return e.Ope })
-				// Strings order by the UTF-8 bytes of their collated form; a
-				// prefix orders before its extensions. See collatedAlphabet.
-				orderProperty(t, cipher, ope, d, byteOrder, collatedString)
-				adjacentProperty(t, cipher, ope, d, []string{"", "a", "aa", "ab", "b", "ba", "ß", "ßa", "中"}, byteOrder)
-				// Collation drops a control or private-use character, and
-				// strips the accent from a decomposed letter, so the terms
-				// cannot tell these pairs apart.
-				adjacentProperty(t, cipher, ope, d, []string{"", "\x7f"}, same)
-				adjacentProperty(t, cipher, ope, d, []string{"ab", "ab"}, same)
-				adjacentProperty(t, cipher, ope, d, []string{"e", "é"}, same)
+				// Strings order by the UTF-8 bytes of their folded form; a
+				// prefix orders before its extensions. See foldedAlphabet.
+				orderProperty(t, cipher, ope, d, byteOrder, foldedString)
+				adjacentProperty(t, cipher, ope, d, []string{"", "a", "aa", "ab", "b", "ba", "ж", "ω", "中"}, byteOrder)
+				// The fold drops case and accents and expands ß, so the terms
+				// cannot tell these apart.
+				adjacentProperty(t, cipher, ope, d, []string{"a", "A"}, same)
+				adjacentProperty(t, cipher, ope, d, []string{"e", "\u00e9", "\u00c9", "e\u0301"}, same)
+				adjacentProperty(t, cipher, ope, d, []string{"ss", "\u00df", "SS"}, same)
+				adjacentProperty(t, cipher, ope, d, []string{"caf\u00e9", "CAFE", "Cafe\u0301"}, same)
+				// Mixed case and accents order by the fold: Zoe after alice,
+				// and an accented letter beside its base letter.
+				names := []string{"alice", "Bob", "eclair", "\u00c9lan", "emu", "Zoe"}
+				adjacentProperty(t, cipher, ope, d, names, inOrder(names))
 			})
 			t.Run("bytes", func(t *testing.T) {
 				d := storedTerm(f.B.Encrypt, ope,
@@ -197,3 +210,39 @@ func TestTermOrderIsPlaintextOrder(t *testing.T) {
 		})
 	}
 }
+
+// The generated ordering methods on a text field derive the term its
+// Encrypt stores for the folded value, and Between refuses a range that
+// is inverted once folded.
+func TestTextOrderingMethodsFoldTheValue(t *testing.T) {
+	c := deterministicClient(t)
+	cipher := c.DefaultKeyset()
+	ctx := context.Background()
+	f := testusers.ProbeFields
+	stored, err := f.S.Encrypt(ctx, cipher, "cafe")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, v := range []string{"cafe", "Caf\u00e9", "CAFE", "cafe\u0301"} {
+		lt, err := f.S.Lt(ctx, cipher, v)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !bytes.Equal(lt, stored.Ore) {
+			t.Errorf("Lt(%q) is not the stored term of cafe", v)
+		}
+	}
+	r, err := f.S.Between(ctx, cipher, "a", "Zoe")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if r.Low.Compare(r.High) >= 0 {
+		t.Errorf("a should order below Zoe")
+	}
+	if _, err := f.S.Between(ctx, cipher, "b", "A"); !errors.Is(err, encrypt.ErrTerm) {
+		t.Errorf("Between(b, A) = %v, want ErrTerm: A folds to a, below b", err)
+	}
+	if _, err := f.S.Between(ctx, cipher, "A", "a"); err != nil {
+		t.Errorf("Between(A, a) is one folded value: %v", err)
+	}
+}