diff --git a/.changeset/perky-plums-dig.md b/.changeset/perky-plums-dig.md
new file mode 100644
index 00000000..0c475a0b
--- /dev/null
+++ b/.changeset/perky-plums-dig.md
@@ -0,0 +1,5 @@
+---
+'@fuzdev/fuz_code': minor
+---
+
+feat: add rust lexer
diff --git a/CLAUDE.md b/CLAUDE.md
index 5105a2bb..720edcd4 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -44,7 +44,7 @@ fuz_code is a **syntax highlighting library**:
 
 - Runtime HTML generation with CSS classes
 - Hand-written single-pass lexers (zero regex), one per language
-- 8 built-in languages (TS, JS, CSS, HTML, JSON, Svelte, Markdown, Bash)
+- 9 built-in languages (TS, JS, CSS, HTML, JSON, Svelte, Markdown, Shell, Rust)
 - Extensible by writing a lexer (`SyntaxLang`)
 - Optional Svelte component (`Code.svelte`)
 
@@ -69,7 +69,7 @@ src/
 │   ├── syntax_styler.ts        # SyntaxStyler class: registry + lex/stylize facade
 │   ├── syntax_styler_global.ts # pre-configured global instance
 │   ├── lexer.ts                # lexer substrate: Lexer, TokenTypeRegistry, flat events, HTML render
-│   ├── lexer_*.ts              # hand-written lexers (json, ts, css, bash, markup, svelte, md)
+│   ├── lexer_*.ts              # hand-written lexers (json, ts, css, bash, markup, svelte, md, rust)
 │   ├── Code.svelte             # main Svelte component
 │   ├── CodeHighlight.svelte    # experimental CSS Highlight API
 │   ├── CodeTextarea.svelte     # experimental live-highlighted textarea
@@ -141,6 +141,11 @@ One `SyntaxLang` lexer per language, registered via `add_lang`:
   info matching and any-length closers, headings, blockquotes, lists, hr)
   with a per-block inline scan (emphasis, inline code, links, entities, raw
   markup via the markup scanner); fences embed their languages
