query-cascade 0.2.1__tar.gz → 0.2.3__tar.gz

{query_cascade-0.2.1 → query_cascade-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: query-cascade
-Version: 0.2.1
+Version: 0.2.3
 Summary: Minimal demand-driven query framework for incremental computation.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -212,7 +212,7 @@ Properties and methods:
 - **`accumulator(name: str) → Accumulator`** — Return a named **`Accumulator`** (see below). Names are keys in the optional **`effects`** map passed to synchronous **`QueryHandle`** calls and **`submit`**.
 - **`snapshot() → Snapshot`** — Capture **`Snapshot(revision=engine.revision)`** for use as **`snapshot=`** on reads. Reads through that snapshot see input and memo state as of that revision; live **`set`** calls do not disturb snapshot reads.
 - **`submit(query, *args, *, snapshot=None, effects=None, executor=None) → concurrent.futures.Future`** — Run **`query(*args)`** on **`executor`**, or on a **lazily created** per-engine **`ThreadPoolExecutor`** when **`executor` is `None`**. The engine captures **`cancel_epoch`** at schedule time; if inputs move on before the task runs, the future may complete with **`QueryCancelled`**. **`snapshot`** defaults to a fresh **`snapshot()`** at submit time when omitted.
-- **`compute_many(calls, *, workers=None, snapshot=None) → list[Any]`** — Run many queries in parallel with a work-stealing scheduler. **`calls`** is a sequence of **`(query_handle, args_tuple)`**. Result order matches **`calls`**. **`workers`** defaults to a sensible value from **`len(calls)`** (capped); **`workers=0`** falls back to that same default. **`snapshot`** defaults to **`snapshot()`** when omitted. There is no **`effects`** parameter on this path—use **`QueryHandle.__call__`** or **`submit`** if you need to collect accumulator output in a dict.
+- **`compute_many(calls, *, workers=None, snapshot=None, effects=None) → list[Any]`** — Run many queries in parallel with a work-stealing scheduler. **`calls`** is a sequence of **`(query_handle, args_tuple)`**. Result order matches **`calls`**. **`workers`** defaults to a sensible value from **`len(calls)`** (capped); **`workers=0`** falls back to that same default. **`snapshot`** defaults to **`snapshot()`** when omitted. When **`effects`** is a dict, accumulator output is collected and appended into **`effects[name]`** deterministically in **call order** (not completion order).
 - **`shutdown(*, wait: bool = True, cancel_futures: bool = False)`** — Shut down the **default** thread pool created by **`submit`**, if any. Call when discarding the engine if you need threads torn down promptly (for example in tests).
 - **`traces() → list[TraceEvent]`** — Copy of recent trace events (subject to **`trace_limit`**).
 - **`clear_traces()`** — Drop all buffered trace events.
@@ -321,7 +321,7 @@ print(deps_only["memo_count"], deps_only["edges"])
 
 ### Query stats (timing and eviction)
 
-**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
+**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). Each value is **inclusive** for that callable: if the body calls other queries, their execution time is included in the parent’s row as well as their own (do not sum **`by_key`** across the graph to get “total work”). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
 
 ```python
 from cascade import Engine
@@ -452,6 +452,7 @@ Answer Yes/No:
 | `dynamic_macro_expansion.py` | Query that **changes downstream dependencies** at runtime |
 | `snapshot_isolation.py` | Snapshot reads while live inputs change |
 | `concurrent_background_work.py` | Dedup under concurrency + cancellation after input changes |
+| `compute_many_with_accumulators.py` | `compute_many(..., effects=...)` accumulator collection |
 | `persistence_and_inspection.py` | Save/load and graph summaries |
 | `gil_parallel_speedup.py` | Threaded CPU benchmark: GIL vs free-threaded |
 

{query_cascade-0.2.1 → query_cascade-0.2.3}/README.md

@@ -199,7 +199,7 @@ Properties and methods:
 - **`accumulator(name: str) → Accumulator`** — Return a named **`Accumulator`** (see below). Names are keys in the optional **`effects`** map passed to synchronous **`QueryHandle`** calls and **`submit`**.
 - **`snapshot() → Snapshot`** — Capture **`Snapshot(revision=engine.revision)`** for use as **`snapshot=`** on reads. Reads through that snapshot see input and memo state as of that revision; live **`set`** calls do not disturb snapshot reads.
 - **`submit(query, *args, *, snapshot=None, effects=None, executor=None) → concurrent.futures.Future`** — Run **`query(*args)`** on **`executor`**, or on a **lazily created** per-engine **`ThreadPoolExecutor`** when **`executor` is `None`**. The engine captures **`cancel_epoch`** at schedule time; if inputs move on before the task runs, the future may complete with **`QueryCancelled`**. **`snapshot`** defaults to a fresh **`snapshot()`** at submit time when omitted.
-- **`compute_many(calls, *, workers=None, snapshot=None) → list[Any]`** — Run many queries in parallel with a work-stealing scheduler. **`calls`** is a sequence of **`(query_handle, args_tuple)`**. Result order matches **`calls`**. **`workers`** defaults to a sensible value from **`len(calls)`** (capped); **`workers=0`** falls back to that same default. **`snapshot`** defaults to **`snapshot()`** when omitted. There is no **`effects`** parameter on this path—use **`QueryHandle.__call__`** or **`submit`** if you need to collect accumulator output in a dict.
+- **`compute_many(calls, *, workers=None, snapshot=None, effects=None) → list[Any]`** — Run many queries in parallel with a work-stealing scheduler. **`calls`** is a sequence of **`(query_handle, args_tuple)`**. Result order matches **`calls`**. **`workers`** defaults to a sensible value from **`len(calls)`** (capped); **`workers=0`** falls back to that same default. **`snapshot`** defaults to **`snapshot()`** when omitted. When **`effects`** is a dict, accumulator output is collected and appended into **`effects[name]`** deterministically in **call order** (not completion order).
 - **`shutdown(*, wait: bool = True, cancel_futures: bool = False)`** — Shut down the **default** thread pool created by **`submit`**, if any. Call when discarding the engine if you need threads torn down promptly (for example in tests).
 - **`traces() → list[TraceEvent]`** — Copy of recent trace events (subject to **`trace_limit`**).
 - **`clear_traces()`** — Drop all buffered trace events.
@@ -308,7 +308,7 @@ print(deps_only["memo_count"], deps_only["edges"])
 
 ### Query stats (timing and eviction)
 
-**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
+**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). Each value is **inclusive** for that callable: if the body calls other queries, their execution time is included in the parent’s row as well as their own (do not sum **`by_key`** across the graph to get “total work”). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
 
 ```python
 from cascade import Engine
