perf(chat): keep the virtual list at full framerate in long sessions

[Tryanks]

Problem

Perceptible jank and low framerate in ChatView, worst in long sessions and during long streaming replies. Three synchronous cost centers were responsible:

1. MarkdownState::push_str reparsed the whole document on every streamed delta — O(len) per append, quadratic over a long reply, all on the UI thread.
2. Every store notification re-hashed every timeline entry (index_turns) and cloned a String id per markdown entry (sync_markdown_residency) — O(session) per notification, growing with chat length.
3. Scrolling into an evicted region or opening a long session parsed large markdown documents synchronously inside the frame.

Changes

• Incremental streaming parse — the parser records root-block source offsets; an append reparses only from the last root block's start and splices the tail onto the reused prefix. Appended link reference definitions (which can restyle earlier blocks) conservatively fall back to a full reparse. Streaming bench (50KB in 100B deltas): ~151ms → ~7ms.
• Incremental turn indexing — TurnIndexCache finds the divergence point via Arc::ptr_eq prefix scan and re-hashes only affected tail turns (1 turn per streaming tick on a 200-turn timeline, asserted in tests). The residency walk pre-filters by the same keep/pinned window decide() uses before allocating ids.
• Async large-markdown builds — texts over 4KiB parse on the background executor while the existing plain-text fallback renders; completion inserts the state, remeasures the turn, and notifies. Generation + pending-map guards handle in-flight updates, evictions, and session switches. Streaming replies start under the threshold and stay on the synchronous incremental path.

Verification

• Equivalence tests: streamed parse ≡ full parse (chunk sizes 1/7/64 over a corpus incl. setext, nested lists, unclosed fences, tables, link refs); incremental indexing ≡ full index_turns across append/replace/toggle/reset/rewind; filtered residency decisions ≡ unfiltered.
• Race tests: in-flight text update lands with latest text; session switch does not resurrect stale builds; no duplicate jobs; small texts stay synchronous.
• cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, cargo test --workspace --locked all pass locally (280 UI tests).

[Tryanks]

Problem

Perceptible jank and low framerate in ChatView, worst in long sessions and during long streaming replies. Three synchronous cost centers were responsible:

1. MarkdownState::push_str reparsed the whole document on every streamed delta — O(len) per append, quadratic over a long reply, all on the UI thread.
2. Every store notification re-hashed every timeline entry (index_turns) and cloned a String id per markdown entry (sync_markdown_residency) — O(session) per notification, growing with chat length.
3. Scrolling into an evicted region or opening a long session parsed large markdown documents synchronously inside the frame.

Changes

• Incremental streaming parse — the parser records root-block source offsets; an append reparses only from the last root block's start and splices the tail onto the reused prefix. Appended link reference definitions (which can restyle earlier blocks) conservatively fall back to a full reparse. Streaming bench (50KB in 100B deltas): ~151ms → ~7ms.
• Incremental turn indexing — TurnIndexCache finds the divergence point via Arc::ptr_eq prefix scan and re-hashes only affected tail turns (1 turn per streaming tick on a 200-turn timeline, asserted in tests). The residency walk pre-filters by the same keep/pinned window decide() uses before allocating ids.
• Async large-markdown builds — texts over 4KiB parse on the background executor while the existing plain-text fallback renders; completion inserts the state, remeasures the turn, and notifies. Generation + pending-map guards handle in-flight updates, evictions, and session switches. Streaming replies start under the threshold and stay on the synchronous incremental path.

Verification

• Equivalence tests: streamed parse ≡ full parse (chunk sizes 1/7/64 over a corpus incl. setext, nested lists, unclosed fences, tables, link refs); incremental indexing ≡ full index_turns across append/replace/toggle/reset/rewind; filtered residency decisions ≡ unfiltered.
• Race tests: in-flight text update lands with latest text; session switch does not resurrect stale builds; no duplicate jobs; small texts stay synchronous.
• cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, cargo test --workspace --locked all pass locally (280 UI tests).

