diff --git a/README.md b/README.md
index 81bca58..272b150 100644
--- a/README.md
+++ b/README.md
@@ -208,19 +208,22 @@ Caption toggle button (`CC`). Renders only for video canvases that carry caption
 
 Synchronized transcript panel. Manages bidirectional scroll↔media sync via an XState-based `SyncController`. Provides `TranscriptContext` to compound children.
 
-| Prop                       | Type                                                                      | Default              | Description                                                                      |
-| -------------------------- | ------------------------------------------------------------------------- | -------------------- | -------------------------------------------------------------------------------- |
-| `annotations`              | `Annotation[]`                                                            | `[]`                 | Transcript segments (falls back to Root context annotations)                     |
-| `syncDebounceMs`           | `number`                                                                  | `150`                | Scroll debounce (ms)                                                             |
-| `syncSettleMs`             | `number`                                                                  | `100`                | Settle delay after scroll (ms)                                                   |
-| `syncPriorityLockDuration` | `number`                                                                  | `1000`               | Priority lock duration (ms)                                                      |
-| `ariaLabel`                | `string`                                                                  | `"Media transcript"` | Region label                                                                     |
-| `announceActiveSegment`    | `boolean`                                                                 | `true`               | Screen reader announcements for active segment                                   |
-| `onActiveAnnotationChange` | `(annotation: Annotation \| null) => void`                                | —                    | Calls when active segment changes                                                |
-| `onSegmentClick`           | `(annotation: Annotation, event: { preventDefault: () => void }) => void` | —                    | Intercept clicks; call `preventDefault()` synchronously to suppress default seek |
-| `empty`                    | `Snippet`                                                                 | —                    | Custom empty state                                                               |
-| `loading`                  | `Snippet`                                                                 | —                    | Custom loading state (replaces the built-in "Loading transcript…")               |
-| `class`                    | `string`                                                                  | `""`                 | CSS class                                                                        |
+| Prop                       | Type                                                                      | Default              | Description                                                                                                                                                                                                                                                                                                                   |
+| -------------------------- | ------------------------------------------------------------------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `annotations`              | `Annotation[]`                                                            | `[]`                 | Transcript segments (falls back to Root context annotations)                                                                                                                                                                                                                                                                  |
+| `syncDebounceMs`           | `number`                                                                  | `150`                | Scroll debounce (ms)                                                                                                                                                                                                                                                                                                          |
+| `syncSettleMs`             | `number`                                                                  | `100`                | Settle delay after scroll (ms)                                                                                                                                                                                                                                                                                                |
+| `syncPriorityLockDuration` | `number`                                                                  | `1000`               | Priority lock duration (ms)                                                                                                                                                                                                                                                                                                   |
+| `searchSeekBehavior`       | `"change" \| "activate"`                                                  | `"change"`           | `"change"` preserves legacy behavior — every selected search match seeks immediately. `"activate"` seeks only on explicit activation (Enter or "Go to match"); typing and previous/next only update highlights. **Recommended: `"activate"`.**                                                                                |
+| `scrollToSeek`             | `boolean`                                                                 | `true`               | When `false`, transcript scrolling never seeks; a deliberate scroll instead enters Browsing (reading mode) so the next playback update can't pull the panel back. Independent of `readingMode`. Changeable at runtime. **Recommended: `false`.**                                                                              |
+| `readingMode`              | `boolean` (bindable)                                                      | `false`              | `false` is Following (playback may scroll the panel, and may seek if `scrollToSeek` is on); `true` is Browsing (the panel is detached — playback still updates the active-passage highlight, but never scrolls or seeks). Turning it back off scrolls the passage at the current time into view without seeking. Panel-local. |
+| `ariaLabel`                | `string`                                                                  | `"Media transcript"` | Region label                                                                                                                                                                                                                                                                                                                  |
+| `announceActiveSegment`    | `boolean`                                                                 | `true`               | Screen reader announcements for active segment                                                                                                                                                                                                                                                                                |
+| `onActiveAnnotationChange` | `(annotation: Annotation \| null) => void`                                | —                    | Calls when active segment changes                                                                                                                                                                                                                                                                                             |
+| `onSegmentClick`           | `(annotation: Annotation, event: { preventDefault: () => void }) => void` | —                    | Intercept clicks; call `preventDefault()` synchronously to suppress default seek                                                                                                                                                                                                                                              |
+| `empty`                    | `Snippet`                                                                 | —                    | Custom empty state                                                                                                                                                                                                                                                                                                            |
+| `loading`                  | `Snippet`                                                                 | —                    | Custom loading state (replaces the built-in "Loading transcript…")                                                                                                                                                                                                                                                            |
+| `class`                    | `string`                                                                  | `""`                 | CSS class                                                                                                                                                                                                                                                                                                                     |
 
 **Children:** Use `TranscriptSearch` and `TranscriptSegments` as compound children. Without children, renders the empty state.
 
