Tag-classify pretokenization — design spec

Principle (simdjson move): compute a per-char tag stream in one SIMD pass, then every pretokenizer is a cheap consumer over that stream. Two orthogonal tag alphabets (atoms for category-based pretokenizers, scripts for UnicodeScripts) are produced by the same generic range-classify engine — only the tables differ. 0-dep at runtime (tables bake to const; unicode_categories is a dev-only generator dep, like bitmap_gen).

                       ┌── classify<Lanes, Table> ──► tag[]  (one SIMD pass, char-start aligned)
 text (UTF-8 bytes) ───┤
                       └── char-start bitplane      (for multibyte / char-count)
                                     │
   tag = ATOM (u4)                   │                    tag = SCRIPT (u8)
     │                               │                          │
     ├ remap(vqtbl1) → class-view ───┤                          └ FSM: split on script change
     │                               │                              (Common/Any/Inherited transparent)
     ├ RunSplit FSM (SIMD boundary + extract)   ← WhitespaceSplit, Whitespace, Punctuation, Digits, Bert
     └ Cl100k/ByteLevel FSM (scalar, segmented) ← cl100k, GPT-2

1. The atom alphabet (12 tags, fits `u4`)

Derived by enumerating all 1.1M codepoints against the exact predicates in the pretokenizer code (scratchpad/atomgen). 10 base atoms + the two ASCII specials promoted (Space, Apostrophe).

#	atom	definition	example
0	`Letter`	`\p{L}`	`a 中 é`
1	`NumWord`	`Nd ∪ Nl` (numeric and `\w`)	`0-9 Ⅷ ٠`
2	`NumOther`	`No` (numeric, not `\w`)	`½ ² ¼`
3	`Newline`	`\r \n`
4	`Space`	`0x20` only
5	`WsOther`	`\s ∖ {\r\n, 0x20}`	`\t` NBSP U+2028
6	`Mark`	`\p{M} ∪ {ZWJ,ZWNJ} ∪ (Other_Alphabetic∖L)`	combining marks
7	`Connector`	`\p{Pc}`	`_ ‿`
8	`Punct`	`(\p{P}∖Pc) ∪ ASCII-sym`, minus `0x27`	`! . , + = < $`
9	`Apostrophe`	`0x27` only	`'`
10	`SymOther`	non-ASCII `\p{S}` ∪ control ∪ unassigned	`× ©` U+0000
11	`NumericOther`	`is_numeric ∖ \p{N}`	numeric-typed non-numbers

Cont (continuation byte) is the 13th value or, equivalently, tag 0xFF + char_start=0; it's transparent to every FSM. Base predicates that forced the split (proven, not guessed): is_alphabetic ≠ \p{L} (27043 cps), is_numeric ≠ \p{N} (478 cps → atom 11), ASCII-vs-Unicode symbol asymmetry (ASCII sym → 8, non-ASCII sym → 10).

2. The generic classify engine (composable lanes)

classify walks 16-byte chunks. Per chunk it runs lanes, each gated by a cheap vmaxvq range test so ASCII-only chunks skip the multibyte lanes entirely. Every lane maps its byte-region to a tag; the structure is shared across tag alphabets, only the per-lane table changes. A Classifier = an ordered set of lanes + their tables.

lane	byte range	mechanism	shared?
ASCII	`< 0x80`	`LUT128[byte] → tag` (nibble-shuffle / range)	structure shared; table per-alphabet
2-byte	`C2–DF`	codepoint bitmap (`vqtbl` `LETTER2`…) or range	per-alphabet
CJK	`E3–EC`	lead-byte range → tag (atoms: `Letter`; scripts: `Han`)	structure shared
3-byte-other	`E0–E2, ED–EF`	SIMD range-search (Thai/Devanagari; the must-fix)	structure shared
4-byte	`F0+`	SIMD range-search (rare)	structure shared
cont	`80–BF`	tag = `Cont`, `char_start=0`	shared

SIMD range-search kernel (used by the 3-byte/4-byte lanes, and the whole script classifier): a sorted threshold list classifies branchlessly by counting thresholds cleared — range_id = Σᵢ (cp ≥ tᵢ) via broadcast vcgeq + accumulate, then tag = TAG_LUT[range_id] (a vqtbl1). No binary search, no data-dependent branches, 16 lanes at a time. This is why the 3-byte-non-CJK marks/letters gap has no scalar slow path.

Output: tag[] (one byte per input byte; continuation bytes = Cont) + a char_start bitplane.

3. Composition: atoms and scripts are the same engine

AtomClassifier   = { ASCII: ATOM_ASCII_LUT, 2byte: ATOM_BITMAPS, CJK: →Letter,
                     3byte: ATOM_GC_RANGES, 4byte: ATOM_GC_RANGES }
ScriptClassifier = { ASCII: SCRIPT_ASCII_LUT (mostly Common/Latin), 2byte: SCRIPT_RANGES,
                     CJK: →Han,  3byte: SCRIPT_RANGES, 4byte: SCRIPT_RANGES }

Same lane code, same gating, same SIMD range kernel — swap the tables. UnicodeScripts' fixed_script (Hira/Kata→Han, space→Any) is a post-remap, the same slot atoms use. So UnicodeScripts reuses the entire classify + FSM framework; it is not a second system, it's a second instantiation. (Script ⊥ atom at the value level — 'a'/'а'/'中' are one atom, three scripts — so they remain separate streams; you run whichever the configured pretokenizer needs.)

4. Pretokenizer interface