[Tryanks]

Problem

Perceptible jank and low framerate in ChatView, worst in long sessions and during long streaming replies. Three synchronous cost centers were responsible:

1. MarkdownState::push_str reparsed the whole document on every streamed delta — O(len) per append, quadratic over a long reply, all on the UI thread.
2. Every store notification re-hashed every timeline entry (index_turns) and cloned a String id per markdown entry (sync_markdown_residency) — O(session) per notification, growing with chat length.
3. Scrolling into an evicted region or opening a long session parsed large markdown documents synchronously inside the frame.

Changes

• Incremental streaming parse — the parser records root-block source offsets; an append reparses only from the last root block's start and splices the tail onto the reused prefix. Appended link reference definitions (which can restyle earlier blocks) conservatively fall back to a full reparse. Streaming bench (50KB in 100B deltas): ~151ms → ~7ms.
• Incremental turn indexing — TurnIndexCache finds the divergence point via Arc::ptr_eq prefix scan and re-hashes only affected tail turns (1 turn per streaming tick on a 200-turn timeline, asserted in tests). The residency walk pre-filters by the same keep/pinned window decide() uses before allocating ids.
• Async large-markdown builds — texts over 4KiB parse on the background executor while the existing plain-text fallback renders; completion inserts the state, remeasures the turn, and notifies. Generation + pending-map guards handle in-flight updates, evictions, and session switches. Streaming replies start under the threshold and stay on the synchronous incremental path.

Verification

• Equivalence tests: streamed parse ≡ full parse (chunk sizes 1/7/64 over a corpus incl. setext, nested lists, unclosed fences, tables, link refs); incremental indexing ≡ full index_turns across append/replace/toggle/reset/rewind; filtered residency decisions ≡ unfiltered.
• Race tests: in-flight text update lands with latest text; session switch does not resurrect stale builds; no duplicate jobs; small texts stay synchronous.
• cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, cargo test --workspace --locked all pass locally (280 UI tests).

[Tryanks]

Problem

Perceptible jank and low framerate in ChatView, worst in long sessions and during long streaming replies. Three synchronous cost centers were responsible:

1. MarkdownState::push_str reparsed the whole document on every streamed delta — O(len) per append, quadratic over a long reply, all on the UI thread.
2. Every store notification re-hashed every timeline entry (index_turns) and cloned a String id per markdown entry (sync_markdown_residency) — O(session) per notification, growing with chat length.
3. Scrolling into an evicted region or opening a long session parsed large markdown documents synchronously inside the frame.

Changes

• Incremental streaming parse — the parser records root-block source offsets; an append reparses only from the last root block's start and splices the tail onto the reused prefix. Appended link reference definitions (which can restyle earlier blocks) conservatively fall back to a full reparse. Streaming bench (50KB in 100B deltas): ~151ms → ~7ms.
• Incremental turn indexing — TurnIndexCache finds the divergence point via Arc::ptr_eq prefix scan and re-hashes only affected tail turns (1 turn per streaming tick on a 200-turn timeline, asserted in tests). The residency walk pre-filters by the same keep/pinned window decide() uses before allocating ids.
• Async large-markdown builds — texts over 4KiB parse on the background executor while the existing plain-text fallback renders; completion inserts the state, remeasures the turn, and notifies. Generation + pending-map guards handle in-flight updates, evictions, and session switches. Streaming replies start under the threshold and stay on the synchronous incremental path.

Verification

• Equivalence tests: streamed parse ≡ full parse (chunk sizes 1/7/64 over a corpus incl. setext, nested lists, unclosed fences, tables, link refs); incremental indexing ≡ full index_turns across append/replace/toggle/reset/rewind; filtered residency decisions ≡ unfiltered.
• Race tests: in-flight text update lands with latest text; session switch does not resurrect stale builds; no duplicate jobs; small texts stay synchronous.
• cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, cargo test --workspace --locked all pass locally (280 UI tests).