@@ -228,17 +231,24 @@ While Root is fetching a VTT transcript (`annotations="auto"`, `transcriptStatus
 
 There is no matching `error` snippet: when the fetch fails (`transcriptStatus === "error"`) the panel falls back to the ordinary empty state. If you want a distinct failure affordance, read `transcriptStatus` from the Root children snippet or handle `onError` and render it yourself.
 
+**Recommended configuration: `searchSeekBehavior="activate"` and `scrollToSeek={false}`.** Playback follows the transcript until the reader searches, scrolls, or explicitly enables reading mode — search and browsing no longer fight playback for control of the panel. With no new props, `Transcript` keeps today's exact behavior (search-driven and scroll-driven seeking).
+
+Whenever `children` are present, `Transcript` renders one "Follow along" switch (`role="switch"`, `aria-checked`, `data-following`) — turning it off enters Browsing — and, only while Browsing, a "Jump to current" button that returns to Following by scrolling the passage at the media's current time into view (never seeking). Both are bare: no appearance, styled by the host (the default `<iiif-transcript-player>` element ships a styled pair — see "Use without Svelte" below). This single control replaces the former auto-scroll-pause button; there is no separate "pause auto-scroll but keep scroll-to-seek" state.
+
 #### `IIIFPlayer.TranscriptSearch`
 
 Search input for filtering transcript segments. **Dual-mode:** reads from `TranscriptContext` inside `Transcript`, or accepts props directly when used standalone.
 
-| Prop            | Type                                             | Default                | Description           |
-| --------------- | ------------------------------------------------ | ---------------------- | --------------------- |
-| `annotations`   | `Annotation[]`                                   | from context           | Annotations to search |
-| `placeholder`   | `string`                                         | `"Search transcript…"` | Input placeholder     |
-| `debounceMs`    | `number`                                         | `150`                  | Input debounce (ms)   |
-| `onmatchchange` | `(matches: Annotation[], index: number) => void` | from context           | Match change callback |
-| `class`         | `string`                                         | `""`                   | CSS class             |
+| Prop              | Type                                              | Default                | Description                                                                                                                                                                       |
+| ----------------- | ------------------------------------------------- | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `annotations`     | `Annotation[]`                                    | from context           | Annotations to search                                                                                                                                                             |
+| `placeholder`     | `string`                                          | `"Search transcript…"` | Input placeholder                                                                                                                                                                 |
+| `debounceMs`      | `number`                                          | `150`                  | Input debounce (ms)                                                                                                                                                               |
+| `onmatchchange`   | `(matches: Annotation[], index: number) => void`  | from context           | Debounced match-list/selection change callback                                                                                                                                    |
+| `onmatchactivate` | `(annotation: Annotation, index: number) => void` | from context           | Explicit activation (Enter, or "Go to match" — shown when `Transcript`'s `searchSeekBehavior` is `"activate"` or while Browsing). Seeks once, regardless of `searchSeekBehavior`. |
+| `onmatchnavigate` | `(annotation: Annotation, index: number) => void` | from context           | Fired only on previous/next navigation (never typing or activation). The default scrolls the newly-selected match into view through the context; never seeks.                     |
+| `onqueryinput`    | `(value: string) => void`                         | from context           | Synchronous input-intent callback, fired before the debounce — the default enters Browsing on a nonempty query in `"activate"` mode.                                              |
+| `class`           | `string`                                          | `""`                   | CSS class                                                                                                                                                                         |
 
 #### `IIIFPlayer.TranscriptSegments`
 
@@ -680,14 +690,17 @@ Unlike the IIFE, this entry keeps `svelte` external, so the `svelte` peer depend
 
 ### Attributes and properties
 
-| Attribute      | Property      | Type      | Default                | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| -------------- | ------------- | --------- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `manifest-url` | `manifestUrl` | `string`  | —                      | Required. **Set once, before the element is connected.** To load another manifest, replace the element. A later write does not reload, but it is not inert either: it reaches the player and changes what the next internal retry fetches and evicts from the manifest cache. Connecting without it is a non-fatal host `iiif-player-error`. Clearing it (removing the attribute, or setting it to `""`) unmounts the player and resets `playerRef` to `null`.                                                                                    |
-| `canvas-index` | `canvasIndex` | `number`  | `0`                    | Reactive and reflected: every canvas switch — yours or the player's own navigation — writes the live index back to the attribute, and both channels keep working afterwards. Validated: a value that is not a non-negative integer (`"abc"`) falls back to `0` and the attribute is repaired to `0`, and an index past the last canvas is ignored; either way you get a non-fatal host `iiif-player-error`, once per bad value per connection. **Removing** the attribute is not an error — it means "back to the default", canvas `0`, silently. |
-| `initial-time` | `initialTime` | `number`  | —                      | Seconds. Applies to the first canvas only, and only on the element's first connection (see the reconnection note under Events). Validated: a value that is not a non-negative finite number is ignored with a non-fatal host `iiif-player-error`, and does not consume the once-per-element application.                                                                                                                                                                                                                                          |
-| `autoplay`     | `autoplay`    | `boolean` | `false`                | Browsers may block it; a blocked autoplay is a non-fatal `iiif-player-error` (`source: "playback"`).                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `label`        | `label`       | `string`  | localized generic name | Host-settable accessible name for the element's top-level region (`role="region"`) — set it when a page has more than one player so assistive technology can tell them apart.                                                                                                                                                                                                                                                                                                                                                                     |
-| `crossorigin`  | `crossorigin` | `string`  | —                      | Forwarded to the underlying `<audio>`/`<video>` element's `crossorigin` attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| Attribute              | Property             | Type      | Default                | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| ---------------------- | -------------------- | --------- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `manifest-url`         | `manifestUrl`        | `string`  | —                      | Required. **Set once, before the element is connected.** To load another manifest, replace the element. A later write does not reload, but it is not inert either: it reaches the player and changes what the next internal retry fetches and evicts from the manifest cache. Connecting without it is a non-fatal host `iiif-player-error`. Clearing it (removing the attribute, or setting it to `""`) unmounts the player and resets `playerRef` to `null`.                                                                                    |
+| `canvas-index`         | `canvasIndex`        | `number`  | `0`                    | Reactive and reflected: every canvas switch — yours or the player's own navigation — writes the live index back to the attribute, and both channels keep working afterwards. Validated: a value that is not a non-negative integer (`"abc"`) falls back to `0` and the attribute is repaired to `0`, and an index past the last canvas is ignored; either way you get a non-fatal host `iiif-player-error`, once per bad value per connection. **Removing** the attribute is not an error — it means "back to the default", canvas `0`, silently. |
+| `initial-time`         | `initialTime`        | `number`  | —                      | Seconds. Applies to the first canvas only, and only on the element's first connection (see the reconnection note under Events). Validated: a value that is not a non-negative finite number is ignored with a non-fatal host `iiif-player-error`, and does not consume the once-per-element application.                                                                                                                                                                                                                                          |
+| `autoplay`             | `autoplay`           | `boolean` | `false`                | Browsers may block it; a blocked autoplay is a non-fatal `iiif-player-error` (`source: "playback"`).                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `label`                | `label`              | `string`  | localized generic name | Host-settable accessible name for the element's top-level region (`role="region"`) — set it when a page has more than one player so assistive technology can tell them apart.                                                                                                                                                                                                                                                                                                                                                                     |
+| `crossorigin`          | `crossorigin`        | `string`  | —                      | Forwarded to the underlying `<audio>`/`<video>` element's `crossorigin` attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `search-seek-behavior` | `searchSeekBehavior` | `string`  | `"change"`             | `"change"` or `"activate"` — see `Transcript`'s prop above. Any other value is a non-fatal host `iiif-player-error`, once per bad value per connection, and falls back to `"change"`. **Recommended: `"activate"`.**                                                                                                                                                                                                                                                                                                                              |
+| `scroll-to-seek`       | `scrollToSeek`       | `boolean` | `true`                 | Value-based, not presence-based: `"false"` (case-insensitive) is `false`; `"true"`, the empty string, and a bare `scroll-to-seek` attribute are `true`; a removed attribute is the default, `true`, silently. Any other string value is a non-fatal host error and falls back to `true`. A property write accepts a real boolean directly. **Recommended: `false`.**                                                                                                                                                                              |
+| `reading-mode`         | `readingMode`        | `boolean` | `false`                | Same value-based parsing as `scroll-to-seek` (default `false`). **Reactive and reflected**, like `canvas-index`: the element's own "Follow along"/"Jump to current" controls, and any property write, write this attribute back through a guarded update that cannot loop. Exposes `:state(browsing)` on the host while `true` (alongside the existing `:state(playing)`/`:state(loading)`/`:state(error)`), for CSS like `iiif-transcript-player:state(browsing) { ... }`.                                                                       |
 
 | Property (not an attribute) | Type                                         | Notes                                                                                                                                                                                                                             |
 | --------------------------- | -------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -698,6 +711,20 @@ Unlike the IIFE, this entry keeps `svelte` external, so the `svelte` peer depend
 
 **Attributes vs properties — two rules.** Use attributes for initial configuration; a property written onto an element before it is upgraded — before the defining `<script>` has run, or before `customElements.define()` is called — is queued and takes effect once the element upgrades, winning over any same-name attribute (the standard custom-element upgrade dance; not a rule this library adds). After the element is upgraded, prefer one channel per key — attributes _or_ properties, not both — and never write the same key twice in one task. An attribute write goes through `attributeChangedCallback` into the component's props; a property write goes through the generated accessor and sets a local override inside the component, leaving those props holding the previous value. For `canvas-index` the element repairs that: every canvas switch writes the attribute explicitly, which refreshes the component's props, so attribute, props and property all hold the live index and a later write on either channel still lands. The repair rides on the switch, so a property write that never causes one — an index past the last canvas, or any write made before the manifest resolves — leaves the component's props holding the previous value; the host error tells you when that happened. What no element can repair is ordering — two writes issued in the _same_ task can resolve either way depending on internal flush state, so the same two lines are not guaranteed to give the same result twice. That is a Svelte custom-element property, not a rule we chose.
 
+`search-seek-behavior`, `scroll-to-seek`, and `reading-mode` work through markup, property writes, and property writes made before the element upgrades, same as every other attribute above. `scroll-to-seek` and `reading-mode` are the element's own manual value-based owner rather than the generic Boolean-attribute parsing `autoplay` uses — Svelte's built-in `type: "Boolean"` is presence-based and cannot tell `reading-mode="false"` from `reading-mode="true"`, so this library parses and reflects the two by hand.
+
+**Recommended: `search-seek-behavior="activate"` and `scroll-to-seek="false"`.**
+
+```html
+<iiif-transcript-player
+  manifest-url="https://example.org/manifest.json"
+  search-seek-behavior="activate"
+  scroll-to-seek="false"
+></iiif-transcript-player>
+```
+
+The default element renders a styled "Follow along" switch and "Jump to current" button in its shadow DOM (unlike the bare `Transcript` component's unstyled pair) and reflects `reading-mode` as the reader toggles it, so `iiif-transcript-player:state(browsing) { ... }` and `iiif-transcript-player[reading-mode] { ... }` both work from page CSS.
+
 ### Events
 
 All events bubble and are composed.
diff --git a/docs/src/components/AVAnnotateDemo.svelte b/docs/src/components/AVAnnotateDemo.svelte
index 0fcb0df..bd5e4c9 100644
--- a/docs/src/components/AVAnnotateDemo.svelte
+++ b/docs/src/components/AVAnnotateDemo.svelte
@@ -287,7 +287,11 @@
         <div
           class="bg-gray-50 rounded-lg shadow-md border border-ink-200 max-h-[600px] flex flex-col overflow-clip"
         >
-          <IIIFPlayer.Transcript {annotations}>
+          <IIIFPlayer.Transcript
+            {annotations}
+            searchSeekBehavior="activate"
+            scrollToSeek={false}
+          >
             <IIIFPlayer.TranscriptSearch />
             <IIIFPlayer.TranscriptSegments annotations={filteredAnnotations}>
               {#snippet segment({
@@ -484,4 +488,16 @@
   :global(.avannotate-demo [data-audio-control="time"]) {
     @apply text-sm text-gray-600 font-medium;
   }
+
+  :global(.avannotate-demo .follow-along-switch) {
+    @apply self-start inline-flex items-center gap-2 px-3 py-1 mb-2 rounded-full border border-ink-300 bg-white text-sm text-gray-700 transition-colors;
+  }
+
+  :global(.avannotate-demo .follow-along-switch[aria-checked="true"]) {
+    @apply bg-terracotta-500 border-terracotta-500 text-white;
+  }
+
+  :global(.avannotate-demo .jump-to-current) {
+    @apply self-start px-3 py-1 mb-2 rounded-full bg-terracotta-500 text-white text-sm transition-colors hover:bg-terracotta-600;
+  }
 </style>
diff --git a/docs/src/components/AutoTranscriptDemo.svelte b/docs/src/components/AutoTranscriptDemo.svelte
index 0417304..11f75ab 100644
--- a/docs/src/components/AutoTranscriptDemo.svelte
+++ b/docs/src/components/AutoTranscriptDemo.svelte
@@ -63,7 +63,10 @@
           <div
             class="bg-gray-50 rounded-lg shadow-md border border-ink-200 max-h-[600px] flex flex-col overflow-clip"
           >
-            <IIIFPlayer.Transcript>
+            <IIIFPlayer.Transcript
+              searchSeekBehavior="activate"
+              scrollToSeek={false}
+            >
               <IIIFPlayer.TranscriptSearch />
               <IIIFPlayer.TranscriptSegments />
             </IIIFPlayer.Transcript>
@@ -152,4 +155,16 @@
   :global(.auto-transcript-demo [data-audio-control="time"]) {
     @apply text-sm text-gray-600 font-medium;
   }
+
+  :global(.auto-transcript-demo .follow-along-switch) {
+    @apply self-start inline-flex items-center gap-2 px-3 py-1 mb-2 rounded-full border border-ink-300 bg-white text-sm text-gray-700 transition-colors;
+  }
+
+  :global(.auto-transcript-demo .follow-along-switch[aria-checked="true"]) {
+    @apply bg-terracotta-500 border-terracotta-500 text-white;
+  }
+
+  :global(.auto-transcript-demo .jump-to-current) {
+    @apply self-start px-3 py-1 mb-2 rounded-full bg-terracotta-500 text-white text-sm transition-colors hover:bg-terracotta-600;
+  }
 </style>
diff --git a/docs/src/components/HTMLAnnotationsDemo.svelte b/docs/src/components/HTMLAnnotationsDemo.svelte
index 1dfc9e9..570240f 100644
--- a/docs/src/components/HTMLAnnotationsDemo.svelte
+++ b/docs/src/components/HTMLAnnotationsDemo.svelte
@@ -46,7 +46,11 @@
       <div
         class="bg-gray-50 rounded-lg shadow-md border border-ink-200 max-h-[600px] flex flex-col overflow-clip"
       >
-        <IIIFPlayer.Transcript {annotations}>
+        <IIIFPlayer.Transcript
+          {annotations}
+          searchSeekBehavior="activate"
+          scrollToSeek={false}
+        >
           <IIIFPlayer.TranscriptSearch />
           <IIIFPlayer.TranscriptSegments>
             {#snippet text({ annotation })}
@@ -142,4 +146,16 @@
   :global(.html-annotations-demo [data-audio-control="time"]) {
     @apply text-sm text-gray-600 font-medium;
   }
+
+  :global(.html-annotations-demo .follow-along-switch) {
+    @apply self-start inline-flex items-center gap-2 px-3 py-1 mb-2 rounded-full border border-ink-300 bg-white text-sm text-gray-700 transition-colors;
+  }
+
+  :global(.html-annotations-demo .follow-along-switch[aria-checked="true"]) {
+    @apply bg-terracotta-500 border-terracotta-500 text-white;
+  }
+
+  :global(.html-annotations-demo .jump-to-current) {
+    @apply self-start px-3 py-1 mb-2 rounded-full bg-terracotta-500 text-white text-sm transition-colors hover:bg-terracotta-600;
+  }
 </style>
diff --git a/docs/src/components/IIIFTranscriptDemo.svelte b/docs/src/components/IIIFTranscriptDemo.svelte
index 6d3272d..ecaaa20 100644
--- a/docs/src/components/IIIFTranscriptDemo.svelte
+++ b/docs/src/components/IIIFTranscriptDemo.svelte
@@ -86,7 +86,11 @@
         <div
           class="bg-gray-50 rounded-lg shadow-md border border-ink-200 max-h-[600px] flex flex-col overflow-clip"
         >
-          <IIIFPlayer.Transcript {annotations}>
+          <IIIFPlayer.Transcript
+            {annotations}
+            searchSeekBehavior="activate"
+            scrollToSeek={false}
+          >
             <IIIFPlayer.TranscriptSearch />
             <IIIFPlayer.TranscriptSegments />
           </IIIFPlayer.Transcript>
@@ -176,4 +180,18 @@
   :global(.iiif-transcript-demo [data-audio-control="time"]) {
     @apply text-sm text-gray-600 font-medium;
   }
+
+  /* Reading mode: the "Follow along" switch and "Jump to current" button
+     ship bare (semantics + state only) — this is the demo's own skin. */
+  :global(.iiif-transcript-demo .follow-along-switch) {
+    @apply self-start inline-flex items-center gap-2 px-3 py-1 mb-2 rounded-full border border-ink-300 bg-white text-sm text-gray-700 transition-colors;
+  }
+
+  :global(.iiif-transcript-demo .follow-along-switch[aria-checked="true"]) {
+    @apply bg-terracotta-500 border-terracotta-500 text-white;
+  }
+
+  :global(.iiif-transcript-demo .jump-to-current) {
+    @apply self-start px-3 py-1 mb-2 rounded-full bg-terracotta-500 text-white text-sm transition-colors hover:bg-terracotta-600;
+  }
 </style>
diff --git a/src/element/IIIFTranscriptPlayerElement.svelte b/src/element/IIIFTranscriptPlayerElement.svelte
index 2993d06..de80fc2 100644
--- a/src/element/IIIFTranscriptPlayerElement.svelte
+++ b/src/element/IIIFTranscriptPlayerElement.svelte
@@ -11,6 +11,19 @@
       annotations: { attribute: "annotations" },
       preprocessManifest: { attribute: "preprocessmanifest" },
       errorCallback: { attribute: "errorcallback" },
+      // No `type` on these three, deliberately (docs/specs/
+      // transcript-reading-mode.md, "Proposed API and compatibility"): the
+      // element owns value-based parsing and reflection for
+      // `scroll-to-seek`/`reading-mode` itself (see `canonicalizeBooleanAttr`
+      // and the `readingMode`/`scrollToSeek` accessor overrides in `extend`
+      // below) rather than Svelte's presence-based `type: "Boolean"` (which
+      // cannot tell `reading-mode="false"` from `reading-mode="true"`) or
+      // Svelte-generated `reflect: true` (which would fight the manual
+      // guarded write). `searchSeekBehavior` needs neither — it is a plain
+      // string enum, validated in the instance script below.
+      searchSeekBehavior: { attribute: "search-seek-behavior", type: "String" },
+      scrollToSeek: { attribute: "scroll-to-seek" },
+      readingMode: { attribute: "reading-mode" },
     },
     extend,
   }}
@@ -44,11 +57,45 @@
     $$p_d: Record<string, unknown>;
     connectedCallback(): Promise<void>;
     disconnectedCallback(): void;
+    // The base (un-extended) class's own generated accessors for the two
+    // manually-owned boolean props — typed loosely (`unknown`) because the
+    // base accessor's runtime value can be a boolean (a property write, see
+    // the override below), a raw attribute string, or null/undefined
+    // (attribute absent). `readingMode`/`scrollToSeek` below narrow it.
+    readingMode: unknown;
+    scrollToSeek: unknown;
   }
   interface SvelteCustomElementConstructor {
     new (...params: never[]): SvelteCustomElementInstance;
   }
 
+  /**
+   * Canonicalizes a `reading-mode`/`scroll-to-seek`-style boolean
+   * attribute or property value against its own default (docs/specs/
+   * transcript-reading-mode.md, "The custom element must own value-based
+   * parsing and reflection…"). `null`/`undefined` (an absent attribute, or
+   * a property that was never set) is the default; a real boolean (a
+   * property write — see the accessor overrides below) is used directly; a
+   * string is matched case-insensitively — `"false"` is `false`; `"true"`
+   * and the empty string (a bare attribute, `<el reading-mode>`) are
+   * `true`. Any other string is invalid: `valid: false`, falls back to the
+   * default, and the instance script reports it as a non-fatal host error
+   * (the "existing validation/error conventions" the spec defers to).
+   */
+  function canonicalizeBooleanAttr(
+    raw: unknown,
+    defaultValue: boolean,
+  ): { value: boolean; valid: boolean } {
+    if (raw == null) return { value: defaultValue, valid: true };
+    if (typeof raw === "boolean") return { value: raw, valid: true };
+    if (typeof raw === "string") {
+      const lower = raw.toLowerCase();
+      if (lower === "false") return { value: false, valid: true };
+      if (lower === "true" || raw === "") return { value: true, valid: true };
+    }
+    return { value: defaultValue, valid: false };
+  }
+
   /**
    * The standard custom-element upgrade dance (WHATWG custom-elements spec,
    * "upgrades"): a property set on the element before it upgrades — before
@@ -117,6 +164,33 @@
         this.__internals = this.attachInternals();
       }
 
+      // `readingMode`/`scrollToSeek` accessor overrides: the base class's
+      // own generated accessor (defined on `Base.prototype` above, before
+      // `extend` runs) reads/writes whatever raw value is currently in the
+      // Svelte component's prop — a boolean from a property write, but a
+      // raw attribute string (or null) from an attribute write, since
+      // neither prop declares a `type` (see `customElement.props` above).
+      // Reading that raw value back out as `el.readingMode` would leak a
+      // string like `"false"` — truthy in JS, the opposite of what it
+      // means — so both accessors canonicalize through the SAME function
+      // the instance script uses for the attribute side, on the way in
+      // (`set`) and the way out (`get`): `get` always returns a genuine
+      // boolean regardless of how the current value got there; `set`
+      // always stores one, so a property write can never itself produce an
+      // invalid raw value for the instance script to canonicalize again.
+      get readingMode(): boolean {
+        return canonicalizeBooleanAttr(super.readingMode, false).value;
+      }
+      set readingMode(value: unknown) {
+        super.readingMode = canonicalizeBooleanAttr(value, false).value;
+      }
+      get scrollToSeek(): boolean {
+        return canonicalizeBooleanAttr(super.scrollToSeek, true).value;
+      }
+      set scrollToSeek(value: unknown) {
+        super.scrollToSeek = canonicalizeBooleanAttr(value, true).value;
+      }
+
       #resolveLocale(): void {
         const match = this.closest("[lang]");
         const value = match?.getAttribute("lang");
@@ -202,6 +276,9 @@
     annotations = "auto",
     preprocessManifest,
     errorCallback,
+    searchSeekBehavior,
+    scrollToSeek,
+    readingMode,
   }: {
     manifestUrl?: string;
     canvasIndex?: number;
@@ -219,6 +296,16 @@
     annotations?: Annotation[] | "auto";
     preprocessManifest?: ((raw: unknown) => unknown) | undefined;
     errorCallback?: ErrorCallback | undefined;
+    /** `search-seek-behavior` attribute. `"change"` | `"activate"`. */
+    searchSeekBehavior?: string;
+    /**
+     * `scroll-to-seek` attribute. Raw: a real boolean from a property write
+     * (already canonicalized by the accessor override in `extend`), or a
+     * raw attribute string/`null` — see `canonicalizeBooleanAttr`.
+     */
+    scrollToSeek?: boolean | string | null;
+    /** `reading-mode` attribute. Same raw shape as `scrollToSeek`. */
+    readingMode?: boolean | string | null;
   } = $props();
 
   // Exposed as a read-only getter on the element (Svelte turns instance
@@ -429,6 +516,132 @@
     return () => clearTimeout(timer);
   });
 
+  // `search-seek-behavior` — a plain string enum, so unlike the two boolean
+  // props below it needs no manual owner, just validation. An unset
+  // attribute/property (`null`/`undefined`) is not misuse — it silently
+  // means the default, `"change"`.
+  const searchSeekBehaviorValid = $derived(
+    searchSeekBehavior == null ||
+      searchSeekBehavior === "change" ||
+      searchSeekBehavior === "activate",
+  );
+  const safeSearchSeekBehavior = $derived<"change" | "activate">(
+    searchSeekBehaviorValid && searchSeekBehavior != null
+      ? (searchSeekBehavior as "change" | "activate")
+      : "change",
+  );
+  const reportedBadSearchSeekBehaviors: unknown[] = [];
+  $effect(() => {
+    if (searchSeekBehaviorValid) return;
+    const value = searchSeekBehavior;
+    untrack(() => {
+      if (reportedBadSearchSeekBehaviors.includes(value)) return;
+      reportedBadSearchSeekBehaviors.push(value);
+      report(
+        new Error(
+          '`search-seek-behavior` must be "change" or "activate"; ignoring it',
+        ),
+        { fatal: false, source: "host" },
+      );
+    });
+  });
+
+  // `scroll-to-seek` — canonicalized by `canonicalizeBooleanAttr` (module
+  // script) against its own default, `true`. Forwarded to `Transcript` as a
+  // plain one-way prop: unlike `reading-mode` below it is never mutated by
+  // the panel itself, so there is nothing to reflect back.
+  const scrollToSeekCanon = $derived(
+    canonicalizeBooleanAttr(scrollToSeek, true),
+  );
+  const safeScrollToSeek = $derived(scrollToSeekCanon.value);
+  const reportedBadScrollToSeek: unknown[] = [];
+  $effect(() => {
+    if (scrollToSeekCanon.valid) return;
+    const value = scrollToSeek;
+    untrack(() => {
+      if (reportedBadScrollToSeek.includes(value)) return;
+      reportedBadScrollToSeek.push(value);
+      report(
+        new Error('`scroll-to-seek` must be "true" or "false"; ignoring it'),
+        { fatal: false, source: "host" },
+      );
+    });
+  });
+
+  // `reading-mode` — canonicalized against its own default, `false`, same
+  // as `scrollToSeek` above. Unlike `scrollToSeek`, this one is bindable on
+  // `Transcript`: the panel's own "Follow along" switch and "Jump to
+  // current" button mutate it from inside. `readingModeState` is the
+  // two-way bridge — bound to `Transcript` in the template below — and the
+  // two effects after it keep it in sync with the host-facing prop in both
+  // directions:
+  //  - host (attribute or property) -> panel: an external `reading-mode`
+  //    change flows down into `readingModeState` so the panel picks it up.
+  //  - panel -> host: a user-driven (or host-driven, echoed back — see the
+  //    guard) change to `readingModeState` reflects onto the `reading-mode`
+  //    attribute, through a GUARDED, deferred write so
+  //    `attributeChangedCallback` cannot re-enter and loop (docs/specs/
+  //    transcript-reading-mode.md: "a GUARDED write that compares against
+  //    the current canonical value and returns early when unchanged").
+  //    Reflection never touches playback — it only calls setAttribute/
+  //    removeAttribute.
+  const readingModeCanon = $derived(
+    canonicalizeBooleanAttr(readingMode, false),
+  );
+  const reportedBadReadingMode: unknown[] = [];
+  $effect(() => {
+    if (readingModeCanon.valid) return;
+    const value = readingMode;
+    untrack(() => {
+      if (reportedBadReadingMode.includes(value)) return;
+      reportedBadReadingMode.push(value);
+      report(
+        new Error('`reading-mode` must be "true" or "false"; ignoring it'),
+        { fatal: false, source: "host" },
+      );
+    });
+  });
+
+  let readingModeState = $state(untrack(() => readingModeCanon.value));
+
+  // Host -> panel. Untracked read/write of `readingModeState` so this
+  // effect reacts only to the host-facing `readingModeCanon` (an
+  // attribute/property change), never to the panel's own writes into
+  // `readingModeState` — that direction is the reflect effect below.
+  $effect(() => {
+    const canon = readingModeCanon.value;
+    untrack(() => {
+      if (readingModeState !== canon) readingModeState = canon;
+    });
+  });
+
+  // Panel -> host, guarded and deferred. Deferring to a microtask (as the
+  // `canvas-index` repair above does) and re-reading `readingModeState` at
+  // execute time, rather than trusting the value captured when the effect
+  // ran, makes rapid toggles self-correcting instead of racing: only the
+  // freshest state is ever written, and the guard compares against the
+  // attribute actually on the DOM right then.
+  $effect(() => {
+    const state = readingModeState;
+    void state; // establish the dependency; read fresh inside the microtask
+    untrack(() => {
+      const host = $host();
+      queueMicrotask(() => {
+        const liveState = readingModeState;
+        const liveCanon = canonicalizeBooleanAttr(
+          host.getAttribute("reading-mode"),
+          false,
+        ).value;
+        if (liveCanon === liveState) return;
+        if (liveState) {
+          host.setAttribute("reading-mode", "");
+        } else {
+          host.removeAttribute("reading-mode");
+        }
+      });
+    });
+  });
+
   // Fatal errors that happen before playerRefValue is ever set (a manifest
   // or first-canvas failure — report()'s `fatal: true` path) need their own
   // flag: PlayerRef.state doesn't exist yet to read `.error` off of.
@@ -452,6 +665,7 @@
     internals.states[isPlayingState ? "add" : "delete"]("playing");
     internals.states[isLoadingState ? "add" : "delete"]("loading");
     internals.states[isErrorState ? "add" : "delete"]("error");
+    internals.states[readingModeState ? "add" : "delete"]("browsing");
   });
 
   const safeAnnotations = $derived<Annotation[] | "auto">(
@@ -641,7 +855,11 @@
           <IIIFPlayer.CanvasNav />
         {/if}
         {#if player.annotations.length > 0 || player.transcriptStatus === "loading" || player.transcriptStatus === "error"}
-          <IIIFPlayer.Transcript>
+          <IIIFPlayer.Transcript
+            searchSeekBehavior={safeSearchSeekBehavior}
+            scrollToSeek={safeScrollToSeek}
+            bind:readingMode={readingModeState}
+          >
             <IIIFPlayer.TranscriptSearch />
             <IIIFPlayer.TranscriptSegments />
           </IIIFPlayer.Transcript>
@@ -783,6 +1001,48 @@
     outline-color: var(--iiif-player-focus, #1d4ed8);
   }
 
+  /* Reading mode: the "Follow along" switch (Transcript's single folded
+     track-audio control) and "Jump to current" (shown only while Browsing).
+     Transcript.svelte ships both bare — semantics and state only, `role`/
+     `aria-checked`/`data-following` on the switch — this is the element's
+     own styled skin, same as every other control-bar hook above. */
+  .iiif-tp :global(.follow-along-switch) {
+    align-self: flex-start;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.25rem 0.625rem;
+    border: 1px solid var(--iiif-player-border, #767676);
+    border-radius: 999px;
+    background: var(--iiif-player-control-bg, #f3f4f6);
+    color: var(--iiif-player-control-fg, inherit);
+    font: inherit;
+    cursor: pointer;
+  }
+
+  .iiif-tp :global(.follow-along-switch[aria-checked="true"]) {
+    background: var(--iiif-player-accent, #1d4ed8);
+    color: var(--iiif-player-accent-fg, #ffffff);
+    border-color: var(--iiif-player-accent, #1d4ed8);
+  }
+
+  .iiif-tp :global(.jump-to-current) {
+    align-self: flex-start;
+    margin-block-start: 0.25rem;
+    padding: 0.25rem 0.6rem;
+    border: 1px solid var(--iiif-player-accent, #1d4ed8);
+    border-radius: 4px;
+    background: var(--iiif-player-accent, #1d4ed8);
+    color: var(--iiif-player-accent-fg, #ffffff);
+    font: inherit;
+    cursor: pointer;
+  }
+
+  .iiif-tp :global(.follow-along-switch:focus),
+  .iiif-tp :global(.jump-to-current:focus) {
+    outline-color: var(--iiif-player-focus, #1d4ed8);
+  }
+
   @media (forced-colors: active) {
     .iiif-tp :global([data-annotation-id][data-state="active"]),
     .iiif-tp :global([data-annotation-id][data-highlighted="true"]),
@@ -798,5 +1058,19 @@
     .iiif-tp :global([data-annotation-id]:focus) {
       outline-color: Highlight;
     }
+
+    .iiif-tp :global(.follow-along-switch),
+    .iiif-tp :global(.jump-to-current) {
+      border-color: ButtonText;
+    }
+
+    .iiif-tp :global(.follow-along-switch[aria-checked="true"]) {
+      border-color: Highlight;
+    }
+
+    .iiif-tp :global(.follow-along-switch:focus),
+    .iiif-tp :global(.jump-to-current:focus) {
+      outline-color: Highlight;
+    }
   }
 </style>
diff --git a/src/element/custom-elements.json b/src/element/custom-elements.json
index eedc4ec..236c529 100644
--- a/src/element/custom-elements.json
+++ b/src/element/custom-elements.json
@@ -43,6 +43,26 @@
               "name": "crossorigin",
               "type": { "text": "string" },
               "fieldName": "crossorigin"
+            },
+            {
+              "name": "search-seek-behavior",
+              "type": { "text": "\"change\" | \"activate\"" },
+              "default": "\"change\"",
+              "fieldName": "searchSeekBehavior"
+            },
+            {
+              "name": "scroll-to-seek",
+              "type": { "text": "boolean" },
+              "default": "true",
+              "fieldName": "scrollToSeek",
+              "description": "Value-based, not presence-based: \"false\" (case-insensitive) is false; \"true\", the empty string, and a bare attribute are true; an absent attribute is the default, true."
+            },
+            {
+              "name": "reading-mode",
+              "type": { "text": "boolean" },
+              "default": "false",
+              "fieldName": "readingMode",
+              "description": "Same value-based parsing as scroll-to-seek, default false. Reactive and reflected: the element's own \"Follow along\"/\"Jump to current\" controls, and any bindable-style write to the readingMode property, write this attribute back (guarded against feedback loops)."
             }
           ],
           "members": [
@@ -146,6 +166,10 @@
             {
               "name": "error",
               "description": "Set while the player is in a fatal error state."
+            },
+            {
+              "name": "browsing",
+              "description": "Set while the transcript panel is Browsing (reading-mode is true) — style the host with :state(browsing)."
             }
           ]
         }
diff --git a/src/element/element-reading-mode.test.ts b/src/element/element-reading-mode.test.ts
new file mode 100644
index 0000000..98dd1d4
--- /dev/null
+++ b/src/element/element-reading-mode.test.ts
@@ -0,0 +1,401 @@
+// src/element/element-reading-mode.test.ts
+//
+// Custom-element configuration for the transcript-reading-mode spec
+// (docs/specs/transcript-reading-mode.md, "Proposed API and compatibility"
+// and the acceptance-gate table): `search-seek-behavior`, `scroll-to-seek`,
+// `reading-mode` attributes/properties, the `:state(browsing)` custom
+// state, and the guarded `reading-mode` reflection. Covers "Custom element
+// configured through markup and properties" and the element half of
+// "Single folded control across surfaces". The final test walks the
+// recommended configuration through the spec's closing journey: listen,
+// search, browse, activate, browse again, return.
+import {
+  describe,
+  test,
+  expect,
+  vi,
+  beforeAll,
+  beforeEach,
+  afterEach,
+} from "vitest";
+import { register, DEFAULT_TAG } from "./register";
+import {
+  mountElement,
+  shadow,
+  untilShadow,
+  waitForEvent,
+  removeAllElements,
+  silentWavDataUrl,
+  withStubMedia,
+  type ElementHandle,
+} from "./test-helpers";
+import {
+  mockFetchRoutes,
+  MANIFEST_WITHOUT_CHAPTERS,
+} from "../test/player/test-fixtures";
+import { manifestCache } from "../lib/player/manifestCache";
+import type { PlayerErrorDetail } from "./events";
+
+type El = ElementHandle & {
+  searchSeekBehavior?: string;
+  scrollToSeek?: boolean;
+  readingMode?: boolean;
+};
+
+const ANNOTATIONS = [
+  { id: "alpha", startTime: 2, endTime: 6, text: "Alpha segment" },
+  { id: "bravo", startTime: 10, endTime: 16, text: "Bravo grapefruit segment" },
+  {
+    id: "charlie",
+    startTime: 22,
+    endTime: 28,
+    text: "Charlie grapefruit finale",
+  },
+];
+
+/** Collects the host-tier iiif-player-error details fired on `el`. */
+function recordHostErrors(el: HTMLElement): PlayerErrorDetail[] {
+  const seen: PlayerErrorDetail[] = [];
+  el.addEventListener("iiif-player-error", (e) => {
+    const detail = (e as CustomEvent<PlayerErrorDetail>).detail;
+    if (detail.source === "host") seen.push(detail);
+  });
+  return seen;
+}
+
+/** Collects "iiif-player-seeked" firings on `el`. */
+function recordSeeks(el: HTMLElement): number {
+  let count = 0;
+  el.addEventListener("iiif-player-seeked", () => {
+    count += 1;
+  });
+  return count;
+}
+
+async function readyAudio(el: HTMLElement): Promise<HTMLAudioElement> {
+  const audio = await untilShadow<HTMLAudioElement>(el, "audio");
+  await vi.waitFor(() => {
+    expect((el as ElementHandle).playerRef).toBeTruthy();
+  });
+  await untilShadow(el, "[data-annotation-id]");
+  return audio;
+}
+
+function typeQuery(el: HTMLElement, query: string): void {
+  const input = shadow(el).querySelector(
+    'input[type="search"]',
+  ) as HTMLInputElement;
+  input.value = query;
+  input.dispatchEvent(new Event("input", { bubbles: true }));
+}
+
+let urlCounter = 0;
+function nextUrl(): string {
+  urlCounter += 1;
+  return `https://example.com/reading-mode-${urlCounter}.json`;
+}
+
+function mockManifest(url: string, seconds = 40) {
+  mockFetchRoutes({
+    [url]: {
+      json: withStubMedia(MANIFEST_WITHOUT_CHAPTERS, {
+        audio: silentWavDataUrl(seconds),
+      }),
+    },
+  });
+}
+
+describe("<iiif-transcript-player> reading-mode configuration", () => {
+  beforeAll(() => {
+    register();
+  });
+  beforeEach(() => {
+    globalThis.fetch = vi.fn() as unknown as typeof fetch;
+  });
+  afterEach(() => {
+    removeAllElements();
+    manifestCache.clear();
+  });
+
+  test('markup attributes configure search-seek-behavior, scroll-to-seek, and reading-mode; scroll-to-seek="false" parses as false', async () => {
+    const url = nextUrl();
+    mockManifest(url);
+    const el = (await mountElement(
+      {
+        "manifest-url": url,
+        "search-seek-behavior": "activate",
+        "scroll-to-seek": "false",
+        "reading-mode": "true",
+      },
+      { annotations: ANNOTATIONS },
+    )) as El;
+    const audio = await readyAudio(el);
+
+    expect(el.searchSeekBehavior).toBe("activate");
+    expect(el.scrollToSeek).toBe(false);
+    expect(el.readingMode).toBe(true);
+    expect(el.matches(":state(browsing)")).toBe(true);
+    // "Go to match" only renders once there is at least one match to go to
+    // (Search.svelte); "Jump to current" depends only on reading mode.
+    expect(shadow(el).querySelector(".jump-to-current")).toBeTruthy();
+
+    // Typing in activate mode never seeks, even once the debounce settles,
+    // and the activation control appears once the match resolves.
+    typeQuery(el, "grapefruit");
+    await new Promise((r) => setTimeout(r, 250));
+    expect(audio.currentTime).toBe(0);
+    expect(
+      shadow(el).querySelector('button[aria-label="Go to match"]'),
+    ).toBeTruthy();
+  });
+
+  test("property writes after upgrade produce the same behavior as the matching attributes", async () => {
+    const url = nextUrl();
+    mockManifest(url);
+    const el = (await mountElement(
+      { "manifest-url": url },
+      { annotations: ANNOTATIONS },
+    )) as El;
+    await readyAudio(el);
+
+    // Legacy defaults beforehand: no activation control, not Browsing.
+    expect(
+      shadow(el).querySelector('button[aria-label="Go to match"]'),
+    ).toBeNull();
+    expect(el.matches(":state(browsing)")).toBe(false);
+
+    el.searchSeekBehavior = "activate";
+    el.scrollToSeek = false;
+    el.readingMode = true;
+
+    await vi.waitFor(() => {
+      expect(el.matches(":state(browsing)")).toBe(true);
+    });
+    expect(shadow(el).querySelector(".jump-to-current")).toBeTruthy();
+    // The property setter always stores a genuine boolean, regardless of
+    // how it later gets reflected onto the attribute.
+    expect(el.readingMode).toBe(true);
+    expect(el.scrollToSeek).toBe(false);
+
+    typeQuery(el, "grapefruit");
+    await new Promise((r) => setTimeout(r, 250));
+    expect(
+      shadow(el).querySelector('button[aria-label="Go to match"]'),
+    ).toBeTruthy();
+  });
+
+  test("properties set before upgrade configure the element at first render", async () => {
+    const url = nextUrl();
+    mockManifest(url);
+    const el = (await mountElement(
+      { "manifest-url": url },
+      {
+        annotations: ANNOTATIONS,
+        searchSeekBehavior: "activate",
+        scrollToSeek: false,
+        readingMode: true,
+      },
+    )) as El;
+    await readyAudio(el);
+
+    expect(el.matches(":state(browsing)")).toBe(true);
+    expect(shadow(el).querySelector(".jump-to-current")).toBeTruthy();
+
+    typeQuery(el, "grapefruit");
+    await new Promise((r) => setTimeout(r, 250));
+    expect(
+      shadow(el).querySelector('button[aria-label="Go to match"]'),
+    ).toBeTruthy();
+  });
+
+  test("an invalid scroll-to-seek or reading-mode value is a one-time host error and falls back to the default; removing the attribute restores the default", async () => {
+    const url = nextUrl();
+    mockManifest(url);
+    const el = document.createElement(DEFAULT_TAG) as El;
+    el.setAttribute("manifest-url", url);
+    el.setAttribute("scroll-to-seek", "sortof");
+    el.setAttribute("reading-mode", "banana");
+    Object.assign(el, { annotations: ANNOTATIONS });
+    const hostErrors = recordHostErrors(el);
+    document.body.appendChild(el);
+    await readyAudio(el);
+
+    expect(el.scrollToSeek).toBe(true);
+    expect(el.readingMode).toBe(false);
+    expect(el.matches(":state(browsing)")).toBe(false);
+    expect(shadow(el).querySelector(".jump-to-current")).toBeNull();
+    expect(hostErrors.length).toBeGreaterThanOrEqual(2);
+    expect(
+      hostErrors.some((e) => e.error.message.includes("`scroll-to-seek`")),
+    ).toBe(true);
+    expect(
+      hostErrors.some((e) => e.error.message.includes("`reading-mode`")),
+    ).toBe(true);
+
+    // A good value afterwards still lands (the channel is not poisoned).
+    el.setAttribute("reading-mode", "");
+    await vi.waitFor(() => {
+      expect(el.matches(":state(browsing)")).toBe(true);
+    });
+
+    // Removing the attribute is "back to the default", not an error.
+    el.removeAttribute("reading-mode");
+    await vi.waitFor(() => {
+      expect(el.matches(":state(browsing)")).toBe(false);
+    });
+    expect(el.readingMode).toBe(false);
+  });
+
+  test('a genuine scroll with scroll-to-seek="false" enters Browsing without seeking', async () => {
+    const url = nextUrl();
+    mockManifest(url);
+    const el = (await mountElement(
+      { "manifest-url": url, "scroll-to-seek": "false" },
+      { annotations: ANNOTATIONS },
+    )) as El;
+    const audio = await readyAudio(el);
+    const panel = await untilShadow<HTMLElement>(el, ".transcript-panel");
+    const segments = shadow(el).querySelectorAll<HTMLElement>(
+      "[data-annotation-id]",
+    );
+    panel.style.cssText =
+      "height: 80px; max-height: 80px; overflow-y: scroll; scroll-behavior: auto";
+    for (const segment of segments) segment.style.minHeight = "120px";
+    const maxScroll = panel.scrollHeight - panel.clientHeight;
+    expect(maxScroll).toBeGreaterThan(0);
+
+    let browserScrollSeen = false;
+    panel.addEventListener("scroll", (event) => {
+      browserScrollSeen ||= event.isTrusted;
+    });
+    panel.scrollTop = maxScroll;
+    await vi.waitFor(() => expect(browserScrollSeen).toBe(true));
+
+    await vi.waitFor(() => {
+      expect(el.matches(":state(browsing)")).toBe(true);
+    });
+    expect(audio.currentTime).toBe(0);
+    await vi.waitFor(() => {
+      expect(el.getAttribute("reading-mode")).not.toBeNull();
+    });
+  });
+
+  test("the Follow along switch is the single track-audio control, toggles :state(browsing), reflects reading-mode, and emits no seeked event", async () => {
+    const url = nextUrl();
+    mockManifest(url);
+    const el = (await mountElement(
+      { "manifest-url": url },
+      { annotations: ANNOTATIONS },
+    )) as El;
+    await readyAudio(el);
+    const seeksBefore = recordSeeks(el);
+
+    const switches = shadow(el).querySelectorAll('[role="switch"]');
+    expect(switches).toHaveLength(1);
+    expect(shadow(el).querySelector("button[aria-pressed]")).toBeNull();
+    const followAlong = switches[0] as HTMLButtonElement;
+    expect(followAlong.getAttribute("aria-checked")).toBe("true");
+    expect(el.getAttribute("reading-mode")).toBeNull();
+
+    followAlong.click();
+
+    await vi.waitFor(() => {
+      expect(el.matches(":state(browsing)")).toBe(true);
+    });
+    expect(followAlong.getAttribute("aria-checked")).toBe("false");
+    await vi.waitFor(() => {
+      expect(el.getAttribute("reading-mode")).not.toBeNull();
+    });
+
+    const jumpToCurrent = shadow(el).querySelector(
+      ".jump-to-current",
+    ) as HTMLButtonElement;
+    expect(jumpToCurrent).toBeTruthy();
+    jumpToCurrent.click();
+
+    await vi.waitFor(() => {
+      expect(el.matches(":state(browsing)")).toBe(false);
+    });
+    await vi.waitFor(() => {
+      expect(el.getAttribute("reading-mode")).toBeNull();
+    });
+    expect(followAlong.getAttribute("aria-checked")).toBe("true");
+
+    // Reflection itself never seeks.
+    expect(seeksBefore).toBe(0);
+  });
+
+  test("recommended configuration (activate + scrollToSeek=false) supports listen, search, browse, activate, browse again, return", async () => {
+    const url = nextUrl();
+    mockManifest(url);
+    const el = (await mountElement(
+      {
+        "manifest-url": url,
+        "search-seek-behavior": "activate",
+        "scroll-to-seek": "false",
+      },
+      { annotations: ANNOTATIONS },
+    )) as El;
+    const audio = await readyAudio(el);
+    let seeks = 0;
+    el.addEventListener("iiif-player-seeked", () => {
+      seeks += 1;
+    });
+
+    // Listen: Following by default, nothing has seeked.
+    expect(el.matches(":state(browsing)")).toBe(false);
+    expect(audio.currentTime).toBe(0);
+
+    // Search: typing enters Browsing on input — before the debounced match
+    // update settles (checked well within the 250ms debounce wait below).
+    typeQuery(el, "grapefruit");
+    await vi.waitFor(() => {
+      expect(el.matches(":state(browsing)")).toBe(true);
+    });
+    await new Promise((r) => setTimeout(r, 250));
+    expect(
+      shadow(el).querySelector('button[aria-label="Go to match"]'),
+    ).toBeTruthy();
+    expect(audio.currentTime).toBe(0);
+    expect(seeks).toBe(0);
+
+    // Browse: previous/next selects a match without seeking.
+    const next = shadow(el).querySelector(
+      'button[aria-label="Next match"]',
+    ) as HTMLButtonElement;
+    next.click();
+    expect(audio.currentTime).toBe(0);
+    expect(seeks).toBe(0);
+
+    // Activate: seeks exactly once to the selected match, stays Browsing.
+    const activateButton = shadow(el).querySelector(
+      'button[aria-label="Go to match"]',
+    ) as HTMLButtonElement;
+    activateButton.click();
+    await waitForEvent(el, "iiif-player-seeked");
+    expect(seeks).toBe(1);
+    expect(el.matches(":state(browsing)")).toBe(true);
+    const seekedTime = audio.currentTime;
+    expect(seekedTime).toBeGreaterThan(0);
+
+    // Browse again: navigating further still does not seek.
+    const prev = shadow(el).querySelector(
+      'button[aria-label="Previous match"]',
+    ) as HTMLButtonElement;
+    prev.click();
+    await new Promise((r) => setTimeout(r, 50));
+    expect(audio.currentTime).toBe(seekedTime);
+    expect(seeks).toBe(1);
+
+    // Return: back to Following, no further seek.
+    const followAlong = shadow(el).querySelector(
+      '[role="switch"]',
+    ) as HTMLButtonElement;
+    followAlong.click();
+    await vi.waitFor(() => {
+      expect(el.matches(":state(browsing)")).toBe(false);
+    });
+    expect(audio.currentTime).toBe(seekedTime);
+    expect(seeks).toBe(1);
+  });
+});
diff --git a/src/element/public-types.d.ts b/src/element/public-types.d.ts
index 8b9ecbb..2c7cccc 100644
--- a/src/element/public-types.d.ts
+++ b/src/element/public-types.d.ts
@@ -76,6 +76,31 @@ export declare class IIIFTranscriptPlayerElement extends HTMLElement {
   label: string;
   /** `crossorigin` attribute. Forwarded to the underlying media element. */
   crossorigin: string;
+  /**
+   * `search-seek-behavior` attribute. `"change"` (default) preserves
+   * legacy search-driven seeking; `"activate"` implements explicit search
+   * activation — see the library's `Transcript` `searchSeekBehavior` prop.
+   * Any other value is a non-fatal `host` error and falls back to
+   * `"change"`.
+   */
+  searchSeekBehavior: "change" | "activate";
+  /**
+   * `scroll-to-seek` attribute, default `true`. Value-based, not
+   * presence-based: `"false"` (case-insensitive) is `false`; `"true"`, the
+   * empty string, and a bare attribute are `true`; an absent attribute is
+   * the default. Any other string value is a non-fatal `host` error and
+   * falls back to `true`. Properties accept a real boolean directly.
+   */
+  scrollToSeek: boolean;
+  /**
+   * `reading-mode` attribute, default `false`. Same value-based parsing as
+   * `scrollToSeek`. Reactive and reflected: the element's own "Follow
+   * along" switch and "Jump to current" button — and any host write to
+   * this property — write the `reading-mode` attribute back through a
+   * guarded, loop-safe update. Exposes `:state(browsing)` for host theming
+   * while `true`.
+   */
+  readingMode: boolean;
   /** Property only. Default `"auto"`. */
   annotations: Annotation[] | "auto";
   /** Property only. Runs on the parsed manifest JSON before validation. */
diff --git a/src/lib/i18n/terms.ts b/src/lib/i18n/terms.ts
index 9abc4aa..d937ed0 100644
--- a/src/lib/i18n/terms.ts
+++ b/src/lib/i18n/terms.ts
@@ -2,8 +2,8 @@
  * Every UI-chrome string keys off one of these. The union covers what
  * exists today (control labels, transcript panel strings, the error
  * banner) plus keys reserved for the companion a11y spec's A-workstream
- * (Captions toggle, auto-scroll pause, the A5 status announcements) so
- * those strings are registry-routed from birth instead of swept in later.
+ * (Captions toggle, the A5 status announcements) so those strings are
+ * registry-routed from birth instead of swept in later.
  */
 export type TermKey =
   | "transcript.loading"
@@ -14,13 +14,20 @@ export type TermKey =
   | "transcript.searchNext"
   | "transcript.searchNoMatches"
   | "transcript.searchMatchCount"
+  | "transcript.searchActivate"
   | "transcript.segmentsLabel"
-  // Reserved for the a11y spec's A3 (auto-scroll pause control).
-  | "transcript.autoscrollPause"
-  | "transcript.autoscrollResume"
+  // The single folded track-audio control (docs/specs/
+  // transcript-reading-mode.md) — supersedes the former
+  // transcript.autoscrollPause/autoscrollResume pair.
+  | "transcript.followAlong"
+  | "transcript.jumpToCurrent"
   // Reserved for the a11y spec's A5 (transcript status announcements).
   | "transcript.loadedAnnouncement"
   | "transcript.unavailableAnnouncement"
+  // Reading-mode transitions (docs/specs/transcript-reading-mode.md,
+  // "Lifecycle and accessibility": announce mode changes politely).
+  | "transcript.followingAnnouncement"
+  | "transcript.browsingAnnouncement"
   | "player.errorLabel"
   | "player.controlsLabel"
   | "player.playButton.play"
@@ -54,11 +61,14 @@ export const EN_TERMS: Record<TermKey, string> = {
   "transcript.searchNext": "Next match",
   "transcript.searchNoMatches": "No matches",
   "transcript.searchMatchCount": "{current} of {total}",
+  "transcript.searchActivate": "Go to match",
   "transcript.segmentsLabel": "Transcript segments",
-  "transcript.autoscrollPause": "Pause auto-scroll",
-  "transcript.autoscrollResume": "Resume auto-scroll",
+  "transcript.followAlong": "Follow along",
+  "transcript.jumpToCurrent": "Jump to current",
   "transcript.loadedAnnouncement": "Transcript loaded, {count} segments",
   "transcript.unavailableAnnouncement": "Transcript unavailable",
+  "transcript.followingAnnouncement": "Following playback",
+  "transcript.browsingAnnouncement": "Browsing — playback continues",
   "player.errorLabel": "Error:",
   "player.controlsLabel": "Media controls",
   "player.playButton.play": "Play",
diff --git a/src/lib/player/Transcript.svelte b/src/lib/player/Transcript.svelte
index e37380d..5adb188 100644
--- a/src/lib/player/Transcript.svelte
+++ b/src/lib/player/Transcript.svelte
@@ -10,6 +10,7 @@
   import type { TranscriptStatus } from "./context";
   import type { Snippet } from "svelte";
   import { SyncController } from "../sync/SyncController.svelte";
+  import { getActiveAnnotationWithIndex } from "../sync/annotationUtils";
   import { t } from "../i18n/registry.svelte";
 
   interface Props {
@@ -21,6 +22,42 @@
     syncSettleMs?: number;
     syncPriorityLockDuration?: number;
 
+    /**
+     * Controls how a selected search match reaches playback.
+     * - `"change"` (default): preserves legacy behavior — every match
+     *   selection (typing or previous/next) seeks immediately.
+     * - `"activate"`: typing and previous/next only update highlights;
+     *   seeking happens once, only through explicit activation (Enter or
+     *   "Go to match" in `TranscriptSearch`/`Search`).
+     * @default "change"
+     */
+    searchSeekBehavior?: "change" | "activate";
+
+    /**
+     * When `false`, transcript scrolling never seeks the media — a
+     * deliberate user scroll instead enters Browsing (reading mode) so the
+     * next playback-driven update can't pull the panel back. Independent of
+     * `readingMode`: both `scrollToSeek=false` and `readingMode=true` stop
+     * scroll-to-seek; only `readingMode` also stops media-driven scrolling.
+     * Can change at runtime without rebuilding the player.
+     * @default true
+     */
+    scrollToSeek?: boolean;
+    /**
+     * Bindable. `false` (Following, the default): playback may scroll the
+     * transcript, and, when `scrollToSeek` is enabled, transcript scrolling
+     * may seek. `true` (Browsing): the panel is detached from playback —
+     * media keeps updating the active-passage highlight and active-
+     * annotation state, but never scrolls the panel, and transcript
+     * scrolling never seeks. Panel-local: two `Transcript` instances track
+     * this independently. Turning `readingMode` back off (via the bindable,
+     * a host property write, or the "Follow along" switch) scrolls the
+     * passage at the media's current time into view without seeking — the
+     * same "return to Following" behavior as "Jump to current".
+     * @default false
+     */
+    readingMode?: boolean;
+
     // Accessibility
     ariaLabel?: string;
     announceActiveSegment?: boolean;
@@ -49,6 +86,9 @@
     syncDebounceMs = 150,
     syncSettleMs = 100,
     syncPriorityLockDuration = 1000,
+    searchSeekBehavior = "change",
+    scrollToSeek = true,
+    readingMode = $bindable(false),
     ariaLabel = "Media transcript",
     announceActiveSegment = true,
     onActiveAnnotationChange,
@@ -125,10 +165,11 @@
   // SyncController instance
   let syncController: SyncController | null = $state.raw(null);
 
-  // A4: auto-scroll pause toggle. Default matches the machine's
-  // autoScrollEnabled default (true) — this component owns the UI state,
-  // the machine owns the gate.
-  let autoScrollEnabled = $state(true);
+  // Reading mode refs: the "Follow along" switch (persistent) and "Jump to
+  // current" button (rendered only while Browsing) — see the focus-transfer
+  // effect below.
+  let followAlongSwitchEl: HTMLButtonElement | null = $state(null);
+  let jumpToCurrentEl: HTMLButtonElement | null = $state(null);
 
   // Derived active annotation ID from SyncController
   let activeAnnotationId = $derived.by(() => {
@@ -145,6 +186,12 @@
   let searchMatches = $state<Annotation[]>([]);
   let currentMatchIndex = $state(-1);
 
+  // Bumped on annotation replacement in "activate" mode or while reading
+  // mode is active — the external reset path TranscriptSearch forwards to
+  // Search's resetSignal prop (docs/specs/transcript-reading-mode.md,
+  // "Lifecycle": clear the query and selected result on canvas switch).
+  let queryResetSignal = $state(0);
+
   // Derive set of highlighted IDs (all search matches)
   const highlightedIds = $derived(new Set(searchMatches.map((m) => m.id)));
 
@@ -171,6 +218,13 @@
     );
     if (!el) return false;
 
+    // Programmatic transcript movement (returning to Following, browsing
+    // search matches, and this consumer-facing scrollToAnnotation itself)
+    // must never feed back into scroll-to-seek as a "deliberate user
+    // scroll" — mark it before the browser fires the resulting scroll
+    // event(s), including through a smooth-scroll animation's duration.
+    syncController?.notifyProgrammaticScroll();
+
     const prefersReducedMotion =
       typeof window !== "undefined" &&
       window.matchMedia("(prefers-reduced-motion: reduce)").matches;
@@ -185,6 +239,57 @@
     return true;
   }
 
+  /**
+   * The passage "Jump to current" / "Return" should scroll to, given the
+   * media's current time: the active cue when inside one; the next cue
+   * when between cues; the first cue before the first one starts; the last
+   * cue after the last one ends; `null` with no annotations at all.
+   * Deliberately does not touch `activeAnnotationId` — that stays purely a
+   * function of playback, so a between-cues return never marks a cue
+   * active that the current time doesn't actually contain.
+   */
+  function findReturnTarget(
+    anns: Annotation[],
+    time: number,
+  ): Annotation | null {
+    if (anns.length === 0) return null;
+
+    const active = getActiveAnnotationWithIndex(time, anns);
+    if (active) return active.annotation;
+
+    const first = anns[0]!;
+    if (time < first.startTime) return first;
+
+    const last = anns[anns.length - 1]!;
+    if (time >= last.endTime) return last;
+
+    const next = anns.find((a) => a.startTime > time);
+    return next ?? last;
+  }
+
+  // Detects annotation replacement (e.g. a canvas switch swapping in a new
+  // annotations array) and, in "activate" mode or while reading mode is
+  // active, bumps queryResetSignal so Search clears its otherwise-private
+  // query and selection (docs/specs/transcript-reading-mode.md, "Lifecycle").
+  // In "change" mode with reading mode off, the query persists — the
+  // existing re-notification path through Search's own annotations-prop
+  // reactivity is untouched. `previousResolvedAnnotations` is a plain
+  // variable (not $state) captured once at setup, so the first run always
+  // sees `current === prev` and never bumps on mount.
+  // svelte-ignore state_referenced_locally
+  let previousResolvedAnnotations = resolvedAnnotations;
+  $effect(() => {
+    const current = resolvedAnnotations;
+    untrack(() => {
+      const prev = previousResolvedAnnotations;
+      previousResolvedAnnotations = current;
+      if (current === prev) return;
+      if (searchSeekBehavior === "activate" || readingMode) {
+        queryResetSignal++;
+      }
+    });
+  });
+
   // Provide TranscriptContext for compound children (TranscriptSearch, TranscriptSegments)
   setTranscriptContext({
     get state() {
@@ -195,29 +300,85 @@
         currentMatchIndex,
         highlightedIds,
         currentMatchId,
+        searchSeekBehavior,
+        readingMode,
+        queryResetSignal,
       };
     },
     actions: {
       handleAnnotationClick,
       handleMatchChange,
+      handleMatchActivate,
+      handleQueryInput,
       scrollToAnnotation,
+      enterBrowsing,
+      returnToFollowing,
     },
   } satisfies TranscriptContext);
 
-  // Search handler - unified callback from Search component
+  // Search handler - unified callback from Search component. Updates
+  // highlight/selection state always; seeks only in legacy "change" mode —
+  // "activate" mode routes seeking exclusively through handleMatchActivate.
+  // Browsing takes precedence even in "change" mode (docs/specs/
+  // transcript-reading-mode.md, "Browsing takes precedence"): once the
+  // reader has detached the panel from playback, match selection must not
+  // seek regardless of searchSeekBehavior. A host that seeks inside its own
+  // onmatchchange override owns that side effect — this only gates the
+  // library's own default.
   function handleMatchChange(matches: Annotation[], index: number) {
     searchMatches = matches;
     currentMatchIndex = index;
 
-    // Scroll to and seek to current match
-    if (index >= 0 && matches[index]) {
+    if (
+      searchSeekBehavior === "change" &&
+      !readingMode &&
+      index >= 0 &&
+      matches[index]
+    ) {
       const match = matches[index];
       lastInteractionWasUser = true;
-      // Seek media to match start time
       actions.seekTo(match.startTime);
     }
   }
 
+  // Explicit search-result activation (Enter or "Go to match"). Seeks
+  // exactly once, regardless of searchSeekBehavior or reading mode — this
+  // is the only seek path search takes in "activate" mode, and activation
+  // stays in Browsing per the spec (it never calls enterBrowsing/
+  // returnToFollowing itself).
+  function handleMatchActivate(annotation: Annotation, index: number) {
+    currentMatchIndex = index;
+    lastInteractionWasUser = true;
+    actions.seekTo(annotation.startTime);
+  }
+
+  // Synchronous query-input intent (Search's onqueryinput, forwarded
+  // through TranscriptSearch). Editing a nonempty query enters Browsing
+  // immediately, before debounce or rendering can cause scrolling — but
+  // only in "activate" mode; legacy "change" mode keeps its existing
+  // seek-on-select behavior and does not auto-enter Browsing from typing.
+  function handleQueryInput(value: string) {
+    if (searchSeekBehavior === "activate" && value.trim() !== "") {
+      enterBrowsing();
+    }
+  }
+
+  /** Enters Browsing. Idempotent. */
+  function enterBrowsing() {
+    readingMode = true;
+  }
+
+  /**
+   * Returns to Following. The actual work — scrolling the passage at the
+   * media's current time into view and the focus-transfer rule — happens
+   * in the readingMode `$effect.pre` below, uniformly for every path that
+   * can flip `readingMode` false→true→false: this action, the "Follow
+   * along" switch, "Jump to current", and a host's own bindable-prop write.
+   */
+  function returnToFollowing() {
+    readingMode = false;
+  }
+
   // Initialize and reinitialize SyncController when dependencies change
   $effect(() => {
     // Capture reactive dependencies
@@ -235,6 +396,7 @@
       debounceMs: syncDebounceMs,
       settleMs: syncSettleMs,
       priorityLockDuration: syncPriorityLockDuration,
+      onUserScroll: handleUserScroll,
     });
 
     try {
@@ -257,14 +419,75 @@
     };
   });
 
-  // Push the panel's auto-scroll flag to whichever controller instance is
-  // current. Separate from the controller-creation effect above so
-  // toggling the flag doesn't tear down and recreate the controller.
+  // Push the fold's two effective policies to whichever controller instance
+  // is current — separate from the controller-creation effect above so
+  // toggling either doesn't tear down and recreate the controller.
+  // Following/Browsing is the single public toggle, but it maps to two
+  // independent SyncController gates: Browsing stops BOTH media->scroll
+  // (autoScrollEnabled) and scroll->seek (scrollToSeekEnabled), while
+  // `scrollToSeek=false` alone — still Following — stops only the latter.
   $effect(() => {
-    const enabled = autoScrollEnabled;
+    const enabled = !readingMode;
     syncController?.setAutoScrollEnabled(enabled);
   });
 
+  $effect(() => {
+    const enabled = scrollToSeek && !readingMode;
+    syncController?.setScrollToSeekEnabled(enabled);
+  });
+
+  // A genuine, deliberate transcript scroll reported by SyncController
+  // (already filtered from auto-scroll echoes and throttled — see
+  // SyncController.onUserScroll). Only relevant while still Following with
+  // scroll-to-seek configured off: that combination is the one case where
+  // user scrolling itself must enter Browsing (docs/specs/
+  // transcript-reading-mode.md, "Reading mode"). When scrollToSeek is true,
+  // scrolling keeps driving the legacy scroll-to-seek behavior instead.
+  function handleUserScroll() {
+    if (!scrollToSeek) {
+      enterBrowsing();
+    }
+  }
+
+  // Returning to Following — by any path that flips readingMode true->false
+  // (the "Follow along" switch, "Jump to current", the returnToFollowing
+  // context action, or a host's own bindable-prop write) — scrolls the
+  // passage at the media's CURRENT time into view (never seeks) and, only
+  // when the disappearing "Jump to current" button currently owns focus,
+  // moves focus to the persistent "Follow along" switch. $effect.pre (not
+  // $effect) so the focus check runs before Svelte removes the Jump button
+  // from the DOM — after removal the browser has already moved focus away
+  // and `document.activeElement` can no longer tell us it was the button.
+  let previousReadingMode = readingMode;
+  $effect.pre(() => {
+    const current = readingMode;
+    const wasBrowsing = previousReadingMode;
+    previousReadingMode = current;
+
+    if (!(wasBrowsing && !current)) return;
+
+    // Untracked: this reads playerContext.state.currentTime and
+    // resolvedAnnotations, neither of which should make this effect re-run
+    // on every playback tick — it must fire only on the readingMode
+    // transition read above.
+    untrack(() => {
+      const jumpButtonHadFocus =
+        jumpToCurrentEl !== null && document.activeElement === jumpToCurrentEl;
+
+      const target = findReturnTarget(
+        resolvedAnnotations,
+        playerContext.state.currentTime,
+      );
+      if (target) {
+        scrollToAnnotation(target.id);
+      }
+
+      if (jumpButtonHadFocus) {
+        followAlongSwitchEl?.focus();
+      }
+    });
+  });
+
   // Single sr-only announcement channel (A5): swaps text rather than
   // mounting/unmounting the live region, since inserting a live region
   // simultaneously with its content is unreliable across SR/browser pairs.
@@ -304,6 +527,24 @@
     });
   });
 