+- `lexer_rust.ts` - Rust, registered as `rust` with `rs` as an alias: one
+  flat scan loop (nested block comments and raw strings resolve with counters;
+  attribute interiors lex inline under an `[`/`]` depth counter — no frame
+  machine), lifetime-vs-char `'` disambiguation, `name!` macros, doc-vs-plain
+  comment split, the r/b/c string prefixes
 
 Embedded languages resolve lazily by name through the registry (markdown
 fences → any language, markup `<script>`/`<style>`/`style=`/`on*=`, svelte
@@ -174,7 +179,7 @@ can't overflow the call stack; past the cap a region stays plain text.
 
 ## Supported languages
 
-`ts`, `js`, `css`, `html`, `json`, `svelte`, `md`, `sh`
+`ts`, `js`, `css`, `html`, `json`, `svelte`, `md`, `sh`, `rust`/`rs`
 
 ## Testing
 
@@ -296,7 +301,7 @@ Theme uses CSS variables from fuz_css:
 3. **Progress discipline** - every scan loop advances position or emits+advances
 4. **Nesting discipline** - no JS-call-stack recursion that scales with input
    nesting. Flat single-pass loops wherever the grammar allows (css, markup,
-   svelte, json, and md need no stacks at all); an explicit pooled frame
+   svelte, json, md, and rust need no stacks at all); an explicit pooled frame
    machine only where a construct's interior re-enters the same grammar
    (`lexer_ts.ts` templates/generics/annotations, `lexer_bash.ts`
    substitutions — use these as the template, including their inline fast
diff --git a/README.md b/README.md
index d1f6f00f..b901211d 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ Highlights:
 - a minimal, explicit API to generate stylized HTML — `stylize(code, lang)`
 - stateless ES modules, instead of globals with side effects
 - written in TypeScript, with no runtime dependencies
-- eight built-in languages (see below), extensible by writing a lexer
+- nine built-in languages (see below), extensible by writing a lexer
 
 Two optional integrations:
 
@@ -112,6 +112,7 @@ Registered by default in `syntax_styler_global` — one hand-written lexer each:
 - [`css`](src/lib/lexer_css.ts)
 - [`json`](src/lib/lexer_json.ts) (with comments — jsonc)
 - [`sh`](src/lib/lexer_bash.ts) (POSIX/bash family — also serves `bash`/`shell`)
+- [`rust`](src/lib/lexer_rust.ts) (also serves `rs`)
 
 Add a language by writing a `SyntaxLang` lexer and registering it with
 `add_lang` — see the existing `lexer_*.ts` modules.
diff --git a/src/lib/code_sample.ts b/src/lib/code_sample.ts
index da240b1e..25e7a405 100644
--- a/src/lib/code_sample.ts
+++ b/src/lib/code_sample.ts
@@ -5,6 +5,6 @@ export interface CodeSample {
 }
 
 // Languages ordered from simple to complex
-export const sample_langs = ['json', 'css', 'ts', 'html', 'svelte', 'md', 'sh'] as const;
+export const sample_langs = ['json', 'css', 'ts', 'rs', 'html', 'svelte', 'md', 'sh'] as const;
 
 export type SampleLang = (typeof sample_langs)[number];
diff --git a/src/lib/lexer.ts b/src/lib/lexer.ts
index f59e9acf..32418f9e 100644
--- a/src/lib/lexer.ts
+++ b/src/lib/lexer.ts
@@ -480,6 +480,8 @@ export const matches_ci = (text: string, from: number, word: string): boolean =>
 
 export const is_digit = (c: number): boolean => c >= 48 && c <= 57;
 
+export const is_upper = (c: number): boolean => c >= 65 && c <= 90;
+
 export const is_ascii_alnum = (c: number): boolean =>
 	(c >= 48 && c <= 57) || ((c | 0x20) >= 97 && (c | 0x20) <= 122);
 
diff --git a/src/lib/lexer_md.ts b/src/lib/lexer_md.ts
index e29a42c7..05848252 100644
--- a/src/lib/lexer_md.ts
+++ b/src/lib/lexer_md.ts
@@ -53,6 +53,7 @@ const T_LANG_JSON = token_type('lang_json');
 const T_LANG_SVELTE = token_type('lang_svelte');
 const T_LANG_BASH = token_type('lang_bash');
 const T_LANG_MD = token_type('lang_md');
+const T_LANG_RUST = token_type('lang_rust');
 const T_HEADING = token_type('heading');
 const T_HEADING_PUNCTUATION = token_type('punctuation', 'heading_punctuation');
 const T_BLOCKQUOTE = token_type('blockquote');
@@ -96,6 +97,7 @@ add_fence_lang('json', 'json', T_LANG_JSON);
 add_fence_lang('svelte', 'svelte', T_LANG_SVELTE);
 add_fence_lang('sh bash shell', 'sh', T_LANG_BASH);
 add_fence_lang('md markdown', 'md', T_LANG_MD);
+add_fence_lang('rust rs', 'rust', T_LANG_RUST);
 
 // line-internal whitespace — `is_space` from the toolkit includes newlines
 const is_line_space = (c: number): boolean => c === 32 || c === 9;
diff --git a/src/lib/lexer_rust.ts b/src/lib/lexer_rust.ts
new file mode 100644
index 00000000..f20db53c
--- /dev/null
+++ b/src/lib/lexer_rust.ts
@@ -0,0 +1,674 @@
+import {
+	is_digit,
+	is_hex_digit,
+	is_ident_start,
+	is_space,
+	is_upper,
+	scan_ident,
+	scan_to_line_end,
+	skip_space,
+	token_type,
+	words_map,
+	type Lexer,
+	type SyntaxLang,
+} from './lexer.ts';
+
+/**
+ * Hand-written Rust lexer.
+ *
+ * A single flat scan loop — Rust has no re-entrant interiors at the token
+ * level (no template interpolations), so the constructs that nest are handled
+ * with counters in one forward pass: block comments nest by depth, raw strings
+ * close on a `"` followed by their opening hash count, and attribute interiors
+ * lex inline (marker and leading path attribute-styled, arguments under the
+ * normal rules) with a `[`/`]` depth counter marking where the bracket closes.
+ *
+ * Disambiguation notes: `'` is a lifetime when ident-shaped text follows
+ * without a closing quote (`'a`, `'static`, loop labels) and a char literal
+ * otherwise; `name!` is a macro invocation unless the `!` starts `!=`; the
+ * string prefixes (`r`/`b`/`c`/`br`/`cr`) are recognized before generic
+ * identifier scanning and fall through to it when no quote follows.
+ *
+ * Resilience: unterminated block comments, strings (which span lines in
+ * Rust), and raw strings extend to the end of the window; an unterminated
+ * attribute simply lexes its interior to there.
+ *
+ * @module
+ */
+
+const T_COMMENT = token_type('comment');
+const T_DOC_COMMENT = token_type('doc_comment', 'comment');
+const T_HASHBANG = token_type('hashbang', 'comment');
+const T_STRING = token_type('string');
+const T_CHAR = token_type('char');
+const T_LIFETIME = token_type('lifetime', 'symbol');
+const T_ATTRIBUTE = token_type('attribute', 'attr_name');
+const T_KEYWORD = token_type('keyword');
+const T_SPECIAL_KEYWORD = token_type('special_keyword');
+const T_BOOLEAN = token_type('boolean');
+const T_NUMBER = token_type('number');
+const T_FUNCTION = token_type('function');
+const T_MACRO = token_type('macro', 'function');
+const T_CLASS_NAME = token_type('class_name');
+const T_BUILTIN = token_type('builtin');
+const T_CONSTANT = token_type('constant');
+const T_CAPITALIZED = token_type('capitalized_identifier', 'class_name');
+const T_OPERATOR = token_type('operator');
+const T_PUNCTUATION = token_type('punctuation');
+
+// word classification kinds
+const K_KEYWORD = 1; // unconditional keyword
+const K_SPECIAL = 2; // unconditional special_keyword (control flow)
+const K_BOOLEAN = 3;
+const K_BUILTIN = 4; // primitive types
+const K_UNION = 5; // weak keyword — a keyword only before an identifier
+const K_MACRO_RULES = 6; // keyword only as `macro_rules!`
+
+const WORDS: Map<string, number> = words_map(
+	[
+		K_KEYWORD,
+		'as async const crate dyn enum extern fn impl in let mod move mut pub ref self Self ' +
+			'static struct super trait type unsafe use where',
+	],
+	[K_SPECIAL, 'await break continue else for if loop match return try while yield'],
+	[K_BOOLEAN, 'true false'],
+	[K_BUILTIN, 'bool char f32 f64 i8 i16 i32 i64 i128 isize str u8 u16 u32 u64 u128 usize'],
+	[K_UNION, 'union'],
+	[K_MACRO_RULES, 'macro_rules'],
+);
+
+// keywords that put the lexer in a type-name context for the next identifier
+const CLASS_CTX_WORDS: Set<string> = new Set([
+	'struct',
+	'enum',
+	'trait',
+	'union',
+	'type',
+	'impl',
+	'dyn',
+]);
+
+/**
+ * Scans a `"` string from the quote at `from`, returning the exclusive end.
+ * Rust strings span lines; unterminated extends to the window end.
+ */
+const scan_rust_string = (text: string, from: number, end: number): number => {
+	let i = from + 1;
+	while (i < end) {
+		const c = text.charCodeAt(i);
+		if (c === 92) i += 2;
+		else if (c === 34) return i + 1;
+		else i++;
+	}
+	return end;
+};
+
+/**
+ * Scans a raw-string body from the opening `"` at `from`, closing on a `"`
+ * followed by `hashes` `#`s. Each probe advances past a `"`, so the scan is
+ * linear in quote-dense bodies. Unterminated extends to the window end.
+ */
+const scan_rust_raw_string = (text: string, from: number, end: number, hashes: number): number => {
+	let i = from + 1;
+	while (i < end) {
+		const q = text.indexOf('"', i);
+		if (q === -1 || q >= end) return end;
+		let h = 0;
+		// bound by `end` — in an embed window, hashes beyond it must not close
+		while (h < hashes && q + 1 + h < end && text.charCodeAt(q + 1 + h) === 35) h++;
+		if (h === hashes) return q + 1 + hashes;
+		i = q + 1;
+	}
+	return end;
+};
+
+/**
+ * Tries a raw-string body at `at` — an optional `#` run then `"`. Returns the
+ * exclusive end past the matching closer (or the window end when
+ * unterminated), or -1 when `at` doesn't open a raw string.
+ */
+const scan_rust_raw_prefixed = (text: string, at: number, end: number): number => {
+	let h = at;
+	while (h < end && text.charCodeAt(h) === 35) h++;
+	if (h >= end || text.charCodeAt(h) !== 34) return -1;
+	return scan_rust_raw_string(text, h, end, h - at);
+};
+
+/**
+ * Scans a nested block comment from the `/*` at `from`, returning the
+ * exclusive end. Rust block comments nest; unterminated extends to the
+ * window end.
+ */
+const scan_rust_block_comment = (text: string, from: number, end: number): number => {
+	let depth = 1;
+	let i = from + 2;
+	while (i < end) {
+		const c = text.charCodeAt(i);
+		// the closer needs both chars inside the window — a `*/` split across
+		// an embed boundary leaves the comment unterminated instead
+		if (c === 42 && i + 1 < end && text.charCodeAt(i + 1) === 47) {
+			depth--;
+			i += 2;
+			if (depth === 0) return i;
+		} else if (c === 47 && i + 1 < end && text.charCodeAt(i + 1) === 42) {
+			depth++;
+			i += 2;
+		} else {
+			i++;
+		}
+	}
+	return end;
+};
+
+/**
+ * Scans a char (or byte-char) literal from the `'` at `from` whose content is
+ * not ident-shaped — an escape or a single code point. Returns the index after
+ * the closing `'`, or -1 when this isn't a char literal.
+ */
+const scan_rust_char = (text: string, from: number, end: number): number => {
+	let i = from + 1;
+	if (i >= end) return -1;
+	const c = text.charCodeAt(i);
+	if (c === 39 || c === 10 || c === 13) return -1;
+	if (c === 92) {
+		// escape: \n \\ \' \0 \x7f \u{10FFFF}
+		const e = text.charCodeAt(i + 1);
+		if (e === 117 && text.charCodeAt(i + 2) === 123) {
+			// \u{hex}, up to 6 hex digits with optional `_` separators
+			let j = i + 3;
+			const limit = j + 12 < end ? j + 12 : end;
+			while (j < limit && (is_hex_digit(text.charCodeAt(j)) || text.charCodeAt(j) === 95)) j++;
+			if (text.charCodeAt(j) !== 125) return -1;
+			i = j + 1;
+		} else {
+			i += 2;
+		}
+	} else {
+		// one code point — a high surrogate half means an astral pair
+		i += c >= 0xd800 && c <= 0xdbff ? 2 : 1;
+	}
+	return i < end && text.charCodeAt(i) === 39 ? i + 1 : -1;
+};
+
+/**
+ * Scans a numeric literal from the digit at `from`, returning the exclusive
+ * end. Handles hex/octal/binary with `_` separators, decimal floats and
+ * exponents, and literal suffixes (`1u8`, `2.5f32`) — any trailing ident run
+ * glues onto the literal, matching rustc's lexing. A trailing `.` is never
+ * consumed without a following digit, so `0..10` and `x.0` lex cleanly.
+ */
+const scan_rust_number = (text: string, from: number, end: number): number => {
+	const scan_digits = (start: number, is_wanted: (c: number) => boolean): number => {
+		let j = start;
+		while (j < end) {
+			const c = text.charCodeAt(j);
+			// rust allows `_` freely between (and after) digits: 1_000, 0x_ff
+			if (is_wanted(c) || c === 95) j++;
+			else break;
+		}
+		return j;
+	};
+	const is_binary = (c: number): boolean => c === 48 || c === 49;
+	const is_octal = (c: number): boolean => c >= 48 && c <= 55;
+
+	let j;
+	if (text.charCodeAt(from) === 48) {
+		const c2 = text.charCodeAt(from + 1);
+		if (c2 === 120 || c2 === 88) {
+			j = scan_digits(from + 2, is_hex_digit);
+		} else if (c2 === 111 || c2 === 79) {
+			j = scan_digits(from + 2, is_octal);
+		} else if (c2 === 98 || c2 === 66) {
+			j = scan_digits(from + 2, is_binary);
+		} else {
+			j = scan_digits(from, is_digit);
+		}
+	} else {
+		j = scan_digits(from, is_digit);
+	}
+	if (text.charCodeAt(j) === 46 && is_digit(text.charCodeAt(j + 1))) {
+		j = scan_digits(j + 1, is_digit);
+	}
+	const e = text.charCodeAt(j);
+	if (e === 101 || e === 69) {
+		let k = j + 1;
+		const sign = text.charCodeAt(k);
+		if (sign === 43 || sign === 45) k++;
+		if (is_digit(text.charCodeAt(k))) j = scan_digits(k, is_digit);
+	}
+	// literal suffix
+	if (j < end && is_ident_start(text.charCodeAt(j))) j = scan_ident(text, j, end);
+	return j > end ? end : j;
+};
+
+/**
+ * Scans a multi-char operator at `i`, returning its length.
+ */
+const scan_rust_operator = (text: string, i: number, end: number): number => {
+	const c = text.charCodeAt(i);
+	const c2 = i + 1 < end ? text.charCodeAt(i + 1) : 0;
+	const c3 = i + 2 < end ? text.charCodeAt(i + 2) : 0;
+	switch (c) {
+		case 43: // +
+		case 42: // *
+		case 47: // /
+		case 37: // %
+		case 94: // ^
+		case 33: // !
+			return c2 === 61 ? 2 : 1;
+		case 45: // -
+			return c2 === 61 || c2 === 62 ? 2 : 1; // -= ->
+		case 38: // &
+			return c2 === 38 || c2 === 61 ? 2 : 1; // && &=
+		case 124: // |
+			return c2 === 124 || c2 === 61 ? 2 : 1; // || |=
+		case 60: // <
+			if (c2 === 60) return c3 === 61 ? 3 : 2; // << <<=
+			return c2 === 61 ? 2 : 1; // <=
+		case 62: // >
+			if (c2 === 62) return c3 === 61 ? 3 : 2; // >> >>=
+			return c2 === 61 ? 2 : 1; // >=
+		case 61: // =
+			return c2 === 61 || c2 === 62 ? 2 : 1; // == =>
+		default:
+			return 1; // ? @
+	}
+};
+
+const lex_rust = (l: Lexer): void => {
+	const {text, end} = l;
+	let i = l.pos;
+	let fn_ctx = false; // after `fn` / `macro_rules!` — the next identifier is a definition name
+	let class_ctx = false; // after `struct`/`enum`/… — the next identifier is a type name
+	let attr_depth = 0; // `[`/`]` depth inside a `#[…]`/`#![…]` attribute (0 = outside)
+	let attr_path = false; // the next identifier is part of the attribute's leading path
+
+	// shebang at the very start of the document (`#!` not opening `#![…]`)
+	if (
+		i === 0 &&
+		text.charCodeAt(0) === 35 &&
+		text.charCodeAt(1) === 33 &&
+		text.charCodeAt(2) !== 91
+	) {
+		const line_end = scan_to_line_end(text, 0, end);
+		l.leaf(T_HASHBANG, 0, line_end);
+		i = line_end;
+	}
+
+	while (i < end) {
+		const c = text.charCodeAt(i);
+		if (is_space(c)) {
+			i++;
+			continue;
+		}
+
+		// identifiers, keywords, and the r/b/c string prefixes
+		if (is_ident_start(c)) {
+			// the leading `::`-separated path of an attribute (`#[derive`, `#[serde`);
+			// the arguments after it lex with the normal rules below
+			if (attr_path) {
+				const path_start = i;
+				const path_end = scan_ident(text, i, end);
+				l.leaf(T_ATTRIBUTE, path_start, path_end);
+				i = path_end;
+				// stay in the path only across a `::` segment separator
+				attr_path = text.charCodeAt(path_end) === 58 && text.charCodeAt(path_end + 1) === 58;
+				continue;
+			}
+			// r"…" r#"…"# r#ident
+			if (c === 114) {
+				const raw_end = scan_rust_raw_prefixed(text, i + 1, end);
+				if (raw_end !== -1) {
+					l.leaf(T_STRING, i, raw_end);
+					i = raw_end;
+					continue;
+				}
+				if (
+					text.charCodeAt(i + 1) === 35 &&
+					i + 2 < end &&
+					is_ident_start(text.charCodeAt(i + 2))
+				) {
+					// r#ident raw identifier — a plain identifier, never a keyword
+					i = scan_ident(text, i + 2, end);
+					fn_ctx = class_ctx = false;
+					continue;
+				}
+			} else if (c === 98) {
+				// b"…" b'…' br"…" br#"…"#
+				const c1 = text.charCodeAt(i + 1);
+				if (c1 === 34) {
+					const str_end = scan_rust_string(text, i + 1, end);
+					l.leaf(T_STRING, i, str_end);
+					i = str_end;
+					continue;
+				}
+				if (c1 === 39) {
+					const char_end = scan_rust_char(text, i + 1, end);
+					if (char_end !== -1) {
+						l.leaf(T_CHAR, i, char_end);
+						i = char_end;
+						continue;
+					}
+				}
+				if (c1 === 114) {
+					const raw_end = scan_rust_raw_prefixed(text, i + 2, end);
+					if (raw_end !== -1) {
+						l.leaf(T_STRING, i, raw_end);
+						i = raw_end;
+						continue;
+					}
+				}
+			} else if (c === 99) {
+				// c"…" cr"…" cr#"…"#
+				const c1 = text.charCodeAt(i + 1);
+				if (c1 === 34) {
+					const str_end = scan_rust_string(text, i + 1, end);
+					l.leaf(T_STRING, i, str_end);
+					i = str_end;
+					continue;
+				}
+				if (c1 === 114) {
+					const raw_end = scan_rust_raw_prefixed(text, i + 2, end);
+					if (raw_end !== -1) {
+						l.leaf(T_STRING, i, raw_end);
+						i = raw_end;
+						continue;
+					}
+				}
+			}
+
+			const start = i;
+			const ident_end = scan_ident(text, i, end);
+			const word = text.slice(start, ident_end);
+			const kind = WORDS.get(word);
+			const was_fn_ctx = fn_ctx;
+			const was_class_ctx = class_ctx;
+			fn_ctx = class_ctx = false;
+			i = ident_end;
+
+			if (kind !== undefined) {
+				if (kind === K_KEYWORD) {
+					l.leaf(T_KEYWORD, start, ident_end);
+					// `fn name`/`struct Name` name the identifier that follows, but
+					// `fn(…)` is a pointer *type* and `impl<T>`/`struct;` have no name
+					// here — only enter the naming context when an identifier actually
+					// follows, or it leaks onto the next value
+					if (word === 'fn') {
+						fn_ctx = is_ident_start(text.charCodeAt(skip_space(text, ident_end, end)));
+					} else if (CLASS_CTX_WORDS.has(word)) {
+						class_ctx = is_ident_start(text.charCodeAt(skip_space(text, ident_end, end)));
+					}
+					continue;
+				}
+				if (kind === K_SPECIAL) {
+					l.leaf(T_SPECIAL_KEYWORD, start, ident_end);
+					continue;
+				}
+				if (kind === K_BOOLEAN) {
+					l.leaf(T_BOOLEAN, start, ident_end);
+					continue;
+				}
+				if (kind === K_BUILTIN) {
+					l.leaf(T_BUILTIN, start, ident_end);
+					continue;
+				}
+				if (kind === K_UNION) {
+					// weak keyword — `union Foo` declares, `let union = …` is illegal
+					// but `union` as a path segment/field is not
+					if (is_ident_start(text.charCodeAt(skip_space(text, ident_end, end)))) {
+						l.leaf(T_KEYWORD, start, ident_end);
+						class_ctx = true;
+						continue;
+					}
+				} else if (kind === K_MACRO_RULES) {
+					if (ident_end < end && text.charCodeAt(ident_end) === 33) {
+						l.leaf(T_KEYWORD, start, ident_end + 1);
+						i = ident_end + 1;
+						fn_ctx = true; // the next identifier names the macro
+						continue;
+					}
+				}
+			}
+
+			if (was_fn_ctx) {
+				l.leaf(T_FUNCTION, start, ident_end);
+				continue;
+			}
+			if (was_class_ctx) {
+				// a path keeps the context for its final segment: `impl fmt::Display`
+				if (text.charCodeAt(ident_end) === 58 && text.charCodeAt(ident_end + 1) === 58) {
+					class_ctx = true;
+					continue;
+				}
+				l.leaf(T_CLASS_NAME, start, ident_end);
+				continue;
+			}
+
+			// `name!` macro invocation — but `x != y` is the operator; the `!`
+			// must sit inside the window so the span can't cross an embed boundary
+			if (
+				ident_end < end &&
+				text.charCodeAt(ident_end) === 33 &&
+				text.charCodeAt(ident_end + 1) !== 61
+			) {
+				l.leaf(T_MACRO, start, ident_end + 1);
+				i = ident_end + 1;
+				continue;
+			}
+
+			// SCREAMING_CASE constants and PascalCase type-ish identifiers; a
+			// single uppercase letter is a generic param (T, E, K, V) far more
+			// often than a constant
+			if (is_upper(c)) {
+				if (ident_end - start === 1) {
+					l.leaf(T_CAPITALIZED, start, ident_end);
+					continue;
+				}
+				let all_caps = true;
+				for (let k = start + 1; k < ident_end; k++) {
+					const cc = text.charCodeAt(k);
+					if (!is_upper(cc) && cc !== 95 && !is_digit(cc)) {
+						all_caps = false;
+						break;
+					}
+				}
+				l.leaf(all_caps ? T_CONSTANT : T_CAPITALIZED, start, ident_end);
+				continue;
+			}
+
+			// call: `foo(…)`; turbofish call: `foo::<T>(…)`
+			if (text.charCodeAt(ident_end) === 40) {
+				l.leaf(T_FUNCTION, start, ident_end);
+				continue;
+			}
+			if (
+				text.charCodeAt(ident_end) === 58 &&
+				text.charCodeAt(ident_end + 1) === 58 &&
+				text.charCodeAt(ident_end + 2) === 60
+			) {
+				l.leaf(T_FUNCTION, start, ident_end);
+				continue;
+			}
+
+			// plain identifier — no token
+			continue;
+		}
+
+		// `'` — lifetime, loop label, or char literal
+		if (c === 39) {
+			const c1 = i + 1 < end ? text.charCodeAt(i + 1) : 0;
+			if (is_ident_start(c1)) {
+				const ident_end = scan_ident(text, i + 1, end);
+				if (ident_end < end && text.charCodeAt(ident_end) === 39) {
+					l.leaf(T_CHAR, i, ident_end + 1); // 'a'
+					i = ident_end + 1;
+				} else {
+					l.leaf(T_LIFETIME, i, ident_end); // 'a  'static  'outer:
+					i = ident_end;
+				}
+				continue;
+			}
+			const char_end = scan_rust_char(text, i, end);
+			if (char_end !== -1) {
+				l.leaf(T_CHAR, i, char_end);
+				i = char_end;
+				continue;
+			}
+			i++; // stray quote — plain text
+			continue;
+		}
+
+		// strings
+		if (c === 34) {
+			const str_end = scan_rust_string(text, i, end);
+			l.leaf(T_STRING, i, str_end);
+			i = str_end;
+			continue;
+		}
+
+		// `/` — comments or division
+		if (c === 47) {
+			const c2 = i + 1 < end ? text.charCodeAt(i + 1) : 0;
+			if (c2 === 47) {
+				const line_end = scan_to_line_end(text, i, end);
+				// classify from window-internal chars only — a marker char beyond
+				// the window is host text, not part of this comment
+				const c3 = i + 2 < end ? text.charCodeAt(i + 2) : 0;
+				const c4 = i + 3 < end ? text.charCodeAt(i + 3) : 0;
+				// `///` (but not `////`) and `//!` are doc comments
+				const is_doc = (c3 === 47 && c4 !== 47) || c3 === 33;
+				l.leaf(is_doc ? T_DOC_COMMENT : T_COMMENT, i, line_end);
+				i = line_end;
+				continue; // comments are transparent — contexts survive
+			}
+			if (c2 === 42) {
+				const comment_end = scan_rust_block_comment(text, i, end);
+				const c3 = i + 2 < end ? text.charCodeAt(i + 2) : 0;
+				const c4 = i + 3 < end ? text.charCodeAt(i + 3) : 0;
+				// `/**` (but not `/**/` or `/***`) and `/*!` are doc comments
+				const is_doc = (c3 === 42 && c4 !== 47 && c4 !== 42) || c3 === 33;
+				l.leaf(is_doc ? T_DOC_COMMENT : T_COMMENT, i, comment_end);
+				i = comment_end;
+				continue;
+			}
+			const op_len = scan_rust_operator(text, i, end);
+			l.leaf(T_OPERATOR, i, i + op_len);
+			i += op_len;
+			continue;
+		}
+
+		// `#` — attribute or stray. The interior lexes inline: the `#[`/`#![`
+		// marker and the leading path are attribute-styled, the arguments get the
+		// normal rules, and the `[`/`]` depth counter bookends the closing bracket
+		if (c === 35) {
+			const c1 = i + 1 < end ? text.charCodeAt(i + 1) : 0;
+			// the whole marker must sit inside the window — a `#![` whose `[` is
+			// beyond an embed boundary stays a stray `#`, not a truncated attribute
+			if (c1 === 91 || (c1 === 33 && i + 2 < end && text.charCodeAt(i + 2) === 91)) {
+				const marker_end = c1 === 33 ? i + 3 : i + 2; // past `#[` or `#![`
+				l.leaf(T_ATTRIBUTE, i, marker_end);
+				i = marker_end;
+				attr_depth = 1;
+				attr_path = true;
+				continue;
+			}
+			i++;
+			continue;
+		}
+
+		// numbers (no `.5` floats in rust — a leading `.` is always punctuation)
+		if (is_digit(c)) {
+			const num_end = scan_rust_number(text, i, end);
+			l.leaf(T_NUMBER, i, num_end);
+			i = num_end;
+			continue;
+		}
+
+		// `.` — member access, or the `..`/`..=`/`...` range operators. The
+		// second `.` must sit inside the window so the span can't cross an embed
+		// boundary; a `.` at the window edge stays punctuation
+		if (c === 46) {
+			if (i + 1 < end && text.charCodeAt(i + 1) === 46) {
+				const c3 = i + 2 < end ? text.charCodeAt(i + 2) : 0;
+				const op_len = c3 === 61 || c3 === 46 ? 3 : 2;
+				l.leaf(T_OPERATOR, i, i + op_len);
+				i += op_len;
+			} else {
+				l.leaf(T_PUNCTUATION, i, i + 1);
+				i++;
+			}
+			continue;
+		}
+
+		// attribute brackets — depth-count so a nested `[` doesn't close the
+		// attribute early, and style the closing `]` to bookend the `#[` marker
+		if (attr_depth > 0 && (c === 91 || c === 93)) {
+			if (c === 91) {
+				attr_depth++;
+				l.leaf(T_PUNCTUATION, i, i + 1);
+			} else {
+				attr_depth--;
+				if (attr_depth === 0) {
+					l.leaf(T_ATTRIBUTE, i, i + 1);
+					attr_path = false;
+				} else {
+					l.leaf(T_PUNCTUATION, i, i + 1);
+				}
+			}
+			i++;
+			continue;
+		}
+
+		// punctuation — `:`/`::` render as punctuation so path runs coalesce
+		if (
+			c === 123 ||
+			c === 125 ||
+			c === 91 ||
+			c === 93 ||
+			c === 40 ||
+			c === 41 ||
+			c === 59 ||
+			c === 44 ||
+			c === 58
+		) {
+			l.leaf(T_PUNCTUATION, i, i + 1);
+			i++;
+			continue;
+		}
+
+		// operators
+		if (
+			c === 43 ||
+			c === 45 ||
+			c === 42 ||
+			c === 37 ||
+			c === 94 ||
+			c === 38 ||
+			c === 124 ||
+			c === 61 ||
+			c === 33 ||
+			c === 60 ||
+			c === 62 ||
+			c === 63 ||
+			c === 64
+		) {
+			const op_len = scan_rust_operator(text, i, end);
+			l.leaf(T_OPERATOR, i, i + op_len);
+			i += op_len;
+			continue;
+		}
+
+		// anything else is plain text
+		i++;
+	}
+	l.pos = end;
+};
+
+/**
+ * The Rust language registration for the lexer engine.
+ */
+export const lexer_rust: SyntaxLang = {
+	id: 'rust',
+	aliases: ['rs'],
+	lex: lex_rust,
+};
diff --git a/src/lib/lexer_ts.ts b/src/lib/lexer_ts.ts
index 9b99c2de..00e52bfc 100644
--- a/src/lib/lexer_ts.ts
+++ b/src/lib/lexer_ts.ts
@@ -4,6 +4,7 @@ import {
 	is_ident,
 	is_ident_start,
 	is_space,
+	is_upper,
 	scan_ident,
 	scan_to_line_end,
 	skip_quoted,
@@ -169,8 +170,6 @@ const create_ts_scan_cache = (): TsScanCache => ({
 	next_rparen: -1,
 });
 
-const is_upper = (c: number): boolean => c >= 65 && c <= 90;
-
 /**
  * Scans a `'` or `"` string from `i`, returning the exclusive end.
  * Handles escapes and line continuations; unterminated stops at the newline.
diff --git a/src/lib/syntax_styler_global.ts b/src/lib/syntax_styler_global.ts
index 4be8cc4e..d506bf1d 100644
--- a/src/lib/syntax_styler_global.ts
+++ b/src/lib/syntax_styler_global.ts
@@ -6,6 +6,7 @@ import {lexer_bash} from './lexer_bash.ts';
 import {lexer_markup, lexer_xml} from './lexer_markup.ts';
 import {lexer_svelte} from './lexer_svelte.ts';
 import {lexer_md} from './lexer_md.ts';
+import {lexer_rust} from './lexer_rust.ts';
 
 /**
  * Pre-configured `SyntaxStyler` instance with all built-in languages registered.
@@ -27,3 +28,4 @@ syntax_styler_global.add_lang(lexer_markup);
 syntax_styler_global.add_lang(lexer_xml);
 syntax_styler_global.add_lang(lexer_svelte);
 syntax_styler_global.add_lang(lexer_md);
+syntax_styler_global.add_lang(lexer_rust);
diff --git a/src/routes/benchmark/benchmark_fixtures.ts b/src/routes/benchmark/benchmark_fixtures.ts
index a9b37e9f..58d8c393 100644
--- a/src/routes/benchmark/benchmark_fixtures.ts
+++ b/src/routes/benchmark/benchmark_fixtures.ts
@@ -44,5 +44,5 @@ export const implementations: Array<BenchmarkedImplementation> = [
 ];
 
 // Languages to test
-export const languages = ['ts', 'css', 'html', 'json', 'svelte', 'md', 'sh'] as const;
+export const languages = ['ts', 'rs', 'css', 'html', 'json', 'svelte', 'md', 'sh'] as const;
 export type Language = (typeof languages)[number];
diff --git a/src/routes/docs/benchmark/+page.svelte b/src/routes/docs/benchmark/+page.svelte
index 49f0f20b..dd1b0598 100644
--- a/src/routes/docs/benchmark/+page.svelte
+++ b/src/routes/docs/benchmark/+page.svelte
@@ -44,29 +44,29 @@
 <TomeContent {tome}>
 	<section>
 		<p>
-			fuz_code is optimized for runtime highlighting, including streaming usecases. It runs one
-			hand-written single-pass lexer per language without regular expressions, emitting a flat token
-			event stream that renders to HTML in one forward pass. There is no grammar interpreter and no
-			backtracking, so highlighting cost stays linear in the length of the input, including partial
-			or malformed source.
+			fuz_code runs one hand-written single-pass lexer per language without regular expressions,
+			emitting a flat token event stream that renders to HTML in one forward pass. There is no
+			grammar interpreter and no backtracking, so highlighting cost stays linear in the length of
+			the input, including partial or malformed source.
+		</p>
+		<p>
+			It is optimized for <em>runtime</em> highlighting, including streaming use cases.
+			<a href="https://github.com/shikijs/shiki">Shiki</a>
+			targets build-time use and runs the
+			<a href="https://shiki.matsu.io/guide/regex-engines">Oniguruma regexp engine</a> that TextMate grammars
+			require, trading runtime speed for grammar and theme coverage. fuz_code trades that coverage for
+			a small, fast runtime path — it also provides tools for pre-compilation, and you can bring your
+			own lexers for languages it doesn't support.
 		</p>
 	</section>
 	<TomeSection>
 		<TomeSectionHeader text="Compared to Shiki and Prism" />
 		<p>
 			The cross-implementation benchmark measures fuz_code against
-			<a href="https://github.com/PrismJS/prism">Prism</a> and
-			<a href="https://github.com/shikijs/shiki">Shiki</a>
-			(both its <a href="https://shiki.matsu.io/guide/regex-engines">Oniguruma regexp engine</a> and its
-			reimplementation in JS). Shiki targets build-time use and works with TextMate grammars, trading
-			runtime speed for capability and compatibility with its large ecosystem of grammars and themes.
-			fuz_code trades that coverage for an efficient runtime path (and also provides tools for pre-compilation),
-			where you can bring your own lexers for languages it doesn't support.
-		</p>
-		<p>
-			For end-to-end <code>stylize</code> calls turning a string of code into a string of stylized HTML,
-			fuz_code is about an order of magnitude faster than Prism and about two orders of magnitude faster
-			than Shiki:
+			<a href="https://github.com/PrismJS/prism">Prism</a> and Shiki (both the JavaScript and
+			Oniguruma engines). For end-to-end <code>stylize</code> — lexing plus HTML generation, the realistic
+			runtime path — fuz_code runs roughly an order of magnitude faster than Prism and about two orders
+			of magnitude faster than Shiki:
 		</p>
 		<div class="overflow-x:auto">
 			<table>
diff --git a/src/routes/lang_color.ts b/src/routes/lang_color.ts
index 505dd40e..c650572d 100644
--- a/src/routes/lang_color.ts
+++ b/src/routes/lang_color.ts
@@ -8,6 +8,7 @@ export const lang_colors: Record<SampleLang, string> = {
 	json: 'color_e', // gold
 	css: 'color_d', // purple
 	ts: 'color_a', // blue
+	rs: 'color_g', // pink (rust's orange and brown are taken)
 	html: 'color_c', // red
 	svelte: 'color_h', // orange
 	md: 'color_f', // brown
diff --git a/src/routes/samples/all.gen.ts b/src/routes/samples/all.gen.ts
index f2e1cc2a..a594c198 100644
--- a/src/routes/samples/all.gen.ts
+++ b/src/routes/samples/all.gen.ts
@@ -9,7 +9,7 @@ import {sample_langs} from '$lib/code_sample.ts';
 export const gen: Gen = async ({origin_path}) => {
 	// Discover all sample files dynamically
 	const sample_files = await fs_search('src/test/fixtures/samples', {
-		file_filter: (path) => /sample_[^/]+\.(ts|css|html|json|svelte|md|sh)$/.test(path),
+		file_filter: (path) => /sample_[^/]+\.(ts|rs|css|html|json|svelte|md|sh)$/.test(path),
 	});
 
 	// Create flat structure with lang_variant keys
diff --git a/src/routes/samples/all.ts b/src/routes/samples/all.ts
index 2853a57a..35c341fd 100644
--- a/src/routes/samples/all.ts
+++ b/src/routes/samples/all.ts
@@ -6,6 +6,7 @@ export type SampleKey =
 	| 'json_complex'
 	| 'css_complex'
 	| 'ts_complex'
+	| 'rs_complex'
 	| 'html_complex'
 	| 'svelte_complex'
 	| 'md_complex'
@@ -236,6 +237,129 @@ export const complex_regex = /^(?:\\/\\*.*?\\*\\/|\\/\\/.*|[^/])+$/;
 
 // string in comment should not be highlighted as string
 // const commented = "this string is in a comment";
+`,
+	},
+	rs_complex: {
+		name: 'rs_complex',
+		lang: 'rs',
+		content: `//! A sample module exercising the Rust lexer's token paths.
+
+use std::collections::HashMap;
+use std::fmt;
+
+/// The maximum number of retries before giving up.
+pub const MAX_RETRIES: u32 = 3;
+static GREETING: &str = "hello, \\"world\\"\\n";
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Event<'a> {
+    Push { repo: &'a str, commits: usize },
+    Tag(String),
+    Empty,
+}
+
+/* a plain block comment
+   /* they nest in rust */
+   still inside the outer one */
+
+#[derive(Default)]
+pub struct Registry<T> {
+    entries: HashMap<String, T>,
+    hits: u64,
+}
+
+impl<T: fmt::Debug> Registry<T> {
+    pub fn new() -> Self {
+        Self {
+            entries: HashMap::new(),
+            hits: 0_u64,
+        }
+    }
+
+    /** Inserts an entry, returning the previous value if present. */
+    pub fn insert(&mut self, key: &str, value: T) -> Option<T> {
+        self.hits += 1;
+        self.entries.insert(key.to_string(), value)
+    }
+
+    pub async fn drain(&mut self) -> Vec<T> {
+        let drained: Vec<T> = self.entries.drain().map(|(_, v)| v).collect();
+        drained
+    }
+}
+
+impl fmt::Display for Event<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Event::Push { repo, commits } => write!(f, "{repo}: {commits} commits"),
+            Event::Tag(name) => write!(f, "tag {name}"),
+            Event::Empty => Ok(()),
+        }
+    }
+}
+
+macro_rules! count {
+    ($($x:expr),*) => {
+        [$($x),*].len()
+    };
+}
+
+fn classify(byte: u8) -> char {
+    match byte {
+        b'a'..=b'z' => 'l',
+        0x30..=0x39 => 'd',
+        b'_' => '_',
+        _ => '?',
+    }
+}
+
+fn first_word<I>(words: I) -> Option<String>
+where
+    I: IntoIterator<Item = String>,
+{
+    let mut it = words.into_iter();
+    let head = it.next()?;
+    Some(head.trim().to_string())
+}
+
+async fn warm(registry: &mut Registry<i64>) -> usize {
+    registry.drain().await.len()
+}
+
+pub fn main() {
+    let mut registry: Registry<i64> = Registry::new();
+    registry.insert("answer", 42);
+    registry.insert("mask", 0b1010_0110 as i64);
+    registry.insert("offset", 0o777);
+    registry.insert("float-ish", 2.5e-3 as i64);
+
+    let pattern = r#"a "raw" string with \\ no escapes"#;
+    let bytes = b"raw bytes\\x00";
+    let path = r"C:\\temp";
+    let emoji = '\\u{1F600}';
+    let newline = '\\n';
+
+    let total: usize = (0..MAX_RETRIES as usize).map(|i| i * 2).sum();
+    let parsed = "17".parse::<u32>().unwrap_or(0);
+    let verbose = true;
+    let quiet: bool = !verbose && false;
+
+    'outer: for (key, value) in [("a", 1), ("b", 2)] {
+        if value > 1 && !key.is_empty() {
+            println!("{key} -> {value}, total={total}, parsed={parsed}");
+            break 'outer;
+        }
+    }
+
+    assert_ne!(count!(1, 2, 3), 0);
+    let seed = first_word(vec![String::from("seed")]);
+    let _ = (pattern, bytes, path, emoji, newline, quiet, classify(b'x'), GREETING, seed, warm);
+
+    unsafe {
+        let raw: *const u64 = &registry.hits;
+        debug_assert!(!raw.is_null());
+    }
+}
 `,
 	},
 	html_complex: {
diff --git a/src/test/fixtures/generated/rs/rs_complex.html b/src/test/fixtures/generated/rs/rs_complex.html
new file mode 100644
index 00000000..a827f61f
--- /dev/null
+++ b/src/test/fixtures/generated/rs/rs_complex.html
@@ -0,0 +1,118 @@
+<span class="token_doc_comment token_comment">//! A sample module exercising the Rust lexer's token paths.</span>
+
+<span class="token_keyword">use</span> std<span class="token_punctuation">::</span>collections<span class="token_punctuation">::</span><span class="token_capitalized_identifier token_class_name">HashMap</span><span class="token_punctuation">;</span>
+<span class="token_keyword">use</span> std<span class="token_punctuation">::</span>fmt<span class="token_punctuation">;</span>
+
+<span class="token_doc_comment token_comment">/// The maximum number of retries before giving up.</span>
+<span class="token_keyword">pub</span> <span class="token_keyword">const</span> <span class="token_constant">MAX_RETRIES</span><span class="token_punctuation">:</span> <span class="token_builtin">u32</span> <span class="token_operator">=</span> <span class="token_number">3</span><span class="token_punctuation">;</span>
+<span class="token_keyword">static</span> <span class="token_constant">GREETING</span><span class="token_punctuation">:</span> <span class="token_operator">&amp;</span><span class="token_builtin">str</span> <span class="token_operator">=</span> <span class="token_string">"hello, \"world\"\n"</span><span class="token_punctuation">;</span>
+
+<span class="token_attribute token_attr_name">#[derive</span><span class="token_punctuation">(</span><span class="token_capitalized_identifier token_class_name">Debug</span><span class="token_punctuation">,</span> <span class="token_capitalized_identifier token_class_name">Clone</span><span class="token_punctuation">,</span> <span class="token_capitalized_identifier token_class_name">PartialEq</span><span class="token_punctuation">)</span><span class="token_attribute token_attr_name">]</span>
+<span class="token_keyword">pub</span> <span class="token_keyword">enum</span> <span class="token_class_name">Event</span><span class="token_operator">&lt;</span><span class="token_lifetime token_symbol">'a</span><span class="token_operator">></span> <span class="token_punctuation">{</span>
+    <span class="token_capitalized_identifier token_class_name">Push</span> <span class="token_punctuation">{</span> repo<span class="token_punctuation">:</span> <span class="token_operator">&amp;</span><span class="token_lifetime token_symbol">'a</span> <span class="token_builtin">str</span><span class="token_punctuation">,</span> commits<span class="token_punctuation">:</span> <span class="token_builtin">usize</span> <span class="token_punctuation">},</span>
+    <span class="token_capitalized_identifier token_class_name">Tag</span><span class="token_punctuation">(</span><span class="token_capitalized_identifier token_class_name">String</span><span class="token_punctuation">),</span>
+    <span class="token_capitalized_identifier token_class_name">Empty</span><span class="token_punctuation">,</span>
+<span class="token_punctuation">}</span>
+
+<span class="token_comment">/* a plain block comment
+   /* they nest in rust */
+   still inside the outer one */</span>
+
+<span class="token_attribute token_attr_name">#[derive</span><span class="token_punctuation">(</span><span class="token_capitalized_identifier token_class_name">Default</span><span class="token_punctuation">)</span><span class="token_attribute token_attr_name">]</span>
+<span class="token_keyword">pub</span> <span class="token_keyword">struct</span> <span class="token_class_name">Registry</span><span class="token_operator">&lt;</span><span class="token_capitalized_identifier token_class_name">T</span><span class="token_operator">></span> <span class="token_punctuation">{</span>
+    entries<span class="token_punctuation">:</span> <span class="token_capitalized_identifier token_class_name">HashMap</span><span class="token_operator">&lt;</span><span class="token_capitalized_identifier token_class_name">String</span><span class="token_punctuation">,</span> <span class="token_capitalized_identifier token_class_name">T</span><span class="token_operator">></span><span class="token_punctuation">,</span>
+    hits<span class="token_punctuation">:</span> <span class="token_builtin">u64</span><span class="token_punctuation">,</span>
+<span class="token_punctuation">}</span>
+
+<span class="token_keyword">impl</span><span class="token_operator">&lt;</span><span class="token_capitalized_identifier token_class_name">T</span><span class="token_punctuation">:</span> fmt<span class="token_punctuation">::</span><span class="token_capitalized_identifier token_class_name">Debug</span><span class="token_operator">></span> <span class="token_capitalized_identifier token_class_name">Registry</span><span class="token_operator">&lt;</span><span class="token_capitalized_identifier token_class_name">T</span><span class="token_operator">></span> <span class="token_punctuation">{</span>
+    <span class="token_keyword">pub</span> <span class="token_keyword">fn</span> <span class="token_function">new</span><span class="token_punctuation">()</span> <span class="token_operator">-></span> <span class="token_keyword">Self</span> <span class="token_punctuation">{</span>
+        <span class="token_keyword">Self</span> <span class="token_punctuation">{</span>
+            entries<span class="token_punctuation">:</span> <span class="token_capitalized_identifier token_class_name">HashMap</span><span class="token_punctuation">::</span><span class="token_function">new</span><span class="token_punctuation">(),</span>
+            hits<span class="token_punctuation">:</span> <span class="token_number">0_u64</span><span class="token_punctuation">,</span>
+        <span class="token_punctuation">}</span>
+    <span class="token_punctuation">}</span>
+
+    <span class="token_doc_comment token_comment">/** Inserts an entry, returning the previous value if present. */</span>
+    <span class="token_keyword">pub</span> <span class="token_keyword">fn</span> <span class="token_function">insert</span><span class="token_punctuation">(</span><span class="token_operator">&amp;</span><span class="token_keyword">mut</span> <span class="token_keyword">self</span><span class="token_punctuation">,</span> key<span class="token_punctuation">:</span> <span class="token_operator">&amp;</span><span class="token_builtin">str</span><span class="token_punctuation">,</span> value<span class="token_punctuation">:</span> <span class="token_capitalized_identifier token_class_name">T</span><span class="token_punctuation">)</span> <span class="token_operator">-></span> <span class="token_capitalized_identifier token_class_name">Option</span><span class="token_operator">&lt;</span><span class="token_capitalized_identifier token_class_name">T</span><span class="token_operator">></span> <span class="token_punctuation">{</span>
+        <span class="token_keyword">self</span><span class="token_punctuation">.</span>hits <span class="token_operator">+=</span> <span class="token_number">1</span><span class="token_punctuation">;</span>
+        <span class="token_keyword">self</span><span class="token_punctuation">.</span>entries<span class="token_punctuation">.</span><span class="token_function">insert</span><span class="token_punctuation">(</span>key<span class="token_punctuation">.</span><span class="token_function">to_string</span><span class="token_punctuation">(),</span> value<span class="token_punctuation">)</span>
+    <span class="token_punctuation">}</span>
+
+    <span class="token_keyword">pub</span> <span class="token_keyword">async</span> <span class="token_keyword">fn</span> <span class="token_function">drain</span><span class="token_punctuation">(</span><span class="token_operator">&amp;</span><span class="token_keyword">mut</span> <span class="token_keyword">self</span><span class="token_punctuation">)</span> <span class="token_operator">-></span> <span class="token_capitalized_identifier token_class_name">Vec</span><span class="token_operator">&lt;</span><span class="token_capitalized_identifier token_class_name">T</span><span class="token_operator">></span> <span class="token_punctuation">{</span>
+        <span class="token_keyword">let</span> drained<span class="token_punctuation">:</span> <span class="token_capitalized_identifier token_class_name">Vec</span><span class="token_operator">&lt;</span><span class="token_capitalized_identifier token_class_name">T</span><span class="token_operator">></span> <span class="token_operator">=</span> <span class="token_keyword">self</span><span class="token_punctuation">.</span>entries<span class="token_punctuation">.</span><span class="token_function">drain</span><span class="token_punctuation">().</span><span class="token_function">map</span><span class="token_punctuation">(</span><span class="token_operator">|</span><span class="token_punctuation">(</span>_<span class="token_punctuation">,</span> v<span class="token_punctuation">)</span><span class="token_operator">|</span> v<span class="token_punctuation">).</span><span class="token_function">collect</span><span class="token_punctuation">();</span>
+        drained
+    <span class="token_punctuation">}</span>
+<span class="token_punctuation">}</span>
+
+<span class="token_keyword">impl</span> fmt<span class="token_punctuation">::</span><span class="token_class_name">Display</span> <span class="token_special_keyword">for</span> <span class="token_capitalized_identifier token_class_name">Event</span><span class="token_operator">&lt;</span><span class="token_lifetime token_symbol">'_</span><span class="token_operator">></span> <span class="token_punctuation">{</span>
+    <span class="token_keyword">fn</span> <span class="token_function">fmt</span><span class="token_punctuation">(</span><span class="token_operator">&amp;</span><span class="token_keyword">self</span><span class="token_punctuation">,</span> f<span class="token_punctuation">:</span> <span class="token_operator">&amp;</span><span class="token_keyword">mut</span> fmt<span class="token_punctuation">::</span><span class="token_capitalized_identifier token_class_name">Formatter</span><span class="token_operator">&lt;</span><span class="token_lifetime token_symbol">'_</span><span class="token_operator">></span><span class="token_punctuation">)</span> <span class="token_operator">-></span> fmt<span class="token_punctuation">::</span><span class="token_capitalized_identifier token_class_name">Result</span> <span class="token_punctuation">{</span>
+        <span class="token_special_keyword">match</span> <span class="token_keyword">self</span> <span class="token_punctuation">{</span>
+            <span class="token_capitalized_identifier token_class_name">Event</span><span class="token_punctuation">::</span><span class="token_capitalized_identifier token_class_name">Push</span> <span class="token_punctuation">{</span> repo<span class="token_punctuation">,</span> commits <span class="token_punctuation">}</span> <span class="token_operator">=></span> <span class="token_macro token_function">write!</span><span class="token_punctuation">(</span>f<span class="token_punctuation">,</span> <span class="token_string">"{repo}: {commits} commits"</span><span class="token_punctuation">),</span>
+            <span class="token_capitalized_identifier token_class_name">Event</span><span class="token_punctuation">::</span><span class="token_capitalized_identifier token_class_name">Tag</span><span class="token_punctuation">(</span>name<span class="token_punctuation">)</span> <span class="token_operator">=></span> <span class="token_macro token_function">write!</span><span class="token_punctuation">(</span>f<span class="token_punctuation">,</span> <span class="token_string">"tag {name}"</span><span class="token_punctuation">),</span>
+            <span class="token_capitalized_identifier token_class_name">Event</span><span class="token_punctuation">::</span><span class="token_capitalized_identifier token_class_name">Empty</span> <span class="token_operator">=></span> <span class="token_capitalized_identifier token_class_name">Ok</span><span class="token_punctuation">(()),</span>
+        <span class="token_punctuation">}</span>
+    <span class="token_punctuation">}</span>
+<span class="token_punctuation">}</span>
+
+<span class="token_keyword">macro_rules!</span> <span class="token_function">count</span> <span class="token_punctuation">{</span>
+    <span class="token_punctuation">(</span><span class="token_function">$</span><span class="token_punctuation">(</span>$x<span class="token_punctuation">:</span>expr<span class="token_punctuation">),</span><span class="token_operator">*</span><span class="token_punctuation">)</span> <span class="token_operator">=></span> <span class="token_punctuation">{</span>
+        <span class="token_punctuation">[</span><span class="token_function">$</span><span class="token_punctuation">(</span>$x<span class="token_punctuation">),</span><span class="token_operator">*</span><span class="token_punctuation">].</span><span class="token_function">len</span><span class="token_punctuation">()</span>
+    <span class="token_punctuation">};</span>
+<span class="token_punctuation">}</span>
+
+<span class="token_keyword">fn</span> <span class="token_function">classify</span><span class="token_punctuation">(</span>byte<span class="token_punctuation">:</span> <span class="token_builtin">u8</span><span class="token_punctuation">)</span> <span class="token_operator">-></span> <span class="token_builtin">char</span> <span class="token_punctuation">{</span>
+    <span class="token_special_keyword">match</span> byte <span class="token_punctuation">{</span>
+        <span class="token_char">b'a'</span><span class="token_operator">..=</span><span class="token_char">b'z'</span> <span class="token_operator">=></span> <span class="token_char">'l'</span><span class="token_punctuation">,</span>
+        <span class="token_number">0x30</span><span class="token_operator">..=</span><span class="token_number">0x39</span> <span class="token_operator">=></span> <span class="token_char">'d'</span><span class="token_punctuation">,</span>
+        <span class="token_char">b'_'</span> <span class="token_operator">=></span> <span class="token_char">'_'</span><span class="token_punctuation">,</span>
+        _ <span class="token_operator">=></span> <span class="token_char">'?'</span><span class="token_punctuation">,</span>
+    <span class="token_punctuation">}</span>
+<span class="token_punctuation">}</span>
+
+<span class="token_keyword">fn</span> <span class="token_function">first_word</span><span class="token_operator">&lt;</span><span class="token_capitalized_identifier token_class_name">I</span><span class="token_operator">></span><span class="token_punctuation">(</span>words<span class="token_punctuation">:</span> <span class="token_capitalized_identifier token_class_name">I</span><span class="token_punctuation">)</span> <span class="token_operator">-></span> <span class="token_capitalized_identifier token_class_name">Option</span><span class="token_operator">&lt;</span><span class="token_capitalized_identifier token_class_name">String</span><span class="token_operator">></span>
+<span class="token_keyword">where</span>
+    <span class="token_capitalized_identifier token_class_name">I</span><span class="token_punctuation">:</span> <span class="token_capitalized_identifier token_class_name">IntoIterator</span><span class="token_operator">&lt;</span><span class="token_capitalized_identifier token_class_name">Item</span> <span class="token_operator">=</span> <span class="token_capitalized_identifier token_class_name">String</span><span class="token_operator">></span><span class="token_punctuation">,</span>
+<span class="token_punctuation">{</span>
+    <span class="token_keyword">let</span> <span class="token_keyword">mut</span> it <span class="token_operator">=</span> words<span class="token_punctuation">.</span><span class="token_function">into_iter</span><span class="token_punctuation">();</span>
+    <span class="token_keyword">let</span> head <span class="token_operator">=</span> it<span class="token_punctuation">.</span><span class="token_function">next</span><span class="token_punctuation">()</span><span class="token_operator">?</span><span class="token_punctuation">;</span>
+    <span class="token_capitalized_identifier token_class_name">Some</span><span class="token_punctuation">(</span>head<span class="token_punctuation">.</span><span class="token_function">trim</span><span class="token_punctuation">().</span><span class="token_function">to_string</span><span class="token_punctuation">())</span>
+<span class="token_punctuation">}</span>
+
+<span class="token_keyword">async</span> <span class="token_keyword">fn</span> <span class="token_function">warm</span><span class="token_punctuation">(</span>registry<span class="token_punctuation">:</span> <span class="token_operator">&amp;</span><span class="token_keyword">mut</span> <span class="token_capitalized_identifier token_class_name">Registry</span><span class="token_operator">&lt;</span><span class="token_builtin">i64</span><span class="token_operator">></span><span class="token_punctuation">)</span> <span class="token_operator">-></span> <span class="token_builtin">usize</span> <span class="token_punctuation">{</span>
+    registry<span class="token_punctuation">.</span><span class="token_function">drain</span><span class="token_punctuation">().</span><span class="token_special_keyword">await</span><span class="token_punctuation">.</span><span class="token_function">len</span><span class="token_punctuation">()</span>
+<span class="token_punctuation">}</span>
+
+<span class="token_keyword">pub</span> <span class="token_keyword">fn</span> <span class="token_function">main</span><span class="token_punctuation">()</span> <span class="token_punctuation">{</span>
+    <span class="token_keyword">let</span> <span class="token_keyword">mut</span> registry<span class="token_punctuation">:</span> <span class="token_capitalized_identifier token_class_name">Registry</span><span class="token_operator">&lt;</span><span class="token_builtin">i64</span><span class="token_operator">></span> <span class="token_operator">=</span> <span class="token_capitalized_identifier token_class_name">Registry</span><span class="token_punctuation">::</span><span class="token_function">new</span><span class="token_punctuation">();</span>
+    registry<span class="token_punctuation">.</span><span class="token_function">insert</span><span class="token_punctuation">(</span><span class="token_string">"answer"</span><span class="token_punctuation">,</span> <span class="token_number">42</span><span class="token_punctuation">);</span>
+    registry<span class="token_punctuation">.</span><span class="token_function">insert</span><span class="token_punctuation">(</span><span class="token_string">"mask"</span><span class="token_punctuation">,</span> <span class="token_number">0b1010_0110</span> <span class="token_keyword">as</span> <span class="token_builtin">i64</span><span class="token_punctuation">);</span>
+    registry<span class="token_punctuation">.</span><span class="token_function">insert</span><span class="token_punctuation">(</span><span class="token_string">"offset"</span><span class="token_punctuation">,</span> <span class="token_number">0o777</span><span class="token_punctuation">);</span>
+    registry<span class="token_punctuation">.</span><span class="token_function">insert</span><span class="token_punctuation">(</span><span class="token_string">"float-ish"</span><span class="token_punctuation">,</span> <span class="token_number">2.5e-3</span> <span class="token_keyword">as</span> <span class="token_builtin">i64</span><span class="token_punctuation">);</span>
+
+    <span class="token_keyword">let</span> pattern <span class="token_operator">=</span> <span class="token_string">r#"a "raw" string with \ no escapes"#</span><span class="token_punctuation">;</span>
+    <span class="token_keyword">let</span> bytes <span class="token_operator">=</span> <span class="token_string">b"raw bytes\x00"</span><span class="token_punctuation">;</span>
+    <span class="token_keyword">let</span> path <span class="token_operator">=</span> <span class="token_string">r"C:\temp"</span><span class="token_punctuation">;</span>
+    <span class="token_keyword">let</span> emoji <span class="token_operator">=</span> <span class="token_char">'\u{1F600}'</span><span class="token_punctuation">;</span>
+    <span class="token_keyword">let</span> newline <span class="token_operator">=</span> <span class="token_char">'\n'</span><span class="token_punctuation">;</span>
+
+    <span class="token_keyword">let</span> total<span class="token_punctuation">:</span> <span class="token_builtin">usize</span> <span class="token_operator">=</span> <span class="token_punctuation">(</span><span class="token_number">0</span><span class="token_operator">..</span><span class="token_constant">MAX_RETRIES</span> <span class="token_keyword">as</span> <span class="token_builtin">usize</span><span class="token_punctuation">).</span><span class="token_function">map</span><span class="token_punctuation">(</span><span class="token_operator">|</span>i<span class="token_operator">|</span> i <span class="token_operator">*</span> <span class="token_number">2</span><span class="token_punctuation">).</span><span class="token_function">sum</span><span class="token_punctuation">();</span>
+    <span class="token_keyword">let</span> parsed <span class="token_operator">=</span> <span class="token_string">"17"</span><span class="token_punctuation">.</span><span class="token_function">parse</span><span class="token_punctuation">::</span><span class="token_operator">&lt;</span><span class="token_builtin">u32</span><span class="token_operator">></span><span class="token_punctuation">().</span><span class="token_function">unwrap_or</span><span class="token_punctuation">(</span><span class="token_number">0</span><span class="token_punctuation">);</span>
+    <span class="token_keyword">let</span> verbose <span class="token_operator">=</span> <span class="token_boolean">true</span><span class="token_punctuation">;</span>
+    <span class="token_keyword">let</span> quiet<span class="token_punctuation">:</span> <span class="token_builtin">bool</span> <span class="token_operator">=</span> <span class="token_operator">!</span>verbose <span class="token_operator">&amp;&amp;</span> <span class="token_boolean">false</span><span class="token_punctuation">;</span>
+
+    <span class="token_lifetime token_symbol">'outer</span><span class="token_punctuation">:</span> <span class="token_special_keyword">for</span> <span class="token_punctuation">(</span>key<span class="token_punctuation">,</span> value<span class="token_punctuation">)</span> <span class="token_keyword">in</span> <span class="token_punctuation">[(</span><span class="token_string">"a"</span><span class="token_punctuation">,</span> <span class="token_number">1</span><span class="token_punctuation">),</span> <span class="token_punctuation">(</span><span class="token_string">"b"</span><span class="token_punctuation">,</span> <span class="token_number">2</span><span class="token_punctuation">)]</span> <span class="token_punctuation">{</span>
+        <span class="token_special_keyword">if</span> value <span class="token_operator">></span> <span class="token_number">1</span> <span class="token_operator">&amp;&amp;</span> <span class="token_operator">!</span>key<span class="token_punctuation">.</span><span class="token_function">is_empty</span><span class="token_punctuation">()</span> <span class="token_punctuation">{</span>
+            <span class="token_macro token_function">println!</span><span class="token_punctuation">(</span><span class="token_string">"{key} -> {value}, total={total}, parsed={parsed}"</span><span class="token_punctuation">);</span>
+            <span class="token_special_keyword">break</span> <span class="token_lifetime token_symbol">'outer</span><span class="token_punctuation">;</span>
+        <span class="token_punctuation">}</span>
+    <span class="token_punctuation">}</span>
+
+    <span class="token_macro token_function">assert_ne!</span><span class="token_punctuation">(</span><span class="token_macro token_function">count!</span><span class="token_punctuation">(</span><span class="token_number">1</span><span class="token_punctuation">,</span> <span class="token_number">2</span><span class="token_punctuation">,</span> <span class="token_number">3</span><span class="token_punctuation">),</span> <span class="token_number">0</span><span class="token_punctuation">);</span>
+    <span class="token_keyword">let</span> seed <span class="token_operator">=</span> <span class="token_function">first_word</span><span class="token_punctuation">(</span><span class="token_macro token_function">vec!</span><span class="token_punctuation">[</span><span class="token_capitalized_identifier token_class_name">String</span><span class="token_punctuation">::</span><span class="token_function">from</span><span class="token_punctuation">(</span><span class="token_string">"seed"</span><span class="token_punctuation">)]);</span>
+    <span class="token_keyword">let</span> _ <span class="token_operator">=</span> <span class="token_punctuation">(</span>pattern<span class="token_punctuation">,</span> bytes<span class="token_punctuation">,</span> path<span class="token_punctuation">,</span> emoji<span class="token_punctuation">,</span> newline<span class="token_punctuation">,</span> quiet<span class="token_punctuation">,</span> <span class="token_function">classify</span><span class="token_punctuation">(</span><span class="token_char">b'x'</span><span class="token_punctuation">),</span> <span class="token_constant">GREETING</span><span class="token_punctuation">,</span> seed<span class="token_punctuation">,</span> warm<span class="token_punctuation">);</span>
+
+    <span class="token_keyword">unsafe</span> <span class="token_punctuation">{</span>
+        <span class="token_keyword">let</span> raw<span class="token_punctuation">:</span> <span class="token_operator">*</span><span class="token_keyword">const</span> <span class="token_builtin">u64</span> <span class="token_operator">=</span> <span class="token_operator">&amp;</span>registry<span class="token_punctuation">.</span>hits<span class="token_punctuation">;</span>
+        <span class="token_macro token_function">debug_assert!</span><span class="token_punctuation">(</span><span class="token_operator">!</span>raw<span class="token_punctuation">.</span><span class="token_function">is_null</span><span class="token_punctuation">());</span>
+    <span class="token_punctuation">}</span>
+<span class="token_punctuation">}</span>
diff --git a/src/test/fixtures/generated/rs/rs_complex.txt b/src/test/fixtures/generated/rs/rs_complex.txt
new file mode 100644
index 00000000..d06501b6
--- /dev/null
+++ b/src/test/fixtures/generated/rs/rs_complex.txt
@@ -0,0 +1,613 @@
+=== STATS ===
+Sample length: 3012 characters
+Total tokens: 588
+
+Token types (18 unique):
+  punctuation: 245
+  operator: 94
+  keyword: 64
+  capitalized_identifier: 48
+  function: 38
+  number: 19
+  builtin: 18
+  string: 15
+  char: 10
+  special_keyword: 7
+  macro: 7
+  lifetime: 6
+  constant: 4
+  attribute: 4
+  doc_comment: 3
+  class_name: 3
+  boolean: 2
+  comment: 1
+
+=== TOKENS ===
+   0-60    doc_comment               //! A sample module exercising the Rust lexer's token paths.
+  62-65    keyword                   use
+  69-71    punctuation               ::
+  82-84    punctuation               ::
+  84-91    capitalized_identifier    HashMap
+  91-92    punctuation               ;
+  93-96    keyword                   use
+ 100-102   punctuation               ::
+ 105-106   punctuation               ;
+ 108-159   doc_comment               /// The maximum number of retries before giving up.
+ 160-163   keyword                   pub
+ 164-169   keyword                   const
+ 170-181   constant                  MAX_RETRIES
+ 181-182   punctuation               :
+ 183-186   builtin                   u32
+ 187-188   operator                  =
+ 189-190   number                    3
+ 190-191   punctuation               ;
+ 192-198   keyword                   static
+ 199-207   constant                  GREETING
+ 207-208   punctuation               :
+ 209-210   operator                  &
+ 210-213   builtin                   str
+ 214-215   operator                  =
+ 216-236   string                    "hello, \"world\"\n"
+ 236-237   punctuation               ;
+ 239-247   attribute                 #[derive
+ 247-248   punctuation               (
+ 248-253   capitalized_identifier    Debug
+ 253-254   punctuation               ,
+ 255-260   capitalized_identifier    Clone
+ 260-261   punctuation               ,
+ 262-271   capitalized_identifier    PartialEq
+ 271-272   punctuation               )
+ 272-273   attribute                 ]
+ 274-277   keyword                   pub
+ 278-282   keyword                   enum
+ 283-288   class_name                Event
+ 288-289   operator                  <
+ 289-291   lifetime                  'a
+ 291-292   operator                  >
+ 293-294   punctuation               {
+ 299-303   capitalized_identifier    Push
+ 304-305   punctuation               {
+ 310-311   punctuation               :
+ 312-313   operator                  &
+ 313-315   lifetime                  'a
+ 316-319   builtin                   str
+ 319-320   punctuation               ,
+ 328-329   punctuation               :
+ 330-335   builtin                   usize
+ 336-338   punctuation               },
+ 343-346   capitalized_identifier    Tag
+ 346-347   punctuation               (
+ 347-353   capitalized_identifier    String
+ 353-355   punctuation               ),
+ 360-365   capitalized_identifier    Empty
+ 365-366   punctuation               ,
+ 367-368   punctuation               }
+ 370-454   comment                   /* a plain block comment\n   /* they nest in rust */\n   still inside the outer one */
+ 456-464   attribute                 #[derive
+ 464-465   punctuation               (
+ 465-472   capitalized_identifier    Default
+ 472-473   punctuation               )
+ 473-474   attribute                 ]
+ 475-478   keyword                   pub
+ 479-485   keyword                   struct
+ 486-494   class_name                Registry
+ 494-495   operator                  <
+ 495-496   capitalized_identifier    T
+ 496-497   operator                  >
+ 498-499   punctuation               {
+ 511-512   punctuation               :
+ 513-520   capitalized_identifier    HashMap
+ 520-521   operator                  <
+ 521-527   capitalized_identifier    String
+ 527-528   punctuation               ,
+ 529-530   capitalized_identifier    T
+ 530-531   operator                  >
+ 531-532   punctuation               ,
+ 541-542   punctuation               :
+ 543-546   builtin                   u64
+ 546-547   punctuation               ,
+ 548-549   punctuation               }
+ 551-555   keyword                   impl
+ 555-556   operator                  <
+ 556-557   capitalized_identifier    T
+ 557-558   punctuation               :
+ 562-564   punctuation               ::
+ 564-569   capitalized_identifier    Debug
+ 569-570   operator                  >
+ 571-579   capitalized_identifier    Registry
+ 579-580   operator                  <
+ 580-581   capitalized_identifier    T
+ 581-582   operator                  >
+ 583-584   punctuation               {
+ 589-592   keyword                   pub
+ 593-595   keyword                   fn
+ 596-599   function                  new
+ 599-601   punctuation               ()
+ 602-604   operator                  ->
+ 605-609   keyword                   Self
+ 610-611   punctuation               {
+ 620-624   keyword                   Self
+ 625-626   punctuation               {
+ 646-647   punctuation               :
+ 648-655   capitalized_identifier    HashMap
+ 655-657   punctuation               ::
+ 657-660   function                  new
+ 660-663   punctuation               (),
+ 680-681   punctuation               :
+ 682-687   number                    0_u64
+ 687-688   punctuation               ,
+ 697-698   punctuation               }
+ 703-704   punctuation               }
+ 710-775   doc_comment               /** Inserts an entry, returning the previous value if present. */
+ 780-783   keyword                   pub
+ 784-786   keyword                   fn
+ 787-793   function                  insert
+ 793-794   punctuation               (
+ 794-795   operator                  &
+ 795-798   keyword                   mut
+ 799-803   keyword                   self
+ 803-804   punctuation               ,
+ 808-809   punctuation               :
+ 810-811   operator                  &
+ 811-814   builtin                   str
+ 814-815   punctuation               ,
+ 821-822   punctuation               :
+ 823-824   capitalized_identifier    T
+ 824-825   punctuation               )
+ 826-828   operator                  ->
+ 829-835   capitalized_identifier    Option
+ 835-836   operator                  <
+ 836-837   capitalized_identifier    T
+ 837-838   operator                  >
+ 839-840   punctuation               {
+ 849-853   keyword                   self
+ 853-854   punctuation               .
+ 859-861   operator                  +=
+ 862-863   number                    1
+ 863-864   punctuation               ;
+ 873-877   keyword                   self
+ 877-878   punctuation               .
+ 885-886   punctuation               .
+ 886-892   function                  insert
+ 892-893   punctuation               (
+ 896-897   punctuation               .
+ 897-906   function                  to_string
+ 906-909   punctuation               (),
+ 915-916   punctuation               )
+ 921-922   punctuation               }
+ 928-931   keyword                   pub
+ 932-937   keyword                   async
+ 938-940   keyword                   fn
+ 941-946   function                  drain
+ 946-947   punctuation               (
+ 947-948   operator                  &
+ 948-951   keyword                   mut
+ 952-956   keyword                   self
+ 956-957   punctuation               )
+ 958-960   operator                  ->
+ 961-964   capitalized_identifier    Vec
+ 964-965   operator                  <
+ 965-966   capitalized_identifier    T
+ 966-967   operator                  >
+ 968-969   punctuation               {
+ 978-981   keyword                   let
+ 989-990   punctuation               :
+ 991-994   capitalized_identifier    Vec
+ 994-995   operator                  <
+ 995-996   capitalized_identifier    T
+ 996-997   operator                  >
+ 998-999   operator                  =
+1000-1004  keyword                   self
+1004-1005  punctuation               .
+1012-1013  punctuation               .
+1013-1018  function                  drain
+1018-1021  punctuation               ().
+1021-1024  function                  map
+1024-1025  punctuation               (
+1025-1026  operator                  |
+1026-1027  punctuation               (
+1028-1029  punctuation               ,
+1031-1032  punctuation               )
+1032-1033  operator                  |
+1035-1037  punctuation               ).
+1037-1044  function                  collect
+1044-1047  punctuation               ();
+1068-1069  punctuation               }
+1070-1071  punctuation               }
+1073-1077  keyword                   impl
+1081-1083  punctuation               ::
+1083-1090  class_name                Display
+1091-1094  special_keyword           for
+1095-1100  capitalized_identifier    Event
+1100-1101  operator                  <
+1101-1103  lifetime                  '_
+1103-1104  operator                  >
+1105-1106  punctuation               {
+1111-1113  keyword                   fn
+1114-1117  function                  fmt
+1117-1118  punctuation               (
+1118-1119  operator                  &
+1119-1123  keyword                   self
+1123-1124  punctuation               ,
+1126-1127  punctuation               :
+1128-1129  operator                  &
+1129-1132  keyword                   mut
+1136-1138  punctuation               ::
+1138-1147  capitalized_identifier    Formatter
+1147-1148  operator                  <
+1148-1150  lifetime                  '_
+1150-1151  operator                  >
+1151-1152  punctuation               )
+1153-1155  operator                  ->
+1159-1161  punctuation               ::
+1161-1167  capitalized_identifier    Result
+1168-1169  punctuation               {
+1178-1183  special_keyword           match
+1184-1188  keyword                   self
+1189-1190  punctuation               {
+1203-1208  capitalized_identifier    Event
+1208-1210  punctuation               ::
+1210-1214  capitalized_identifier    Push
+1215-1216  punctuation               {
+1221-1222  punctuation               ,
+1231-1232  punctuation               }
+1233-1235  operator                  =>
+1236-1242  macro                     write!
+1242-1243  punctuation               (
+1244-1245  punctuation               ,
+1246-1273  string                    "{repo}: {commits} commits"
+1273-1275  punctuation               ),
+1288-1293  capitalized_identifier    Event
+1293-1295  punctuation               ::
+1295-1298  capitalized_identifier    Tag
+1298-1299  punctuation               (
+1303-1304  punctuation               )
+1305-1307  operator                  =>
+1308-1314  macro                     write!
+1314-1315  punctuation               (
+1316-1317  punctuation               ,
+1318-1330  string                    "tag {name}"
+1330-1332  punctuation               ),
+1345-1350  capitalized_identifier    Event
+1350-1352  punctuation               ::
+1352-1357  capitalized_identifier    Empty
+1358-1360  operator                  =>
+1361-1363  capitalized_identifier    Ok
+1363-1368  punctuation               (()),
+1377-1378  punctuation               }
+1383-1384  punctuation               }
+1385-1386  punctuation               }
+1388-1400  keyword                   macro_rules!
+1401-1406  function                  count
+1407-1408  punctuation               {
+1413-1414  punctuation               (
+1414-1415  function                  $
+1415-1416  punctuation               (
+1418-1419  punctuation               :
+1423-1425  punctuation               ),
+1425-1426  operator                  *
+1426-1427  punctuation               )
+1428-1430  operator                  =>
+1431-1432  punctuation               {
+1441-1442  punctuation               [
+1442-1443  function                  $
+1443-1444  punctuation               (
+1446-1448  punctuation               ),
+1448-1449  operator                  *
+1449-1451  punctuation               ].
+1451-1454  function                  len
+1454-1456  punctuation               ()
+1461-1463  punctuation               };
+1464-1465  punctuation               }
+1467-1469  keyword                   fn
+1470-1478  function                  classify
+1478-1479  punctuation               (
+1483-1484  punctuation               :
+1485-1487  builtin                   u8
+1487-1488  punctuation               )
+1489-1491  operator                  ->
+1492-1496  builtin                   char
+1497-1498  punctuation               {
+1503-1508  special_keyword           match
+1514-1515  punctuation               {
+1524-1528  char                      b'a'
+1528-1531  operator                  ..=
+1531-1535  char                      b'z'
+1536-1538  operator                  =>
+1539-1542  char                      'l'
+1542-1543  punctuation               ,
+1552-1556  number                    0x30
+1556-1559  operator                  ..=
+1559-1563  number                    0x39
+1564-1566  operator                  =>
+1567-1570  char                      'd'
+1570-1571  punctuation               ,
+1580-1584  char                      b'_'
+1585-1587  operator                  =>
+1588-1591  char                      '_'
+1591-1592  punctuation               ,
+1603-1605  operator                  =>
+1606-1609  char                      '?'
+1609-1610  punctuation               ,
+1615-1616  punctuation               }
+1617-1618  punctuation               }
+1620-1622  keyword                   fn
+1623-1633  function                  first_word
+1633-1634  operator                  <
+1634-1635  capitalized_identifier    I
+1635-1636  operator                  >
+1636-1637  punctuation               (
+1642-1643  punctuation               :
+1644-1645  capitalized_identifier    I
+1645-1646  punctuation               )
+1647-1649  operator                  ->
+1650-1656  capitalized_identifier    Option
+1656-1657  operator                  <
+1657-1663  capitalized_identifier    String
+1663-1664  operator                  >
+1665-1670  keyword                   where
+1675-1676  capitalized_identifier    I
+1676-1677  punctuation               :
+1678-1690  capitalized_identifier    IntoIterator
+1690-1691  operator                  <
+1691-1695  capitalized_identifier    Item
+1696-1697  operator                  =
+1698-1704  capitalized_identifier    String
+1704-1705  operator                  >
+1705-1706  punctuation               ,
+1707-1708  punctuation               {
+1713-1716  keyword                   let
+1717-1720  keyword                   mut
+1724-1725  operator                  =
+1731-1732  punctuation               .
+1732-1741  function                  into_iter
+1741-1744  punctuation               ();
+1749-1752  keyword                   let
+1758-1759  operator                  =
+1762-1763  punctuation               .
+1763-1767  function                  next
+1767-1769  punctuation               ()
+1769-1770  operator                  ?
+1770-1771  punctuation               ;
+1776-1780  capitalized_identifier    Some
+1780-1781  punctuation               (
+1785-1786  punctuation               .
+1786-1790  function                  trim
+1790-1793  punctuation               ().
+1793-1802  function                  to_string
+1802-1805  punctuation               ())
+1806-1807  punctuation               }
+1809-1814  keyword                   async
+1815-1817  keyword                   fn
+1818-1822  function                  warm
+1822-1823  punctuation               (
+1831-1832  punctuation               :
+1833-1834  operator                  &
+1834-1837  keyword                   mut
+1838-1846  capitalized_identifier    Registry
+1846-1847  operator                  <
+1847-1850  builtin                   i64
+1850-1851  operator                  >
+1851-1852  punctuation               )
+1853-1855  operator                  ->
+1856-1861  builtin                   usize
+1862-1863  punctuation               {
+1876-1877  punctuation               .
+1877-1882  function                  drain
+1882-1885  punctuation               ().
+1885-1890  special_keyword           await
+1890-1891  punctuation               .
+1891-1894  function                  len
+1894-1896  punctuation               ()
+1897-1898  punctuation               }
+1900-1903  keyword                   pub
+1904-1906  keyword                   fn
+1907-1911  function                  main
+1911-1913  punctuation               ()
+1914-1915  punctuation               {
+1920-1923  keyword                   let
+1924-1927  keyword                   mut
+1936-1937  punctuation               :
+1938-1946  capitalized_identifier    Registry
+1946-1947  operator                  <
+1947-1950  builtin                   i64
+1950-1951  operator                  >
+1952-1953  operator                  =
+1954-1962  capitalized_identifier    Registry
+1962-1964  punctuation               ::
+1964-1967  function                  new
+1967-1970  punctuation               ();
+1983-1984  punctuation               .
+1984-1990  function                  insert
+1990-1991  punctuation               (
+1991-1999  string                    "answer"
+1999-2000  punctuation               ,
+2001-2003  number                    42
+2003-2005  punctuation               );
+2018-2019  punctuation               .
+2019-2025  function                  insert
+2025-2026  punctuation               (
+2026-2032  string                    "mask"
+2032-2033  punctuation               ,
+2034-2045  number                    0b1010_0110
+2046-2048  keyword                   as
+2049-2052  builtin                   i64
+2052-2054  punctuation               );
+2067-2068  punctuation               .
+2068-2074  function                  insert
+2074-2075  punctuation               (
+2075-2083  string                    "offset"
+2083-2084  punctuation               ,
+2085-2090  number                    0o777
+2090-2092  punctuation               );
+2105-2106  punctuation               .
+2106-2112  function                  insert
+2112-2113  punctuation               (
+2113-2124  string                    "float-ish"
+2124-2125  punctuation               ,
+2126-2132  number                    2.5e-3
+2133-2135  keyword                   as
+2136-2139  builtin                   i64
+2139-2141  punctuation               );
+2147-2150  keyword                   let
+2159-2160  operator                  =
+2161-2198  string                    r#"a "raw" string with \ no escapes"#
+2198-2199  punctuation               ;
+2204-2207  keyword                   let
+2214-2215  operator                  =
+2216-2232  string                    b"raw bytes\x00"
+2232-2233  punctuation               ;
+2238-2241  keyword                   let
+2247-2248  operator                  =
+2249-2259  string                    r"C:\temp"
+2259-2260  punctuation               ;
+2265-2268  keyword                   let
+2275-2276  operator                  =
+2277-2288  char                      '\u{1F600}'
+2288-2289  punctuation               ;
+2294-2297  keyword                   let
+2306-2307  operator                  =
+2308-2312  char                      '\n'
+2312-2313  punctuation               ;
+2319-2322  keyword                   let
+2328-2329  punctuation               :
+2330-2335  builtin                   usize
+2336-2337  operator                  =
+2338-2339  punctuation               (
+2339-2340  number                    0
+2340-2342  operator                  ..
+2342-2353  constant                  MAX_RETRIES
+2354-2356  keyword                   as
+2357-2362  builtin                   usize
+2362-2364  punctuation               ).
+2364-2367  function                  map
+2367-2368  punctuation               (
+2368-2369  operator                  |
+2370-2371  operator                  |
+2374-2375  operator                  *
+2376-2377  number                    2
+2377-2379  punctuation               ).
+2379-2382  function                  sum
+2382-2385  punctuation               ();
+2390-2393  keyword                   let
+2401-2402  operator                  =
+2403-2407  string                    "17"
+2407-2408  punctuation               .
+2408-2413  function                  parse
+2413-2415  punctuation               ::
+2415-2416  operator                  <
+2416-2419  builtin                   u32
+2419-2420  operator                  >
+2420-2423  punctuation               ().
+2423-2432  function                  unwrap_or
+2432-2433  punctuation               (
+2433-2434  number                    0
+2434-2436  punctuation               );
+2441-2444  keyword                   let
+2453-2454  operator                  =
+2455-2459  boolean                   true
+2459-2460  punctuation               ;
+2465-2468  keyword                   let
+2474-2475  punctuation               :
+2476-2480  builtin                   bool
+2481-2482  operator                  =
+2483-2484  operator                  !
+2492-2494  operator                  &&
+2495-2500  boolean                   false
+2500-2501  punctuation               ;
+2507-2513  lifetime                  'outer
+2513-2514  punctuation               :
+2515-2518  special_keyword           for
+2519-2520  punctuation               (
+2523-2524  punctuation               ,
+2530-2531  punctuation               )
+2532-2534  keyword                   in
+2535-2537  punctuation               [(
+2537-2540  string                    "a"
+2540-2541  punctuation               ,
+2542-2543  number                    1
+2543-2545  punctuation               ),
+2546-2547  punctuation               (
+2547-2550  string                    "b"
+2550-2551  punctuation               ,
+2552-2553  number                    2
+2553-2555  punctuation               )]
+2556-2557  punctuation               {
+2566-2568  special_keyword           if
+2575-2576  operator                  >
+2577-2578  number                    1
+2579-2581  operator                  &&
+2582-2583  operator                  !
+2586-2587  punctuation               .
+2587-2595  function                  is_empty
+2595-2597  punctuation               ()
+2598-2599  punctuation               {
+2612-2620  macro                     println!
+2620-2621  punctuation               (
+2621-2671  string                    "{key} -> {value}, total={total}, parsed={parsed}"
+2671-2673  punctuation               );
+2686-2691  special_keyword           break
+2692-2698  lifetime                  'outer
+2698-2699  punctuation               ;
+2708-2709  punctuation               }
+2714-2715  punctuation               }
+2721-2731  macro                     assert_ne!
+2731-2732  punctuation               (
+2732-2738  macro                     count!
+2738-2739  punctuation               (
+2739-2740  number                    1
+2740-2741  punctuation               ,
+2742-2743  number                    2
+2743-2744  punctuation               ,
+2745-2746  number                    3
+2746-2748  punctuation               ),
+2749-2750  number                    0
+2750-2752  punctuation               );
+2757-2760  keyword                   let
+2766-2767  operator                  =
+2768-2778  function                  first_word
+2778-2779  punctuation               (
+2779-2783  macro                     vec!
+2783-2784  punctuation               [
+2784-2790  capitalized_identifier    String
+2790-2792  punctuation               ::
+2792-2796  function                  from
+2796-2797  punctuation               (
+2797-2803  string                    "seed"
+2803-2807  punctuation               )]);
+2812-2815  keyword                   let
+2818-2819  operator                  =
+2820-2821  punctuation               (
+2828-2829  punctuation               ,
+2835-2836  punctuation               ,
+2841-2842  punctuation               ,
+2848-2849  punctuation               ,
+2857-2858  punctuation               ,
+2864-2865  punctuation               ,
+2866-2874  function                  classify
+2874-2875  punctuation               (
+2875-2879  char                      b'x'
+2879-2881  punctuation               ),
+2882-2890  constant                  GREETING
+2890-2891  punctuation               ,
+2896-2897  punctuation               ,
+2902-2904  punctuation               );
+2910-2916  keyword                   unsafe
+2917-2918  punctuation               {
+2927-2930  keyword                   let
+2934-2935  punctuation               :
+2936-2937  operator                  *
+2937-2942  keyword                   const
+2943-2946  builtin                   u64
+2947-2948  operator                  =
+2949-2950  operator                  &
+2958-2959  punctuation               .
+2963-2964  punctuation               ;
+2973-2986  macro                     debug_assert!
+2986-2987  punctuation               (
+2987-2988  operator                  !
+2991-2992  punctuation               .
+2992-2999  function                  is_null
+2999-3003  punctuation               ());
+3008-3009  punctuation               }
+3010-3011  punctuation               }
diff --git a/src/test/fixtures/helpers.ts b/src/test/fixtures/helpers.ts
index 65f5904c..a06cb1d5 100644
--- a/src/test/fixtures/helpers.ts
+++ b/src/test/fixtures/helpers.ts
@@ -22,7 +22,7 @@ export interface GeneratedOutput {
  */
 export const discover_samples = async (): Promise<Array<SampleSpec>> => {
 	const sample_files = await fs_search('src/test/fixtures/samples', {
-		file_filter: (path) => /sample_[^/]+\.(ts|css|html|json|svelte|md|sh)$/.test(path),
+		file_filter: (path) => /sample_[^/]+\.(ts|rs|css|html|json|svelte|md|sh)$/.test(path),
 	});
 
 	const samples: Array<SampleSpec> = [];
diff --git a/src/test/fixtures/samples/sample_complex.rs b/src/test/fixtures/samples/sample_complex.rs
new file mode 100644
index 00000000..f97ae8dd
--- /dev/null
+++ b/src/test/fixtures/samples/sample_complex.rs
@@ -0,0 +1,118 @@
+//! A sample module exercising the Rust lexer's token paths.
+
+use std::collections::HashMap;
+use std::fmt;
+
+/// The maximum number of retries before giving up.
+pub const MAX_RETRIES: u32 = 3;
+static GREETING: &str = "hello, \"world\"\n";
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Event<'a> {
+    Push { repo: &'a str, commits: usize },
+    Tag(String),
+    Empty,
+}
+
+/* a plain block comment
+   /* they nest in rust */
+   still inside the outer one */
+
+#[derive(Default)]
+pub struct Registry<T> {
+    entries: HashMap<String, T>,
+    hits: u64,
+}
+
+impl<T: fmt::Debug> Registry<T> {
+    pub fn new() -> Self {
+        Self {
+            entries: HashMap::new(),
+            hits: 0_u64,
+        }
+    }
+
+    /** Inserts an entry, returning the previous value if present. */
+    pub fn insert(&mut self, key: &str, value: T) -> Option<T> {
+        self.hits += 1;
+        self.entries.insert(key.to_string(), value)
+    }
+
+    pub async fn drain(&mut self) -> Vec<T> {
+        let drained: Vec<T> = self.entries.drain().map(|(_, v)| v).collect();
+        drained
+    }
+}
+
+impl fmt::Display for Event<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Event::Push { repo, commits } => write!(f, "{repo}: {commits} commits"),
+            Event::Tag(name) => write!(f, "tag {name}"),
+            Event::Empty => Ok(()),
+        }
+    }
+}
+
+macro_rules! count {
+    ($($x:expr),*) => {
+        [$($x),*].len()
+    };
+}
+
+fn classify(byte: u8) -> char {
+    match byte {
+        b'a'..=b'z' => 'l',
+        0x30..=0x39 => 'd',
+        b'_' => '_',
+        _ => '?',
+    }
+}
+
+fn first_word<I>(words: I) -> Option<String>
+where
+    I: IntoIterator<Item = String>,
+{
+    let mut it = words.into_iter();
+    let head = it.next()?;
+    Some(head.trim().to_string())
+}
+
+async fn warm(registry: &mut Registry<i64>) -> usize {
+    registry.drain().await.len()
+}
+
+pub fn main() {
+    let mut registry: Registry<i64> = Registry::new();
+    registry.insert("answer", 42);
+    registry.insert("mask", 0b1010_0110 as i64);
+    registry.insert("offset", 0o777);
+    registry.insert("float-ish", 2.5e-3 as i64);
+
+    let pattern = r#"a "raw" string with \ no escapes"#;
+    let bytes = b"raw bytes\x00";
+    let path = r"C:\temp";
+    let emoji = '\u{1F600}';
+    let newline = '\n';
+
+    let total: usize = (0..MAX_RETRIES as usize).map(|i| i * 2).sum();
+    let parsed = "17".parse::<u32>().unwrap_or(0);
+    let verbose = true;
+    let quiet: bool = !verbose && false;
+
+    'outer: for (key, value) in [("a", 1), ("b", 2)] {
+        if value > 1 && !key.is_empty() {
+            println!("{key} -> {value}, total={total}, parsed={parsed}");
+            break 'outer;
+        }
+    }
+
+    assert_ne!(count!(1, 2, 3), 0);
+    let seed = first_word(vec![String::from("seed")]);
+    let _ = (pattern, bytes, path, emoji, newline, quiet, classify(b'x'), GREETING, seed, warm);
+
+    unsafe {
+        let raw: *const u64 = &registry.hits;
+        debug_assert!(!raw.is_null());
+    }
+}
diff --git a/src/test/lexer_rust.test.ts b/src/test/lexer_rust.test.ts
new file mode 100644
index 00000000..3733144b
--- /dev/null
+++ b/src/test/lexer_rust.test.ts
@@ -0,0 +1,553 @@
+import {describe, test, assert} from 'vitest';
+import {readFileSync} from 'node:fs';
+
+import {syntax_styler_global} from '$lib/syntax_styler_global.ts';
+import {
+	Lexer,
+	syntax_events_to_tokens,
+	token_types_global,
+	validate_syntax_events,
+} from '$lib/lexer.ts';
+import {lexer_rust} from '$lib/lexer_rust.ts';
+
+const tokens_of = (text: string): Array<[string, string]> =>
+	syntax_events_to_tokens(syntax_styler_global.lex(text, 'rust')).map((t) => [
+		t.type,
+		text.slice(t.start, t.end),
+	]);
+
+describe('lexer_rust', () => {
+	test('resolves under both the rust id and the rs alias', () => {
+		assert.ok(syntax_styler_global.has_lang('rust'));
+		assert.ok(syntax_styler_global.has_lang('rs'));
+	});
+
+	test('keywords split into declaration and control-flow kinds', () => {
+		assert.deepEqual(tokens_of('fn add(a: u32) -> u32 { return a; }'), [
+			['keyword', 'fn'],
+			['function', 'add'],
+			['punctuation', '('],
+			['punctuation', ':'],
+			['builtin', 'u32'],
+			['punctuation', ')'],
+			['operator', '->'],
+			['builtin', 'u32'],
+			['punctuation', '{'],
+			['special_keyword', 'return'],
+			['punctuation', ';'],
+			['punctuation', '}'],
+		]);
+	});
+
+	test('distinguishes lifetimes from char literals', () => {
+		assert.deepEqual(tokens_of("&'a str"), [
+			['operator', '&'],
+			['lifetime', "'a"],
+			['builtin', 'str'],
+		]);
+		assert.deepEqual(tokens_of("'y'"), [['char', "'y'"]]);
+		assert.deepEqual(tokens_of("&'static str"), [
+			['operator', '&'],
+			['lifetime', "'static"],
+			['builtin', 'str'],
+		]);
+	});
+
+	test('loop labels lex as lifetimes', () => {
+		assert.deepEqual(tokens_of("'outer: loop { break 'outer; }"), [
+			['lifetime', "'outer"],
+			['punctuation', ':'],
+			['special_keyword', 'loop'],
+			['punctuation', '{'],
+			['special_keyword', 'break'],
+			['lifetime', "'outer"],
+			['punctuation', ';'],
+			['punctuation', '}'],
+		]);
+	});
+
+	test('char escapes, unicode escapes, and astral chars', () => {
+		assert.deepEqual(tokens_of("'\\n'"), [['char', "'\\n'"]]);
+		assert.deepEqual(tokens_of("'\\''"), [['char', "'\\''"]]);
+		assert.deepEqual(tokens_of("'\\u{1F600}'"), [['char', "'\\u{1F600}'"]]);
+		assert.deepEqual(tokens_of("'😀'"), [['char', "'😀'"]]);
+	});
+
+	test('a stray quote stays plain text', () => {
+		assert.deepEqual(tokens_of("' + 1"), [
+			['operator', '+'],
+			['number', '1'],
+		]);
+	});
+
+	test('lifetime renders with the symbol alias class', () => {
+		assert.include(
+			syntax_styler_global.stylize("'a", 'rust'),
+			'<span class="token_lifetime token_symbol">',
+		);
+	});
+
+	test('strings span lines and handle escapes', () => {
+		assert.deepEqual(tokens_of('"line1\nline2" x'), [['string', '"line1\nline2"']]);
+		assert.deepEqual(tokens_of('"a \\" b"'), [['string', '"a \\" b"']]);
+		assert.deepEqual(tokens_of('"unterminated'), [['string', '"unterminated']]);
+	});
+
+	test('raw strings close on their hash count', () => {
+		assert.deepEqual(tokens_of('r#"has "quotes" inside"#'), [
+			['string', 'r#"has "quotes" inside"#'],
+		]);
+		assert.deepEqual(tokens_of('r"plain\\raw"'), [['string', 'r"plain\\raw"']]);
+		assert.deepEqual(tokens_of('r##"needs "# more"## x'), [['string', 'r##"needs "# more"##']]);
+		assert.deepEqual(tokens_of('r#"unterminated'), [['string', 'r#"unterminated']]);
+	});
+
+	test('byte and c-string literals', () => {
+		assert.deepEqual(tokens_of('b"bytes\\x00"'), [['string', 'b"bytes\\x00"']]);
+		assert.deepEqual(tokens_of("b'x'"), [['char', "b'x'"]]);
+		assert.deepEqual(tokens_of('br##"raw"##'), [['string', 'br##"raw"##']]);
+		assert.deepEqual(tokens_of('c"hello"'), [['string', 'c"hello"']]);
+		assert.deepEqual(tokens_of('cr#"raw"#'), [['string', 'cr#"raw"#']]);
+	});
+
+	test('raw identifiers are plain, never keywords', () => {
+		assert.deepEqual(tokens_of('let r#type = 1;'), [
+			['keyword', 'let'],
+			['operator', '='],
+			['number', '1'],
+			['punctuation', ';'],
+		]);
+	});
+
+	test('macro invocations include the bang; != stays an operator', () => {
+		assert.deepEqual(tokens_of('println!("hi")'), [
+			['macro', 'println!'],
+			['punctuation', '('],
+			['string', '"hi"'],
+			['punctuation', ')'],
+		]);
+		assert.deepEqual(tokens_of('a != b'), [['operator', '!=']]);
+	});
+
+	test('macro renders with the function alias class', () => {
+		assert.include(
+			syntax_styler_global.stylize('vec![]', 'rust'),
+			'<span class="token_macro token_function">vec!</span>',
+		);
+	});
+
+	test('line comments split doc from plain', () => {
+		assert.deepEqual(tokens_of('// plain'), [['comment', '// plain']]);
+		assert.deepEqual(tokens_of('/// doc'), [['doc_comment', '/// doc']]);
+		assert.deepEqual(tokens_of('//! inner doc'), [['doc_comment', '//! inner doc']]);
+		assert.deepEqual(tokens_of('//// four slashes'), [['comment', '//// four slashes']]);
+	});
+
+	test('block comments nest', () => {
+		assert.deepEqual(tokens_of('/* a /* nested */ b */ 1'), [
+			['comment', '/* a /* nested */ b */'],
+			['number', '1'],
+		]);
+		assert.deepEqual(tokens_of('/* unterminated /* still'), [
+			['comment', '/* unterminated /* still'],
+		]);
+	});
+
+	test('block doc comments split doc from plain', () => {
+		assert.deepEqual(tokens_of('/** outer doc */'), [['doc_comment', '/** outer doc */']]);
+		assert.deepEqual(tokens_of('/*! inner doc */'), [['doc_comment', '/*! inner doc */']]);
+		assert.deepEqual(tokens_of('/**/'), [['comment', '/**/']]);
+	});
+
+	test('attribute interiors lex inline; strings/chars/comments hide their brackets', () => {
+		// marker + leading path are attribute-styled; the arguments get normal rules
+		assert.deepEqual(tokens_of('#[derive(Debug, Clone)]'), [
+			['attribute', '#[derive'],
+			['punctuation', '('],
+			['capitalized_identifier', 'Debug'],
+			['punctuation', ','],
+			['capitalized_identifier', 'Clone'],
+			['punctuation', ')'],
+			['attribute', ']'],
+		]);
+		// a path-only attribute coalesces back to a single token
+		assert.deepEqual(tokens_of('#[inline]'), [['attribute', '#[inline]']]);
+		assert.deepEqual(tokens_of('#![allow(dead_code)]'), [
+			['attribute', '#![allow'],
+			['punctuation', '('],
+			['punctuation', ')'],
+			['attribute', ']'],
+		]);
+		// `::`-separated paths keep each segment attribute-styled
+		assert.deepEqual(tokens_of('#[a::b]'), [
+			['attribute', '#[a'],
+			['punctuation', '::'],
+			['attribute', 'b]'],
+		]);
+		// a `]` inside a string, char, or comment must not close the attribute early
+		assert.deepEqual(tokens_of('#[doc = "has ] bracket"]'), [
+			['attribute', '#[doc'],
+			['operator', '='],
+			['string', '"has ] bracket"'],
+			['attribute', ']'],
+		]);
+		assert.deepEqual(tokens_of("#[foo(']')]"), [
+			['attribute', '#[foo'],
+			['punctuation', '('],
+			['char', "']'"],
+			['punctuation', ')'],
+			['attribute', ']'],
+		]);
+		assert.deepEqual(tokens_of('#[foo(/* ] */)]'), [
+			['attribute', '#[foo'],
+			['punctuation', '('],
+			['comment', '/* ] */'],
+			['punctuation', ')'],
+			['attribute', ']'],
+		]);
+		// a nested `[…]` is depth-counted, not an early close
+		assert.deepEqual(tokens_of('#[foo[0]]'), [
+			['attribute', '#[foo'],
+			['punctuation', '['],
+			['number', '0'],
+			['punctuation', ']'],
+			['attribute', ']'],
+		]);
+		// an empty attribute stays contained — the naming context can't leak out
+		assert.deepEqual(tokens_of('#[]\nfn a() {}'), [
+			['attribute', '#[]'],
+			['keyword', 'fn'],
+			['function', 'a'],
+			['punctuation', '()'],
+			['punctuation', '{}'],
+		]);
+		assert.deepEqual(tokens_of('#[unterminated'), [['attribute', '#[unterminated']]);
+	});
+
+	test('numbers with radices, separators, and suffixes', () => {
+		assert.deepEqual(tokens_of('1_000u64'), [['number', '1_000u64']]);
+		assert.deepEqual(tokens_of('0xFF_u8'), [['number', '0xFF_u8']]);
+		assert.deepEqual(tokens_of('0b1010_1010'), [['number', '0b1010_1010']]);
+		assert.deepEqual(tokens_of('0o777'), [['number', '0o777']]);
+		assert.deepEqual(tokens_of('2.5e-3'), [['number', '2.5e-3']]);
+	});
+
+	test('ranges do not consume a trailing dot', () => {
+		assert.deepEqual(tokens_of('0..10'), [
+			['number', '0'],
+			['operator', '..'],
+			['number', '10'],
+		]);
+		assert.deepEqual(tokens_of('1..=5'), [
+			['number', '1'],
+			['operator', '..='],
+			['number', '5'],
+		]);
+		assert.deepEqual(tokens_of('x.0'), [
+			['punctuation', '.'],
+			['number', '0'],
+		]);
+	});
+
+	test('turbofish calls lex as functions', () => {
+		assert.deepEqual(tokens_of('iter.collect::<Vec<u8>>()'), [
+			['punctuation', '.'],
+			['function', 'collect'],
+			['punctuation', '::'],
+			['operator', '<'],
+			['capitalized_identifier', 'Vec'],
+			['operator', '<'],
+			['builtin', 'u8'],
+			['operator', '>>'],
+			['punctuation', '()'],
+		]);
+	});
+
+	test('type-declaration keywords mark the next identifier as a type name', () => {
+		assert.deepEqual(tokens_of('struct point;'), [
+			['keyword', 'struct'],
+			['class_name', 'point'],
+			['punctuation', ';'],
+		]);
+		assert.deepEqual(tokens_of('impl fmt::Display for MyType'), [
+			['keyword', 'impl'],
+			['punctuation', '::'],
+			['class_name', 'Display'],
+			['special_keyword', 'for'],
+			['capitalized_identifier', 'MyType'],
+		]);
+	});
+
+	test('a naming keyword without a following name does not leak the context', () => {
+		// `impl<T>` — the generic param is not a type name here, matching `fn id<T>`
+		assert.deepEqual(tokens_of('impl<T> Foo for Bar {}'), [
+			['keyword', 'impl'],
+			['operator', '<'],
+			['capitalized_identifier', 'T'],
+			['operator', '>'],
+			['capitalized_identifier', 'Foo'],
+			['special_keyword', 'for'],
+			['capitalized_identifier', 'Bar'],
+			['punctuation', '{}'],
+		]);
+		// a nameless `struct;` must not color the following identifier as a type
+		assert.deepEqual(tokens_of('struct; foo'), [
+			['keyword', 'struct'],
+			['punctuation', ';'],
+		]);
+	});
+
+	test('try is a control-flow keyword', () => {
+		assert.deepEqual(tokens_of('try { x }'), [
+			['special_keyword', 'try'],
+			['punctuation', '{'],
+			['punctuation', '}'],
+		]);
+	});
+
+	test('union is a weak keyword', () => {
+		assert.deepEqual(tokens_of('union MyUnion'), [
+			['keyword', 'union'],
+			['class_name', 'MyUnion'],
+		]);
+		assert.deepEqual(tokens_of('foo.union(x)'), [
+			['punctuation', '.'],
+			['function', 'union'],
+			['punctuation', '('],
+			['punctuation', ')'],
+		]);
+	});
+
+	test('macro_rules! is a keyword and names the macro like a function', () => {
+		assert.deepEqual(tokens_of('macro_rules! vec2 {}'), [
+			['keyword', 'macro_rules!'],
+			['function', 'vec2'],
+			['punctuation', '{}'],
+		]);
+	});
+
+	test('screaming-case constants and single-letter generics', () => {
+		assert.deepEqual(tokens_of('const MAX_SIZE: usize = 10;'), [
+			['keyword', 'const'],
+			['constant', 'MAX_SIZE'],
+			['punctuation', ':'],
+			['builtin', 'usize'],
+			['operator', '='],
+			['number', '10'],
+			['punctuation', ';'],
+		]);
+		assert.deepEqual(tokens_of('fn id<T>(x: T) -> T'), [
+			['keyword', 'fn'],
+			['function', 'id'],
+			['operator', '<'],
+			['capitalized_identifier', 'T'],
+			['operator', '>'],
+			['punctuation', '('],
+			['punctuation', ':'],
+			['capitalized_identifier', 'T'],
+			['punctuation', ')'],
+			['operator', '->'],
+			['capitalized_identifier', 'T'],
+		]);
+	});
+
+	test('shebang at the document start', () => {
+		assert.deepEqual(tokens_of('#!/usr/bin/env cargo\nfn main() {}'), [
+			['hashbang', '#!/usr/bin/env cargo'],
+			['keyword', 'fn'],
+			['function', 'main'],
+			['punctuation', '()'],
+			['punctuation', '{}'],
+		]);
+	});
+
+	test('the try operator is punctuation-adjacent operator, not a char', () => {
+		assert.deepEqual(tokens_of('let x = parse()?;'), [
+			['keyword', 'let'],
+			['operator', '='],
+			['function', 'parse'],
+			['punctuation', '()'],
+			['operator', '?'],
+			['punctuation', ';'],
+		]);
+		assert.deepEqual(tokens_of('value?.field'), [
+			['operator', '?'],
+			['punctuation', '.'],
+		]);
+	});
+
+	test('where clauses keep their keyword and type bounds', () => {
+		assert.deepEqual(tokens_of('where T: Clone + Send'), [
+			['keyword', 'where'],
+			['capitalized_identifier', 'T'],
+			['punctuation', ':'],
+			['capitalized_identifier', 'Clone'],
+			['operator', '+'],
+			['capitalized_identifier', 'Send'],
+		]);
+	});
+
+	test('fn-pointer types do not name the following value', () => {
+		// `fn()` is a type, not a definition — `foo` is a value, not a function
+		assert.deepEqual(tokens_of('let handler: fn() = foo;'), [
+			['keyword', 'let'],
+			['punctuation', ':'],
+			['keyword', 'fn'],
+			['punctuation', '()'],
+			['operator', '='],
+			['punctuation', ';'],
+		]);
+		// `fn name` still names the definition
+		assert.deepEqual(tokens_of('fn parse() {}'), [
+			['keyword', 'fn'],
+			['function', 'parse'],
+			['punctuation', '()'],
+			['punctuation', '{}'],
+		]);
+	});
+
+	test('postfix await is a keyword after a dot', () => {
+		assert.deepEqual(tokens_of('fut.await'), [
+			['punctuation', '.'],
+			['special_keyword', 'await'],
+		]);
+	});
+
+	test('match arms and closures', () => {
+		assert.deepEqual(tokens_of('match n { 1 => x, _ => y }'), [
+			['special_keyword', 'match'],
+			['punctuation', '{'],
+			['number', '1'],
+			['operator', '=>'],
+			['punctuation', ','],
+			['operator', '=>'],
+			['punctuation', '}'],
+		]);
+		assert.deepEqual(tokens_of('|a| a + 1'), [
+			['operator', '|'],
+			['operator', '|'],
+			['operator', '+'],
+			['number', '1'],
+		]);
+	});
+
+	test('capitalized identifiers get the class_name alias', () => {
+		assert.include(
+			syntax_styler_global.stylize('Some(1)', 'rust'),
+			'<span class="token_capitalized_identifier token_class_name">Some</span>',
+		);
+	});
+});
+
+describe('lexer_rust embedding', () => {
+	test('markdown fences embed rust', () => {
+		const text = '```rust\nfn main() { println!("hi"); }\n```\n';
+		const types = new Set(
+			syntax_events_to_tokens(syntax_styler_global.lex(text, 'md')).map((t) => t.type),
+		);
+		assert.ok(types.has('lang_rust'), 'expected the fence lang container');
+		assert.ok(types.has('keyword'), 'expected the embedded fn keyword');
+		assert.ok(types.has('function'), 'expected the embedded function name');
+		assert.ok(types.has('macro'), 'expected the embedded macro');
+	});
+
+	// lexes `text` with the window truncated to `window_end`, as `Lexer.embed`
+	// does for fenced regions — no token may extend past the window
+	const window_tokens = (text: string, window_end: number): Array<[string, number, number]> => {
+		const lexer = new Lexer();
+		lexer.text = text;
+		lexer.pos = 0;
+		lexer.end = window_end;
+		lexer_rust.lex(lexer);
+		const tokens = syntax_events_to_tokens({
+			text,
+			events: lexer.events,
+			events_len: lexer.events_len,
+			types: token_types_global,
+		});
+		for (const t of tokens) {
+			assert.isAtMost(t.end, window_end, `token ${t.type} extends past the window`);
+		}
+		return tokens.map((t) => [t.type, t.start, t.end]);
+	};
+
+	test('a `!` beyond the window cannot extend a macro span', () => {
+		assert.deepEqual(window_tokens('foo!', 3), []);
+	});
+
+	test("a `'` beyond the window cannot turn a lifetime into a char", () => {
+		assert.deepEqual(window_tokens("'a'", 2), [['lifetime', 0, 2]]);
+	});
+
+	test('raw-string hashes beyond the window cannot close the string', () => {
+		assert.deepEqual(window_tokens('r#"x"#', 5), [['string', 0, 5]]);
+	});
+
+	test('a block-comment closer split across the window stays unterminated', () => {
+		assert.deepEqual(window_tokens('/* x */', 6), [['comment', 0, 6]]);
+	});
+
+	test('a `#![` marker whose `[` is beyond the window does not overrun', () => {
+		// only `#!` is in the window — it must not form an attribute across the edge
+		assert.deepEqual(window_tokens('#![x]', 2), [['operator', 1, 2]]);
+	});
+
+	test('a second `.` beyond the window cannot extend a range operator', () => {
+		// only the first `.` is in the window — it stays punctuation rather than
+		// consuming the host `..` past the boundary
+		assert.deepEqual(window_tokens('...', 1), [['punctuation', 0, 1]]);
+		assert.deepEqual(window_tokens('..=', 2), [['operator', 0, 2]]);
+	});
+});
+
+describe('lexer_rust sample', () => {
+	const content = readFileSync('src/test/fixtures/samples/sample_complex.rs', 'utf8');
+
+	test('sample lexes with valid invariants', () => {
+		const lexed = syntax_styler_global.lex(content, 'rust');
+		assert.deepEqual(validate_syntax_events(lexed), []);
+	});
+
+	test('sample produces its characteristic token types', () => {
+		const types = new Set(
+			syntax_events_to_tokens(syntax_styler_global.lex(content, 'rust')).map((t) => t.type),
+		);
+		for (const t of [
+			'keyword',
+			'special_keyword',
+			'function',
+			'macro',
+			'class_name',
+			'capitalized_identifier',
+			'constant',
+			'builtin',
+			'string',
+			'char',
+			'lifetime',
+			'attribute',
+			'comment',
+			'doc_comment',
+			'number',
+			'boolean',
+			'operator',
+			'punctuation',
+		]) {
+			assert.ok(types.has(t), `expected a ${t} token in the sample`);
+		}
+	});
+
+	test('lexing is deterministic', () => {
+		const a = syntax_events_to_tokens(syntax_styler_global.lex(content, 'rust'));
+		const b = syntax_events_to_tokens(syntax_styler_global.lex(content, 'rust'));
+		assert.deepEqual(a, b);
+	});
+
+	test('every prefix lexes without throwing, with valid invariants', () => {
+		for (let len = 0; len <= content.length; len += 7) {
+			const prefix = content.slice(0, len);
+			const lexed = syntax_styler_global.lex(prefix, 'rust');
+			const issues = validate_syntax_events(lexed);
+			assert.deepEqual(issues, [], `prefix of length ${len}`);
+		}
+	});
+});
diff --git a/src/test/pathological.ts b/src/test/pathological.ts
index 583f3991..cd6b2103 100644
--- a/src/test/pathological.ts
+++ b/src/test/pathological.ts
@@ -247,4 +247,31 @@ export const PATHOLOGICAL_CASES: Array<PathologicalCase> = [
 		lang: 'md',
 		generate: (size) => repeat_to_size('```md\n', size),
 	},
+	{
+		// every `'` triggers the lifetime-vs-char ident scan
+		name: 'rust_lifetime_dense',
+		lang: 'rust',
+		generate: (size) => repeat_to_size("'a ", size),
+	},
+	{
+		// one attribute per few chars — each pays the balanced-bracket scan
+		name: 'rust_attr_dense',
+		lang: 'rust',
+		generate: (size) => repeat_to_size('#[a]', size),
+	},
+	{
+		// one block comment nested as deep as the input allows — the nesting
+		// depth counter must resolve it in a single forward pass
+		name: 'rust_comment_full_depth',
+		lang: 'rust',
+		generate: (size: number): string => '/*'.repeat(Math.max(1, Math.floor(size / 2))),
+	},
+	{
+		// a raw string dense in `"` that never carries enough hashes to close —
+		// each quote probe must advance rather than rescan
+		name: 'rust_raw_hash_dense',
+		lang: 'rust',
+		generate: (size: number): string =>
+			'r##"' + '"#'.repeat(Math.max(1, Math.floor((size - 7) / 2))) + '"##',
+	},
 ];