[Tryanks]

Problem

Perceptible jank and low framerate in ChatView, worst in long sessions and during long streaming replies. Three synchronous cost centers were responsible:

1. MarkdownState::push_str reparsed the whole document on every streamed delta — O(len) per append, quadratic over a long reply, all on the UI thread.
2. Every store notification re-hashed every timeline entry (index_turns) and cloned a String id per markdown entry (sync_markdown_residency) — O(session) per notification, growing with chat length.
3. Scrolling into an evicted region or opening a long session parsed large markdown documents synchronously inside the frame.

Changes

• Incremental streaming parse — the parser records root-block source offsets; an append reparses only from the last root block's start and splices the tail onto the reused prefix. Appended link reference definitions (which can restyle earlier blocks) conservatively fall back to a full reparse. Streaming bench (50KB in 100B deltas): ~151ms → ~7ms.
• Incremental turn indexing — TurnIndexCache finds the divergence point via Arc::ptr_eq prefix scan and re-hashes only affected tail turns (1 turn per streaming tick on a 200-turn timeline, asserted in tests). The residency walk pre-filters by the same keep/pinned window decide() uses before allocating ids.
• Async large-markdown builds — texts over 4KiB parse on the background executor while the existing plain-text fallback renders; completion inserts the state, remeasures the turn, and notifies. Generation + pending-map guards handle in-flight updates, evictions, and session switches. Streaming replies start under the threshold and stay on the synchronous incremental path.

Verification

• Equivalence tests: streamed parse ≡ full parse (chunk sizes 1/7/64 over a corpus incl. setext, nested lists, unclosed fences, tables, link refs); incremental indexing ≡ full index_turns across append/replace/toggle/reset/rewind; filtered residency decisions ≡ unfiltered.
• Race tests: in-flight text update lands with latest text; session switch does not resurrect stale builds; no duplicate jobs; small texts stay synchronous.
• cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, cargo test --workspace --locked all pass locally (280 UI tests).

[Tryanks]

Problem

Perceptible jank and low framerate in ChatView, worst in long sessions and during long streaming replies. Three synchronous cost centers were responsible:

1. MarkdownState::push_str reparsed the whole document on every streamed delta — O(len) per append, quadratic over a long reply, all on the UI thread.
2. Every store notification re-hashed every timeline entry (index_turns) and cloned a String id per markdown entry (sync_markdown_residency) — O(session) per notification, growing with chat length.
3. Scrolling into an evicted region or opening a long session parsed large markdown documents synchronously inside the frame.

Changes

• Incremental streaming parse — the parser records root-block source offsets; an append reparses only from the last root block's start and splices the tail onto the reused prefix. Appended link reference definitions (which can restyle earlier blocks) conservatively fall back to a full reparse. Streaming bench (50KB in 100B deltas): ~151ms → ~7ms.
• Incremental turn indexing — TurnIndexCache finds the divergence point via Arc::ptr_eq prefix scan and re-hashes only affected tail turns (1 turn per streaming tick on a 200-turn timeline, asserted in tests). The residency walk pre-filters by the same keep/pinned window decide() uses before allocating ids.
• Async large-markdown builds — texts over 4KiB parse on the background executor while the existing plain-text fallback renders; completion inserts the state, remeasures the turn, and notifies. Generation + pending-map guards handle in-flight updates, evictions, and session switches. Streaming replies start under the threshold and stay on the synchronous incremental path.

Verification

• Equivalence tests: streamed parse ≡ full parse (chunk sizes 1/7/64 over a corpus incl. setext, nested lists, unclosed fences, tables, link refs); incremental indexing ≡ full index_turns across append/replace/toggle/reset/rewind; filtered residency decisions ≡ unfiltered.
• Race tests: in-flight text update lands with latest text; session switch does not resurrect stale builds; no duplicate jobs; small texts stay synchronous.
• cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, cargo test --workspace --locked all pass locally (280 UI tests).