@@ -439,6 +439,7 @@ Answer Yes/No:
 | `dynamic_macro_expansion.py` | Query that **changes downstream dependencies** at runtime |
 | `snapshot_isolation.py` | Snapshot reads while live inputs change |
 | `concurrent_background_work.py` | Dedup under concurrency + cancellation after input changes |
+| `compute_many_with_accumulators.py` | `compute_many(..., effects=...)` accumulator collection |
 | `persistence_and_inspection.py` | Save/load and graph summaries |
 | `gil_parallel_speedup.py` | Threaded CPU benchmark: GIL vs free-threaded |
 

{query_cascade-0.2.1 → query_cascade-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "query-cascade"
-version = "0.2.1"
+version = "0.2.3"
 description = "Minimal demand-driven query framework for incremental computation."
 requires-python = ">=3.12"
 readme = "README.md"

{query_cascade-0.2.1 → query_cascade-0.2.3}/src/cascade/_evaluator.py

@@ -162,7 +162,13 @@ class Evaluator:
                     self._store.trace_event("cache_hit", key)
                     return existing, True
 
-                if self.try_mark_green(key, existing, runtime.snapshot):
+                self._store.pin_memo_verification_locked(key)
+                try:
+                    green = self.try_mark_green(key, existing, runtime.snapshot)
+                finally:
+                    self._store.unpin_memo_verification_locked(key)
+
+                if green:
                     existing.verified_at = runtime.snapshot.revision
                     self._store.touch_memo_locked(key)
                     self._store.trace_event("cache_green", key)

{query_cascade-0.2.1 → query_cascade-0.2.3}/src/cascade/_store.py

@@ -48,6 +48,9 @@ class GraphStore:
         self.in_flight: dict[tuple[QueryKey, int], concurrent.futures.Future[MemoEntry]] = {}
         # Lazy min-heap (last_access, key); stale entries removed on pop (touches push new tuples).
         self._lru_heap: list[tuple[int, QueryKey]] = []
+        # Refcount: memo rows participating in an in-flight cache/verify sequence must not
+        # be LRU-evicted (nested recompute can otherwise drop the parent before verify ends).
+        self._memo_verify_pin_count: dict[QueryKey, int] = {}
 
     def monotonic_seconds(self) -> float:
         return self._monotonic_seconds()
@@ -142,6 +145,16 @@ class GraphStore:
         memo.last_access = self.next_access_id
         heapq.heappush(self._lru_heap, (memo.last_access, key))
 
+    def pin_memo_verification_locked(self, key: QueryKey) -> None:
+        self._memo_verify_pin_count[key] = self._memo_verify_pin_count.get(key, 0) + 1
+
+    def unpin_memo_verification_locked(self, key: QueryKey) -> None:
+        n = self._memo_verify_pin_count.get(key, 0)
+        if n <= 1:
+            self._memo_verify_pin_count.pop(key, None)
+        else:
+            self._memo_verify_pin_count[key] = n - 1
+
     def push_memo_lru_locked(self, key: QueryKey) -> None:
         memo = self.memos.get(key)
         if memo is None:
@@ -149,6 +162,7 @@ class GraphStore:
         heapq.heappush(self._lru_heap, (memo.last_access, key))
 
     def drop_memo_locked(self, key: QueryKey) -> None:
+        self._memo_verify_pin_count.pop(key, None)
         memo = self.memos.pop(key, None)
         if memo is None:
             return
@@ -170,9 +184,22 @@ class GraphStore:
             memo = self.memos.get(key)
             if memo is None or memo.last_access != last_acc:
                 continue
+            if self._memo_verify_pin_count.get(key, 0) > 0:
+                continue
             return key
         return None
 
+    def _unpinned_lru_fallback_key_locked(self) -> QueryKey | None:
+        best_k: QueryKey | None = None
+        best_acc: int | None = None
+        for k, memo in self.memos.items():
+            if self._memo_verify_pin_count.get(k, 0) > 0:
+                continue
+            if best_acc is None or memo.last_access < best_acc:
+                best_acc = memo.last_access
+                best_k = k
+        return best_k
+
     def evict_if_needed_locked(self) -> None:
         while len(self.memos) > self.max_entries:
             victim = self._pop_lru_victim_key_locked()
@@ -180,7 +207,9 @@ class GraphStore:
                 self._rebuild_lru_heap_locked()
                 victim = self._pop_lru_victim_key_locked()
             if victim is None:
-                victim = min(self.memos.items(), key=lambda it: it[1].last_access)[0]
+                victim = self._unpinned_lru_fallback_key_locked()
+            if victim is None:
+                break
             self.trace_event("evict", victim, "lru")
             if self._stats_enabled:
                 self._stats_evictions_total += 1
@@ -354,6 +383,7 @@ class GraphStore:
             # In-flight dedup futures are process-local/transient and should never
             # survive a load boundary.
             self.in_flight.clear()
+            self._memo_verify_pin_count.clear()
             self._rebuild_lru_heap_locked()
 
     def make_persistence_payload(self) -> dict[str, Any]:

{query_cascade-0.2.1 → query_cascade-0.2.3}/src/cascade/engine.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import concurrent.futures
 import os
 import threading
-from typing import Any, Callable, Iterable, Literal, Mapping, Sequence
+from typing import Any, Callable, Iterable, Iterator, Literal, Mapping, Sequence
 
 from ._errors import CancellationError, CycleError, QueryCancelled
 from ._evaluator import Evaluator
@@ -262,18 +262,95 @@ class Engine:
         *,
         workers: int | None = None,
         snapshot: Snapshot | None = None,
+        effects: dict[str, list[Any]] | None = None,
     ) -> list[Any]:
         if not calls:
             return []
         run_snapshot = snapshot or self.snapshot()
         worker_count = workers or min(32, max(1, len(calls)))
         scheduler = WorkStealingExecutor(worker_count)