+  // Mode-change announcements (spec accessibility bullet: "Announce match
+  // counts and mode changes politely"). `previousReadingModeForAnnouncement`
+  // is a plain variable captured once at setup — same pattern as
+  // `previousReadingMode` above — so the first run always sees no change and
+  // never announces on mount.
+  let previousReadingModeForAnnouncement = readingMode;
+  $effect(() => {
+    const current = readingMode;
+    untrack(() => {
+      const was = previousReadingModeForAnnouncement;
+      previousReadingModeForAnnouncement = current;
+      if (was === current) return;
+      announcementText = current
+        ? t("transcript.browsingAnnouncement")
+        : t("transcript.followingAnnouncement");
+    });
+  });
+
   // Fire onActiveAnnotationChange when active annotation changes
   $effect(() => {
     const id = activeAnnotationId;
@@ -357,14 +598,25 @@
   {:else if children}
     <button
       type="button"
-      class="auto-scroll-toggle"
-      aria-pressed={!autoScrollEnabled}
-      onclick={() => (autoScrollEnabled = !autoScrollEnabled)}
+      class="follow-along-switch"
+      role="switch"
+      aria-checked={!readingMode}
+      data-following={!readingMode}
+      bind:this={followAlongSwitchEl}
+      onclick={() => (readingMode ? returnToFollowing() : enterBrowsing())}
     >
-      {autoScrollEnabled
-        ? t("transcript.autoscrollPause")
-        : t("transcript.autoscrollResume")}
+      {t("transcript.followAlong")}
     </button>
+    {#if readingMode}
+      <button
+        type="button"
+        class="jump-to-current"
+        bind:this={jumpToCurrentEl}
+        onclick={returnToFollowing}
+      >
+        {t("transcript.jumpToCurrent")}
+      </button>
+    {/if}
     {@render children()}
   {/if}
 
diff --git a/src/lib/player/TranscriptSearch.svelte b/src/lib/player/TranscriptSearch.svelte
index bd0c0cc..ff59d09 100644
--- a/src/lib/player/TranscriptSearch.svelte
+++ b/src/lib/player/TranscriptSearch.svelte
@@ -9,6 +9,23 @@
     placeholder?: string;
     debounceMs?: number;
     onmatchchange?: (matches: Annotation[], index: number) => void;
+    /**
+     * Fired on explicit activation (Enter or "Go to match"). Overrides the
+     * default, which seeks once through the transcript context.
+     */
+    onmatchactivate?: (annotation: Annotation, index: number) => void;
+    /**
+     * Fired only from explicit previous/next navigation (never typing or
+     * activation). Overrides the default, which scrolls the newly-selected
+     * match into view through the transcript context's `scrollToAnnotation`.
+     */
+    onmatchnavigate?: (annotation: Annotation, index: number) => void;
+    /**
+     * Fired synchronously from `Search`'s raw input event, before debounce.
+     * Overrides the default, which forwards the value to the transcript
+     * context's `handleQueryInput` seam.
+     */
+    onqueryinput?: (value: string) => void;
     class?: string;
   }
 
@@ -17,6 +34,9 @@
     placeholder: placeholderProp,
     debounceMs = 150,
     onmatchchange: onmatchchangeProp,
+    onmatchactivate: onmatchactivateProp,
+    onmatchnavigate: onmatchnavigateProp,
+    onqueryinput: onqueryinputProp,
     class: className = "",
   }: Props = $props();
 
@@ -34,6 +54,42 @@
   const onmatchchange = $derived(
     onmatchchangeProp ?? transcriptCtx?.actions.handleMatchChange,
   );
+  const onmatchactivate = $derived(
+    onmatchactivateProp ?? transcriptCtx?.actions.handleMatchActivate,
+  );
+  // Default scrolls the newly-selected match into view via the context —
+  // distinct from onmatchchange/onmatchactivate, and never fired from typing
+  // (spec: typing must not scroll). Scoped to activate mode or Browsing:
+  // in the legacy default (searchSeekBehavior="change", reading mode off),
+  // prev/next historically only changed the match and sought through
+  // onmatchchange — no explicit programmatic scroll.
+  const onmatchnavigate = $derived(
+    onmatchnavigateProp ??
+      ((annotation: Annotation) => {
+        const state = transcriptCtx?.state;
+        if (
+          state?.searchSeekBehavior === "activate" ||
+          state?.readingMode === true
+        ) {
+          transcriptCtx?.actions.scrollToAnnotation(annotation.id);
+        }
+      }),
+  );
+  // The context's handleQueryInput is optional (a seam the reading-mode step
+  // fills in) — read at call time rather than snapshotting a possibly-absent
+  // function into the default.
+  const onqueryinput = $derived(
+    onqueryinputProp ??
+      ((value: string) => transcriptCtx?.actions.handleQueryInput?.(value)),
+  );
+  // Show the activation control when searchSeekBehavior is "activate" OR
+  // while Browsing (reading mode active) — in legacy "change" mode, entering
+  // Browsing still needs an explicit way to jump to a match, since Browsing
+  // suppresses the seek-on-select that "change" mode otherwise relies on.
+  const showActivation = $derived(
+    transcriptCtx?.state.searchSeekBehavior === "activate" ||
+      transcriptCtx?.state.readingMode === true,
+  );
 </script>
 
 <div class="transcript-search-sticky">
@@ -42,6 +98,11 @@
     {placeholder}
     {debounceMs}
     {onmatchchange}
+    {onmatchactivate}
+    {onmatchnavigate}
+    {onqueryinput}
+    {showActivation}
+    resetSignal={transcriptCtx?.state.queryResetSignal}
     class={className}
   />
 </div>
diff --git a/src/lib/player/TranscriptSegments.svelte b/src/lib/player/TranscriptSegments.svelte
index 477a7be..35c5f0b 100644
--- a/src/lib/player/TranscriptSegments.svelte
+++ b/src/lib/player/TranscriptSegments.svelte
@@ -2,6 +2,7 @@
   import type { Snippet } from "svelte";
   import Segment from "../transcript/Segment.svelte";
   import { getNextIndex, focusSegmentAtIndex } from "../transcript/keyboardNav";
+  import { isTextSelectionActive } from "../transcript/utils";
   import { tryGetTranscriptContext } from "./transcript-context";
   import type { Annotation } from "../sync/types";
   import { t } from "../i18n/registry.svelte";
@@ -141,12 +142,24 @@
    * Scroll a specific annotation into view.
    * Returns true if the annotation was found, false otherwise.
    * Respects prefers-reduced-motion by default; pass options to override.
+   *
+   * Delegates to the transcript context's own `scrollToAnnotation` when
+   * available (the normal case — TranscriptSegments is used inside
+   * Transcript): that's the one that marks the scroll programmatic for
+   * SyncController, so a consumer calling this never feeds a spurious
+   * "deliberate user scroll" into scroll-to-seek (docs/specs/
+   * transcript-reading-mode.md, Lifecycle). Falls back to a local
+   * implementation when used standalone, outside Transcript.
    */
   export function scrollToAnnotation(
     annotationId: string,
     // eslint-disable-next-line no-undef
     options?: ScrollIntoViewOptions,
   ): boolean {
+    if (transcriptCtx) {
+      return transcriptCtx.actions.scrollToAnnotation(annotationId, options);
+    }
+
     if (!containerEl) return false;
     const el = containerEl.querySelector(
       `[data-annotation-id="${CSS.escape(annotationId)}"]`,
@@ -251,7 +264,14 @@
             "data-current-match": isCurrentMatch ? "true" : undefined,
             "aria-current": isActive ? "true" : undefined,
             tabindex: i === focusedIndex ? 0 : -1,
-            onclick: () => onclick?.(annotation),
+            onclick: () => {
+              // A drag-to-select ending in a click must not also activate
+              // (seek) — same guard Segment.svelte applies to its own
+              // onclick (Fix B). Keyboard activation below is never a
+              // drag, so onkeydown stays unguarded.
+              if (isTextSelectionActive()) return;
+              onclick?.(annotation);
+            },
             onkeydown: (event: KeyboardEvent) => {
               if (event.key === "Enter" || event.key === " ") {
                 event.preventDefault();
diff --git a/src/lib/player/transcript-context.ts b/src/lib/player/transcript-context.ts
index 53cc6bd..ceb646c 100644
--- a/src/lib/player/transcript-context.ts
+++ b/src/lib/player/transcript-context.ts
@@ -8,11 +8,63 @@ export interface TranscriptState {
   currentMatchIndex: number;
   highlightedIds: Set<string>;
   currentMatchId: string | null;
+  /**
+   * Configured search-seek behavior (`Transcript`'s `searchSeekBehavior`
+   * prop). `"activate"` is what makes `TranscriptSearch` show the "Go to
+   * match" activation control and route seeking through
+   * `handleMatchActivate` instead of `handleMatchChange`.
+   */
+  searchSeekBehavior: "change" | "activate";
+  /**
+   * `true` while this panel is Browsing — the reader has detached the
+   * transcript from playback (mirrors `Transcript`'s bindable
+   * `readingMode`). `false` is Following. Panel-local: two `Transcript`
+   * instances under the same player track this independently.
+   */
+  readingMode: boolean;
+  /**
+   * Bumped (incremented) whenever `Transcript` clears the search query on
+   * annotation replacement — `activate` mode, or while reading mode is
+   * active (docs/specs/transcript-reading-mode.md, "Lifecycle"). `Search`'s
+   * query is otherwise private `$state`; this is the external reset path
+   * `TranscriptSearch` forwards to `Search`'s `resetSignal` prop. In `change`
+   * mode with reading mode off, this does not change on replacement — the
+   * query persists (legacy behavior).
+   */
+  queryResetSignal: number;
 }
 
 export interface TranscriptActions {
   handleAnnotationClick: (annotation: Annotation) => void;
   handleMatchChange: (matches: Annotation[], index: number) => void;
+  /**
+   * Explicit search-result activation (Enter in the search input, or the
+   * "Go to match" button). Seeks once to the annotation's start time
+   * regardless of `searchSeekBehavior` — this is the only seek path when
+   * `searchSeekBehavior` is `"activate"`.
+   */
+  handleMatchActivate: (annotation: Annotation, index: number) => void;
+  /**
+   * Synchronous query-input intent, forwarded from `Search`'s
+   * `onqueryinput`. Reserved for the reading-mode step (entering Browsing
+   * on input while `searchSeekBehavior` is `"activate"`); optional until
+   * that step implements it, so `TranscriptSearch` can wire the seam now
+   * without every context needing to provide it yet.
+   */
+  handleQueryInput?: (value: string) => void;
+  /**
+   * Enters Browsing. Idempotent — safe to call when already Browsing. A
+   * custom (host-built) "Follow along" control calls this to turn the
+   * switch off.
+   */
+  enterBrowsing: () => void;
+  /**
+   * Returns to Following: scrolls the passage at the media's current time
+   * into view (never seeks) and exits Browsing. Same effect as turning
+   * "Follow along" back on — a custom "Jump to current" control calls this.
+   * Idempotent when already Following.
+   */
+  returnToFollowing: () => void;
   /**
    * Scroll a specific annotation into view within the transcript panel.
    * Returns true if the annotation was found, false otherwise.
diff --git a/src/lib/sync/SyncController.svelte.ts b/src/lib/sync/SyncController.svelte.ts
index d3f115a..d94fc3f 100644
--- a/src/lib/sync/SyncController.svelte.ts
+++ b/src/lib/sync/SyncController.svelte.ts
@@ -48,8 +48,21 @@ export class SyncController {
   private annotations: Annotation[] = [];
   private isInitialized = false;
   private cleanupHandlers: Array<() => void> = [];
-  private lastProgrammaticScroll: number = 0; // Timestamp of last auto-scroll
   private lastScrollEvent: number = 0; // Timestamp of last processed scroll event (for throttling)
+  // Tracks an in-flight programmatic scroll (auto-scroll, return-to-following,
+  // browsing search results, or a consumer scrollToAnnotation call) so the
+  // container's own scroll listener can treat echoes of it as non-user
+  // input rather than deliberate scrolling — see beginProgrammaticScroll().
+  private programmaticScrollActive = false;
+  private programmaticScrollCleanup: (() => void) | null = null;
+  private programmaticScrollFallbackTimer: ReturnType<
+    typeof setTimeout
+  > | null = null;
+  // Idle gap after the last echo scroll before the fallback closes a
+  // programmatic-scroll transaction (used when no `scrollend` arrives). Longer
+  // than a smooth scroll's inter-frame gap, so it only elapses once scrolling
+  // has actually stopped.
+  private static readonly PROGRAMMATIC_SCROLL_SETTLE_MS = 250;
 
   /**
    * Creates a new SyncController instance.
@@ -120,7 +133,7 @@ export class SyncController {
       // Track when auto-scroll happens to block subsequent scroll events
       // mediaDriven means we're auto-scrolling the transcript
       if (state.matches("mediaDriven")) {
-        this.lastProgrammaticScroll = Date.now();
+        this.beginProgrammaticScroll();
       }
     });
 
@@ -186,11 +199,15 @@ export class SyncController {
       if (this.scrollContainer && this.actor) {
         const now = Date.now();
 
-        // Ignore scroll events for 600ms after auto-scroll
-        // scrollIntoView({ behavior: 'smooth' }) triggers scroll events during its animation.
-        // We must block these for the full animation duration (~500ms) to prevent jump-back.
-        const timeSinceAutoScroll = now - this.lastProgrammaticScroll;
-        if (timeSinceAutoScroll < 600) {
+        // Ignore scroll events while a programmatic scroll transaction is
+        // active. scrollIntoView({ behavior: 'smooth' }) triggers scroll
+        // events throughout its animation, which can outlast any fixed
+        // timeout — the transaction is closed explicitly by `scrollend`
+        // (with a generous fallback timer), not by elapsed time.
+        if (this.programmaticScrollActive) {
+          // Re-arm the quiet-period fallback: while echoes keep arriving the
+          // timer keeps getting pushed out, so it never elapses mid-animation.
+          this.armProgrammaticScrollFallback();
           return; // Skip scroll events during/after auto-scroll animation
         }
 
@@ -202,6 +219,11 @@ export class SyncController {
         }
         this.lastScrollEvent = now;
 
+        // A genuine, deliberate scroll — reported regardless of whether
+        // scroll-to-seek is currently enabled; the panel decides what to do
+        // with it (enter reading mode when scrollToSeek is configured off).
+        this.config.onUserScroll?.();
+
         const { scrollTop, scrollHeight, clientHeight } = this.scrollContainer;
         const maxScroll = scrollHeight - clientHeight;
         const scrollProgress = maxScroll > 0 ? scrollTop / maxScroll : 0;
@@ -265,6 +287,81 @@ export class SyncController {
     this.actor?.send({ type: "SET_AUTO_SCROLL_ENABLED", enabled });
   }
 
+  /**
+   * Push the effective scroll-to-seek policy (`scrollToSeek` prop AND NOT
+   * reading mode). No-ops before initialize().
+   */
+  setScrollToSeekEnabled(enabled: boolean): void {
+    this.actor?.send({ type: "SET_SCROLL_TO_SEEK_ENABLED", enabled });
+  }
+
+  /**
+   * Marks a scroll about to happen (or already animating) as programmatic,
+   * so the container's own scroll listener treats it as an auto-scroll echo
+   * rather than a deliberate user scroll. Callers: the panel's own
+   * `scrollToAnnotation` (covers returning to Following, browsing search
+   * results, and the consumer-facing `scrollToAnnotation` API — all
+   * programmatic transcript movement per
+   * docs/specs/transcript-reading-mode.md's Lifecycle section).
+   */
+  notifyProgrammaticScroll(): void {
+    this.beginProgrammaticScroll();
+  }
+
+  /**
+   * Opens a programmatic-scroll transaction: scroll echoes are suppressed
+   * until it closes. Primary close is the container's `scrollend` event
+   * (fires once a smooth-scroll animation settles, however long that takes).
+   * The fallback is a QUIET-PERIOD timer, re-armed on every echo scroll (see
+   * `handleScroll`), so it fires only once scrolling has been idle for
+   * `PROGRAMMATIC_SCROLL_SETTLE_MS` — never mid-animation, no matter how long
+   * the scroll runs. That covers engines without `scrollend` support and the
+   * case where the target is already in view (no scroll, hence no `scrollend`,
+   * ever fires).
+   */
+  private beginProgrammaticScroll(): void {
+    this.endProgrammaticScroll();
+
+    const container = this.scrollContainer;
+    if (!container) return; // nothing can scroll → nothing to suppress
+
+    this.programmaticScrollActive = true;
+
+    const onScrollEnd = () => this.endProgrammaticScroll();
+    container.addEventListener("scrollend", onScrollEnd, { once: true });
+    this.programmaticScrollCleanup = () =>
+      container.removeEventListener("scrollend", onScrollEnd);
+
+    this.armProgrammaticScrollFallback();
+  }
+
+  /**
+   * (Re)starts the quiet-period fallback timer. Called when the transaction
+   * opens and again on every suppressed echo scroll, so the timer only
+   * elapses after scrolling stops — it can never expire during an in-flight
+   * smooth scroll.
+   */
+  private armProgrammaticScrollFallback(): void {
+    if (this.programmaticScrollFallbackTimer !== null) {
+      clearTimeout(this.programmaticScrollFallbackTimer);
+    }
+    this.programmaticScrollFallbackTimer = setTimeout(
+      () => this.endProgrammaticScroll(),
+      SyncController.PROGRAMMATIC_SCROLL_SETTLE_MS,
+    );
+  }
+
+  /** Closes the current programmatic-scroll transaction, if any. */
+  private endProgrammaticScroll(): void {
+    this.programmaticScrollActive = false;
+    this.programmaticScrollCleanup?.();
+    this.programmaticScrollCleanup = null;
+    if (this.programmaticScrollFallbackTimer !== null) {
+      clearTimeout(this.programmaticScrollFallbackTimer);
+      this.programmaticScrollFallbackTimer = null;
+    }
+  }
+
   /**
    * Check if the controller is ready (machine is in ready state).
    */
@@ -291,6 +388,7 @@ export class SyncController {
     // Clean up event listeners
     this.cleanupHandlers.forEach((cleanup) => cleanup());
     this.cleanupHandlers = [];
+    this.endProgrammaticScroll();
 
     if (this.actor) {
       this.actor.stop();
diff --git a/src/lib/sync/actors/videoController.ts b/src/lib/sync/actors/videoController.ts
index c82de77..1e8118b 100644
--- a/src/lib/sync/actors/videoController.ts
+++ b/src/lib/sync/actors/videoController.ts
@@ -16,6 +16,18 @@ export interface VideoControllerInput {
   viewer: IIIFMediaViewerRef;
   /** Target time to seek to (seconds) */
   targetTime: number;
+  /**
+   * Scroll-to-seek policy epoch captured when this seek was queued (when
+   * `scrollDriven` was entered). Compared against the live epoch —
+   * `getCurrentEpoch()` — immediately before `seekTo()`, so a seek queued
+   * while scrolling drops silently if the policy (`scrollToSeek` /
+   * reading mode) changed while this actor was still awaiting readiness. A
+   * transition guard on the *next* event would be too late: this promise
+   * calls `seekTo()` itself, before it resolves.
+   */
+  queuedEpoch: number;
+  /** Reads the parent machine's live epoch at call time — not a snapshot. */
+  getCurrentEpoch: () => number;
 }
 
 /**
@@ -43,11 +55,21 @@ async function waitForReady(viewer: IIIFMediaViewerRef): Promise<void> {
  */
 export const videoController = fromPromise(
   async ({ input }: { input: VideoControllerInput }) => {
-    const { viewer, targetTime } = input;
+    const { viewer, targetTime, queuedEpoch, getCurrentEpoch } = input;
 
     // Wait for viewer to be ready
     await waitForReady(viewer);
 
+    // The policy check runs immediately before the seek — a state
+    // transition guard elsewhere would be too late, since this promise is
+    // what calls seekTo(), before it resolves. Drop the seek silently if
+    // the scroll-to-seek policy changed while this actor was awaiting
+    // readiness (docs/specs/transcript-reading-mode.md, "Toggle policy off
+    // while a scroll-driven seek awaits readiness").
+    if (getCurrentEpoch() !== queuedEpoch) {
+      return;
+    }
+
     // Get duration and clamp targetTime to valid range [0, duration]
     const duration = viewer.getDuration();
     let clampedTime = Math.max(0, Math.min(targetTime, duration));
diff --git a/src/lib/sync/syncMachine.ts b/src/lib/sync/syncMachine.ts
index b4c3c20..204896f 100644
--- a/src/lib/sync/syncMachine.ts
+++ b/src/lib/sync/syncMachine.ts
@@ -44,6 +44,8 @@ function createInitialContext(): SyncContext {
     annotations: [],
     priorityLockDuration: 1000,
     autoScrollEnabled: true,
+    scrollToSeekEnabled: true,
+    scrollSeekEpoch: 0,
   };
 }
 
@@ -67,6 +69,20 @@ function canSyncToVideo({ context }: { context: SyncContext }): boolean {
   return syncPriority.direction === "scroll";
 }
 
+/**
+ * Guard: is scroll-to-seek currently allowed at all?
+ *
+ * Combines the panel's effective policy (`scrollToSeekEnabled` — the
+ * `scrollToSeek` prop AND NOT reading mode) with the existing priority-lock
+ * guard. Applied to every `TRANSCRIPT_SCROLL` transition, including the
+ * re-entrant one inside `scrollDriven`, so disabling the policy mid-flight
+ * blocks both the in-flight seek (via the epoch check inside
+ * `videoController`) and any further scroll from starting a new one.
+ */
+function canScrollSeek({ context }: { context: SyncContext }): boolean {
+  return context.scrollToSeekEnabled && canSyncToVideo({ context });
+}
+
 /**
  * Guard: Has the active annotation changed?
  * Used to trigger transcript auto-scroll only on annotation boundaries.
@@ -113,6 +129,7 @@ export const syncMachine = setup({
   guards: {
     canSyncToVideo,
     annotationChanged,
+    canScrollSeek,
   },
   actions: {
     /**
@@ -245,6 +262,28 @@ export const syncMachine = setup({
         return context.autoScrollEnabled;
       },
     }),
+
+    /**
+     * Update the scroll-to-seek policy and bump its epoch. The epoch is
+     * bumped on every processed event regardless of direction — a
+     * conservative "any policy change invalidates whatever was queued
+     * before" rule that's simpler to reason about than only bumping on
+     * disable.
+     */
+    setScrollToSeekEnabled: assign({
+      scrollToSeekEnabled: ({ context, event }) => {
+        if (event.type === "SET_SCROLL_TO_SEEK_ENABLED") {
+          return event.enabled;
+        }
+        return context.scrollToSeekEnabled;
+      },
+      scrollSeekEpoch: ({ context, event }) => {
+        if (event.type === "SET_SCROLL_TO_SEEK_ENABLED") {
+          return context.scrollSeekEpoch + 1;
+        }
+        return context.scrollSeekEpoch;
+      },
+    }),
   },
 }).createMachine({
   id: "sync",
@@ -265,7 +304,7 @@ export const syncMachine = setup({
       on: {
         TRANSCRIPT_SCROLL: {
           target: "scrollDriven",
-          guard: "canSyncToVideo",
+          guard: "canScrollSeek",
           actions: [
             "updateScrollProgress",
             "calculateTargetTime",
@@ -284,6 +323,9 @@ export const syncMachine = setup({
         SET_AUTO_SCROLL_ENABLED: {
           actions: ["setAutoScrollEnabled"],
         },
+        SET_SCROLL_TO_SEEK_ENABLED: {
+          actions: ["setScrollToSeekEnabled"],
+        },
         RESET: {
           target: "idle",
           actions: ["clearSync"],
@@ -294,9 +336,14 @@ export const syncMachine = setup({
       invoke: {
         id: "videoController",
         src: "videoController",
-        input: ({ context }) => ({
+        input: ({ context, self }) => ({
           viewer: context.viewer!,
           targetTime: context.targetTime,
+          // Captured once, at invoke time; compared against the live value
+          // (read through the getter, not this snapshot) immediately before
+          // the seek's side effect inside videoController.
+          queuedEpoch: context.scrollSeekEpoch,
+          getCurrentEpoch: () => self.getSnapshot().context.scrollSeekEpoch,
         }),
         onDone: "ready",
         onError: "ready",
@@ -304,6 +351,7 @@ export const syncMachine = setup({
       on: {
         TRANSCRIPT_SCROLL: {
           target: "scrollDriven",
+          guard: "canScrollSeek",
           reenter: true,
           actions: [
             "updateScrollProgress",
@@ -314,6 +362,9 @@ export const syncMachine = setup({
         SET_AUTO_SCROLL_ENABLED: {
           actions: ["setAutoScrollEnabled"],
         },
+        SET_SCROLL_TO_SEEK_ENABLED: {
+          actions: ["setScrollToSeekEnabled"],
+        },
         RESET: {
           target: "idle",
           actions: ["clearSync"],
@@ -357,6 +408,9 @@ export const syncMachine = setup({
         SET_AUTO_SCROLL_ENABLED: {
           actions: ["setAutoScrollEnabled"],
         },
+        SET_SCROLL_TO_SEEK_ENABLED: {
+          actions: ["setScrollToSeekEnabled"],
+        },
         RESET: {
           target: "idle",
           actions: ["clearSync"],
diff --git a/src/lib/sync/types.ts b/src/lib/sync/types.ts
index 41661c3..b2e6bbe 100644
--- a/src/lib/sync/types.ts
+++ b/src/lib/sync/types.ts
@@ -47,6 +47,23 @@ export interface SyncContext {
    * are unaffected; only the automatic scroll-into-view is silenced.
    */
   autoScrollEnabled: boolean;
+  /**
+   * Effective scroll-to-seek policy (the `scrollToSeek` prop AND NOT
+   * reading mode), pushed in from the panel. When false, `TRANSCRIPT_SCROLL`
+   * is ignored entirely — the machine never enters `scrollDriven` and never
+   * invokes `videoController`.
+   */
+  scrollToSeekEnabled: boolean;
+  /**
+   * Bumped on every `SET_SCROLL_TO_SEEK_ENABLED`. A scroll-driven seek
+   * queued in `scrollDriven` captures this value at invoke time and
+   * compares it against the live value immediately before calling
+   * `viewer.seekTo()` — see `videoController`'s `queuedEpoch`. This is what
+   * lets disabling the policy cancel a seek that is already awaiting viewer
+   * readiness, where a transition guard on the next event would be too
+   * late.
+   */
+  scrollSeekEpoch: number;
 }
 
 /**
@@ -63,6 +80,7 @@ export type SyncEvent =
   | { type: "VIDEO_TIME_UPDATE"; currentTime: number }
   | { type: "TRANSCRIPT_SCROLL"; scrollProgress: number; mappedTime: number }
   | { type: "SET_AUTO_SCROLL_ENABLED"; enabled: boolean }
+  | { type: "SET_SCROLL_TO_SEEK_ENABLED"; enabled: boolean }
   | { type: "RESET" };
 
 /**
@@ -76,6 +94,15 @@ export interface SyncConfig {
   settleMs: number;
   /** Duration to lock sync priority after user interaction (milliseconds) */
   priorityLockDuration: number;
+  /**
+   * Reports a genuine, deliberate transcript scroll — the same event that
+   * would drive `TRANSCRIPT_SCROLL`, after the auto-scroll-echo suppression
+   * and debounce throttle, regardless of whether scroll-to-seek is
+   * currently enabled. The panel uses this to enter Browsing when
+   * `scrollToSeek` is configured off; SyncController itself has no opinion
+   * on reading mode.
+   */
+  onUserScroll?: () => void;
 }
 
 /**
diff --git a/src/lib/transcript/Search.svelte b/src/lib/transcript/Search.svelte
index c387fc1..29f61ff 100644
--- a/src/lib/transcript/Search.svelte
+++ b/src/lib/transcript/Search.svelte
@@ -21,6 +21,46 @@
     onmatchchange?:
       | ((matches: Annotation[], currentIndex: number) => void)
       | undefined;
+    /**
+     * Synchronous input-intent callback, fired on every keystroke from the
+     * raw input event — before the debounce that drives `onmatchchange`.
+     * Search never acts on this itself; it exists for a host (or
+     * `TranscriptSearch`) to react to typing before matches resolve.
+     */
+    onqueryinput?: ((value: string) => void) | undefined;
+    /**
+     * Fired when the selected match is explicitly activated: Enter in the
+     * search input, or the "Go to match" button (rendered only when
+     * `showActivation` is true).
+     */
+    onmatchactivate?:
+      | ((annotation: Annotation, index: number) => void)
+      | undefined;
+    /**
+     * Fired only from explicit previous/next navigation, after `currentIndex`
+     * updates, with the newly-selected match — never from typing or
+     * activation. Lets a host (`TranscriptSearch`) scroll the browsed match
+     * into view without also auto-scrolling on every keystroke (spec: typing
+     * must not scroll).
+     */
+    onmatchnavigate?:
+      | ((annotation: Annotation, index: number) => void)
+      | undefined;
+    /**
+     * External reset signal (a context-level counter, typically). Any change
+     * from its previous value — not its initial value on mount — clears the
+     * query and resets selection to the first match. Lets a host clear the
+     * otherwise-private `query` state (e.g. on canvas switch) without a
+     * bindable query prop.
+     */
+    resetSignal?: number | undefined;
+    /**
+     * Renders the "Go to match" activation control and enables Enter-to-
+     * activate. Search stays agnostic about *why* — a host decides based on
+     * its own seek-behavior/reading-mode policy.
+     * @default false
+     */
+    showActivation?: boolean;
     /** CSS class for the search container */
     class?: string;
   }
@@ -30,6 +70,11 @@
     placeholder: placeholderProp,
     debounceMs = 150,
     onmatchchange,
+    onqueryinput,
+    onmatchactivate,
+    onmatchnavigate,
+    resetSignal,
+    showActivation = false,
     class: className = "",
   }: Props = $props();
 
@@ -40,6 +85,13 @@
   let query = $state("");
   let currentIndex = $state(0);
   let debounceTimeout: ReturnType<typeof setTimeout> | null = null;
+  let isComposing = $state(false);
+  // The input is intentionally uncontrolled (no `value={query}`) so typing
+  // never fights the debounce — the DOM owns the displayed text between
+  // keystrokes. An external reset (resetSignal, below) is the one path that
+  // must also clear what's visibly in the box, so it writes to the element
+  // directly rather than relying on a value binding.
+  let inputEl: HTMLInputElement | null = $state(null);
 
   // Derived: filter annotations by search query
   const matches = $derived.by(() => {
@@ -72,29 +124,105 @@
     if (debounceTimeout) clearTimeout(debounceTimeout);
   });
 
+  // External reset signal (canvas-switch query clearing — see the
+  // `resetSignal` prop doc). `previousResetSignal` is a plain variable
+  // (not $state), captured once at component setup, so the first run of the
+  // effect below always sees `current === previousResetSignal` and never
+  // fires on mount — same pattern as Transcript's `previousReadingMode`.
+  // svelte-ignore state_referenced_locally
+  let previousResetSignal = resetSignal;
+  $effect(() => {
+    const current = resetSignal;
+    if (current === previousResetSignal) return;
+    previousResetSignal = current;
+    if (debounceTimeout) {
+      clearTimeout(debounceTimeout);
+      debounceTimeout = null;
+    }
+    query = "";
+    currentIndex = 0;
+    if (inputEl) inputEl.value = "";
+  });
+
+  // Commits a query value immediately, cancelling any pending debounce.
+  // Resets the selection to the first match only when the query actually
+  // changes — an unchanged commit (e.g. Enter pressed with no pending edit)
+  // must not clobber a selection the reader navigated to via prev/next.
+  function commitQuery(value: string) {
+    if (debounceTimeout) {
+      clearTimeout(debounceTimeout);
+      debounceTimeout = null;
+    }
+    if (value !== query) {
+      query = value;
+      currentIndex = 0;
+    }
+  }
+
   // Debounced input handler
   function handleInput(event: Event) {
     const target = event.target as HTMLInputElement;
     const value = target.value;
 
+    // Synchronous intent signal — fires before debounce, on every keystroke.
+    onqueryinput?.(value);
+
     // Debounce search
     if (debounceTimeout) clearTimeout(debounceTimeout);
 
-    debounceTimeout = setTimeout(() => {
-      query = value;
-      currentIndex = 0;
-    }, debounceMs);
+    debounceTimeout = setTimeout(() => commitQuery(value), debounceMs);
+  }
+
+  function handleCompositionStart() {
+    isComposing = true;
   }
 
-  // Navigation
+  function handleCompositionEnd() {
+    isComposing = false;
+  }
+
+  // Activates the currently selected match. Reads `matches`/`currentIndex`
+  // fresh (both may have just been recomputed by `commitQuery`) rather than
+  // trusting a value that predates a synchronous query commit.
+  function activate() {
+    if (matches.length === 0) return;
+    const idx = currentIndex >= matches.length ? 0 : currentIndex;
+    const match = matches[idx];
+    if (!match) return;
+    if (idx !== currentIndex) currentIndex = idx;
+    onmatchactivate?.(match, idx);
+  }
+
+  function handleKeydown(event: KeyboardEvent) {
+    if (event.key !== "Enter") return;
+    if (!showActivation) return;
+    // IME composition guard: the isComposing flag tracked via
+    // compositionstart/end is the source of truth; event.isComposing is
+    // checked too for browsers that report it on the confirming keydown.
+    if (isComposing || event.isComposing) return;
+
+    event.preventDefault();
+    // Evaluate the current input first — never activate against a query
+    // that's still waiting on debounce.
+    commitQuery((event.currentTarget as HTMLInputElement).value);
+    activate();
+  }
+
+  // Navigation. Fires onmatchnavigate — distinct from the debounced
+  // onmatchchange — so a host can scroll the browsed match into view without
+  // also auto-scrolling on every keystroke (typing never scrolls).
   function navigatePrevious() {
     if (matches.length === 0) return;
     currentIndex = currentIndex <= 0 ? matches.length - 1 : currentIndex - 1;
+    const match = matches[currentIndex];
+    if (match) onmatchnavigate?.(match, currentIndex);
   }
 
   function navigateNext() {
     if (matches.length === 0) return;
     currentIndex = currentIndex >= matches.length - 1 ? 0 : currentIndex + 1;
+    const match = matches[currentIndex];
+    if (match) onmatchnavigate?.(match, currentIndex);
   }
 
   // Match count display
@@ -112,7 +240,11 @@
   <input
     type="search"
     {placeholder}
+    bind:this={inputEl}
     oninput={handleInput}
+    onkeydown={handleKeydown}
+    oncompositionstart={handleCompositionStart}
+    oncompositionend={handleCompositionEnd}
     aria-label={t("transcript.searchLabel")}
     autocomplete="off"
     spellcheck="false"
@@ -138,6 +270,16 @@
     >
       ↓
     </button>
+
+    {#if showActivation}
+      <button
+        type="button"
+        onclick={activate}
+        aria-label={t("transcript.searchActivate")}
+      >
+        {t("transcript.searchActivate")}
+      </button>
+    {/if}
   {/if}
 </div>
 
diff --git a/src/lib/transcript/Segment.svelte b/src/lib/transcript/Segment.svelte
index ced9f2f..95cf39a 100644
--- a/src/lib/transcript/Segment.svelte
+++ b/src/lib/transcript/Segment.svelte
@@ -2,7 +2,7 @@
 <script lang="ts">
   import type { Snippet } from "svelte";
   import type { Annotation } from "../sync/types";
-  import { formatTimestamp } from "./utils";
+  import { formatTimestamp, isTextSelectionActive } from "./utils";
 
   interface Props {
     /** Transcript annotation with timing and text */
@@ -59,6 +59,16 @@
     text,
     tabindex,
   }: Props = $props();
+
+  // A drag-to-select ending in a click must not also activate (seek) —
+  // selecting/copying transcript text is not a request to jump to that
+  // passage (docs/specs/transcript-reading-mode.md, "Reading mode").
+  // Keyboard activation (Enter/Space, below) always calls onclick directly —
+  // a keypress is never a drag, so it must keep working even mid-selection.
+  function handleClick() {
+    if (isTextSelectionActive()) return;
+    onclick?.();
+  }
 </script>
 
 <div
@@ -68,7 +78,7 @@
   data-highlighted={isHighlighted ? "true" : undefined}
   data-current-match={isCurrentMatch ? "true" : undefined}
   part={isActive ? "segment segment-active" : "segment"}
-  {onclick}
+  onclick={handleClick}
   onkeydown={(event) => {
     if (event.key === "Enter" || event.key === " ") {
       event.preventDefault();
diff --git a/src/lib/transcript/utils.ts b/src/lib/transcript/utils.ts
index ac10cb8..624a390 100644
--- a/src/lib/transcript/utils.ts
+++ b/src/lib/transcript/utils.ts
@@ -14,6 +14,17 @@ export function formatTimestamp(seconds: number): string {
   return `${mins}:${secs.toString().padStart(2, "0")}`;
 }
 
+/**
+ * True when a non-collapsed, non-empty text selection currently exists.
+ * Used to suppress click-activation at the end of a drag-to-select gesture —
+ * selecting/copying transcript text is not a request to jump to that
+ * passage (docs/specs/transcript-reading-mode.md, "Reading mode").
+ */
+export function isTextSelectionActive(): boolean {
+  const sel = typeof window !== "undefined" ? window.getSelection() : null;
+  return !!sel && !sel.isCollapsed && sel.toString().trim() !== "";
+}
+
 /**
  * Find annotation by ID
  */
diff --git a/src/test/player/TestTranscriptReadingMode.svelte b/src/test/player/TestTranscriptReadingMode.svelte
new file mode 100644
index 0000000..2e625cd
--- /dev/null
+++ b/src/test/player/TestTranscriptReadingMode.svelte
@@ -0,0 +1,58 @@
+<!--
+  Test wrapper for the reading-mode acceptance rows (docs/specs/
+  transcript-reading-mode.md): a single Transcript + TranscriptSegments
+  panel with `scrollToSeek` and a bindable `readingMode` exposed as props,
+  plus `setReadingMode` — an exported imperative setter that mutates the
+  bound value exactly the way an external host's own `bind:readingMode`
+  would, standing in for a "host property write" from outside the panel
+  (as opposed to a click on the panel's own Follow along switch / Jump to
+  current button).
+
+  `context` is read once at init, same contract as the other Test*Harness
+  components in this directory: setPlayerContext must run during
+  initialization and the test never reassigns the prop.
+-->
+<script lang="ts">
+  import { setPlayerContext } from "../../lib/player/context";
+  import type { PlayerContext } from "../../lib/player/context";
+  import Transcript from "../../lib/player/Transcript.svelte";
+  import TranscriptSegments from "../../lib/player/TranscriptSegments.svelte";
+  import TestTranscriptContextConsumer from "./TestTranscriptContextConsumer.svelte";
+  import type { TranscriptContext } from "../../lib/player/transcript-context";
+  import type { Annotation } from "../../lib/sync/types";
+
+  interface Props {
+    context: PlayerContext;
+    annotations: Annotation[];
+    scrollToSeek?: boolean;
+    readingMode?: boolean;
+    onContextReady?: (ctx: TranscriptContext) => void;
+  }
+
+  let {
+    context,
+    annotations,
+    scrollToSeek,
+    readingMode = $bindable(false),
+    onContextReady,
+  }: Props = $props();
+
+  // svelte-ignore state_referenced_locally
+  setPlayerContext(context);
+
+  /** Simulates an external host property write (not the panel's own UI). */
+  export function setReadingMode(value: boolean) {
+    readingMode = value;
+  }
+</script>
+
+<Transcript
+  {annotations}
+  {...scrollToSeek === undefined ? {} : { scrollToSeek }}
+  bind:readingMode
+>
+  {#if onContextReady}
+    <TestTranscriptContextConsumer onResult={onContextReady} />
+  {/if}
+  <TranscriptSegments />
+</Transcript>
diff --git a/src/test/player/TestTranscriptWithSearch.svelte b/src/test/player/TestTranscriptWithSearch.svelte
new file mode 100644
index 0000000..21cadba
--- /dev/null
+++ b/src/test/player/TestTranscriptWithSearch.svelte
@@ -0,0 +1,56 @@
+<!--
+  Test wrapper that sets PlayerContext and mounts Transcript with
+  TranscriptSearch as a compound child, so tests can exercise the real
+  Search -> TranscriptSearch -> Transcript -> PlayerContext wiring (typing,
+  Enter, browsing, activation) through actual user interactions rather than
+  a captured context.
+
+  `context` is read once at init: setPlayerContext must run during
+  initialization and the test never reassigns the prop (same contract as
+  TestContextHarness). annotations is uncontrolled after mount — driven
+  imperatively via setAnnotations, following TestRootAnnotationsWrapper's
+  pattern — so tests can exercise annotation replacement without a remount.
+-->
+<script lang="ts">
+  import { setPlayerContext } from "../../lib/player/context";
+  import type { PlayerContext } from "../../lib/player/context";
+  import Transcript from "../../lib/player/Transcript.svelte";
+  import TranscriptSearch from "../../lib/player/TranscriptSearch.svelte";
+  import TestTranscriptContextConsumer from "./TestTranscriptContextConsumer.svelte";
+  import type { Annotation } from "../../lib/sync/types";
+  import type { TranscriptContext } from "../../lib/player/transcript-context";
+
+  interface Props {
+    context: PlayerContext;
+    annotations?: Annotation[];
+    searchSeekBehavior?: "change" | "activate";
+    onContextReady?: (ctx: TranscriptContext) => void;
+  }
+
+  let {
+    context,
+    annotations: initialAnnotations,
+    searchSeekBehavior,
+    onContextReady,
+  }: Props = $props();
+
+  // svelte-ignore state_referenced_locally
+  setPlayerContext(context);
+
+  // svelte-ignore state_referenced_locally
+  let annotations = $state<Annotation[] | undefined>(initialAnnotations);
+
+  export function setAnnotations(value: Annotation[]) {
+    annotations = value;
+  }
+</script>
+
+<Transcript
+  {...annotations ? { annotations } : {}}
+  {...searchSeekBehavior ? { searchSeekBehavior } : {}}
+>
+  {#if onContextReady}
+    <TestTranscriptContextConsumer onResult={onContextReady} />
+  {/if}
+  <TranscriptSearch />
+</Transcript>
diff --git a/src/test/player/TestTranscriptWithSegments.svelte b/src/test/player/TestTranscriptWithSegments.svelte
index afcb0f0..879a708 100644
--- a/src/test/player/TestTranscriptWithSegments.svelte
+++ b/src/test/player/TestTranscriptWithSegments.svelte
@@ -14,15 +14,20 @@
     // Optional: when omitted, Transcript falls back to PlayerContext
     // annotations (exercised by the context-fallback capture tests).
     annotations?: Annotation[];
+    searchSeekBehavior?: "change" | "activate";
     onContextReady?: (ctx: TranscriptContext) => void;
   }
 
-  let { annotations, onContextReady }: Props = $props();
+  let { annotations, searchSeekBehavior, onContextReady }: Props = $props();
 </script>
 
-<!-- Omit the annotations prop entirely when undefined so Transcript falls back
-     to PlayerContext annotations (and to satisfy exactOptionalPropertyTypes). -->
-<Transcript {...annotations ? { annotations } : {}}>
+<!-- Omit the annotations/searchSeekBehavior props entirely when undefined so
+     Transcript falls back to PlayerContext annotations and its own default
+     (and to satisfy exactOptionalPropertyTypes). -->
+<Transcript
+  {...annotations ? { annotations } : {}}
+  {...searchSeekBehavior ? { searchSeekBehavior } : {}}
+>
   {#if onContextReady}
     <TestTranscriptContextConsumer onResult={onContextReady} />
   {/if}
diff --git a/src/test/player/TestTwoReadingModePanels.svelte b/src/test/player/TestTwoReadingModePanels.svelte
new file mode 100644
index 0000000..15c398d
--- /dev/null
+++ b/src/test/player/TestTwoReadingModePanels.svelte
@@ -0,0 +1,49 @@
+<!--
+  Test wrapper for the "two-panel independence" acceptance row: two
+  Transcript + TranscriptSegments panels under the same player context,
+  each with its own annotations and its own captured TranscriptContext, so
+  a test can toggle reading mode on one panel and assert the other's
+  reading state (and scroll-to-seek behavior) is untouched.
+-->
+<script lang="ts">
+  import { setPlayerContext } from "../../lib/player/context";
+  import type { PlayerContext } from "../../lib/player/context";
+  import Transcript from "../../lib/player/Transcript.svelte";
+  import TranscriptSegments from "../../lib/player/TranscriptSegments.svelte";
+  import TestTranscriptContextConsumer from "./TestTranscriptContextConsumer.svelte";
+  import type { TranscriptContext } from "../../lib/player/transcript-context";
+  import type { Annotation } from "../../lib/sync/types";
+
+  interface Props {
+    context: PlayerContext;
+    annotationsA: Annotation[];
+    annotationsB: Annotation[];
+    onContextReadyA: (ctx: TranscriptContext) => void;
+    onContextReadyB: (ctx: TranscriptContext) => void;
+  }
+
+  let {
+    context,
+    annotationsA,
+    annotationsB,
+    onContextReadyA,
+    onContextReadyB,
+  }: Props = $props();
+
+  // svelte-ignore state_referenced_locally
+  setPlayerContext(context);
+</script>
+
+<div class="panel-a">
+  <Transcript annotations={annotationsA}>
+    <TestTranscriptContextConsumer onResult={onContextReadyA} />
+    <TranscriptSegments />
+  </Transcript>
+</div>
+
+<div class="panel-b">
+  <Transcript annotations={annotationsB}>
+    <TestTranscriptContextConsumer onResult={onContextReadyB} />
+    <TranscriptSegments />
+  </Transcript>
+</div>
diff --git a/src/test/player/Transcript.readingMode.svelte.test.ts b/src/test/player/Transcript.readingMode.svelte.test.ts
new file mode 100644
index 0000000..0ab2949
--- /dev/null
+++ b/src/test/player/Transcript.readingMode.svelte.test.ts
@@ -0,0 +1,453 @@
+// src/test/player/Transcript.readingMode.svelte.test.ts
+//
+// Step 2 of docs/specs/transcript-reading-mode.md: the synchronization
+// policy and the reading/return controls. Covers the acceptance-gate rows
+// assigned to this step: scroll-with-seek-off, enable-reading-mode-while-
+// seek-on, return inside-cue, return between-cue, policy-off-mid-seek (+ no
+// replay — see src/test/sync/syncMachine.test.ts and
+// src/test/sync/videoController.test.ts for the machine/actor-level
+// coverage of that row), two-panel independence, return focus ownership vs
+// host write, and single-folded-control. Search-activation coverage lives
+// in Transcript.searchSeekBehavior.svelte.test.ts (step 1); the custom
+// element and docs are step 3.
+import { describe, test, expect } from "vitest";
+import { flushSync } from "svelte";
+import { render } from "vitest-browser-svelte";
+import TestTranscriptReadingMode from "./TestTranscriptReadingMode.svelte";
+import TestTwoReadingModePanels from "./TestTwoReadingModePanels.svelte";
+import { createMockPlayerContext } from "./test-utils";
+import type { Annotation } from "../../lib/sync/types";
+import type { TranscriptContext } from "../../lib/player/transcript-context";
+
+// render() from vitest-browser-svelte auto-unmounts each component between
+// tests (no manual target/afterEach teardown).
+describe("Transcript reading mode", () => {
+  const mockAnnotations: Annotation[] = [
+    { id: "a1", startTime: 0, endTime: 5, text: "First annotation" },
+    { id: "a2", startTime: 5, endTime: 10, text: "Second annotation" },
+    { id: "a3", startTime: 10, endTime: 15, text: "Third annotation" },
+  ];
+
+  describe("Single folded control across surfaces", () => {
+    test("exactly one track-audio control (Follow along); no separate pause-auto-scroll button", () => {
+      const ctx = createMockPlayerContext();
+      const { container } = render(TestTranscriptReadingMode, {
+        props: { context: ctx, annotations: mockAnnotations },
+      });
+      flushSync();
+
+      expect(container.querySelector(".auto-scroll-toggle")).toBeNull();
+
+      const switches = container.querySelectorAll('[role="switch"]');
+      expect(switches).toHaveLength(1);
+      const toggle = switches[0] as HTMLButtonElement;
+      expect(toggle.getAttribute("aria-checked")).toBe("true");
+      expect(toggle.getAttribute("data-following")).toBe("true");
+
+      // Jump to current does not exist while Following.
+      expect(container.querySelector(".jump-to-current")).toBeNull();
+    });
+
+    test("Jump to current appears only while Browsing", () => {
+      const ctx = createMockPlayerContext();
+      const { container } = render(TestTranscriptReadingMode, {
+        props: { context: ctx, annotations: mockAnnotations },
+      });
+      flushSync();
+
+      const followSwitch = container.querySelector(
+        ".follow-along-switch",
+      ) as HTMLButtonElement;
+      followSwitch.click();
+      flushSync();
+
+      expect(followSwitch.getAttribute("aria-checked")).toBe("false");
+      expect(container.querySelector(".jump-to-current")).not.toBeNull();
+    });
+  });
+
+  describe("Scroll with scroll-to-seek off", () => {
+    test("a deliberate scroll enters reading mode; no seek, and playback-driven scroll stops", async () => {
+      // SyncController is only created once a mediaElement is present (see
+      // Transcript's controller-creation effect) — the default mock leaves
+      // it null, so a live controller (and its DOM scroll listener) needs a
+      // stub element here.
+      const ctx = createMockPlayerContext({
+        mediaElement: document.createElement("audio"),
+      });
+      let capturedCtx: TranscriptContext | null = null;
+
+      const { container } = render(TestTranscriptReadingMode, {
+        props: {
+          context: ctx,
+          annotations: mockAnnotations,
+          scrollToSeek: false,
+          onContextReady: (c) => {
+            capturedCtx = c;
+          },
+        },
+      });
+      flushSync();
+
+      expect(capturedCtx!.state.readingMode).toBe(false);
+
+      const panel = container.querySelector(".transcript-panel") as HTMLElement;
+      const segments = container.querySelectorAll<HTMLElement>(
+        "[data-annotation-id]",
+      );
+      expect(segments.length).toBeGreaterThan(0);
+      panel.style.cssText =
+        "height: 60px; max-height: 60px; overflow-y: scroll; scroll-behavior: auto";
+      for (const segment of segments) segment.style.minHeight = "80px";
+      const maxScroll = panel.scrollHeight - panel.clientHeight;
+      expect(maxScroll).toBeGreaterThan(0);
+
+      let browserScrollSeen = false;
+      panel.addEventListener("scroll", (event) => {
+        browserScrollSeen ||= event.isTrusted;
+      });
+      // A real, trusted scroll — not a player action, not a synthetic event.
+      panel.scrollTop = maxScroll;
+      await new Promise<void>((resolve) => {
+        const check = () => {
+          if (browserScrollSeen) resolve();
+          else requestAnimationFrame(check);
+        };
+        check();
+      });
+      flushSync();
+
+      expect(ctx.actions.seekTo).not.toHaveBeenCalled();
+      expect(capturedCtx!.state.readingMode).toBe(true);
+
+      const followSwitch = container.querySelector(
+        ".follow-along-switch",
+      ) as HTMLButtonElement;
+      expect(followSwitch.getAttribute("aria-checked")).toBe("false");
+    });
+  });
+
+  describe("Enable reading mode while scroll-to-seek is on", () => {
+    test("scroll->seek and media->scroll both stop; explicit segment activation still seeks", () => {
+      const ctx = createMockPlayerContext();
+      let capturedCtx: TranscriptContext | null = null;
+
+      const { container } = render(TestTranscriptReadingMode, {
+        props: {
+          context: ctx,
+          annotations: mockAnnotations,
+          scrollToSeek: true,
+          onContextReady: (c) => {
+            capturedCtx = c;
+          },
+        },
+      });
+      flushSync();
+
+      const followSwitch = container.querySelector(
+        ".follow-along-switch",
+      ) as HTMLButtonElement;
+      followSwitch.click();
+      flushSync();
+
+      expect(capturedCtx!.state.readingMode).toBe(true);
+
+      // Explicit segment activation is unaffected by reading mode.
+      const segment = container.querySelector(
+        '[data-annotation-id="a2"]',
+      ) as HTMLElement;
+      segment.click();
+      flushSync();
+
+      expect(ctx.actions.seekTo).toHaveBeenCalledWith(5);
+    });
+  });
+
+  describe("Return", () => {
+    test("current time inside a cue: scrolls the active cue into view, no seek, returns to Following", () => {
+      const anns: Annotation[] = [
+        { id: "before", startTime: 0, endTime: 60, text: "Before" },
+        { id: "active", startTime: 70, endTime: 80, text: "Active cue" },
+        { id: "after", startTime: 90, endTime: 100, text: "After" },
+      ];
+      const ctx = createMockPlayerContext({ state: { currentTime: 75 } });
+      let capturedCtx: TranscriptContext | null = null;
+
+      const { container } = render(TestTranscriptReadingMode, {
+        props: {
+          context: ctx,
+          annotations: anns,
+          readingMode: true,
+          onContextReady: (c) => {
+            capturedCtx = c;
+          },
+        },
+      });
+      flushSync();
+      expect(capturedCtx!.state.readingMode).toBe(true);
+
+      const active = container.querySelector(
+        '[data-annotation-id="active"]',
+      ) as HTMLElement;
+      let called = 0;
+      active.scrollIntoView = () => {
+        called++;
+      };
+
+      capturedCtx!.actions.returnToFollowing();
+      flushSync();
+
+      expect(called).toBe(1);
+      expect(ctx.actions.seekTo).not.toHaveBeenCalled();
+      expect(capturedCtx!.state.readingMode).toBe(false);
+    });
+
+    test("current time between cues: scrolls the next cue into view without marking it active, no seek, returns to Following", () => {
+      const anns: Annotation[] = [
+        { id: "before", startTime: 0, endTime: 60, text: "Before" },
+        { id: "next", startTime: 90, endTime: 100, text: "Next cue" },
+        { id: "after", startTime: 110, endTime: 120, text: "After" },
+      ];
+      const ctx = createMockPlayerContext({ state: { currentTime: 75 } });
+      let capturedCtx: TranscriptContext | null = null;
+
+      const { container } = render(TestTranscriptReadingMode, {
+        props: {
+          context: ctx,
+          annotations: anns,
+          readingMode: true,
+          onContextReady: (c) => {
+            capturedCtx = c;
+          },
+        },
+      });
+      flushSync();
+
+      const next = container.querySelector(
+        '[data-annotation-id="next"]',
+      ) as HTMLElement;
+      let called = 0;
+      next.scrollIntoView = () => {
+        called++;
+      };
+
+      capturedCtx!.actions.returnToFollowing();
+      flushSync();
+
+      expect(called).toBe(1);
+      expect(ctx.actions.seekTo).not.toHaveBeenCalled();
+      expect(capturedCtx!.state.readingMode).toBe(false);
+      expect(capturedCtx!.state.activeAnnotationId).not.toBe("next");
+    });
+
+    test("no annotations: returns to Following without scrolling and without a fallback seek", () => {
+      // With zero annotations Transcript renders its empty state instead of
+      // `children` (so the context-capturing consumer never mounts) — drive
+      // the return through the bindable prop itself, the same "host
+      // property write" path used below, rather than the context action.
+      const ctx = createMockPlayerContext({ state: { currentTime: 75 } });
+
+      const { component: wrapper } = render(TestTranscriptReadingMode, {
+        props: {
+          context: ctx,
+          annotations: [],
+          readingMode: true,
+        },
+      });
+      flushSync();
+
+      expect(() => {
+        (
+          wrapper as unknown as { setReadingMode: (v: boolean) => void }
+        ).setReadingMode(false);
+      }).not.toThrow();
+      flushSync();
+
+      expect(ctx.actions.seekTo).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("Return focus ownership vs host property write", () => {
+    test("focus moves to the Follow along switch only when Jump to current owned focus", () => {
+      const ctx = createMockPlayerContext({ state: { currentTime: 2 } });
+      const { container } = render(TestTranscriptReadingMode, {
+        props: { context: ctx, annotations: mockAnnotations },
+      });
+      flushSync();
+
+      const followSwitch = container.querySelector(
+        ".follow-along-switch",
+      ) as HTMLButtonElement;
+      followSwitch.click();
+      flushSync();
+
+      const jumpButton = container.querySelector(
+        ".jump-to-current",
+      ) as HTMLButtonElement;
+      expect(jumpButton).not.toBeNull();
+      jumpButton.focus();
+      expect(document.activeElement).toBe(jumpButton);
+
+      jumpButton.click();
+      flushSync();
+
+      expect(container.querySelector(".jump-to-current")).toBeNull();
+      expect(document.activeElement).toBe(followSwitch);
+    });
+
+    test("returning to Following via a host property write does not move focus", () => {
+      const ctx = createMockPlayerContext({ state: { currentTime: 2 } });
+      const { container, component: wrapper } = render(
+        TestTranscriptReadingMode,
+        {
+          props: {
+            context: ctx,
+            annotations: mockAnnotations,
+            readingMode: true,
+          },
+        },
+      );
+      flushSync();
+
+      // Something else on the page owns focus — not the Jump button.
+      const decoy = document.createElement("input");
+      document.body.appendChild(decoy);
+      decoy.focus();
+      expect(document.activeElement).toBe(decoy);
+
+      // A host writes the bindable prop directly (not a click on our own
+      // Jump to current button).
+      (
+        wrapper as unknown as { setReadingMode: (v: boolean) => void }
+      ).setReadingMode(false);
+      flushSync();
+
+      expect(container.querySelector(".jump-to-current")).toBeNull();
+      expect(document.activeElement).toBe(decoy);
+
+      decoy.remove();
+    });
+  });
+
+  describe("Two-panel independence", () => {
+    test("reading state stays independent per panel", () => {
+      const ctx = createMockPlayerContext();
+      let capturedA: TranscriptContext | null = null;
+      let capturedB: TranscriptContext | null = null;
+
+      const annotationsA: Annotation[] = [
+        { id: "pa1", startTime: 0, endTime: 5, text: "Panel A first" },
+      ];
+      const annotationsB: Annotation[] = [
+        { id: "pb1", startTime: 0, endTime: 5, text: "Panel B first" },
+      ];
+
+      const { container } = render(TestTwoReadingModePanels, {
+        props: {
+          context: ctx,
+          annotationsA,
+          annotationsB,
+          onContextReadyA: (c: TranscriptContext) => {
+            capturedA = c;
+          },
+          onContextReadyB: (c: TranscriptContext) => {
+            capturedB = c;
+          },
+        },
+      });
+      flushSync();
+
+      expect(capturedA!.state.readingMode).toBe(false);
+      expect(capturedB!.state.readingMode).toBe(false);
+
+      capturedA!.actions.enterBrowsing();
+      flushSync();
+
+      expect(capturedA!.state.readingMode).toBe(true);
+      expect(capturedB!.state.readingMode).toBe(false);
+
+      // Panel B's own Follow along switch still reflects Following.
+      const panelBSwitch = container.querySelector(
+        ".panel-b .follow-along-switch",
+      ) as HTMLButtonElement;
+      expect(panelBSwitch.getAttribute("aria-checked")).toBe("true");
+
+      // Panel B's explicit segment activation still seeks — its
+      // SyncController was never disabled by panel A entering Browsing.
+      const panelBSegment = container.querySelector(
+        '.panel-b [data-annotation-id="pb1"]',
+      ) as HTMLElement;
+      panelBSegment.click();
+      flushSync();
+      expect(ctx.actions.seekTo).toHaveBeenCalledWith(0);
+    });
+  });
+
+  describe("Mode-change announcement (Finding 5)", () => {
+    test("does not announce on mount", () => {
+      const ctx = createMockPlayerContext();
+      const { container } = render(TestTranscriptReadingMode, {
+        props: { context: ctx, annotations: mockAnnotations },
+      });
+      flushSync();
+
+      const liveRegion = container.querySelector(".sr-only");
+      expect(liveRegion?.textContent).toBe("");
+    });
+
+    test("entering Browsing (Follow along off) announces the Browsing message", () => {
+      const ctx = createMockPlayerContext();
+      const { container } = render(TestTranscriptReadingMode, {
+        props: { context: ctx, annotations: mockAnnotations },
+      });
+      flushSync();
+
+      const followSwitch = container.querySelector(
+        ".follow-along-switch",
+      ) as HTMLButtonElement;
+      followSwitch.click();
+      flushSync();
+
+      const liveRegion = container.querySelector(".sr-only");
+      expect(liveRegion?.textContent).toBe("Browsing — playback continues");
+    });
+
+    test("returning to Following (Jump to current) announces the Following message", () => {
+      const ctx = createMockPlayerContext();
+      const { container } = render(TestTranscriptReadingMode, {
+        props: {
+          context: ctx,
+          annotations: mockAnnotations,
+          readingMode: true,
+        },
+      });
+      flushSync();
+
+      const jumpButton = container.querySelector(
+        ".jump-to-current",
+      ) as HTMLButtonElement;
+      jumpButton.click();
+      flushSync();
+
+      const liveRegion = container.querySelector(".sr-only");
+      expect(liveRegion?.textContent).toBe("Following playback");
+    });
+
+    test("a host property write that flips readingMode also announces", () => {
+      const ctx = createMockPlayerContext();
+      const { container, component: wrapper } = render(
+        TestTranscriptReadingMode,
+        { props: { context: ctx, annotations: mockAnnotations } },
+      );
+      flushSync();
+
+      (
+        wrapper as unknown as { setReadingMode: (v: boolean) => void }
+      ).setReadingMode(true);
+      flushSync();
+
+      const liveRegion = container.querySelector(".sr-only");
+      expect(liveRegion?.textContent).toBe("Browsing — playback continues");
+    });
+  });
+});
diff --git a/src/test/player/Transcript.searchSeekBehavior.svelte.test.ts b/src/test/player/Transcript.searchSeekBehavior.svelte.test.ts
new file mode 100644
index 0000000..cd9bfc8
--- /dev/null
+++ b/src/test/player/Transcript.searchSeekBehavior.svelte.test.ts
@@ -0,0 +1,403 @@
+// src/test/player/Transcript.searchSeekBehavior.svelte.test.ts
+//
+// Covers the "Separate match UPDATES from match ACTIVATION" acceptance-gate
+// rows (docs/specs/transcript-reading-mode.md): activate-mode type/browse/
+// activate, clearing the query / zero results / replacing annotations, and
+// the two legacy change-mode regression rows. Reading-mode controls and the
+// sync concurrency fix are out of scope here (later steps).
+import { describe, test, expect, vi } from "vitest";
+import { flushSync } from "svelte";
+import { render } from "vitest-browser-svelte";
+import TestContextHarness from "./TestContextHarness.svelte";
+import TestTranscriptWithSegments from "./TestTranscriptWithSegments.svelte";
+import TestTranscriptWithSearch from "./TestTranscriptWithSearch.svelte";
+import { createMockPlayerContext } from "./test-utils";
+import type { Annotation } from "../../lib/sync/types";
+import type { TranscriptContext } from "../../lib/player/transcript-context";
+
+// render() from vitest-browser-svelte auto-unmounts each component between
+// tests (no manual target/afterEach teardown).
+describe("Transcript searchSeekBehavior", () => {
+  const mockAnnotations: Annotation[] = [
+    { id: "a1", startTime: 0, endTime: 5, text: "Hello world" },
+    { id: "a2", startTime: 5, endTime: 10, text: "Goodbye world" },
+    { id: "a3", startTime: 100, endTime: 120, text: "Testing search" },
+  ];
+
+  async function typeQuery(container: HTMLElement, query: string) {
+    const input = container.querySelector(
+      'input[type="search"]',
+    ) as HTMLInputElement;
+    input.value = query;
+    input.dispatchEvent(new Event("input", { bubbles: true }));
+    await new Promise((r) => setTimeout(r, 200));
+    flushSync();
+  }
+
+  test("context state defaults searchSeekBehavior to change", () => {
+    const playerCtx = createMockPlayerContext();
+    let capturedCtx: TranscriptContext | null = null;
+
+    render(TestContextHarness, {
+      props: {
+        context: playerCtx,
+        component: TestTranscriptWithSegments,
+        props: {
+          annotations: mockAnnotations,
+          onContextReady: (ctx: TranscriptContext) => {
+            capturedCtx = ctx;
+          },
+        },
+      },
+    });
+    flushSync();
+
+    expect(capturedCtx!.state.searchSeekBehavior).toBe("change");
+  });
+
+  test("context state reflects an explicit searchSeekBehavior prop", () => {
+    const playerCtx = createMockPlayerContext();
+    let capturedCtx: TranscriptContext | null = null;
+
+    render(TestContextHarness, {
+      props: {
+        context: playerCtx,
+        component: TestTranscriptWithSegments,
+        props: {
+          annotations: mockAnnotations,
+          searchSeekBehavior: "activate",
+          onContextReady: (ctx: TranscriptContext) => {
+            capturedCtx = ctx;
+          },
+        },
+      },
+    });
+    flushSync();
+
+    expect(capturedCtx!.state.searchSeekBehavior).toBe("activate");
+  });
+
+  describe("legacy 'change' mode (default) — Existing integration with no new props", () => {
+    test("handleMatchChange still seeks on match select (regression)", () => {
+      const playerCtx = createMockPlayerContext();
+      let capturedCtx: TranscriptContext | null = null;
+
+      render(TestContextHarness, {
+        props: {
+          context: playerCtx,
+          component: TestTranscriptWithSegments,
+          props: {
+            annotations: mockAnnotations,
+            onContextReady: (ctx: TranscriptContext) => {
+              capturedCtx = ctx;
+            },
+          },
+        },
+      });
+      flushSync();
+
+      capturedCtx!.actions.handleMatchChange([mockAnnotations[1]!], 0);
+
+      expect(playerCtx.actions.seekTo).toHaveBeenCalledWith(5);
+    });
+
+    test("typing a query end-to-end still seeks to the selected match (no activation control renders)", async () => {
+      const playerCtx = createMockPlayerContext();
+
+      const { container } = render(TestTranscriptWithSearch, {
+        props: { context: playerCtx, annotations: mockAnnotations },
+      });
+      flushSync();
+
+      await typeQuery(container, "world");
+
+      expect(playerCtx.actions.seekTo).toHaveBeenCalledWith(0); // a1's startTime
+      expect(
+        container.querySelector('button[aria-label="Go to match"]'),
+      ).toBeNull();
+    });
+
+    test("Query and canvas switch in legacy change mode: the query persists across annotation replacement (not cleared by the new rule)", async () => {
+      const playerCtx = createMockPlayerContext();
+
+      const { container, component: wrapper } = render(
+        TestTranscriptWithSearch,
+        {
+          props: { context: playerCtx, annotations: mockAnnotations },
+        },
+      );
+      flushSync();
+
+      await typeQuery(container, "world");
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      expect(input.value).toBe("world");
+
+      // Simulate a canvas switch: a new annotations array replaces the old
+      // one. Legacy behavior does not clear the query or otherwise reset
+      // Search — it re-filters the same committed query against the new
+      // array, exactly as an ordinary annotations-prop change always has.
+      const replacement: Annotation[] = [
+        { id: "b1", startTime: 20, endTime: 25, text: "A brave new world" },
+      ];
+      wrapper.setAnnotations(replacement);
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      expect(input.value).toBe("world");
+      const counter = container.querySelector(".match-counter");
+      expect(counter?.textContent).toBe("1 of 1");
+    });
+  });
+
+  describe("'activate' mode", () => {
+    test("Playing at 30s; typing a query matching a later annotation does not seek, play, or pause", async () => {
+      const playerCtx = createMockPlayerContext({
+        state: { currentTime: 30, isPlaying: true },
+      });
+      let capturedCtx: TranscriptContext | null = null;
+
+      const { container } = render(TestTranscriptWithSearch, {
+        props: {
+          context: playerCtx,
+          annotations: mockAnnotations,
+          searchSeekBehavior: "activate",
+          onContextReady: (c: TranscriptContext) => {
+            capturedCtx = c;
+          },
+        },
+      });
+      flushSync();
+      expect(capturedCtx!.state.readingMode).toBe(false);
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "Testing"; // matches a3, startTime 100
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      flushSync();
+
+      // Synchronously, before debounce: no playback call yet, but Browsing
+      // is already entered (docs/specs/transcript-reading-mode.md,
+      // "Search" item 2 — "enters Browsing immediately on input").
+      expect(playerCtx.actions.seekTo).not.toHaveBeenCalled();
+      expect(capturedCtx!.state.readingMode).toBe(true);
+
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+
+      // Match count reflects the resolved match after debounce.
+      const counter = container.querySelector(".match-counter");
+      expect(counter?.textContent).toBe("1 of 1");
+
+      expect(playerCtx.actions.seekTo).not.toHaveBeenCalled();
+      expect(playerCtx.actions.play).not.toHaveBeenCalled();
+      expect(playerCtx.actions.pause).not.toHaveBeenCalled();
+    });
+
+    test("Paused at 30s; browsing next/previous matches does not seek or change play state", async () => {
+      const playerCtx = createMockPlayerContext({
+        state: { currentTime: 30, isPlaying: false },
+      });
+
+      const { container } = render(TestTranscriptWithSearch, {
+        props: {
+          context: playerCtx,
+          annotations: mockAnnotations,
+          searchSeekBehavior: "activate",
+        },
+      });
+      flushSync();
+
+      await typeQuery(container, "world"); // a1, a2
+
+      const nextBtn = container.querySelector(
+        'button[aria-label="Next match"]',
+      ) as HTMLButtonElement;
+      nextBtn.click();
+      flushSync();
+      const prevBtn = container.querySelector(
+        'button[aria-label="Previous match"]',
+      ) as HTMLButtonElement;
+      prevBtn.click();
+      flushSync();
+
+      expect(playerCtx.actions.seekTo).not.toHaveBeenCalled();
+      expect(playerCtx.actions.play).not.toHaveBeenCalled();
+      expect(playerCtx.actions.pause).not.toHaveBeenCalled();
+    });
+
+    test("Activating a match seeks exactly once, without touching play state or rate", async () => {
+      const playerCtx = createMockPlayerContext({
+        state: { currentTime: 30, isPlaying: true, playbackRate: 1 },
+      });
+
+      const { container } = render(TestTranscriptWithSearch, {
+        props: {
+          context: playerCtx,
+          annotations: mockAnnotations,
+          searchSeekBehavior: "activate",
+        },
+      });
+      flushSync();
+
+      await typeQuery(container, "Testing"); // a3, startTime 100
+
+      const goBtn = container.querySelector(
+        'button[aria-label="Go to match"]',
+      ) as HTMLButtonElement;
+      expect(goBtn).not.toBeNull();
+      goBtn.click();
+
+      expect(playerCtx.actions.seekTo).toHaveBeenCalledTimes(1);
+      expect(playerCtx.actions.seekTo).toHaveBeenCalledWith(100);
+      expect(playerCtx.actions.play).not.toHaveBeenCalled();
+      expect(playerCtx.actions.pause).not.toHaveBeenCalled();
+      expect(playerCtx.actions.setPlaybackRate).not.toHaveBeenCalled();
+    });
+
+    test("clearing the query does not seek", async () => {
+      const playerCtx = createMockPlayerContext();
+
+      const { container } = render(TestTranscriptWithSearch, {
+        props: {
+          context: playerCtx,
+          annotations: mockAnnotations,
+          searchSeekBehavior: "activate",
+        },
+      });
+      flushSync();
+
+      await typeQuery(container, "world");
+      await typeQuery(container, "");
+
+      expect(playerCtx.actions.seekTo).not.toHaveBeenCalled();
+    });
+
+    test("a query with zero results does not seek", async () => {
+      const playerCtx = createMockPlayerContext();
+
+      const { container } = render(TestTranscriptWithSearch, {
+        props: {
+          context: playerCtx,
+          annotations: mockAnnotations,
+          searchSeekBehavior: "activate",
+        },
+      });
+      flushSync();
+
+      await typeQuery(container, "zzzzz");
+
+      expect(playerCtx.actions.seekTo).not.toHaveBeenCalled();
+    });
+
+    test("replacing annotations recalculates matches and clamps selection without seeking", async () => {
+      const playerCtx = createMockPlayerContext();
+
+      const { container, component: wrapper } = render(
+        TestTranscriptWithSearch,
+        {
+          props: {
+            context: playerCtx,
+            annotations: mockAnnotations,
+            searchSeekBehavior: "activate",
+          },
+        },
+      );
+      flushSync();
+
+      await typeQuery(container, "world"); // matches a1, a2 from the current canvas
+      expect(playerCtx.actions.seekTo).not.toHaveBeenCalled();
+
+      // Replace with a different canvas's annotations (simulates a canvas
+      // switch) — the query re-filters the new array via Search's own
+      // $derived, still with no implicit seek.
+      const replacement: Annotation[] = [
+        { id: "b1", startTime: 0, endTime: 5, text: "A different world" },
+      ];
+      wrapper.setAnnotations(replacement);
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      expect(playerCtx.actions.seekTo).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("Canvas-switch query clearing (Finding 2)", () => {
+    test("'activate' mode: canvas switch clears the query and selection, no seek", async () => {
+      const playerCtx = createMockPlayerContext();
+
+      const { container, component: wrapper } = render(
+        TestTranscriptWithSearch,
+        {
+          props: {
+            context: playerCtx,
+            annotations: mockAnnotations,
+            searchSeekBehavior: "activate",
+          },
+        },
+      );
+      flushSync();
+
+      await typeQuery(container, "world"); // matches a1, a2
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      expect(input.value).toBe("world");
+
+      const replacement: Annotation[] = [
+        { id: "b1", startTime: 20, endTime: 25, text: "A brave new world" },
+      ];
+      wrapper.setAnnotations(replacement);
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      expect(input.value).toBe("");
+      const counter = container.querySelector(".match-counter");
+      expect(counter?.textContent).toBe("");
+      expect(playerCtx.actions.seekTo).not.toHaveBeenCalled();
+    });
+
+    test("'change' mode while reading mode is active: canvas switch clears the query and selection, no seek", async () => {
+      const playerCtx = createMockPlayerContext();
+
+      const { container, component: wrapper } = render(
+        TestTranscriptWithSearch,
+        {
+          props: { context: playerCtx, annotations: mockAnnotations },
+        },
+      );
+      flushSync();
+
+      await typeQuery(container, "world"); // seeks once in legacy change mode
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      expect(input.value).toBe("world");
+      vi.mocked(playerCtx.actions.seekTo).mockClear();
+
+      const followSwitch = container.querySelector(
+        ".follow-along-switch",
+      ) as HTMLButtonElement;
+      followSwitch.click();
+      flushSync();
+      expect(followSwitch.getAttribute("aria-checked")).toBe("false");
+
+      const replacement: Annotation[] = [
+        { id: "b1", startTime: 20, endTime: 25, text: "A brave new world" },
+      ];
+      wrapper.setAnnotations(replacement);
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      expect(input.value).toBe("");
+      expect(playerCtx.actions.seekTo).not.toHaveBeenCalled();
+    });
+  });
+});
diff --git a/src/test/player/Transcript.svelte.test.ts b/src/test/player/Transcript.svelte.test.ts
index add97d8..984f348 100644
--- a/src/test/player/Transcript.svelte.test.ts
+++ b/src/test/player/Transcript.svelte.test.ts
@@ -87,8 +87,12 @@ describe("Transcript", () => {
     expect(panel?.hasAttribute("lang")).toBe(false);
   });
 
-  describe("auto-scroll pause toggle (A4)", () => {
-    test("renders a toggle with aria-pressed reflecting the paused state", () => {
+  // The former auto-scroll pause button (A4) is superseded by the single
+  // "Follow along" switch — see docs/specs/transcript-reading-mode.md's
+  // folded-control paragraph and Transcript.readingMode.svelte.test.ts for
+  // the reading-mode behavior this switch now drives.
+  describe("Follow along switch", () => {
+    test("renders a switch with aria-checked/data-following reflecting Following, off = Browsing", () => {
       const ctx = createMockPlayerContext();
 
       const { container } = render(TestContextHarness, {
@@ -104,23 +108,26 @@ describe("Transcript", () => {
       flushSync();
 
       const toggle = container.querySelector(
-        ".auto-scroll-toggle",
+        ".follow-along-switch",
       ) as HTMLButtonElement;
       expect(toggle).not.toBeNull();
-      expect(toggle.getAttribute("aria-pressed")).toBe("false");
+      expect(toggle.getAttribute("role")).toBe("switch");
+      expect(toggle.getAttribute("aria-checked")).toBe("true");
+      expect(toggle.getAttribute("data-following")).toBe("true");
 
       toggle.click();
       flushSync();
 
-      expect(toggle.getAttribute("aria-pressed")).toBe("true");
+      expect(toggle.getAttribute("aria-checked")).toBe("false");
+      expect(toggle.getAttribute("data-following")).toBe("false");
     });
 
-    test("scrollToAnnotation still scrolls after auto-scroll is paused", () => {
+    test("scrollToAnnotation still scrolls while Browsing", () => {
       const ctx = createMockPlayerContext();
       let capturedTranscriptCtx: TranscriptContext | null = null;
 
       // TestTranscriptWithSegments composes Transcript + TranscriptSegments so
-      // segments render inside the scroll container and the toggle button is
+      // segments render inside the scroll container and the switch is
       // reachable; onContextReady captures the transcript context.
       const { container } = render(TestContextHarness, {
         props: {
@@ -137,11 +144,11 @@ describe("Transcript", () => {
       flushSync();
 
       const toggle = container.querySelector(
-        ".auto-scroll-toggle",
+        ".follow-along-switch",
       ) as HTMLButtonElement;
       toggle.click();
       flushSync();
-      expect(toggle.getAttribute("aria-pressed")).toBe("true");
+      expect(toggle.getAttribute("aria-checked")).toBe("false");
 
       const segmentEl = container.querySelector(
         '[data-annotation-id="a2"]',
diff --git a/src/test/player/TranscriptSearch.svelte.test.ts b/src/test/player/TranscriptSearch.svelte.test.ts
index e307343..23900d8 100644
--- a/src/test/player/TranscriptSearch.svelte.test.ts
+++ b/src/test/player/TranscriptSearch.svelte.test.ts
@@ -63,4 +63,401 @@ describe("TranscriptSearch", () => {
     expect(matches).toHaveLength(1);
     expect(matches[0].id).toBe("a1");
   });
+
+  describe("activation control (searchSeekBehavior='activate')", () => {
+    test("shows the Go to match control only when context searchSeekBehavior is activate", async () => {
+      const transcriptCtx = createMockTranscriptContext({
+        state: { annotations: mockAnnotations, searchSeekBehavior: "change" },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: { context: transcriptCtx, component: TranscriptSearch },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "Hello";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+
+      expect(
+        container.querySelector('button[aria-label="Go to match"]'),
+      ).toBeNull();
+    });
+
+    test("default activation seeks through the context handleMatchActivate", async () => {
+      const handleMatchActivate = vi.fn();
+      const transcriptCtx = createMockTranscriptContext({
+        state: { annotations: mockAnnotations, searchSeekBehavior: "activate" },
+        actions: { handleMatchActivate },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: { context: transcriptCtx, component: TranscriptSearch },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "Hello";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+
+      const goBtn = container.querySelector(
+        'button[aria-label="Go to match"]',
+      ) as HTMLButtonElement;
+      expect(goBtn).not.toBeNull();
+      goBtn.click();
+
+      expect(handleMatchActivate).toHaveBeenCalledWith(mockAnnotations[0], 0);
+    });
+
+    test("a supplied onmatchactivate prop overrides the context default", async () => {
+      const handleMatchActivate = vi.fn();
+      const onmatchactivate = vi.fn();
+      const transcriptCtx = createMockTranscriptContext({
+        state: { annotations: mockAnnotations, searchSeekBehavior: "activate" },
+        actions: { handleMatchActivate },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: {
+          context: transcriptCtx,
+          component: TranscriptSearch,
+          props: { onmatchactivate },
+        },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "Hello";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+
+      const goBtn = container.querySelector(
+        'button[aria-label="Go to match"]',
+      ) as HTMLButtonElement;
+      goBtn.click();
+
+      expect(onmatchactivate).toHaveBeenCalledWith(mockAnnotations[0], 0);
+      expect(handleMatchActivate).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("activation control while reading mode is active (Finding 1)", () => {
+    test("shows the Go to match control and Enter-to-activate works with searchSeekBehavior=change (default) while Browsing", async () => {
+      const handleMatchActivate = vi.fn();
+      const transcriptCtx = createMockTranscriptContext({
+        state: {
+          annotations: mockAnnotations,
+          searchSeekBehavior: "change",
+          readingMode: true,
+        },
+        actions: { handleMatchActivate },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: { context: transcriptCtx, component: TranscriptSearch },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "Hello";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+
+      const goBtn = container.querySelector(
+        'button[aria-label="Go to match"]',
+      ) as HTMLButtonElement;
+      expect(goBtn).not.toBeNull();
+
+      input.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Enter", bubbles: true }),
+      );
+
+      expect(handleMatchActivate).toHaveBeenCalledWith(mockAnnotations[0], 0);
+    });
+
+    test("regression: in change mode while Following (readingMode=false), no activation control renders", async () => {
+      const transcriptCtx = createMockTranscriptContext({
+        state: {
+          annotations: mockAnnotations,
+          searchSeekBehavior: "change",
+          readingMode: false,
+        },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: { context: transcriptCtx, component: TranscriptSearch },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "Hello";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+
+      expect(
+        container.querySelector('button[aria-label="Go to match"]'),
+      ).toBeNull();
+    });
+  });
+
+  describe("onmatchnavigate (scroll-on-navigate — Finding 4)", () => {
+    test("default onmatchnavigate scrolls to the newly selected match via the context (activate mode)", async () => {
+      const scrollToAnnotation = vi.fn().mockReturnValue(true);
+      const transcriptCtx = createMockTranscriptContext({
+        state: { annotations: mockAnnotations, searchSeekBehavior: "activate" },
+        actions: { scrollToAnnotation },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: { context: transcriptCtx, component: TranscriptSearch },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "world"; // matches a1, a2
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+      scrollToAnnotation.mockClear();
+
+      const nextBtn = container.querySelector(
+        'button[aria-label="Next match"]',
+      ) as HTMLButtonElement;
+      nextBtn.click();
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      expect(scrollToAnnotation).toHaveBeenCalledWith("a2");
+    });
+
+    test("a supplied onmatchnavigate prop overrides the context default", async () => {
+      const scrollToAnnotation = vi.fn().mockReturnValue(true);
+      const onmatchnavigate = vi.fn();
+      const transcriptCtx = createMockTranscriptContext({
+        state: { annotations: mockAnnotations },
+        actions: { scrollToAnnotation },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: {
+          context: transcriptCtx,
+          component: TranscriptSearch,
+          props: { onmatchnavigate },
+        },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "world";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+      scrollToAnnotation.mockClear();
+
+      const nextBtn = container.querySelector(
+        'button[aria-label="Next match"]',
+      ) as HTMLButtonElement;
+      nextBtn.click();
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      expect(onmatchnavigate).toHaveBeenCalledWith(mockAnnotations[1], 1);
+      expect(scrollToAnnotation).not.toHaveBeenCalled();
+    });
+
+    // Fix C: the legacy default (searchSeekBehavior="change", reading mode
+    // off) historically only changed the match on prev/next — no explicit
+    // programmatic scroll. Gate the default so it scrolls only in activate
+    // mode or while Browsing (docs/specs/transcript-reading-mode.md scopes
+    // "results scroll" to activate).
+    test("in change mode with reading mode off, navigating does not call scrollToAnnotation (legacy default)", async () => {
+      const scrollToAnnotation = vi.fn().mockReturnValue(true);
+      const transcriptCtx = createMockTranscriptContext({
+        state: {
+          annotations: mockAnnotations,
+          searchSeekBehavior: "change",
+          readingMode: false,
+        },
+        actions: { scrollToAnnotation },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: { context: transcriptCtx, component: TranscriptSearch },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "world"; // matches a1, a2
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+      scrollToAnnotation.mockClear();
+
+      const nextBtn = container.querySelector(
+        'button[aria-label="Next match"]',
+      ) as HTMLButtonElement;
+      nextBtn.click();
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      expect(scrollToAnnotation).not.toHaveBeenCalled();
+    });
+
+    test("in change mode while Browsing (readingMode=true), navigating still calls scrollToAnnotation", async () => {
+      const scrollToAnnotation = vi.fn().mockReturnValue(true);
+      const transcriptCtx = createMockTranscriptContext({
+        state: {
+          annotations: mockAnnotations,
+          searchSeekBehavior: "change",
+          readingMode: true,
+        },
+        actions: { scrollToAnnotation },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: { context: transcriptCtx, component: TranscriptSearch },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "world"; // matches a1, a2
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+      scrollToAnnotation.mockClear();
+
+      const nextBtn = container.querySelector(
+        'button[aria-label="Next match"]',
+      ) as HTMLButtonElement;
+      nextBtn.click();
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      expect(scrollToAnnotation).toHaveBeenCalledWith("a2");
+    });
+
+    test("typing does not call scrollToAnnotation", async () => {
+      const scrollToAnnotation = vi.fn().mockReturnValue(true);
+      const transcriptCtx = createMockTranscriptContext({
+        state: { annotations: mockAnnotations },
+        actions: { scrollToAnnotation },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: { context: transcriptCtx, component: TranscriptSearch },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "world";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      await new Promise((r) => setTimeout(r, 200));
+      flushSync();
+
+      expect(scrollToAnnotation).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("onqueryinput (query-input seam)", () => {
+    test("forwards Search's synchronous onqueryinput to the context handleQueryInput, before the debounced match update", () => {
+      const handleQueryInput = vi.fn();
+      const handleMatchChange = vi.fn();
+      const transcriptCtx = createMockTranscriptContext({
+        state: { annotations: mockAnnotations, searchSeekBehavior: "activate" },
+        actions: { handleQueryInput, handleMatchChange },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: { context: transcriptCtx, component: TranscriptSearch },
+      });
+      flushSync();
+      const callsBefore = handleMatchChange.mock.calls.length;
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "Hello";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+
+      expect(handleQueryInput).toHaveBeenCalledWith("Hello");
+      // Debounce hasn't elapsed yet — the match update hasn't fired.
+      expect(handleMatchChange.mock.calls.length).toBe(callsBefore);
+    });
+
+    test("does not throw when the context provides no handleQueryInput", () => {
+      const transcriptCtx = createMockTranscriptContext({
+        state: { annotations: mockAnnotations },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: { context: transcriptCtx, component: TranscriptSearch },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "Hello";
+      expect(() =>
+        input.dispatchEvent(new Event("input", { bubbles: true })),
+      ).not.toThrow();
+    });
+
+    test("a supplied onqueryinput prop overrides the context default", () => {
+      const handleQueryInput = vi.fn();
+      const onqueryinput = vi.fn();
+      const transcriptCtx = createMockTranscriptContext({
+        actions: { handleQueryInput },
+      });
+
+      const { container } = render(TestTranscriptContextHarness, {
+        props: {
+          context: transcriptCtx,
+          component: TranscriptSearch,
+          props: { onqueryinput },
+        },
+      });
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "Hello";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+
+      expect(onqueryinput).toHaveBeenCalledWith("Hello");
+      expect(handleQueryInput).not.toHaveBeenCalled();
+    });
+  });
 });
diff --git a/src/test/player/TranscriptSegments.svelte.test.ts b/src/test/player/TranscriptSegments.svelte.test.ts
index eef19cc..efba42b 100644
--- a/src/test/player/TranscriptSegments.svelte.test.ts
+++ b/src/test/player/TranscriptSegments.svelte.test.ts
@@ -206,6 +206,86 @@ describe("TranscriptSegments", () => {
       const customSegments = host.querySelectorAll(".custom-segment");
       expect(customSegments).toHaveLength(3);
     });
+
+    // Fix B: custom segment snippets bypassed the text-selection guard that
+    // Segment.svelte already applies to its own onclick (docs/specs/
+    // transcript-reading-mode.md: "Selecting/copying transcript text must
+    // not trigger segment activation on pointer release").
+    describe("text-selection suppresses click activation for a custom snippet", () => {
+      test("does not call onclick when a non-collapsed text selection exists at click time (drag-to-select)", () => {
+        const onclick = vi.fn();
+        const { container: host } = render(TestSegmentSnippetWrapper, {
+          props: { annotations: mockAnnotations, onclick },
+        });
+        flushSync();
+
+        const segment = host.querySelector(
+          '.custom-segment[data-annotation-id="a1"]',
+        ) as HTMLElement;
+        const textEl = segment.querySelector(".custom-text") as HTMLElement;
+
+        const range = document.createRange();
+        range.selectNodeContents(textEl);
+        const selection = window.getSelection()!;
+        selection.removeAllRanges();
+        selection.addRange(range);
+        expect(selection.isCollapsed).toBe(false);
+
+        segment.click();
+
+        expect(onclick).not.toHaveBeenCalled();
+
+        selection.removeAllRanges();
+      });
+
+      test("still calls onclick on a plain click with a collapsed selection", () => {
+        const onclick = vi.fn();
+        const { container: host } = render(TestSegmentSnippetWrapper, {
+          props: { annotations: mockAnnotations, onclick },
+        });
+        flushSync();
+
+        window.getSelection()?.removeAllRanges();
+
+        const segment = host.querySelector(
+          '.custom-segment[data-annotation-id="a1"]',
+        ) as HTMLElement;
+        segment.click();
+
+        expect(onclick).toHaveBeenCalledWith(mockAnnotations[0]);
+      });
+
+      test("still activates on Enter even while a non-collapsed selection exists (keyboard activation is never a drag)", () => {
+        const onclick = vi.fn();
+        const { container: host } = render(TestSegmentSnippetWrapper, {
+          props: { annotations: mockAnnotations, onclick },
+        });
+        flushSync();
+
+        const segment = host.querySelector(
+          '.custom-segment[data-annotation-id="a1"]',
+        ) as HTMLElement;
+        const textEl = segment.querySelector(".custom-text") as HTMLElement;
+
+        const range = document.createRange();
+        range.selectNodeContents(textEl);
+        const selection = window.getSelection()!;
+        selection.removeAllRanges();
+        selection.addRange(range);
+
+        segment.dispatchEvent(
+          new KeyboardEvent("keydown", {
+            key: "Enter",
+            bubbles: true,
+            cancelable: true,
+          }),
+        );
+
+        expect(onclick).toHaveBeenCalledWith(mockAnnotations[0]);
+
+        selection.removeAllRanges();
+      });
+    });
   });
 
   // onkeydown extensibility (LDA-2118)
diff --git a/src/test/player/transcript-context.test.ts b/src/test/player/transcript-context.test.ts
index a25532d..d064057 100644
--- a/src/test/player/transcript-context.test.ts
+++ b/src/test/player/transcript-context.test.ts
@@ -29,11 +29,17 @@ describe("transcript-context", () => {
         currentMatchIndex: -1,
         highlightedIds: new Set(),
         currentMatchId: null,
+        searchSeekBehavior: "change",
+        readingMode: false,
+        queryResetSignal: 0,
       },
       actions: {
         handleAnnotationClick: vi.fn(),
         handleMatchChange: vi.fn(),
+        handleMatchActivate: vi.fn(),
         scrollToAnnotation: vi.fn().mockReturnValue(false),
+        enterBrowsing: vi.fn(),
+        returnToFollowing: vi.fn(),
       },
     };
 
@@ -63,6 +69,9 @@ describe("transcript-context", () => {
       currentMatchIndex: -1,
       highlightedIds: new Set<string>(),
       currentMatchId: null,
+      searchSeekBehavior: "change",
+      readingMode: false,
+      queryResetSignal: 0,
     };
 
     expect(state.annotations).toEqual([]);
diff --git a/src/test/player/transcript-test-utils.ts b/src/test/player/transcript-test-utils.ts
index 8c6d81f..080ce44 100644
--- a/src/test/player/transcript-test-utils.ts
+++ b/src/test/player/transcript-test-utils.ts
@@ -15,12 +15,18 @@ export function createMockTranscriptContext(
       currentMatchIndex: -1,
       highlightedIds: new Set<string>(),
       currentMatchId: null,
+      searchSeekBehavior: "change",
+      readingMode: false,
+      queryResetSignal: 0,
       ...overrides.state,
     },
     actions: {
       handleAnnotationClick: vi.fn(),
       handleMatchChange: vi.fn(),
+      handleMatchActivate: vi.fn(),
       scrollToAnnotation: vi.fn().mockReturnValue(false),
+      enterBrowsing: vi.fn(),
+      returnToFollowing: vi.fn(),
       ...overrides.actions,
     },
   };
diff --git a/src/test/sync/SyncController.test.ts b/src/test/sync/SyncController.test.ts
index 4429b74..54b5ed6 100644
--- a/src/test/sync/SyncController.test.ts
+++ b/src/test/sync/SyncController.test.ts
@@ -116,4 +116,168 @@ describe("SyncController media-driven auto-scroll", () => {
 
     ctrl.destroy();
   });
+
+  it("setScrollToSeekEnabled sends SET_SCROLL_TO_SEEK_ENABLED to the underlying actor", () => {
+    const viewer = createMockViewer(() => 0);
+    const { container } = createContainer();
+    const ctrl = new SyncController();
+    ctrl.initialize(viewer, container, annotations);
+
+    ctrl.setScrollToSeekEnabled(false);
+
+    // @ts-expect-error -- reaching into the private actor field for this one assertion
+    const ctx = ctrl.actor!.getSnapshot().context;
+    expect(ctx.scrollToSeekEnabled).toBe(false);
+
+    ctrl.destroy();
+  });
+});
+
+// docs/specs/transcript-reading-mode.md "Lifecycle and accessibility":
+// "Returning, browsing search results, and consumer scrollToAnnotation
+// calls are programmatic transcript movement; they must never feed back
+// into scroll-to-seek, including after a smooth-scroll animation ends."
+describe("SyncController user-scroll reporting", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  function createScrollableContainer(): HTMLElement {
+    const container = document.createElement("div");
+    Object.defineProperty(container, "scrollHeight", {
+      value: 1000,
+      configurable: true,
+    });
+    Object.defineProperty(container, "clientHeight", {
+      value: 200,
+      configurable: true,
+    });
+    Object.defineProperty(container, "scrollTop", {
+      value: 0,
+      writable: true,
+      configurable: true,
+    });
+    return container;
+  }
+
+  it("calls onUserScroll for a genuine scroll event", () => {
+    const viewer = createMockViewer(() => 0);
+    const container = createScrollableContainer();
+    const onUserScroll = vi.fn();
+    const ctrl = new SyncController({ onUserScroll });
+    ctrl.initialize(viewer, container, annotations);
+
+    container.scrollTop = 500;
+    container.dispatchEvent(new Event("scroll"));
+
+    expect(onUserScroll).toHaveBeenCalledTimes(1);
+    ctrl.destroy();
+  });
+
+  it("does not call onUserScroll for a scroll suppressed as an echo of a programmatic scroll", () => {
+    const viewer = createMockViewer(() => 0);
+    const container = createScrollableContainer();
+    const onUserScroll = vi.fn();
+    const ctrl = new SyncController({ onUserScroll });
+    ctrl.initialize(viewer, container, annotations);
+
+    ctrl.notifyProgrammaticScroll();
+    container.scrollTop = 500;
+    container.dispatchEvent(new Event("scroll"));
+
+    expect(onUserScroll).not.toHaveBeenCalled();
+    ctrl.destroy();
+  });
+
+  it("suppresses echoes throughout a smooth scroll that outlasts the fallback window, releasing on scrollend", async () => {
+    vi.useFakeTimers();
+    const viewer = createMockViewer(() => 0);
+    const container = createScrollableContainer();
+    const onUserScroll = vi.fn();
+    const ctrl = new SyncController({ onUserScroll });
+    ctrl.initialize(viewer, container, annotations);
+
+    ctrl.notifyProgrammaticScroll();
+
+    // A long smooth scroll emits echo events continuously, well past 1s. Each
+    // echo re-arms the settle fallback, so no echo may be reclassified as a
+    // user scroll mid-animation, however long the scroll runs.
+    for (let elapsed = 0; elapsed < 2000; elapsed += 100) {
+      await vi.advanceTimersByTimeAsync(100);
+      container.scrollTop += 25;
+      container.dispatchEvent(new Event("scroll"));
+    }
+    expect(onUserScroll).not.toHaveBeenCalled();
+
+    // The animation settles: scrollend closes the transaction; a later genuine
+    // scroll is reported.
+    container.dispatchEvent(new Event("scrollend"));
+    await vi.advanceTimersByTimeAsync(300);
+    container.scrollTop += 25;
+    container.dispatchEvent(new Event("scroll"));
+    expect(onUserScroll).toHaveBeenCalledTimes(1);
+
+    ctrl.destroy();
+  });
+
+  it("releases the transaction a settle period after scrolling stops, without a scrollend event", async () => {
+    vi.useFakeTimers();
+    const viewer = createMockViewer(() => 0);
+    const container = createScrollableContainer();
+    const onUserScroll = vi.fn();
+    const ctrl = new SyncController({ onUserScroll });
+    ctrl.initialize(viewer, container, annotations);
+
+    ctrl.notifyProgrammaticScroll();
+
+    // Echoes past 1s, then scrolling stops. No scrollend is dispatched (engines
+    // without scrollend support). The quiet-period fallback must close the
+    // transaction — but only after the echoes stop, never during them.
+    for (let elapsed = 0; elapsed < 1500; elapsed += 100) {
+      await vi.advanceTimersByTimeAsync(100);
+      container.scrollTop += 25;
+      container.dispatchEvent(new Event("scroll"));
+    }
+    expect(onUserScroll).not.toHaveBeenCalled();
+
+    // A quiet settle period with no further echoes closes the transaction.
+    await vi.advanceTimersByTimeAsync(300);
+    container.scrollTop += 25;
+    container.dispatchEvent(new Event("scroll"));
+    expect(onUserScroll).toHaveBeenCalledTimes(1);
+
+    ctrl.destroy();
+  });
+
+  it("collapses overlapping programmatic scrolls into one transaction with no premature close", async () => {
+    vi.useFakeTimers();
+    const viewer = createMockViewer(() => 0);
+    const container = createScrollableContainer();
+    const onUserScroll = vi.fn();
+    const ctrl = new SyncController({ onUserScroll });
+    ctrl.initialize(viewer, container, annotations);
+
+    // Rapid successive programmatic scrolls (e.g. repeated next-match presses).
+    ctrl.notifyProgrammaticScroll();
+    await vi.advanceTimersByTimeAsync(50);
+    ctrl.notifyProgrammaticScroll();
+
+    // Echoes from the ongoing animation stay suppressed under the newest
+    // transaction; the earlier transaction's listener was removed, so nothing
+    // closes the newer one prematurely.
+    for (let elapsed = 0; elapsed < 400; elapsed += 100) {
+      await vi.advanceTimersByTimeAsync(100);
+      container.scrollTop += 25;
+      container.dispatchEvent(new Event("scroll"));
+    }
+    expect(onUserScroll).not.toHaveBeenCalled();
+
+    container.dispatchEvent(new Event("scrollend"));
+    await vi.advanceTimersByTimeAsync(300);
+    container.scrollTop += 25;
+    container.dispatchEvent(new Event("scroll"));
+    expect(onUserScroll).toHaveBeenCalledTimes(1);
+
+    ctrl.destroy();
+  });
 });
diff --git a/src/test/sync/syncMachine.test.ts b/src/test/sync/syncMachine.test.ts
index 8caa2a1..9114a99 100644
--- a/src/test/sync/syncMachine.test.ts
+++ b/src/test/sync/syncMachine.test.ts
@@ -590,4 +590,166 @@ describe("syncMachine", () => {
       actor.stop();
     });
   });
+
+  // docs/specs/transcript-reading-mode.md "Reading mode" and the
+  // "Toggle policy off while a scroll-driven seek awaits readiness"
+  // acceptance-gate row. videoController calls viewer.seekTo() from inside
+  // the actor, before its promise resolves — a transition guard on the
+  // *next* event is too late to stop a seek already in flight, so the
+  // policy check has to run immediately before that side effect.
+  describe("scrollToSeekEnabled gate (scroll-to-seek policy)", () => {
+    it("defaults scrollToSeekEnabled to true", () => {
+      const actor = createActor(syncMachine);
+      actor.start();
+      expect(actor.getSnapshot().context.scrollToSeekEnabled).toBe(true);
+      actor.stop();
+    });
+
+    it("SET_SCROLL_TO_SEEK_ENABLED updates context from any state", () => {
+      const actor = createActor(syncMachine);
+      actor.start();
+      actor.send({
+        type: "INITIALIZE",
+        viewer: createMockViewer(),
+        scrollContainer: createMockScrollContainer(),
+        annotations,
+      });
+
+      actor.send({ type: "SET_SCROLL_TO_SEEK_ENABLED", enabled: false });
+
+      expect(actor.getSnapshot().context.scrollToSeekEnabled).toBe(false);
+      actor.stop();
+    });
+
+    it("blocks entering scrollDriven when scroll-to-seek is disabled (no seek, no state change)", () => {
+      const viewer = createMockViewer();
+      const actor = createActor(syncMachine);
+      actor.start();
+      actor.send({
+        type: "INITIALIZE",
+        viewer,
+        scrollContainer: createMockScrollContainer(),
+        annotations,
+      });
+      actor.send({ type: "SET_SCROLL_TO_SEEK_ENABLED", enabled: false });
+
+      actor.send({
+        type: "TRANSCRIPT_SCROLL",
+        scrollProgress: 0.5,
+        mappedTime: 7.5,
+      });
+
+      expect(actor.getSnapshot().value).toBe("ready");
+      expect(viewer.seekTo).not.toHaveBeenCalled();
+      actor.stop();
+    });
+
+    it("blocks a further scroll from re-entering scrollDriven once disabled mid-flight", async () => {
+      const viewer = createMockViewer();
+      const actor = createActor(syncMachine);
+      actor.start();
+      actor.send({
+        type: "INITIALIZE",
+        viewer,
+        scrollContainer: createMockScrollContainer(),
+        annotations,
+      });
+
+      actor.send({
+        type: "TRANSCRIPT_SCROLL",
+        scrollProgress: 0.2,
+        mappedTime: 3,
+      });
+      expect(actor.getSnapshot().value).toBe("scrollDriven");
+
+      actor.send({ type: "SET_SCROLL_TO_SEEK_ENABLED", enabled: false });
+
+      // A later scroll while still (re-)disabled must not start a fresh
+      // scroll-driven seek.
+      actor.send({
+        type: "TRANSCRIPT_SCROLL",
+        scrollProgress: 0.5,
+        mappedTime: 7.5,
+      });
+
+      await vi.waitFor(() => {
+        expect(actor.getSnapshot().value).toBe("ready");
+      });
+      expect(viewer.seekTo).not.toHaveBeenCalled();
+      actor.stop();
+    });
+
+    it("cancels a scroll-driven seek disabled while it awaits viewer readiness, and does not replay it once re-enabled", async () => {
+      let isReady = false;
+      const viewer = createMockViewer({ isReady: vi.fn(() => isReady) });
+      const actor = createActor(syncMachine);
+      actor.start();
+      actor.send({
+        type: "INITIALIZE",
+        viewer,
+        scrollContainer: createMockScrollContainer(),
+        annotations,
+      });
+
+      actor.send({
+        type: "TRANSCRIPT_SCROLL",
+        scrollProgress: 0.5,
+        mappedTime: 7.5,
+      });
+      expect(actor.getSnapshot().value).toBe("scrollDriven");
+
+      // Disable while videoController is still polling isReady().
+      actor.send({ type: "SET_SCROLL_TO_SEEK_ENABLED", enabled: false });
+
+      // Let the viewer become ready — the actor's waitForReady() resolves
+      // and the epoch check must drop the seek rather than firing it late.
+      isReady = true;
+      await vi.waitFor(
+        () => {
+          expect(actor.getSnapshot().value).toBe("ready");
+        },
+        { timeout: 3000 },
+      );
+      expect(viewer.seekTo).not.toHaveBeenCalled();
+
+      // Re-enabling afterward must not replay the dropped seek — the actor
+      // that would have replayed it has already completed.
+      actor.send({ type: "SET_SCROLL_TO_SEEK_ENABLED", enabled: true });
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      expect(viewer.seekTo).not.toHaveBeenCalled();
+
+      actor.stop();
+    }, 10000);
+
+    it("still seeks once viewer readiness resolves when the policy stayed enabled throughout", async () => {
+      let isReady = false;
+      const viewer = createMockViewer({
+        isReady: vi.fn(() => isReady),
+        getDuration: vi.fn(() => 60),
+      });
+      const actor = createActor(syncMachine);
+      actor.start();
+      actor.send({
+        type: "INITIALIZE",
+        viewer,
+        scrollContainer: createMockScrollContainer(),
+        annotations,
+      });
+
+      actor.send({
+        type: "TRANSCRIPT_SCROLL",
+        scrollProgress: 0.5,
+        mappedTime: 7.5,
+      });
+
+      isReady = true;
+      await vi.waitFor(
+        () => {
+          expect(viewer.seekTo).toHaveBeenCalledWith(7.5);
+        },
+        { timeout: 3000 },
+      );
+      actor.stop();
+    }, 10000);
+  });
 });
diff --git a/src/test/sync/videoController.test.ts b/src/test/sync/videoController.test.ts
index a583dbd..b732f3a 100644
--- a/src/test/sync/videoController.test.ts
+++ b/src/test/sync/videoController.test.ts
@@ -17,6 +17,12 @@ function createMockViewer(
   };
 }
 
+// videoController's epoch-based scroll-to-seek policy check is exercised
+// directly by the "policy epoch check" describe block below; every other
+// test in this file wants the seek to proceed unaffected, hence a fixed,
+// matching queued/current epoch pair.
+const noPolicyChange = { queuedEpoch: 0, getCurrentEpoch: () => 0 };
+
 /** Wait for a promise actor to complete. */
 function waitForDone(
   actor: ReturnType<typeof createActor<typeof videoController>>,
@@ -32,7 +38,7 @@ describe("videoController actor", () => {
   it("seeks to target time when viewer is ready", async () => {
     const viewer = createMockViewer();
     const actor = createActor(videoController, {
-      input: { viewer, targetTime: 30 },
+      input: { viewer, targetTime: 30, ...noPolicyChange },
     });
 
     actor.start();
@@ -44,7 +50,7 @@ describe("videoController actor", () => {
   it("clamps target time to [0, duration]", async () => {
     const viewer = createMockViewer({ getDuration: vi.fn(() => 60) });
     const actor = createActor(videoController, {
-      input: { viewer, targetTime: 100 },
+      input: { viewer, targetTime: 100, ...noPolicyChange },
     });
 
     actor.start();
@@ -57,7 +63,7 @@ describe("videoController actor", () => {
   it("handles near-end seeks by backing off 1 second", async () => {
     const viewer = createMockViewer({ getDuration: vi.fn(() => 60) });
     const actor = createActor(videoController, {
-      input: { viewer, targetTime: 59.5 },
+      input: { viewer, targetTime: 59.5, ...noPolicyChange },
     });
 
     actor.start();
@@ -72,7 +78,7 @@ describe("videoController actor", () => {
     // yield -0.5 unless the lower bound is re-enforced after the adjustment.
     const viewer = createMockViewer({ getDuration: vi.fn(() => 0.5) });
     const actor = createActor(videoController, {
-      input: { viewer, targetTime: 0.25 },
+      input: { viewer, targetTime: 0.25, ...noPolicyChange },
     });
 
     actor.start();
@@ -87,7 +93,7 @@ describe("videoController actor", () => {
   it("seeks to 0 when duration is 0", async () => {
     const viewer = createMockViewer({ getDuration: vi.fn(() => 0) });
     const actor = createActor(videoController, {
-      input: { viewer, targetTime: 5 },
+      input: { viewer, targetTime: 5, ...noPolicyChange },
     });
 
     actor.start();
@@ -103,7 +109,7 @@ describe("videoController actor", () => {
           getDuration: vi.fn(() => duration),
         });
         const actor = createActor(videoController, {
-          input: { viewer, targetTime },
+          input: { viewer, targetTime, ...noPolicyChange },
         });
         actor.start();
         await waitForDone(actor);
@@ -132,7 +138,7 @@ describe("videoController actor", () => {
     });
 
     const actor = createActor(videoController, {
-      input: { viewer, targetTime: 10 },
+      input: { viewer, targetTime: 10, ...noPolicyChange },
     });
 
     actor.start();
@@ -150,7 +156,7 @@ describe("videoController actor", () => {
     vi.useFakeTimers();
 
     const actor = createActor(videoController, {
-      input: { viewer, targetTime: 10 },
+      input: { viewer, targetTime: 10, ...noPolicyChange },
     });
 
     actor.subscribe({
@@ -169,4 +175,43 @@ describe("videoController actor", () => {
 
     vi.useRealTimers();
   });
+
+  describe("policy epoch check", () => {
+    it("seeks when the current epoch still matches the queued one", async () => {
+      const viewer = createMockViewer();
+      const actor = createActor(videoController, {
+        input: {
+          viewer,
+          targetTime: 10,
+          queuedEpoch: 5,
+          getCurrentEpoch: () => 5,
+        },
+      });
+
+      actor.start();
+      await waitForDone(actor);
+
+      expect(viewer.seekTo).toHaveBeenCalledWith(10);
+    });
+
+    it("drops the seek silently when the epoch changed before readiness resolved", async () => {
+      const viewer = createMockViewer();
+      const actor = createActor(videoController, {
+        input: {
+          viewer,
+          targetTime: 10,
+          queuedEpoch: 5,
+          // The policy changed (e.g. scroll-to-seek was disabled) while
+          // this actor was awaiting readiness.
+          getCurrentEpoch: () => 6,
+        },
+      });
+
+      actor.start();
+      await waitForDone(actor);
+
+      expect(viewer.seekTo).not.toHaveBeenCalled();
+      expect(actor.getSnapshot().status).toBe("done");
+    });
+  });
 });
diff --git a/src/test/transcript/Search.svelte.test.ts b/src/test/transcript/Search.svelte.test.ts
index 3b4c560..eff59df 100644
--- a/src/test/transcript/Search.svelte.test.ts
+++ b/src/test/transcript/Search.svelte.test.ts
@@ -3,6 +3,7 @@ import { describe, it, expect, vi } from "vitest";
 import { flushSync } from "svelte";
 import { render } from "vitest-browser-svelte";
 import Search from "../../lib/transcript/Search.svelte";
+import TestSearchResetSignalWrapper from "./TestSearchResetSignalWrapper.svelte";
 import type { Annotation } from "../../lib/sync/types";
 
 describe("Transcript.Search", () => {
@@ -205,4 +206,383 @@ describe("Transcript.Search", () => {
     const counter = container.querySelector(".match-counter");
     expect(counter?.textContent).toBe("No matches");
   });
+
+  describe("onqueryinput (synchronous input intent)", () => {
+    it("fires synchronously on input, before the debounced onmatchchange", () => {
+      const onqueryinput = vi.fn();
+      const onmatchchange = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onqueryinput, onmatchchange },
+      }));
+      flushSync();
+      const callsBefore = onmatchchange.mock.calls.length;
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "world";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+
+      expect(onqueryinput).toHaveBeenCalledWith("world");
+      // Debounce (150ms default) has not elapsed — matches haven't changed yet.
+      expect(onmatchchange.mock.calls.length).toBe(callsBefore);
+    });
+
+    it("fires with an empty string when the query is cleared", () => {
+      const onqueryinput = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onqueryinput },
+      }));
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+
+      expect(onqueryinput).toHaveBeenCalledWith("");
+    });
+
+    it("does not fire from previous/next navigation", async () => {
+      const onqueryinput = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onqueryinput },
+      }));
+      flushSync();
+
+      await typeQuery("world");
+      onqueryinput.mockClear();
+
+      const nextBtn = container.querySelector(
+        'button[aria-label="Next match"]',
+      ) as HTMLButtonElement;
+      nextBtn.click();
+      flushSync();
+
+      expect(onqueryinput).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("activation control (showActivation)", () => {
+    it("renders no activation control by default (legacy change mode)", async () => {
+      ({ container } = render(Search, { props: { annotations } }));
+      flushSync();
+
+      await typeQuery("world");
+
+      expect(
+        container.querySelector('button[aria-label="Go to match"]'),
+      ).toBeNull();
+    });
+
+    it("renders a Go to match button when showActivation is true and matches exist", async () => {
+      ({ container } = render(Search, {
+        props: { annotations, showActivation: true },
+      }));
+      flushSync();
+
+      expect(
+        container.querySelector('button[aria-label="Go to match"]'),
+      ).toBeNull();
+
+      await typeQuery("world");
+
+      expect(
+        container.querySelector('button[aria-label="Go to match"]'),
+      ).not.toBeNull();
+    });
+
+    it("hides the Go to match button when there are zero matches", async () => {
+      ({ container } = render(Search, {
+        props: { annotations, showActivation: true },
+      }));
+      flushSync();
+
+      await typeQuery("zzzzz");
+
+      expect(
+        container.querySelector('button[aria-label="Go to match"]'),
+      ).toBeNull();
+    });
+
+    it("clicking Go to match activates the currently selected match", async () => {
+      const onmatchactivate = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onmatchactivate, showActivation: true },
+      }));
+      flushSync();
+
+      await typeQuery("world"); // 2 matches: a1, a2 — currentIndex 0
+
+      const nextBtn = container.querySelector(
+        'button[aria-label="Next match"]',
+      ) as HTMLButtonElement;
+      nextBtn.click();
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      const goBtn = container.querySelector(
+        'button[aria-label="Go to match"]',
+      ) as HTMLButtonElement;
+      goBtn.click();
+
+      expect(onmatchactivate).toHaveBeenCalledWith(annotations[1], 1);
+    });
+  });
+
+  describe("Enter-to-activate", () => {
+    it("does nothing when showActivation is false", async () => {
+      const onmatchactivate = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onmatchactivate },
+      }));
+      flushSync();
+
+      await typeQuery("world");
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Enter", bubbles: true }),
+      );
+
+      expect(onmatchactivate).not.toHaveBeenCalled();
+    });
+
+    it("activates the selected match on Enter", async () => {
+      const onmatchactivate = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onmatchactivate, showActivation: true },
+      }));
+      flushSync();
+
+      await typeQuery("Testing"); // single match: a3
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Enter", bubbles: true }),
+      );
+
+      expect(onmatchactivate).toHaveBeenCalledWith(annotations[2], 0);
+    });
+
+    it("activates whatever match browsing had selected, not index 0", async () => {
+      const onmatchactivate = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onmatchactivate, showActivation: true },
+      }));
+      flushSync();
+
+      await typeQuery("world"); // a1, a2
+
+      const nextBtn = container.querySelector(
+        'button[aria-label="Next match"]',
+      ) as HTMLButtonElement;
+      nextBtn.click();
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Enter", bubbles: true }),
+      );
+
+      expect(onmatchactivate).toHaveBeenCalledWith(annotations[1], 1);
+    });
+
+    it("evaluates the current input before activating when Enter interrupts a pending debounce (not a stale result)", async () => {
+      const onmatchactivate = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onmatchactivate, showActivation: true },
+      }));
+      flushSync();
+
+      await typeQuery("world"); // commits "world" — a1 selected
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.value = "Testing"; // change the query but don't wait for debounce
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      input.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Enter", bubbles: true }),
+      );
+
+      // Activates the freshly-typed query's match (a3), never the stale a1.
+      expect(onmatchactivate).toHaveBeenCalledWith(annotations[2], 0);
+      expect(onmatchactivate).not.toHaveBeenCalledWith(
+        annotations[0],
+        expect.anything(),
+      );
+    });
+
+    it("does not activate while IME composition is in progress", () => {
+      const onmatchactivate = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onmatchactivate, showActivation: true },
+      }));
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      input.dispatchEvent(new CompositionEvent("compositionstart"));
+      input.value = "Testing";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      input.dispatchEvent(
+        new KeyboardEvent("keydown", {
+          key: "Enter",
+          bubbles: true,
+          isComposing: true,
+        }),
+      );
+
+      expect(onmatchactivate).not.toHaveBeenCalled();
+
+      input.dispatchEvent(new CompositionEvent("compositionend"));
+    });
+  });
+
+  describe("resetSignal (external query/selection reset — Finding 2)", () => {
+    it("does not clear an already-empty query on mount", () => {
+      ({ container } = render(TestSearchResetSignalWrapper, {
+        props: { annotations },
+      }));
+      flushSync();
+
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      expect(input.value).toBe("");
+    });
+
+    it("clears the query and resets selection to the first match when resetSignal changes", async () => {
+      const onmatchchange = vi.fn();
+      let wrapper!: { bumpResetSignal: () => void };
+      ({ container, component: wrapper } = render(
+        TestSearchResetSignalWrapper,
+        { props: { annotations, onmatchchange } },
+      ));
+      flushSync();
+
+      await typeQuery("world"); // a1, a2
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      expect(input.value).toBe("world");
+
+      onmatchchange.mockClear();
+      wrapper.bumpResetSignal();
+      flushSync();
+
+      expect(input.value).toBe("");
+      const counter = container.querySelector(".match-counter");
+      expect(counter?.textContent).toBe("");
+      // Clearing re-runs the existing matches effect — same "cleared" shape
+      // as typing an empty query.
+      const lastCall = onmatchchange.mock.calls.at(-1)!;
+      expect(lastCall[0]).toEqual([]);
+      expect(lastCall[1]).toBe(-1);
+    });
+
+    it("does not clear the query when resetSignal is not supplied (standalone use)", async () => {
+      ({ container } = render(Search, { props: { annotations } }));
+      flushSync();
+
+      await typeQuery("world");
+      const input = container.querySelector(
+        'input[type="search"]',
+      ) as HTMLInputElement;
+      expect(input.value).toBe("world");
+    });
+  });
+
+  describe("onmatchnavigate (scroll-on-navigate seam — Finding 4)", () => {
+    it("fires with the newly selected match on next, after currentIndex updates", async () => {
+      const onmatchnavigate = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onmatchnavigate },
+      }));
+      flushSync();
+
+      await typeQuery("world"); // a1, a2 — currentIndex 0
+      onmatchnavigate.mockClear();
+
+      const nextBtn = container.querySelector(
+        'button[aria-label="Next match"]',
+      ) as HTMLButtonElement;
+      nextBtn.click();
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      expect(onmatchnavigate).toHaveBeenCalledWith(annotations[1], 1);
+    });
+
+    it("fires with the newly selected match on previous", async () => {
+      const onmatchnavigate = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onmatchnavigate },
+      }));
+      flushSync();
+
+      await typeQuery("world"); // a1, a2 — currentIndex 0
+      onmatchnavigate.mockClear();
+
+      const prevBtn = container.querySelector(
+        'button[aria-label="Previous match"]',
+      ) as HTMLButtonElement;
+      prevBtn.click(); // wraps to last match
+      flushSync();
+      await new Promise((r) => setTimeout(r, 50));
+      flushSync();
+
+      expect(onmatchnavigate).toHaveBeenCalledWith(annotations[1], 1);
+    });
+
+    it("does not fire while typing", async () => {
+      const onmatchnavigate = vi.fn();
+      ({ container } = render(Search, {
+        props: { annotations, onmatchnavigate },
+      }));
+      flushSync();
+
+      await typeQuery("world");
+
+      expect(onmatchnavigate).not.toHaveBeenCalled();
+    });
+
+    it("does not fire on activation", async () => {
+      const onmatchnavigate = vi.fn();
+      const onmatchactivate = vi.fn();
+      ({ container } = render(Search, {
+        props: {
+          annotations,
+          onmatchnavigate,
+          onmatchactivate,
+          showActivation: true,
+        },
+      }));
+      flushSync();
+
+      await typeQuery("world");
+      onmatchnavigate.mockClear();
+
+      const goBtn = container.querySelector(
+        'button[aria-label="Go to match"]',
+      ) as HTMLButtonElement;
+      goBtn.click();
+
+      expect(onmatchactivate).toHaveBeenCalled();
+      expect(onmatchnavigate).not.toHaveBeenCalled();
+    });
+  });
 });
diff --git a/src/test/transcript/Segment.svelte.test.ts b/src/test/transcript/Segment.svelte.test.ts
index 661c51b..27c7173 100644
--- a/src/test/transcript/Segment.svelte.test.ts
+++ b/src/test/transcript/Segment.svelte.test.ts
@@ -165,4 +165,80 @@ describe("Transcript.Segment", () => {
     const custom = container.querySelector(".custom-text");
     expect(custom?.getAttribute("data-language")).toBe("fr");
   });
+
+  describe("text-selection suppresses click activation (Finding 3)", () => {
+    it("does not call onclick when a non-collapsed text selection exists at click time (drag-to-select)", () => {
+      const onclick = vi.fn();
+      const { container } = render(Segment, {
+        props: { annotation: mockAnnotation, onclick },
+      });
+      flushSync();
+
+      const segment = container.querySelector(
+        "[data-annotation-id]",
+      ) as HTMLElement;
+      const textEl = segment.querySelector(".text") as HTMLElement;
+
+      const range = document.createRange();
+      range.selectNodeContents(textEl);
+      const selection = window.getSelection()!;
+      selection.removeAllRanges();
+      selection.addRange(range);
+      expect(selection.isCollapsed).toBe(false);
+
+      segment.click();
+
+      expect(onclick).not.toHaveBeenCalled();
+
+      selection.removeAllRanges();
+    });
+
+    it("still calls onclick on a plain click with a collapsed selection", () => {
+      const onclick = vi.fn();
+      const { container } = render(Segment, {
+        props: { annotation: mockAnnotation, onclick },
+      });
+      flushSync();
+
+      window.getSelection()?.removeAllRanges();
+
+      const segment = container.querySelector(
+        "[data-annotation-id]",
+      ) as HTMLElement;
+      segment.click();
+
+      expect(onclick).toHaveBeenCalledTimes(1);
+    });
+
+    it("still calls onclick on Enter even while a non-collapsed selection exists (keyboard activation is never a drag)", () => {
+      const onclick = vi.fn();
+      const { container } = render(Segment, {
+        props: { annotation: mockAnnotation, onclick },
+      });
+      flushSync();
+
+      const segment = container.querySelector(
+        "[data-annotation-id]",
+      ) as HTMLElement;
+      const textEl = segment.querySelector(".text") as HTMLElement;
+
+      const range = document.createRange();
+      range.selectNodeContents(textEl);
+      const selection = window.getSelection()!;
+      selection.removeAllRanges();
+      selection.addRange(range);
+
+      segment.dispatchEvent(
+        new KeyboardEvent("keydown", {
+          key: "Enter",
+          bubbles: true,
+          cancelable: true,
+        }),
+      );
+
+      expect(onclick).toHaveBeenCalledTimes(1);
+
+      selection.removeAllRanges();
+    });
+  });
 });
diff --git a/src/test/transcript/TestSearchResetSignalWrapper.svelte b/src/test/transcript/TestSearchResetSignalWrapper.svelte
new file mode 100644
index 0000000..be59972
--- /dev/null
+++ b/src/test/transcript/TestSearchResetSignalWrapper.svelte
@@ -0,0 +1,27 @@
+<!--
+  Test wrapper exposing Search's `resetSignal` prop as a mutable, exported
+  bump — following TestTranscriptReadingMode.svelte's pattern one directory
+  over: `context`/`annotations`-style props are read once, and an exported
+  imperative setter mutates local state the same way a host-level context
+  reset action would (Transcript bumping `queryResetSignal` on annotation
+  replacement).
+-->
+<script lang="ts">
+  import Search from "../../lib/transcript/Search.svelte";
+  import type { Annotation } from "../../lib/sync/types";
+
+  interface Props {
+    annotations: Annotation[];
+    onmatchchange?: (matches: Annotation[], index: number) => void;
+  }
+  let { annotations, onmatchchange }: Props = $props();
+
+  let resetSignal = $state(0);
+
+  /** Simulates a context-level query-reset signal bump (Finding 2). */
+  export function bumpResetSignal() {
+    resetSignal++;
+  }
+</script>
+
+<Search {annotations} {onmatchchange} {resetSignal} />