[Tryanks]

Problem

Perceptible jank and low framerate in ChatView, worst in long sessions and during long streaming replies. Three synchronous cost centers were responsible:

1. MarkdownState::push_str reparsed the whole document on every streamed delta — O(len) per append, quadratic over a long reply, all on the UI thread.
2. Every store notification re-hashed every timeline entry (index_turns) and cloned a String id per markdown entry (sync_markdown_residency) — O(session) per notification, growing with chat length.
3. Scrolling into an evicted region or opening a long session parsed large markdown documents synchronously inside the frame.

Changes

• Incremental streaming parse — the parser records root-block source offsets; an append reparses only from the last root block's start and splices the tail onto the reused prefix. Appended link reference definitions (which can restyle earlier blocks) conservatively fall back to a full reparse. Streaming bench (50KB in 100B deltas): ~151ms → ~7ms.
• Incremental turn indexing — TurnIndexCache finds the divergence point via Arc::ptr_eq prefix scan and re-hashes only affected tail turns (1 turn per streaming tick on a 200-turn timeline, asserted in tests). The residency walk pre-filters by the same keep/pinned window decide() uses before allocating ids.
• Async large-markdown builds — texts over 4KiB parse on the background executor while the existing plain-text fallback renders; completion inserts the state, remeasures the turn, and notifies. Generation + pending-map guards handle in-flight updates, evictions, and session switches. Streaming replies start under the threshold and stay on the synchronous incremental path.

Verification

• Equivalence tests: streamed parse ≡ full parse (chunk sizes 1/7/64 over a corpus incl. setext, nested lists, unclosed fences, tables, link refs); incremental indexing ≡ full index_turns across append/replace/toggle/reset/rewind; filtered residency decisions ≡ unfiltered.
• Race tests: in-flight text update lands with latest text; session switch does not resurrect stale builds; no duplicate jobs; small texts stay synchronous.
• cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, cargo test --workspace --locked all pass locally (280 UI tests).

[Tryanks]

Problem

Perceptible jank and low framerate in ChatView, worst in long sessions and during long streaming replies. Three synchronous cost centers were responsible:

1. MarkdownState::push_str reparsed the whole document on every streamed delta — O(len) per append, quadratic over a long reply, all on the UI thread.
2. Every store notification re-hashed every timeline entry (index_turns) and cloned a String id per markdown entry (sync_markdown_residency) — O(session) per notification, growing with chat length.
3. Scrolling into an evicted region or opening a long session parsed large markdown documents synchronously inside the frame.

Changes

• Incremental streaming parse — the parser records root-block source offsets; an append reparses only from the last root block's start and splices the tail onto the reused prefix. Appended link reference definitions (which can restyle earlier blocks) conservatively fall back to a full reparse. Streaming bench (50KB in 100B deltas): ~151ms → ~7ms.
• Incremental turn indexing — TurnIndexCache finds the divergence point via Arc::ptr_eq prefix scan and re-hashes only affected tail turns (1 turn per streaming tick on a 200-turn timeline, asserted in tests). The residency walk pre-filters by the same keep/pinned window decide() uses before allocating ids.
• Async large-markdown builds — texts over 4KiB parse on the background executor while the existing plain-text fallback renders; completion inserts the state, remeasures the turn, and notifies. Generation + pending-map guards handle in-flight updates, evictions, and session switches. Streaming replies start under the threshold and stay on the synchronous incremental path.

Verification

• Equivalence tests: streamed parse ≡ full parse (chunk sizes 1/7/64 over a corpus incl. setext, nested lists, unclosed fences, tables, link refs); incremental indexing ≡ full index_turns across append/replace/toggle/reset/rewind; filtered residency decisions ≡ unfiltered.
• Race tests: in-flight text update lands with latest text; session switch does not resurrect stale builds; no duplicate jobs; small texts stay synchronous.
• cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, cargo test --workspace --locked all pass locally (280 UI tests).