+        per_call_effects: list[dict[str, list[Any]] | None]
+        if effects is None:
+            per_call_effects = [None] * len(calls)
+        else:
+            per_call_effects = [{} for _ in range(len(calls))]
         for idx, (query, args) in enumerate(calls):
             scheduler.submit_indexed(
                 idx,
-                lambda q=query, a=args: self._query_call(q.id, q.raw, a, snapshot=run_snapshot),
+                lambda q=query, a=args, e=per_call_effects[idx]: self._query_call(
+                    q.id,
+                    q.raw,
+                    a,
+                    snapshot=run_snapshot,
+                    effects=e,
+                ),
             )
-        return scheduler.run(len(calls))
+        results = scheduler.run(len(calls))
+        if effects is not None:
+            for call_effects in per_call_effects:
+                if not call_effects:
+                    continue
+                for name, items in call_effects.items():
+                    if not items:
+                        continue
+                    effects.setdefault(name, []).extend(items)
+        return results
+
+    def compute_many_stream(
+        self,
+        calls: Sequence[tuple[_QueryHandle, tuple[Any, ...]]],
+        *,
+        workers: int | None = None,
+        snapshot: Snapshot | None = None,
+        effects: dict[str, list[Any]] | None = None,
+    ) -> Iterator[tuple[int, Any, dict[str, list[Any]]]]:
+        """Yield completed results as each call finishes.
+
+        Yields ``(index, value, call_effects)`` where ``index`` matches the position in
+        ``calls`` and ``call_effects`` contains accumulator output for that call when
+        ``effects`` was provided (otherwise an empty dict).
+
+        Unlike :meth:`compute_many`, this API yields items in *completion order*.
+        If ``effects`` is provided, it is populated after all calls complete, merged
+        deterministically in call order (matching :meth:`compute_many`).
+        """
+        if not calls:
+            return
+
+        run_snapshot = snapshot or self.snapshot()
+        worker_count = workers or min(32, max(1, len(calls)))
+
+        per_call_effects: list[dict[str, list[Any]]]
+        per_call_effects = [{} for _ in range(len(calls))]
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=worker_count) as pool:
+            future_to_index: dict[concurrent.futures.Future[Any], int] = {}
+            for idx, (query, args) in enumerate(calls):
+                fut = pool.submit(
+                    self._query_call,
+                    query.id,
+                    query.raw,
+                    args,
+                    snapshot=run_snapshot,
+                    effects=per_call_effects[idx] if effects is not None else None,
+                )
+                future_to_index[fut] = idx
+
+            for fut in concurrent.futures.as_completed(future_to_index):
+                idx = future_to_index[fut]
+                value = fut.result()
+                call_effects = per_call_effects[idx] if effects is not None else {}
+                item = (idx, value, call_effects)
+                yield item
+
+        if effects is not None:
+            for call_effects in per_call_effects:
+                if not call_effects:
+                    continue
+                for name, items in call_effects.items():
+                    if not items:
+                        continue
+                    effects.setdefault(name, []).extend(items)
 
     def traces(self) -> list[TraceEvent]:
         return self._store.traces()