PreTokenizer = {
    classifier: &Classifier,     // Atoms (almost always) or Scripts
    remap:      Remap,           // tag → consumer class
    fsm:        Fsm,             // class-view → spans
}

Remap: for ≤16 tags (atoms) it's a 16-byte vqtbl1 table — 16 chars remapped in one instruction. For scripts (>16 tags) there is no small remap; the FSM compares script-ids directly.
Fsm kinds (all local over the remapped tag view; the boundary stream is tag ∈ mask):
- Split { delim_mask, behavior } — the HF delimiter split. A char is a match iff tag ∈ delim_mask; matches are per-char, non-matches are runs; then behavior ∈ {Removed, Isolated, Contiguous, MergedWithPrevious, MergedWithNext} places boundaries / drops the match segments exactly as SplitDelimiterBehavior (normalizer.rs). Covers WhitespaceSplit (WS,Removed), Punctuation (Punct∪Pc∪Apostrophe,Isolated), Digits (numeric,Contiguous), Metaspace (Space→▁,MergedWithNext), CharDelimiterSplit (byte), Split-literal. → SIMD class-change → movemask → extract; Contiguous/Removed/Isolated are pure boundary masks (bitmask wins here), MergedWith* a one-lane shift.
- ClassRuns { drop_mask, isolate_mask } — cut at every class change; drop drop_mask runs, isolate isolate_mask per-char. Covers Whitespace (drop WS, keep Word+Symbol runs) and Bert (drop WS, isolate Punct). This is the case that keeps two run types, so it isn't a single Split.
- Cl100k / ByteLevel — the 7-rule (GPT-2) scalar FSM (segmented {1,3} / ws-tail — measured to beat the bitmask here). Peeks original bytes for the contraction suffix literals (ASCII).
- ScriptRun — run-split on script change, transparent set {Common, Inherited, Any} sticks to the neighbouring run.

FSMs read the tag stream as primary input and may peek the original bytes for literal matches that tags can't encode (cl100k contraction suffixes 's/'re, Metaspace marker, delimiter char).

5. Remap tables (atoms → consumer class), all `[u8;16]`

Atom index: 0 Letter · 1 NumWord · 2 NumOther · 3 Newline · 4 Space · 5 WsOther · 6 Mark · 7 Connector · 8 Punct · 9 Apostrophe · 10 SymOther · 11 NumericOther

                 0    1    2    3    4    5    6    7    8    9   10   11
cl100k        [  L,   N,   N,  NL,  SP,  WS,   O,   O,   O,  AP,   O,   O ]   // AP triggers rule 1; SP is rule-4 ` ?`
ByteLevel     [  L,   N,   N,  WS,  SP,  WS,   O,   O,   O,   O,   O,   O ]   // no \r\n split
Whitespace    [Wrd, Wrd, Sym,  ws,  ws,  ws, Wrd, Wrd, Sym, Sym, Sym, Sym ]
WhitespaceSpl [  ·,   ·,   ·,  WS,  WS,  WS,   ·,   ·,   ·,   ·,   ·,   · ]
Punctuation   [  ·,   ·,   ·,   ·,   ·,   ·,   ·,   P,   P,   P,   ·,   · ]
Digits        [  ·,   N,   N,   ·,   ·,   ·,   ·,   ·,   ·,   ·,   ·,   N ]
Bert          [  O,   O,   O,  WS,  WS,  WS,   O,   P,   P,   P,   O,   O ]   // ws-split + isolate punct

6. Outside the tag substrate

Split(regex) — runtime pattern; feature-gated, rarely used. Escape hatch, not designed for.
CharDelimiterSplit — arbitrary single byte; a byte compare, touches no tag.
FixedLength — positional char count; rides the char_start bitplane only.
Metaspace / cl100k-apostrophe — literal-byte matches; FSM peeks original bytes (§4).

7. Portability (SIMD and non-SIMD share one table set)

Every table (LETTER2/3, NUMBER2/3, and the new MARK2/3/PUNCT2/3/SYM2/3/CONNECTOR + 3-byte range tables) is arch-independent data, baked const by bitmap_gen (dev-only generator). Each lane has two readers producing the identical tag:

lane	SIMD reader (aarch64)	scalar reader (portable)
ASCII	nibble-shuffle	`LUT128[byte]`
2/3-byte bitmap	`vqtbl` gather	`(TABLE[idx] >> bit) & 1` — this is `FastLetter/FastNumber::step`
CJK / range	branchless `Σ(cp ≥ tᵢ)`	plain range loop / binary search

So classify_cats = #[cfg(aarch64)] classify_neon else classify_scalar, both emitting the same tag[] (one byte-exact gate covers both). The matchers already built are the scalar 2/3-byte reader, reused as-is. Downstream is already portable: remap is a table index; the FSMs are scalar even on NEON (the shipped split is scalar). The only aarch64-only piece is the SIMD boundary-extract optimisation for Split/ClassRuns; its scalar fallback is a run-scan (the measured winner for short runs regardless).

8. Speed contract

classify is the one hot pass; keep the ASCII/2-byte/CJK fast lanes, SIMD range for the rest. No scalar slow path (range kernel is branchless SIMD).
remap is 1 vqtbl1 / 16 chars.
RunSplit pretokenizers extract via SIMD boundary bitmask (this is where the bitmask wins — no segmented rules).
cl100k/ByteLevel stay scalar-FSM (segmented rules; measured winner vs onig 5–45×, byte-exact).
byte-exactness gate: every FSM's output must equal its reference (regex / current impl) over a multi-script corpus. That single assert has caught every bug in this line of work.