diff --git a/CHANGELOG.md b/CHANGELOG.md
index a64a1ce..197b8d5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,20 +4,23 @@ All notable changes to this project will be documented in this file.
 
 ## [0.4.0] - 2024-04-23
 
+## [0.4.0] - 2024-04-23
+
 ### Features
 
 - Generalize to running one-shot systems instead of firing events.
-- Use a plugin, can configure schedule and system set.
+- Use plugin.
+- Can configure schedule and system set.
 - Remove `GamepadEvent`; use system with input `In<Gamepad>`.
-- Add IntoCondSystem that adds `only_if()` conditions to `IntoSystems`.
+- Add `IntoCondSystem` that adds `only_if()` conditions to `IntoSystems`.
 - Add `only_if` example.
-- Add prelude module for glob imports.
+- Add `prelude` module for glob imports.
 
 ### Refactor
 
 - Hollow out lib so it's just `mod` and `pub use` statements.
 - Extract sets of functionality from `lib.rs` into `chord.rs`, `cache.rs` and `plugin.rs`.
-- Extract simulated tests into `tests/` directory.
+- Extract tests into `tests/simulated.rs`.
 
 ## [0.3.0] - 2024-03-08
 
diff --git a/Cargo.toml b/Cargo.toml
index 259d01e..959f5a8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,7 @@ path = "examples/multiple_input.rs"
 
 [dependencies]
 bevy = { version = "0.13", default-features = false, features = [] }
-trie-rs = { version = "0.3" }
+trie-rs = { version = "0.4" }
 keyseq = { version = "0.2.3", features = [ "bevy" ] }
 
 [dev-dependencies]
diff --git a/src/cache.rs b/src/cache.rs
index a072f89..c7c3860 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -1,17 +1,23 @@
+//! Cache the trie for reuse.
 use crate::input_sequence::InputSequence;
-use bevy::ecs::system::Resource;
-use trie_rs::map::{Trie, TrieBuilder};
+use bevy::{ecs::system::Resource, log::info, reflect::TypePath};
+use std::{collections::HashMap, hash::Hash};
+use trie_rs::{
+    inc_search::{IncSearch, Position},
+    map::{Trie, TrieBuilder},
+};
 
 /// Contains the trie for the input sequences.
 #[derive(Resource)]
 pub struct InputSequenceCache<A, In> {
-    pub(crate) trie: Option<Trie<A, InputSequence<A, In>>>,
+    trie: Option<Trie<A, InputSequence<A, In>>>,
+    position: HashMap<In, Position>,
 }
 
 impl<A, In> InputSequenceCache<A, In>
 where
-    A: Ord + Clone + Send + Sync + 'static,
-    In: Send + Sync + Clone + 'static,
+    A: Ord + Clone + Send + Sync + TypePath + 'static,
+    In: Send + Sync + Clone + Eq + Hash + 'static,
 {
     /// Retrieve the cached trie without iterating through `sequences`. Or if
     /// the cache has been invalidated, build and cache a new trie using the
@@ -25,13 +31,53 @@ where
             for sequence in sequences {
                 builder.insert(sequence.acts.clone(), sequence.clone());
             }
+            // info!(
+            //     "Building trie for {} input sequences.",
+            //     A::short_type_path()
+            // );
+            assert!(
+                self.position.is_empty(),
+                "Position should be none when rebuilding trie"
+            );
             builder.build()
         })
     }
+
+    /// Store a search.
+    pub fn store(&mut self, key: In, position: Position) {
+        self.position.insert(key, position);
+    }
+
+    /// Recall a search OR create a new search.
+    pub fn recall<'a, 'b>(
+        &'b mut self,
+        key: In,
+        sequences: impl Iterator<Item = &'a InputSequence<A, In>>,
+    ) -> IncSearch<'a, A, InputSequence<A, In>>
+    where
+        'b: 'a,
+    {
+        let position = self.position.get(&key).cloned();
+        let trie = self.trie(sequences);
+        position
+            .map(move |p| IncSearch::resume(trie, p))
+            .unwrap_or_else(move || trie.inc_search())
+    }
+}
+
+impl<A, In> InputSequenceCache<A, In> {
+    /// Clears the cache.
+    pub fn reset(&mut self) {
+        self.trie = None;
+        self.position.clear();
+    }
 }
 
 impl<A, In> Default for InputSequenceCache<A, In> {
     fn default() -> Self {
-        Self { trie: None }
+        Self {
+            trie: None,
+            position: HashMap::new(),
+        }
     }
 }