{query_cascade-0.2.1 → query_cascade-0.2.3}/src/query_cascade.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: query-cascade
-Version: 0.2.1
+Version: 0.2.3
 Summary: Minimal demand-driven query framework for incremental computation.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -212,7 +212,7 @@ Properties and methods:
 - **`accumulator(name: str) → Accumulator`** — Return a named **`Accumulator`** (see below). Names are keys in the optional **`effects`** map passed to synchronous **`QueryHandle`** calls and **`submit`**.
 - **`snapshot() → Snapshot`** — Capture **`Snapshot(revision=engine.revision)`** for use as **`snapshot=`** on reads. Reads through that snapshot see input and memo state as of that revision; live **`set`** calls do not disturb snapshot reads.
 - **`submit(query, *args, *, snapshot=None, effects=None, executor=None) → concurrent.futures.Future`** — Run **`query(*args)`** on **`executor`**, or on a **lazily created** per-engine **`ThreadPoolExecutor`** when **`executor` is `None`**. The engine captures **`cancel_epoch`** at schedule time; if inputs move on before the task runs, the future may complete with **`QueryCancelled`**. **`snapshot`** defaults to a fresh **`snapshot()`** at submit time when omitted.
-- **`compute_many(calls, *, workers=None, snapshot=None) → list[Any]`** — Run many queries in parallel with a work-stealing scheduler. **`calls`** is a sequence of **`(query_handle, args_tuple)`**. Result order matches **`calls`**. **`workers`** defaults to a sensible value from **`len(calls)`** (capped); **`workers=0`** falls back to that same default. **`snapshot`** defaults to **`snapshot()`** when omitted. There is no **`effects`** parameter on this path—use **`QueryHandle.__call__`** or **`submit`** if you need to collect accumulator output in a dict.
+- **`compute_many(calls, *, workers=None, snapshot=None, effects=None) → list[Any]`** — Run many queries in parallel with a work-stealing scheduler. **`calls`** is a sequence of **`(query_handle, args_tuple)`**. Result order matches **`calls`**. **`workers`** defaults to a sensible value from **`len(calls)`** (capped); **`workers=0`** falls back to that same default. **`snapshot`** defaults to **`snapshot()`** when omitted. When **`effects`** is a dict, accumulator output is collected and appended into **`effects[name]`** deterministically in **call order** (not completion order).
 - **`shutdown(*, wait: bool = True, cancel_futures: bool = False)`** — Shut down the **default** thread pool created by **`submit`**, if any. Call when discarding the engine if you need threads torn down promptly (for example in tests).
 - **`traces() → list[TraceEvent]`** — Copy of recent trace events (subject to **`trace_limit`**).
 - **`clear_traces()`** — Drop all buffered trace events.
