cc-transcript 14.45.10__tar.gz → 14.45.12__tar.gz

{cc_transcript-14.45.10 → cc_transcript-14.45.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.45.10
+Version: 14.45.12
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{cc_transcript-14.45.10 → cc_transcript-14.45.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.45.10" # informational — releases stamp the version from the git tag
+version = "14.45.12" # informational — releases stamp the version from the git tag
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"

{cc_transcript-14.45.10 → cc_transcript-14.45.12}/rust/crates/core/src/snapshot.rs

@@ -14565,6 +14565,74 @@ mod tests {
         assert!(validate().unwrap_err().status == Status::PermissionDenied);
     }
 
+    #[test]
+    fn source_validation_skips_its_parent_hold_once_cancelled_or_past_its_deadline() {
+        let source = Source::new(&format!("{}\n", user("root")));
+        let sources = canonical_members(&source.directory.join("members"), &["a", "b"], "");
+        let store = store();
+        let owner = context("a");
+        let validate = |cancel: &Cancellation, deadline: u64| {
+            let before = store.source_resolutions.load(Ordering::Relaxed);
+            let validated = store
+                .validate_source_stamps(&sources, &owner, cancel, deadline)
+                .map_err(|error| error.status);
+            (
+                validated,
+                store.source_resolutions.load(Ordering::Relaxed) - before,
+            )
+        };
+        assert_eq!(
+            validate(&Cancellation::default(), now_ms() + 30_000),
+            (Ok(true), 2)
+        );
+        for (cancels, status) in [(true, Status::Cancelled), (false, Status::Deadline)] {
+            let cancel = Cancellation::default();
+            let deadline = now_ms() + 1_000;
+            *store.resolve_hook.lock().unwrap() = Some(Arc::new({
+                let (cancel, last) = (cancel.clone(), sources[1].path.clone());
+                move |path: &Path| {
+                    if path != last {
+                        return;
+                    }
+                    if cancels {
+                        cancel.cancel();
+                    } else {
+                        while now_ms() <= deadline {
+                            std::thread::sleep(std::time::Duration::from_millis(5));
+                        }
+                    }
+                }
+            }));
+            assert_eq!(validate(&cancel, deadline), (Err(status), 1));
+        }
+    }
+
+    #[test]
+    fn empty_membership_validation_reports_cancellation_and_an_expired_deadline() {
+        let store = store();
+        let owner = context("a");
+        let cancelled = Cancellation::default();
+        cancelled.cancel();
+        for (cancel, deadline, status) in [
+            (Cancellation::default(), now_ms(), Status::Deadline),
+            (cancelled, now_ms() + 30_000, Status::Cancelled),
+        ] {
+            let before = store.source_resolutions.load(Ordering::Relaxed);
+            assert_eq!(
+                (
+                    store
+                        .validate_source_stamps(&[], &owner, &cancel, deadline)
+                        .map_err(|error| error.status),
+                    store
+                        .validate_sidechain_dirs(&[], &owner, &cancel, deadline)
+                        .map_err(|error| error.status),
+                ),
+                (Err(status), Err(status))
+            );
+            assert_eq!(store.source_resolutions.load(Ordering::Relaxed), before);
+        }
+    }
+
     #[test]
     fn early_positive_query_rejects_a_parent_retargeted_during_its_page() {
         let source = Source::new(&format!("{}\n", user("root")));
@@ -15423,6 +15491,58 @@ mod tests {
         store.assert_conserved();
     }
 
+    #[test]
+    fn a_stopped_fact_read_keeps_the_entry_for_the_next_member_reader() {
+        for (expected, cancels) in [("cancelled", true), ("deadline", false)] {
+            let EvictedMembers {
+                source,
+                members,
+                store,
+                owner,
+                indexed,
+                ..
+            } = evicted_members(&["thread-a"]);
+            let key = fact_entry_key(&members[0], &owner);
+            let cancellation = Cancellation::default();
+            let stop = cancellation.clone();
+            let deadline = now_ms() + if cancels { 30_000 } else { 1_500 };
+            store.prepared_disk.set_read_hook(Some(Box::new(move || {
+                if cancels {
+                    stop.cancel();
+                } else {
+                    while now_ms() < deadline {
+                        std::thread::sleep(Duration::from_millis(5));
+                    }
+                }
+            })));
+            let stopped = store.request(
+                &warm_request(&source, &["thread-a"], deadline),
+                &owner,
+                &cancellation,
+            );
+            store.prepared_disk.set_read_hook(None);
+            assert_eq!(stopped["status"].as_str(), Some(expected), "{stopped:?}");
+            assert_eq!(cache_reads(&stopped), (Some(0), Some(0), Some(0)));
+            assert_eq!(store.fact_lookups.load(Ordering::Relaxed), 1);
+            assert!(store.prepared_disk.has_entry(&key).unwrap());
+            assert!(!store.lock_state().fact_read_in_flight);
+            store.assert_conserved();
+            let reused = store.request(
+                &warm_request(&source, &["thread-a"], now_ms() + 30_000),
+                &owner,
+                &Cancellation::default(),
+            );
+            assert_eq!(reused["status"].as_str(), Some("ok"), "{reused:?}");
+            assert_eq!(reused["data"]["complete"].as_bool(), Some(true));
+            assert_eq!(cache_reads(&reused), (Some(1), Some(indexed), Some(0)));
+            assert_eq!(store.fact_lookups.load(Ordering::Relaxed), 2);
+            assert!(resident_member_facts(&store, &members)
+                .iter()
+                .all(Option::is_some));
+            store.assert_conserved();
+        }
+    }
+
     fn user_text(id: &str, text: &str) -> String {
         format!(
             r#"{{"type":"user","uuid":"{id}","sessionId":"s","timestamp":"2026-01-02T03:04:05Z","message":{{"content":"{text}"}}}}"#
@@ -16447,6 +16567,54 @@ mod tests {
         store.assert_conserved();
     }
 
+    #[test]
+    fn a_cancelled_root_fact_read_keeps_the_entry_and_builds_nothing() {
+        let source = Source::new(&format!("{}\n{}\n", user("root"), user("child")));
+        let store = fact_budget_store(16 * 1024 * 1024);
+        let owner = context("a");
+        let bounds = limits(&acquire(&source.path)).unwrap();
+        let root = pinned_root(&store, &source, &owner);
+        assert_eq!(root_facts_read(&store, &root, &owner, &bounds).1, 0);
+        assert_eq!(
+            store
+                .lock_state()
+                .remove_identity_facts(root.stamp.identity),
+            1
+        );
+        let key = fact_entry_key(&source.path, &owner);
+        let builds = store.fact_builds.load(Ordering::Relaxed);
+        let cancellation = Cancellation::default();
+        let stop = cancellation.clone();
+        store
+            .prepared_disk
+            .set_read_hook(Some(Box::new(move || stop.cancel())));
+        let mut usage = [0u64; 20];
+        let stopped = store
+            .prepared_root_facts(
+                &root,
+                &json!({"id":"native","version":"1"}),
+                &owner,
+                &bounds,
+                PreparedCacheReads::Unmetered,
+                &cancellation,
+                &mut usage,
+                FactsNeed::Index,
+            )
+            .err()
+            .map(|error| error.status);
+        store.prepared_disk.set_read_hook(None);
+        assert_eq!(stopped, Some(Status::Cancelled));
+        assert_eq!((usage[18], usage[19]), (0, 0));
+        assert_eq!(store.fact_lookups.load(Ordering::Relaxed), 1);
+        assert_eq!(store.fact_builds.load(Ordering::Relaxed), builds);
+        assert!(store.prepared_disk.has_entry(&key).unwrap());
+        assert!(!store.lock_state().fact_read_in_flight);
+        store.assert_conserved();
+        assert_eq!(root_facts_read(&store, &root, &owner, &bounds).1, 1);
+        assert_eq!(store.fact_builds.load(Ordering::Relaxed), builds);
+        store.assert_conserved();
+    }
+
     #[test]
     fn waiting_reader_with_a_different_binding_never_reuses_the_published_facts() {
         let source = Source::new(&format!("{}\n{}\n", user("root"), user("child")));
@@ -17846,6 +18014,32 @@ mod tests {
         );
     }
 
+    #[test]
+    fn registered_warmer_cancelled_on_its_last_step_fails_its_final_hold() {
+        let (source, store, owner, mut request) = registered_warming(300);
+        registered_pages(&store, &owner, &request);
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(source.directory.join("thread-0255.jsonl"))
+            .unwrap()
+            .write_all(format!("{}\n", user("appended")).as_bytes())
+            .unwrap();
+        let cancel = Cancellation::default();
+        *store.built_facts_hook.lock().unwrap() = Some(Arc::new({
+            let cancel = cancel.clone();
+            move |_: &Arc<crate::snapshot_prepared::PreparedFacts>| cancel.cancel()
+        }));
+        let builds = store.fact_builds.load(Ordering::Relaxed);
+        request.insert("deadline_unix_ms", json!(now_ms() + 120_000));
+        let cancelled = store.request(&request, &owner, &cancel);
+        assert_eq!(
+            cancelled["status"].as_str(),
+            Some("cancelled"),
+            "{cancelled:?}"
+        );
+        assert_eq!(store.fact_builds.load(Ordering::Relaxed) - builds, 1);
+    }
+
     #[test]
     fn disk_facts_complete_queries_when_memory_fact_budget_is_smaller() {
         let source = Source::new(&format!("{}\n", user("root")));

{cc_transcript-14.45.10 → cc_transcript-14.45.12}/rust/crates/core/src/snapshot_prepared_disk.rs

@@ -13,7 +13,9 @@ use std::sync::{LazyLock, Mutex};
 use sha2::{Digest, Sha256};
 use sonic_rs::{json, JsonValueTrait, Value};
 
-use crate::snapshot::{SnapshotError, SourceIdentity, SourceStamp, Status, PARSER_VERSION};
+use crate::snapshot::{
+    Cancellation, SnapshotError, SourceIdentity, SourceStamp, Status, PARSER_VERSION,
+};
 #[cfg(test)]
 use crate::snapshot_ledger::Reserved;
 use crate::snapshot_ledger::{Table, Work};
@@ -45,6 +47,7 @@ const ROOM_SWEEP_NAMES: usize = 256;
 const ENTRY_NAME_BYTES: usize = 166;
 const LEGACY_ENTRY_NAME_BYTES: [usize; 2] = [150, 118];
 const MAX_STRANDED_OWNED: usize = 64;
+const READ_CHUNK_BYTES: usize = 64 * 1024;
 
 static ACTIVE_OWNERS: LazyLock<Mutex<HashSet<String>>> =
     LazyLock::new(|| Mutex::new(HashSet::new()));
@@ -164,6 +167,24 @@ fn probed_read_bytes(stored: usize) -> usize {
     stored.saturating_add(1)
 }
 
+fn read_chunks(
+    file: &std::fs::File,
+    wanted: usize,
+    bytes: &mut Vec<u8>,
+    mut checkpoint: impl FnMut() -> Result<(), SnapshotError>,
+) -> Result<(), SnapshotError> {
+    let mut unread = file.take(wanted as u64);
+    while (&mut unread)
+        .take(READ_CHUNK_BYTES as u64)
+        .read_to_end(bytes)
+        .map_err(disk_error)?
+        == READ_CHUNK_BYTES
+    {
+        checkpoint()?;
+    }
+    Ok(())
+}
+
 fn openat_file(dir_fd: libc::c_int, name: &CStr, flags: libc::c_int) -> io::Result<std::fs::File> {
     let fd = unsafe {
         libc::openat(
@@ -1591,9 +1612,13 @@ impl PreparedDiskCache {
         read: &mut DiskRead,
         need: FactsNeed,
         admitted: usize,
+        cancel: &Cancellation,
+        deadline_unix_ms: u64,
     ) -> Result<DiskLookup, SnapshotError> {
+        cancel.check(deadline_unix_ms)?;
         self.check_dir()?;
         let mut state = self.state.lock().expect("prepared facts disk state");
+        cancel.check(deadline_unix_ms)?;
         let Some(entry) = state.entries.get(&key.name) else {
             return Ok(DiskLookup::Miss);
         };
@@ -1623,18 +1648,23 @@ impl PreparedDiskCache {
             {
                 return Err(incomplete("prepared facts cache entry changed"));
             }
-            #[cfg(test)]
-            run_read_hook(&self.owner_name);
+            let checkpoint = || {
+                #[cfg(test)]
+                run_read_hook(&self.owner_name);
+                cancel.check(deadline_unix_ms)
+            };
+            checkpoint()?;
             let mut bytes = Vec::with_capacity(wanted.min(expected));
             read.operations += 1;
-            let finished = (&file).take(wanted as u64).read_to_end(&mut bytes);
+            let finished = read_chunks(&file, wanted, &mut bytes, checkpoint);
             read.bytes += bytes.len() as u64;
-            finished.map_err(disk_error)?;
+            finished?;
             if need == FactsNeed::Index
                 && file.metadata().map_err(disk_error)?.len() != expected as u64
             {
                 return Err(incomplete("prepared facts cache entry changed"));
             }
+            cancel.check(deadline_unix_ms)?;
             let index_end = HEADER_BYTES + index_bytes;
             let verified = bytes
                 .get(..HEADER_BYTES)
@@ -1668,11 +1698,13 @@ impl PreparedDiskCache {
             if !verified {
                 return Err(incomplete("prepared facts cache integrity check failed"));
             }
+            cancel.check(deadline_unix_ms)?;
             let index: DecodedIndexSection = sonic_rs::from_slice(&bytes[HEADER_BYTES..index_end])
                 .map_err(|_| incomplete("prepared facts cache payload invalid"))?;
             let overrides = match served {
                 FactsNeed::Index => OverrideFacts::Unloaded,
                 FactsNeed::Full => {
+                    cancel.check(deadline_unix_ms)?;
                     let section: Option<Vec<OverrideEvent>> =
                         sonic_rs::from_slice(&bytes[index_end..])
                             .map_err(|_| incomplete("prepared facts cache payload invalid"))?;
@@ -1680,6 +1712,7 @@ impl PreparedDiskCache {
                 }
             };
             let facts = PreparedFacts::from_sections(index, overrides);
+            cancel.check(deadline_unix_ms)?;
             if inherited {
                 if facts.accounted_bytes() > accounted_bound {
                     return Err(incomplete("prepared facts cache accounting exceeded"));
@@ -1714,6 +1747,9 @@ impl PreparedDiskCache {
                     DiskLookup::IndexOnly(facts)
                 })
             }
+            Err(error) if matches!(error.status, Status::Cancelled | Status::Deadline) => {
+                Err(error)
+            }
             Err(_) => {
                 self.retire(&mut state, key.name)?;
                 Ok(if inherited {
@@ -2202,7 +2238,14 @@ mod tests {
         read: &mut DiskRead,
         need: FactsNeed,
     ) -> Result<DiskLookup, SnapshotError> {
-        cache.lookup(key, read, need, cache.decoded_bytes(key, need).unwrap_or(0))
+        cache.lookup(
+            key,
+            read,
+            need,
+            cache.decoded_bytes(key, need).unwrap_or(0),
+            &Cancellation::default(),
+            u64::MAX,
+        )
     }
 
     fn cache(cap: usize) -> PreparedDiskCache {
@@ -2956,6 +2999,163 @@ mod tests {
         assert_eq!(cache.stats().entries, 0);
     }
 
+    fn chunked_facts() -> PreparedFacts {
+        let mut facts = PreparedFacts {
+            inputs: json!({
+                "calls": [["Read", ["/repo/file.rs"]]],
+                "commands": [],
+                "edited_files": [],
+                "skills": [],
+            }),
+            has_error: false,
+            overrides: OverrideFacts::Loaded(vec![OverrideEvent {
+                text: "x".repeat(3 * READ_CHUNK_BYTES),
+                tools: vec!["Read".to_owned()],
+            }]),
+            accounted: 0,
+        };
+        facts.refresh_accounted();
+        facts
+    }
+
+    #[test]
+    fn a_stopped_lookup_reads_no_further_and_keeps_the_entry() {
+        let cache = cache(2 * 1024 * 1024);
+        let entry = revision(1);
+        let built = chunked_facts();
+        assert!(cache
+            .insert(&entry, &built, |_| true, |_| true)
+            .unwrap()
+            .serves());
+        let path = cache.entry_path(entry.digest);
+        let stored = fs::read(&path).unwrap();
+        assert!(
+            stored.len() > 2 * READ_CHUNK_BYTES,
+            "entry {}",
+            stored.len()
+        );
+        let admitted = cache.decoded_bytes(&entry, FactsNeed::Full).unwrap();
+        for (site, cancelled, cancelled_at_read, deadline_unix_ms, status, counted) in [
+            (
+                "before the first read",
+                false,
+                Some(1),
+                u64::MAX,
+                Status::Cancelled,
+                (0, 0),
+            ),
+            (
+                "at a chunk boundary",
+                false,
+                Some(2),
+                u64::MAX,
+                Status::Cancelled,
+                (1, READ_CHUNK_BYTES as u64),
+            ),
+            (
+                "past the deadline",
+                false,
+                None,
+                0,
+                Status::Deadline,
+                (0, 0),
+            ),
+            (
+                "cancelled past the deadline",
+                true,
+                None,
+                0,
+                Status::Cancelled,
+                (0, 0),
+            ),
+        ] {
+            let cancel = Cancellation::default();
+            if cancelled {
+                cancel.cancel();
+            }
+            let stop = cancel.clone();
+            let mut reads = 0;
+            cache.set_read_hook(Some(Box::new(move || {
+                reads += 1;
+                if Some(reads) == cancelled_at_read {
+                    stop.cancel();
+                }
+            })));
+            let mut read = DiskRead::default();
+            let stopped = cache
+                .lookup(
+                    &entry,
+                    &mut read,
+                    FactsNeed::Full,
+                    admitted,
+                    &cancel,
+                    deadline_unix_ms,
+                )
+                .err()
+                .map(|error| error.status);
+            cache.set_read_hook(None);
+            assert_eq!(stopped, Some(status), "{site}");
+            assert_eq!((read.operations, read.bytes), counted, "{site}");
+            assert_eq!(fs::read(&path).unwrap(), stored, "{site}");
+            assert_eq!(cache.stats().entries, 1, "{site}");
+        }
+        let mut read = DiskRead::default();
+        let DiskLookup::Hit(loaded) = lookup(&cache, &entry, &mut read, FactsNeed::Full).unwrap()
+        else {
+            panic!("expected the kept entry to serve");
+        };
+        assert_eq!((read.operations, read.bytes), (1, stored.len() as u64));
+        assert_eq!(
+            loaded.text_section().unwrap()[0].text,
+            built.text_section().unwrap()[0].text
+        );
+    }
+
+    #[test]
+    fn a_stopped_inherited_lookup_leaves_the_entry_unadopted() {
+        let namespace = isolated_namespace();
+        let built = pushed_facts(5, 5);
+        let entry = revision(1);
+        let left = left_behind(&namespace, &entry, &built);
+        let stored = fs::metadata(&left).unwrap().len();
+        let successor = reuse_cache(&namespace, 64 * 1024);
+        let inherited = budget(&successor);
+        assert_eq!(inherited, (1, 0, stored as usize, 0));
+        let admitted = successor.decoded_bytes(&entry, FactsNeed::Full).unwrap();
+        let cancel = Cancellation::default();
+        let stop = cancel.clone();
+        successor.set_read_hook(Some(Box::new(move || stop.cancel())));
+        let mut read = DiskRead::default();
+        let stopped = successor
+            .lookup(
+                &entry,
+                &mut read,
+                FactsNeed::Full,
+                admitted,
+                &cancel,
+                u64::MAX,
+            )
+            .err()
+            .map(|error| error.status);
+        successor.set_read_hook(None);
+        assert_eq!(stopped, Some(Status::Cancelled));
+        assert_eq!((read.operations, read.bytes), (0, 0));
+        assert_eq!(budget(&successor), inherited);
+        assert!(left.exists());
+        assert!(!successor.has_entry(&entry).unwrap());
+        let DiskLookup::Hit(loaded) =
+            lookup(&successor, &entry, &mut read, FactsNeed::Full).unwrap()
+        else {
+            panic!("expected the inherited entry to serve");
+        };
+        assert_eq!(loaded.inputs, built.inputs);
+        assert_eq!((read.operations, read.bytes), (1, stored));
+        assert_eq!(budget(&successor), (1, stored as usize, 0, 0));
+        assert!(!left.exists());
+        drop(successor);
+        fs::remove_dir_all(namespace).unwrap();
+    }
+
     fn pushed_facts(events: usize, tools: usize) -> PreparedFacts {
         let mut override_events = Vec::new();
         for event in 0..events {
@@ -4767,7 +4967,14 @@ mod tests {
         let mut read = DiskRead::default();
         assert!(matches!(
             cache
-                .lookup(&entry, &mut read, FactsNeed::Full, admitted)
+                .lookup(
+                    &entry,
+                    &mut read,
+                    FactsNeed::Full,
+                    admitted,
+                    &Cancellation::default(),
+                    u64::MAX,
+                )
                 .unwrap(),
             DiskLookup::Changed
         ));

{cc_transcript-14.45.10 → cc_transcript-14.45.12}/rust/crates/core/src/snapshot_prepared_service.rs

@@ -358,7 +358,14 @@ impl NativeStore {
                 #[cfg(test)]
                 self.fact_lookups.fetch_add(1, Ordering::Relaxed);
                 let mut read = crate::snapshot_prepared_disk::DiskRead::default();
-                let lookup = self.prepared_disk.lookup(&key, &mut read, need, decoded);
+                let lookup = self.prepared_disk.lookup(
+                    &key,
+                    &mut read,
+                    need,
+                    decoded,
+                    cancel,
+                    remaining.deadline_unix_ms,
+                );
                 usage[18] += read.operations;
                 usage[19] += read.bytes;
                 match lookup? {
@@ -584,7 +591,14 @@ impl NativeStore {
             #[cfg(test)]
             self.fact_lookups.fetch_add(1, Ordering::Relaxed);
             let mut read = crate::snapshot_prepared_disk::DiskRead::default();
-            let lookup = self.prepared_disk.lookup(&key, &mut read, need, decoded);
+            let lookup = self.prepared_disk.lookup(
+                &key,
+                &mut read,
+                need,
+                decoded,
+                cancel,
+                remaining.deadline_unix_ms,
+            );
             usage[18] += read.operations;
             usage[19] += read.bytes;
             if let PreparedCacheReads::Warming(..) = cache_reads {
@@ -904,7 +918,7 @@ impl NativeStore {
                 return Ok(false);
             }
         }
-        dirs.hold()
+        dirs.hold(|| cancel.check(deadline))
     }
 
     fn validate_sidechain_dirs(
@@ -935,7 +949,7 @@ impl NativeStore {
                 return Ok(false);
             }
         }
-        dirs.hold()
+        dirs.hold(|| cancel.check(deadline))
     }
 
     fn prepare_graph(
@@ -1670,7 +1684,7 @@ impl NativeStore {
             });
         }
         let since = active_since_ns(request)?;
-        if !dirs.hold()?
+        if !dirs.hold(|| cancel.check(remaining.deadline_unix_ms))?
             || members
                 .iter()
                 .filter(|member| active(member, since))
@@ -2146,7 +2160,10 @@ impl NativeStore {
             steps += 1;
             uncached_steps += usize::from(!cached);
         }
-        if !dirs.hold()? {
+        if !dirs.hold(|| match cancel.check(remaining.deadline_unix_ms) {
+            Err(error) if error.status == Status::Deadline => Ok(()),
+            checked => checked,
+        })? {
             return Err(SnapshotError::new(
                 Status::Changed,
                 "registered source changed",
@@ -2253,7 +2270,7 @@ impl NativeStore {
         let page = self
             .prepared_query_steps(&mut cursor, &mut dirs, context, reservation, cancel, usage)
             .and_then(|page| {
-                if dirs.hold()? {
+                if dirs.hold(|| cancel.check(cursor.remaining.deadline_unix_ms))? {
                     Ok(page)
                 } else {
                     Err(SnapshotError::new(
@@ -3075,8 +3092,10 @@ impl<'a> ResolvedDirs<'a> {
         Ok(canonical)
     }
 
-    fn hold(&self) -> Result<bool, SnapshotError> {
+    fn hold(&self, check: impl Fn() -> Result<(), SnapshotError>) -> Result<bool, SnapshotError> {
+        check()?;
         for (directory, canonical) in &self.dirs {
+            check()?;
             match self.store.canonical_path(directory) {
                 Ok(current) if current == *canonical => {}
                 Ok(_) => return Ok(false),
@@ -3084,6 +3103,7 @@ impl<'a> ResolvedDirs<'a> {
                 Err(error) => return Err(io_error(error)),
             }
         }
+        check()?;
         Ok(true)
     }
 }