diff --git a/src/covec.rs b/src/covec.rs
deleted file mode 100644
index abfbd4b..0000000
--- a/src/covec.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-/// Helps keep two correlated vectors in sync.
-pub(crate) struct Covec<T, S>(pub(crate) Vec<T>, pub(crate) Vec<S>);
-
-impl<T, S> Covec<T, S> {
-    pub(crate) fn push(&mut self, x: T, y: S) {
-        self.0.push(x);
-        self.1.push(y);
-    }
-
-    pub(crate) fn drain1_sync(&mut self) {
-        let len0 = self.0.len();
-        let len1 = self.1.len();
-        let _ = self.1.drain(0..len1.saturating_sub(len0));
-    }
-}
-
-impl<T, S> Default for Covec<T, S> {
-    fn default() -> Self {
-        Self(vec![], vec![])
-    }
-}
diff --git a/src/frame_time.rs b/src/frame_time.rs
index 9b85bb5..b09cdde 100644
--- a/src/frame_time.rs
+++ b/src/frame_time.rs
@@ -1,6 +1,6 @@
 use crate::time_limit::TimeLimit;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct FrameTime {
     pub(crate) frame: u32,
     pub(crate) time: f32,
diff --git a/src/lib.rs b/src/lib.rs
index 5390869..2f3f6c8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,32 +2,30 @@
 #![doc = include_str!("../README.md")]
 #![forbid(missing_docs)]
 
-pub use keyseq::{
-    bevy::{pkey as key, pkeyseq as keyseq},
-    Modifiers,
-};
-
 pub use chord::KeyChord;
 pub use plugin::InputSequencePlugin;
 pub use time_limit::TimeLimit;
 
 pub mod action;
-mod cache;
+pub mod cache;
 mod chord;
 pub mod cond_system;
-mod covec;
 mod frame_time;
 pub mod input_sequence;
 mod plugin;
 mod time_limit;
 
-/// Convenient splat import
-pub mod prelude {
-    pub use std::time::Duration;
+pub use keyseq::{
+    bevy::{pkey as key, pkeyseq as keyseq},
+    Modifiers,
+};
 
-    pub use crate::input_sequence::{ButtonSequence, InputSequence, KeySequence};
+/// Convenient glob import
+pub mod prelude {
+    pub use super::input_sequence::{ButtonSequence, InputSequence, KeySequence};
+    pub use super::{action, keyseq, InputSequencePlugin, Modifiers, TimeLimit};
 
-    pub use super::{action, InputSequencePlugin, keyseq, Modifiers, TimeLimit};
+    pub use super::chord::KeyChord;
     pub use super::cond_system::IntoCondSystem;
+    pub use std::time::Duration;
 }
-
diff --git a/src/plugin.rs b/src/plugin.rs
index e109a9e..e99615f 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -16,17 +16,16 @@ use bevy::{
     time::Time,
     utils::intern::Interned,
 };
-use std::collections::HashMap;
+use std::collections::{HashMap, VecDeque};
 
 use crate::{
     cache::InputSequenceCache,
     chord::is_modifier,
-    covec::Covec,
     frame_time::FrameTime,
     input_sequence::{ButtonSequence, InputSequence, KeySequence},
     KeyChord, Modifiers,
 };
-use trie_rs::map::Trie;
+use trie_rs::inc_search::{Answer, IncSearch};
 
 /// ButtonInput sequence plugin.
 pub struct InputSequencePlugin {
@@ -161,55 +160,55 @@ impl InputSequencePlugin {
     }
 }
 
-fn detect_additions<A: Clone + Send + Sync + 'static, In: 'static>(
-    secrets: Query<&InputSequence<A, In>, Added<InputSequence<A, In>>>,
+fn detect_additions<A: Clone + Send + Sync + 'static, In: Send + Sync + 'static>(
+    sequences: Query<&InputSequence<A, In>, Added<InputSequence<A, In>>>,
     mut cache: ResMut<InputSequenceCache<A, In>>,
 ) {
-    if secrets.iter().next().is_some() {
-        cache.trie = None;
+    if sequences.iter().next().is_some() {
+        cache.reset();
     }
 }
 
-fn detect_removals<A: Clone + Send + Sync + 'static, In: 'static>(
+fn detect_removals<A: Clone + Send + Sync + 'static, In: Send + Sync + 'static>(
     mut cache: ResMut<InputSequenceCache<A, In>>,
     mut removals: RemovedComponents<InputSequence<A, In>>,
 ) {
     if removals.read().next().is_some() {
-        cache.trie = None;
+        cache.reset();
     }
 }
 
 #[allow(clippy::too_many_arguments)]
 fn button_sequence_matcher(
-    secrets: Query<&ButtonSequence>,
+    sequences: Query<&ButtonSequence>,
     time: Res<Time>,
     buttons: Res<ButtonInput<GamepadButton>>,
-    mut last_buttons: Local<HashMap<usize, Covec<GamepadButtonType, FrameTime>>>,
+    mut last_times: Local<HashMap<usize, VecDeque<FrameTime>>>,
     mut cache: ResMut<InputSequenceCache<GamepadButtonType, Gamepad>>,
     frame_count: Res<FrameCount>,
     mut commands: Commands,
 ) {
-    let trie = cache.trie(secrets.iter());
     let now = FrameTime {
         frame: frame_count.0,
         time: time.elapsed_seconds(),
     };
     for button in buttons.get_just_pressed() {
-        let pad_buttons = match last_buttons.get_mut(&button.gamepad.id) {
+        let last_times = match last_times.get_mut(&button.gamepad.id) {
             Some(x) => x,
             None => {
-                last_buttons.insert(button.gamepad.id, Covec::default());
-                last_buttons.get_mut(&button.gamepad.id).unwrap()
+                last_times.insert(button.gamepad.id, VecDeque::new());
+                last_times.get_mut(&button.gamepad.id).unwrap()
             }
         };
 
-        pad_buttons.push(button.button_type, now.clone());
-        let start = pad_buttons.1[0].clone();
-        for seq in consume_input(trie, &mut pad_buttons.0) {
+        last_times.push_back(now.clone());
+        let start = &last_times[0];
+        let mut search = cache.recall(button.gamepad, sequences.iter().by_ref());
+        for seq in inc_consume_input(&mut search, std::iter::once(button.button_type)) {
             if seq
                 .time_limit
                 .as_ref()
-                .map(|limit| (&now - &start).has_timedout(limit))
+                .map(|limit| (&now - start).has_timedout(limit))
                 .unwrap_or(false)
             {
                 // Sequence timed out.
@@ -217,73 +216,93 @@ fn button_sequence_matcher(
                 commands.run_system_with_input(seq.system_id, button.gamepad);
             }
         }
-        pad_buttons.drain1_sync();
+        let prefix_len = search.prefix_len();
+        let l = last_times.len();
+        let _ = last_times.drain(0..l - prefix_len);
+        let position = search.into();
+        cache.store(button.gamepad, position);
     }
 }
 
 #[allow(clippy::too_many_arguments)]
 fn key_sequence_matcher(
-    secrets: Query<&KeySequence>,
+    sequences: Query<&KeySequence>,
     time: Res<Time>,
     keys: Res<ButtonInput<KeyCode>>,
-    mut last_keys: Local<Covec<KeyChord, FrameTime>>,
+    mut last_times: Local<VecDeque<FrameTime>>,
     mut cache: ResMut<InputSequenceCache<KeyChord, ()>>,
     frame_count: Res<FrameCount>,
     mut commands: Commands,
 ) {
     let mods = Modifiers::from_input(&keys);
-    let trie = cache.trie(secrets.iter());
     let now = FrameTime {
         frame: frame_count.0,
         time: time.elapsed_seconds(),
     };
-    for key_code in keys.get_just_pressed() {
-        if is_modifier(*key_code) {
-            continue;
-        }
-        let key = KeyChord(mods, *key_code);
-        last_keys.push(key, now.clone());
-        let start = last_keys.1[0].clone();
-        for seq in consume_input(trie, &mut last_keys.0) {
+    let maybe_start = last_times.front().cloned();
+    let mut input = keys
+        .get_just_pressed()
+        .filter(|k| !is_modifier(**k))
+        .map(|k| {
+            let chord = KeyChord(mods, *k);
+            last_times.push_back(now.clone());
+            chord
+        })
+        .peekable();
+    if input.peek().is_none() {
+        return;
+    }
+    let mut search = cache.recall((), sequences.iter());
+
+    // eprintln!("maybe_start {maybe_start:?} now {now:?}");
+    for seq in inc_consume_input(&mut search, input) {
+        if let Some(ref start) = maybe_start {
             if seq
                 .time_limit
                 .as_ref()
-                .map(|limit| (&now - &start).has_timedout(limit))
+                .map(|limit| (&now - start).has_timedout(limit))
                 .unwrap_or(false)
             {
                 // Sequence timed out.
-            } else {
-                commands.run_system(seq.system_id);
+                continue;
             }
         }
-        last_keys.drain1_sync();
+        commands.run_system(seq.system_id);
     }
+    let prefix_len = search.prefix_len();
+    let l = last_times.len();
+    let _ = last_times.drain(0..l - prefix_len);
+    let position = search.into();
+    cache.store((), position);
 }
 
-fn consume_input<'a, K, V>(trie: &'a Trie<K, V>, input: &mut Vec<K>) -> impl Iterator<Item = &'a V>
+/// Incrementally consume the input.
+fn inc_consume_input<'a, 'b, K, V>(
+    search: &'b mut IncSearch<'a, K, V>,
+    input: impl Iterator<Item = K> + 'b,
+) -> impl Iterator<Item = &'a V> + 'b
 where
     K: Clone + Eq + Ord,
-    // V: Clone,
+    'a: 'b,
 {
-    let mut result = vec![];
-    let mut min_prefix = None;
-    for i in 0..input.len() {
-        if let Some(seq) = trie.exact_match(&input[i..]) {
-            result.push(seq);
-        }
-        if min_prefix.is_none() && trie.is_prefix(&input[i..]) {
-            min_prefix = Some(i);
-            // let _ = input.drain(0..i);
-            // return result.into_iter();
-        }
-    }
-    match min_prefix {
-        Some(i) => {
-            let _ = input.drain(0..i);
-        }
-        None => {
-            input.clear();
+    input.filter_map(move |k| {
+        match search.query(&k) {
+            Some(Answer::Match) => {
+                let result = Some(search.value().unwrap());
+                search.reset();
+                result
+            }
+            Some(Answer::PrefixAndMatch) => Some(search.value().unwrap()),
+            Some(Answer::Prefix) => None,
+            None => {
+                search.reset();
+                // This could be the start of a new sequence.
+                if search.query(&k).is_none() {
+                    // This may not be necessary.
+                    search.reset();
+                }
+                None
+            }
         }
-    }
-    result.into_iter()
+    })
 }
diff --git a/tests/simulated.rs b/tests/simulated.rs
index 9418e31..78c4308 100644
--- a/tests/simulated.rs
+++ b/tests/simulated.rs
@@ -498,6 +498,7 @@ mod simulate_app {
                 .time_limit(TimeLimit::Frames(1)),
         );
 
+        // eprintln!("t0");
         press_key(&mut app, KeyCode::KeyA);
         app.update();
         assert!(app
@@ -507,9 +508,11 @@ mod simulate_app {
             .next()
             .is_none());
 
+        // eprintln!("t1");
         clear_just_pressed(&mut app, KeyCode::KeyA);
         app.update();
 
+        // eprintln!("t2");
         press_key(&mut app, KeyCode::KeyB);
         app.update();
         assert!(app