@@ -321,7 +321,7 @@ print(deps_only["memo_count"], deps_only["edges"])
 
 ### Query stats (timing and eviction)
 
-**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
+**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). Each value is **inclusive** for that callable: if the body calls other queries, their execution time is included in the parent’s row as well as their own (do not sum **`by_key`** across the graph to get “total work”). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
 
 ```python
 from cascade import Engine
@@ -452,6 +452,7 @@ Answer Yes/No:
 | `dynamic_macro_expansion.py` | Query that **changes downstream dependencies** at runtime |
 | `snapshot_isolation.py` | Snapshot reads while live inputs change |
 | `concurrent_background_work.py` | Dedup under concurrency + cancellation after input changes |
+| `compute_many_with_accumulators.py` | `compute_many(..., effects=...)` accumulator collection |
 | `persistence_and_inspection.py` | Save/load and graph summaries |
 | `gil_parallel_speedup.py` | Threaded CPU benchmark: GIL vs free-threaded |
 

{query_cascade-0.2.1 → query_cascade-0.2.3}/src/query_cascade.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ tests/test_evaluator_and_synthetic_coverage.py
 tests/test_examples.py
 tests/test_internal_invariants.py
 tests/test_performance.py
+tests/test_repro_touch_memo_keyerror.py
 tests/test_scale_behavior.py
 tests/test_serde.py
 tests/test_stateful_engine_invariants.py

{query_cascade-0.2.1 → query_cascade-0.2.3}/tests/test_engine_compute_many.py

@@ -83,6 +83,79 @@ def test_compute_many_with_zero_workers_falls_back_to_default_worker_selection()
     assert result == [i + 1 for i in range(6)]
 
 
+def test_compute_many_can_collect_accumulator_effects() -> None:
+    engine = Engine()
+    progress = engine.accumulator("progress")
+
+    @engine.query
+    def job(name: str) -> str:
+        progress.push(("start", name))
+        progress.push(("done", name))
+        return name.upper()
+
+    effects: dict[str, list[object]] = {}
+    result = engine.compute_many([(job, ("a",)), (job, ("b",)), (job, ("c",))], workers=3, effects=effects)
+    assert result == ["A", "B", "C"]
+    assert effects == {
+        "progress": [
+            ("start", "a"),
+            ("done", "a"),
+            ("start", "b"),
+            ("done", "b"),
+            ("start", "c"),
+            ("done", "c"),
+        ]
+    }
+
+
+def test_compute_many_stream_yields_in_completion_order() -> None:
+    engine = Engine()
+
+    @engine.query
+    def delayed(i: int) -> int:
+        time.sleep(0.004 * (4 - i))
+        return i
+
+    calls = [(delayed, (i,)) for i in range(4)]
+    items = list(engine.compute_many_stream(calls, workers=4))
+    # i=3 sleeps least, so it should complete first.
+    assert [idx for idx, _value, _effects in items] == [3, 2, 1, 0]
+    assert sorted(value for _idx, value, _effects in items) == [0, 1, 2, 3]
+
+
+def test_compute_many_stream_can_yield_and_collect_accumulator_effects() -> None:
+    engine = Engine()
+    progress = engine.accumulator("progress")
+
+    @engine.query
+    def job(name: str, seconds: float) -> str:
+        progress.push(("start", name))
+        time.sleep(seconds)
+        progress.push(("done", name))
+        return name.upper()
+
+    calls = [(job, ("a", 0.03)), (job, ("b", 0.01)), (job, ("c", 0.02))]
+    effects: dict[str, list[object]] = {}
+    items = list(engine.compute_many_stream(calls, workers=3, effects=effects))
+
+    # Stream yields in completion order (b, c, a).
+    assert [value for _idx, value, _call_effects in items] == ["B", "C", "A"]
+    # Each yielded item includes just that call's effects.
+    by_value = {value: call_effects["progress"] for _idx, value, call_effects in items}
+    assert by_value["A"] == [("start", "a"), ("done", "a")]
+    assert by_value["B"] == [("start", "b"), ("done", "b")]
+    assert by_value["C"] == [("start", "c"), ("done", "c")]
+    # Aggregate effects dict is merged in call order, matching compute_many.
+    assert effects["progress"] == [
+        ("start", "a"),
+        ("done", "a"),
+        ("start", "b"),
+        ("done", "b"),
+        ("start", "c"),
+        ("done", "c"),
+    ]
+
+
 def test_work_stealing_run_raises_first_recorded_task_error() -> None:
     scheduler = WorkStealingExecutor(workers=2)
 

query_cascade-0.2.3/tests/test_repro_touch_memo_keyerror.py

@@ -0,0 +1,70 @@
+"""Regression: nested ``try_mark_green`` must not LRU-evict memos mid-verify.
+
+Previously, ``compute_or_get_memo`` could touch a parent memo, call
+``try_mark_green`` (which recursively recomputed deps), and nested
+``evict_if_needed_locked`` could evict that parent before the post-verify
+``touch_memo_locked`` → ``KeyError``.  Query memos under verification are now
+refcount-pinned in :class:`~cascade._store.GraphStore` so LRU skips them until
+``unpin_memo_verification_locked``.
+"""
+
+from __future__ import annotations
+
+from cascade import Engine
+
+
+def _run_nested_verify_under_pressure(*, max_entries: int = 6) -> None:
+    engine = Engine(max_entries=max_entries, trace_limit=2_000)
+    inp = engine.input(lambda: 0)
+
+    @engine.query
+    def aux(i: int) -> int:
+        return i + 1
+
+    @engine.query
+    def leaf(i: int) -> int:
+        return aux(i)
+
+    @engine.query
+    def root() -> int:
+        return sum(leaf(j) for j in range(3))
+
+    assert root() == 6
+    inp.set(1)
+    assert root() == 6
+
+
+def test_nested_verify_with_small_memo_table_no_keyerror() -> None:
+    """Seven query keys, ``max_entries == 6``: first run evicts; second run verifies."""
+    _run_nested_verify_under_pressure(max_entries=6)
+
+
+def test_same_graph_succeeds_with_smaller_cache() -> None:
+    _run_nested_verify_under_pressure(max_entries=5)
+
+
+def test_many_fillers_after_revision_before_root_still_computes(max_entries: int = 12) -> None:
+    engine = Engine(max_entries=max_entries, trace_limit=10_000)
+    inp = engine.input(lambda: 0)
+
+    @engine.query
+    def filler(n: int) -> int:
+        return n
+
+    @engine.query
+    def aux(i: int) -> int:
+        return i + 1
+
+    @engine.query
+    def leaf(i: int) -> int:
+        return aux(i)
+
+    @engine.query
+    def root() -> int:
+        return sum(leaf(j) for j in range(3))
+
+    assert root() == 6
+    for n in range(400):
+        filler(n)
+    inp.set(1)
+    assert root() == 6