glitchlings 0.4.0__tar.gz → 0.4.1__tar.gz

{glitchlings-0.4.0 → glitchlings-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.4.0
+Version: 0.4.1
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -420,7 +420,7 @@ _How can a computer need reading glasses?_
 
 ### Zeedub
 
-_A whispering glyph parasite that lives in the interstices of codepoints, marking territory with invisible traces._
+_Watch your step around here._
 
 > _**Invisible Ink.**_ Zeedub slips zero-width codepoints between non-space character pairs, forcing models to reason about text whose visible form masks hidden glyphs.
 >

{glitchlings-0.4.0 → glitchlings-0.4.1}/README.md

@@ -177,7 +177,7 @@ _How can a computer need reading glasses?_
 
 ### Zeedub
 
-_A whispering glyph parasite that lives in the interstices of codepoints, marking territory with invisible traces._
+_Watch your step around here._
 
 > _**Invisible Ink.**_ Zeedub slips zero-width codepoints between non-space character pairs, forcing models to reason about text whose visible form masks hidden glyphs.
 >

{glitchlings-0.4.0 → glitchlings-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "glitchlings"
-version = "0.4.0"
+version = "0.4.1"
 description = "Monsters for your language games."
 readme = "README.md"
 requires-python = ">=3.10"

{glitchlings-0.4.0 → glitchlings-0.4.1}/rust/zoo/src/glitch_ops.rs

@@ -398,6 +398,7 @@ impl GlitchOp for SwapAdjacentWordsOp {
         }
 
         let mut index = 0usize;
+        let mut replacements: SmallVec<[(usize, String); 8]> = SmallVec::new();
         while index + 1 < total_words {
             let left_segment = match buffer.word_segment(index) {
                 Some(segment) => segment,
@@ -423,13 +424,17 @@ impl GlitchOp for SwapAdjacentWordsOp {
             if should_swap {
                 let left_replacement = format!("{left_prefix}{right_core}{left_suffix}");
                 let right_replacement = format!("{right_prefix}{left_core}{right_suffix}");
-                buffer.replace_word(index, &left_replacement)?;
-                buffer.replace_word(index + 1, &right_replacement)?;
+                replacements.push((index, left_replacement));
+                replacements.push((index + 1, right_replacement));
             }
 
             index += 2;
         }
 
+        if !replacements.is_empty() {
+            buffer.replace_words_bulk(replacements.into_iter())?;
+        }
+
         Ok(())
     }
 }

{glitchlings-0.4.0 → glitchlings-0.4.1}/rust/zoo/src/lib.rs

@@ -122,6 +122,47 @@ fn cached_layout_vec(layout_dict: &PyDict) -> PyResult<Arc<Vec<(String, Vec<Stri
     Ok(entry.clone())
 }
 
+#[derive(Debug)]
+struct PyGagglePlanInput {
+    name: String,
+    scope: i32,
+    order: i32,
+}
+
+impl<'py> FromPyObject<'py> for PyGagglePlanInput {
+    fn extract(obj: &'py PyAny) -> PyResult<Self> {
+        if let Ok(dict) = obj.downcast::<PyDict>() {
+            let name: String = dict
+                .get_item("name")?
+                .ok_or_else(|| PyValueError::new_err("plan input missing 'name' field"))?
+                .extract()?;
+            let scope: i32 = dict
+                .get_item("scope")?
+                .ok_or_else(|| PyValueError::new_err("plan input missing 'scope' field"))?
+                .extract()?;
+            let order: i32 = dict
+                .get_item("order")?
+                .ok_or_else(|| PyValueError::new_err("plan input missing 'order' field"))?
+                .extract()?;
+            return Ok(Self { name, scope, order });
+        }
+
+        let name = obj
+            .getattr("name")
+            .map_err(|_| PyValueError::new_err("plan input missing attribute 'name'"))?
+            .extract()?;
+        let scope = obj
+            .getattr("scope")
+            .map_err(|_| PyValueError::new_err("plan input missing attribute 'scope'"))?
+            .extract()?;
+        let order = obj
+            .getattr("order")
+            .map_err(|_| PyValueError::new_err("plan input missing attribute 'order'"))?
+            .extract()?;
+        Ok(Self { name, scope, order })
+    }
+}
+
 #[derive(Debug)]
 enum PyGlitchOperation {
     Reduplicate {
@@ -346,6 +387,30 @@ fn redact_words(
     apply_operation(text, op, rng).map_err(glitch_ops::GlitchOpError::into_pyerr)
 }
 
+#[pyfunction]
+fn plan_glitchlings(
+    glitchlings: Vec<PyGagglePlanInput>,
+    master_seed: i128,
+) -> PyResult<Vec<(usize, u64)>> {
+    let plan = pipeline::plan_gaggle(
+        glitchlings
+            .into_iter()
+            .enumerate()
+            .map(|(index, input)| pipeline::GagglePlanInput {
+                index,
+                name: input.name,
+                scope: input.scope,
+                order: input.order,
+            })
+            .collect(),
+        master_seed,
+    );
+    Ok(plan
+        .into_iter()
+        .map(|entry| (entry.index, entry.seed))
+        .collect())
+}
+
 #[pyfunction]
 fn compose_glitchlings(
     text: &str,
@@ -418,6 +483,7 @@ fn _zoo_rust(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(swap_adjacent_words, m)?)?;
     m.add_function(wrap_pyfunction!(ocr_artifacts, m)?)?;
     m.add_function(wrap_pyfunction!(redact_words, m)?)?;
+    m.add_function(wrap_pyfunction!(plan_glitchlings, m)?)?;
     m.add_function(wrap_pyfunction!(compose_glitchlings, m)?)?;
     m.add_function(wrap_pyfunction!(typogre::fatfinger, m)?)?;
     m.add_function(wrap_pyfunction!(zeedub::inject_zero_widths, m)?)?;

{glitchlings-0.4.0 → glitchlings-0.4.1}/rust/zoo/src/pipeline.rs

@@ -68,6 +68,57 @@ impl Pipeline {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GagglePlanEntry {
+    pub index: usize,
+    pub seed: u64,
+}
+
+#[derive(Debug, Clone)]
+pub struct GagglePlanInput {
+    pub index: usize,
+    pub name: String,
+    pub scope: i32,
+    pub order: i32,
+}
+
+struct PlannedGlitchling {
+    index: usize,
+    name: String,
+    scope: i32,
+    order: i32,
+    seed: u64,
+}
+
+pub fn plan_gaggle(inputs: Vec<GagglePlanInput>, master_seed: i128) -> Vec<GagglePlanEntry> {
+    let mut planned: Vec<PlannedGlitchling> = inputs
+        .into_iter()
+        .map(|input| PlannedGlitchling {
+            seed: derive_seed(master_seed, &input.name, input.index as i128),
+            index: input.index,
+            name: input.name,
+            scope: input.scope,
+            order: input.order,
+        })
+        .collect();
+
+    planned.sort_by(|left, right| {
+        left.scope
+            .cmp(&right.scope)
+            .then(left.order.cmp(&right.order))
+            .then(left.name.cmp(&right.name))
+            .then(left.index.cmp(&right.index))
+    });
+
+    planned
+        .into_iter()
+        .map(|item| GagglePlanEntry {
+            index: item.index,
+            seed: item.seed,
+        })
+        .collect()
+}
+
 pub fn derive_seed(master_seed: i128, glitchling_name: &str, index: i128) -> u64 {
     let mut hasher = Blake2s::<U8>::new();
     Digest::update(&mut hasher, int_to_bytes(master_seed));
@@ -109,7 +160,9 @@ fn int_to_bytes(value: i128) -> Vec<u8> {
 
 #[cfg(test)]
 mod tests {
-    use super::{derive_seed, GlitchDescriptor, Pipeline};
+    use super::{
+        derive_seed, plan_gaggle, GagglePlanEntry, GagglePlanInput, GlitchDescriptor, Pipeline,
+    };
     use crate::glitch_ops::{
         DeleteRandomWordsOp, GlitchOperation, OcrArtifactsOp, RedactWordsOp, ReduplicateWordsOp,
         SwapAdjacentWordsOp,
@@ -222,4 +275,55 @@ mod tests {
             .expect("pipeline succeeds");
         assert_eq!(output, "this Echo please line");
     }
+
+    #[test]
+    fn plan_gaggle_orders_by_scope_order_and_name() {
+        let master_seed = 5151i128;
+        let inputs = vec![
+            GagglePlanInput {
+                index: 0,
+                name: "Typogre".to_string(),
+                scope: 5,
+                order: 3,
+            },
+            GagglePlanInput {
+                index: 1,
+                name: "Reduple".to_string(),
+                scope: 4,
+                order: 3,
+            },
+            GagglePlanInput {
+                index: 2,
+                name: "Rushmore".to_string(),
+                scope: 4,
+                order: 2,
+            },
+            GagglePlanInput {
+                index: 3,
+                name: "Mim1c".to_string(),
+                scope: 5,
+                order: 2,
+            },
+        ];
+        let plan = plan_gaggle(inputs, master_seed);
+        let expected = vec![
+            GagglePlanEntry {
+                index: 2,
+                seed: derive_seed(master_seed, "Rushmore", 2),
+            },
+            GagglePlanEntry {
+                index: 1,
+                seed: derive_seed(master_seed, "Reduple", 1),
+            },
+            GagglePlanEntry {
+                index: 3,
+                seed: derive_seed(master_seed, "Mim1c", 3),
+            },
+            GagglePlanEntry {
+                index: 0,
+                seed: derive_seed(master_seed, "Typogre", 0),
+            },
+        ];
+        assert_eq!(plan, expected);
+    }
 }

{glitchlings-0.4.0 → glitchlings-0.4.1}/rust/zoo/src/rng.rs

@@ -323,6 +323,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn random_matches_python_for_additional_seed() {
+        let mut rng = PyRng::new(3815924951222172525);
+        let expected = [
+            0.18518006574496737,
+            0.5841689581060610,
+            0.3699113163178772,
+            0.7394349068470196,
+            0.6855497906317899,
+        ];
+        for value in expected {
+            let actual = rng.random();
+            assert!(
+                (actual - value).abs() < 1e-15,
+                "expected {value}, got {actual}"
+            );
+        }
+    }
+
     #[test]
     fn randrange_supports_default_arguments() {
         let mut rng = PyRng::new(151);

{glitchlings-0.4.0 → glitchlings-0.4.1}/rust/zoo/src/text_buffer.rs

@@ -171,6 +171,35 @@ impl TextBuffer {
         Ok(())
     }
 
+    /// Replace multiple words in a single pass, avoiding repeated reindexing.
+    pub fn replace_words_bulk<I>(
+        &mut self,
+        replacements: I,
+    ) -> Result<(), TextBufferError>
+    where
+        I: IntoIterator<Item = (usize, String)>,
+    {
+        let mut applied_any = false;
+        for (word_index, replacement) in replacements {
+            let segment_index = self
+                .word_segment_indices
+                .get(word_index)
+                .copied()
+                .ok_or(TextBufferError::InvalidWordIndex { index: word_index })?;
+            let segment = self
+                .segments
+                .get_mut(segment_index)
+                .ok_or(TextBufferError::InvalidWordIndex { index: word_index })?;
+            segment.set_text(replacement, SegmentKind::Word);
+            applied_any = true;
+        }
+
+        if applied_any {
+            self.reindex();
+        }
+        Ok(())
+    }
+
     /// Deletes the word at the requested index.
     pub fn delete_word(&mut self, word_index: usize) -> Result<(), TextBufferError> {
         let segment_index = self
@@ -402,6 +431,22 @@ mod tests {
         assert_eq!(buffer.spans().len(), 5);
     }
 
+    #[test]
+    fn bulk_replace_words_updates_multiple_entries() {
+        let mut buffer = TextBuffer::from_str("alpha beta gamma delta");
+        buffer
+            .replace_words_bulk(vec![
+                (0, "delta".to_string()),
+                (3, "alpha".to_string()),
+            ])
+            .expect("bulk replace succeeds");
+        assert_eq!(buffer.to_string(), "delta beta gamma alpha");
+        let spans = buffer.spans();
+        assert_eq!(spans[0].char_range, 0..5);
+        assert_eq!(spans.len(), 7);
+        assert_eq!(spans.last().unwrap().char_range, 17..22);
+    }
+
     #[test]
     fn replace_char_range_handles_multisegment_updates() {
         let mut buffer = TextBuffer::from_str("Hello world");

{glitchlings-0.4.0 → glitchlings-0.4.1}/src/glitchlings/lexicon/__init__.py

@@ -4,10 +4,12 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from hashlib import blake2s
+from pathlib import Path
 import random
 from typing import Callable, Iterable
 
 from glitchlings.config import get_config
+from ._cache import CacheEntries, CacheSnapshot
 
 
 class Lexicon(ABC):
@@ -79,6 +81,21 @@ class Lexicon(ABC):
         return f"{self.__class__.__name__}(seed={self._seed!r})"
 
 
+class LexiconBackend(Lexicon):
+    """Extended lexicon interface that supports cache persistence."""
+
+    Cache = CacheEntries
+
+    @classmethod
+    @abstractmethod
+    def load_cache(cls, path: str | Path) -> CacheSnapshot:
+        """Return a validated cache snapshot loaded from ``path``."""
+
+    @abstractmethod
+    def save_cache(self, path: str | Path | None = None) -> Path | None:
+        """Persist the backend cache to ``path`` and return the destination."""
+
+
 from .graph import GraphLexicon
 from .metrics import (
     compare_lexicons,
@@ -176,6 +193,7 @@ def get_default_lexicon(seed: int | None = None) -> Lexicon:
 
 __all__ = [
     "Lexicon",
+    "LexiconBackend",
     "VectorLexicon",
     "GraphLexicon",
     "WordNetLexicon",

glitchlings-0.4.1/src/glitchlings/lexicon/_cache.py

@@ -0,0 +1,111 @@
+"""Shared cache helpers for lexicon backends."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from hashlib import blake2s
+from pathlib import Path
+from typing import Mapping, Sequence
+
+
+CacheEntries = dict[str, list[str]]
+
+
+@dataclass(frozen=True)
+class CacheSnapshot:
+    """Materialised cache data and its integrity checksum."""
+
+    entries: CacheEntries
+    checksum: str | None = None
+
+
+def _normalise_entries(payload: Mapping[str, Sequence[str]]) -> CacheEntries:
+    """Convert raw cache payloads into canonical mapping form."""
+
+    entries: CacheEntries = {}
+    for key, values in payload.items():
+        if not isinstance(key, str):
+            raise RuntimeError("Synonym cache keys must be strings.")
+        if not isinstance(values, Sequence):
+            raise RuntimeError("Synonym cache values must be sequences of strings.")
+        entries[key] = [str(value) for value in values]
+    return entries
+
+
+def _canonical_json(entries: Mapping[str, Sequence[str]]) -> str:
+    """Return a deterministic JSON serialisation for ``entries``."""
+
+    serialisable = {key: list(values) for key, values in sorted(entries.items())}
+    return json.dumps(serialisable, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def compute_checksum(entries: Mapping[str, Sequence[str]]) -> str:
+    """Return a BLAKE2s checksum for ``entries``."""
+
+    digest = blake2s(_canonical_json(entries).encode("utf8"), digest_size=16)
+    return digest.hexdigest()
+
+
+def load_cache(path: Path) -> CacheSnapshot:
+    """Load a cache from ``path`` and verify its checksum if present."""
+
+    if not path.exists():
+        return CacheSnapshot(entries={}, checksum=None)
+
+    with path.open("r", encoding="utf8") as handle:
+        payload = json.load(handle)
+
+    checksum: str | None = None
+    entries_payload: Mapping[str, Sequence[str]]
+
+    if isinstance(payload, Mapping) and "__meta__" in payload and "entries" in payload:
+        meta = payload["__meta__"]
+        entries_payload = payload["entries"]  # type: ignore[assignment]
+        if not isinstance(entries_payload, Mapping):
+            raise RuntimeError("Synonym cache entries must be stored as a mapping.")
+        if isinstance(meta, Mapping):
+            raw_checksum = meta.get("checksum")
+            if raw_checksum is not None and not isinstance(raw_checksum, str):
+                raise RuntimeError("Synonym cache checksum must be a string when provided.")
+            checksum = raw_checksum
+        else:
+            raise RuntimeError("Synonym cache metadata must be a mapping.")
+    elif isinstance(payload, Mapping):
+        entries_payload = payload  # legacy format without metadata
+    else:
+        raise RuntimeError("Synonym cache payload must be a mapping of strings to lists.")
+
+    entries = _normalise_entries(entries_payload)
+    if checksum is not None:
+        expected = compute_checksum(entries)
+        if checksum != expected:
+            raise RuntimeError(
+                "Synonym cache checksum mismatch; the cache file appears to be corrupted."
+            )
+
+    return CacheSnapshot(entries=entries, checksum=checksum)
+
+
+def write_cache(path: Path, entries: Mapping[str, Sequence[str]]) -> CacheSnapshot:
+    """Persist ``entries`` to ``path`` with checksum metadata."""
+
+    serialisable = {key: list(values) for key, values in sorted(entries.items())}
+    checksum = compute_checksum(serialisable)
+    payload = {
+        "__meta__": {
+            "checksum": checksum,
+            "entries": len(serialisable),
+        },
+        "entries": serialisable,
+    }
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    with path.open("w", encoding="utf8") as handle:
+        json.dump(payload, handle, ensure_ascii=False, indent=2, sort_keys=True)
+
+    return CacheSnapshot(entries=serialisable, checksum=checksum)
+
+
+__all__ = ["CacheEntries", "CacheSnapshot", "compute_checksum", "load_cache", "write_cache"]
+

{glitchlings-0.4.0 → glitchlings-0.4.1}/src/glitchlings/lexicon/graph.py

@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-import json
 import re
 from pathlib import Path
 from typing import Iterable, Mapping, MutableMapping, Sequence
 
-from . import Lexicon
+from . import LexiconBackend
+from ._cache import CacheSnapshot, load_cache as _load_cache_file, write_cache as _write_cache_file
 from .vector import VectorLexicon
 
 
@@ -140,30 +140,7 @@ def _load_numberbatch(path: Path, *, languages: set[str]) -> Mapping[str, list[f
     return embeddings
 
 
-def _load_cache(path: Path) -> dict[str, list[str]]:
-    if not path.exists():
-        return {}
-    with path.open("r", encoding="utf8") as handle:
-        payload = json.load(handle)
-    if not isinstance(payload, Mapping):
-        raise RuntimeError("Graph lexicon cache must be a mapping of strings to lists.")
-    cache: dict[str, list[str]] = {}
-    for key, values in payload.items():
-        if not isinstance(key, str):
-            raise RuntimeError("Graph lexicon cache keys must be strings.")
-        if not isinstance(values, Sequence):
-            raise RuntimeError("Graph lexicon cache values must be sequences of strings.")
-        cache[key] = [str(value) for value in values]
-    return cache
-
-
-def _write_cache(path: Path, cache: Mapping[str, Sequence[str]]) -> None:
-    serialisable = {key: list(values) for key, values in sorted(cache.items())}
-    with path.open("w", encoding="utf8") as handle:
-        json.dump(serialisable, handle, ensure_ascii=False, indent=2, sort_keys=True)
-
-
-class GraphLexicon(Lexicon):
+class GraphLexicon(LexiconBackend):
     """Lexicon backed by ConceptNet/Numberbatch embeddings."""
 
     def __init__(
@@ -184,9 +161,12 @@ class GraphLexicon(Lexicon):
         self._max_neighbors = max(1, max_neighbors)
         self._min_similarity = min_similarity
         self._cache: MutableMapping[str, list[str]] = {}
-        self._cache_path = Path(cache_path) if cache_path is not None else None
+        self._cache_path: Path | None = Path(cache_path) if cache_path is not None else None
+        self._cache_checksum: str | None = None
         if self._cache_path is not None:
-            self._cache.update(_load_cache(self._cache_path))
+            snapshot = _load_cache_file(self._cache_path)
+            self._cache.update(snapshot.entries)
+            self._cache_checksum = snapshot.checksum
         if cache is not None:
             for key, values in cache.items():
                 self._cache[str(key)] = [str(value) for value in values]
@@ -278,6 +258,12 @@ class GraphLexicon(Lexicon):
     def export_cache(self) -> dict[str, list[str]]:
         return {key: list(values) for key, values in self._cache.items()}
 
+    @classmethod
+    def load_cache(cls, path: str | Path) -> CacheSnapshot:
+        """Load and validate a persisted ConceptNet cache file."""
+
+        return _load_cache_file(Path(path))
+
     def save_cache(self, path: str | Path | None = None) -> Path:
         if path is None:
             if self._cache_path is None:
@@ -286,7 +272,8 @@ class GraphLexicon(Lexicon):
         else:
             target = Path(path)
             self._cache_path = target
-        _write_cache(target, self._cache)
+        snapshot = _write_cache_file(target, self._cache)
+        self._cache_checksum = snapshot.checksum
         self._cache_dirty = False
         return target
 

{glitchlings-0.4.0 → glitchlings-0.4.1}/src/glitchlings/lexicon/vector.py

@@ -10,7 +10,8 @@ from pathlib import Path
 import sys
 from typing import Any, Callable, Iterable, Iterator, Mapping, MutableMapping, Sequence
 
-from . import Lexicon
+from . import LexiconBackend
+from ._cache import CacheSnapshot, load_cache as _load_cache_file, write_cache as _write_cache_file
 
 
 def _cosine_similarity(vector_a: Sequence[float], vector_b: Sequence[float]) -> float:
@@ -241,38 +242,7 @@ def _resolve_source(source: Any | None) -> _Adapter | None:
     raise RuntimeError("Unsupported vector source supplied to VectorLexicon.")
 
 
-def _load_cache(path: Path) -> dict[str, list[str]]:
-    """Load a synonym cache from ``path`` if it exists."""
-
-    if not path.exists():
-        return {}
-
-    with path.open("r", encoding="utf8") as handle:
-        payload = json.load(handle)
-
-    if not isinstance(payload, Mapping):
-        raise RuntimeError("Synonym cache must be a JSON mapping of strings to lists.")
-
-    cache: dict[str, list[str]] = {}
-    for key, values in payload.items():
-        if not isinstance(key, str):
-            raise RuntimeError("Synonym cache keys must be strings.")
-        if not isinstance(values, Sequence):
-            raise RuntimeError("Synonym cache values must be lists of strings.")
-        cache[key] = [str(value) for value in values]
-
-    return cache
-
-
-def _write_cache(path: Path, cache: Mapping[str, Sequence[str]]) -> None:
-    """Write ``cache`` to ``path`` deterministically."""
-
-    serialisable = {key: list(values) for key, values in sorted(cache.items())}
-    with path.open("w", encoding="utf8") as handle:
-        json.dump(serialisable, handle, ensure_ascii=False, indent=2, sort_keys=True)
-
-
-class VectorLexicon(Lexicon):
+class VectorLexicon(LexiconBackend):
     """Lexicon implementation backed by dense word embeddings."""
 
     def __init__(
@@ -292,9 +262,13 @@ class VectorLexicon(Lexicon):
         self._max_neighbors = max(1, max_neighbors)
         self._min_similarity = min_similarity
         self._cache: MutableMapping[str, list[str]] = {}
+        self._cache_path: Path | None
+        self._cache_checksum: str | None = None
         if cache_path is not None:
             path = Path(cache_path)
-            self._cache.update(_load_cache(path))
+            snapshot = _load_cache_file(path)
+            self._cache.update(snapshot.entries)
+            self._cache_checksum = snapshot.checksum
             self._cache_path = path
         else:
             self._cache_path = None
@@ -411,6 +385,12 @@ class VectorLexicon(Lexicon):
 
         return {key: list(values) for key, values in self._cache.items()}
 
+    @classmethod
+    def load_cache(cls, path: str | Path) -> CacheSnapshot:
+        """Load and validate a cache file for reuse."""
+
+        return _load_cache_file(Path(path))
+
     def save_cache(self, path: str | Path | None = None) -> Path:
         """Persist the current cache to disk, returning the path used."""
 
@@ -422,7 +402,8 @@ class VectorLexicon(Lexicon):
             target = Path(path)
             self._cache_path = target
 
-        _write_cache(target, self._cache)
+        snapshot = _write_cache_file(target, self._cache)
+        self._cache_checksum = snapshot.checksum
         self._cache_dirty = False
         return target