lora-python 0.12.0__tar.gz → 0.14.0__tar.gz

{lora_python-0.12.0 → lora_python-0.14.0}/Cargo.lock

@@ -773,7 +773,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "lora-ast",
  "lora-builtins-meta",
@@ -784,14 +784,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -799,11 +799,11 @@ dependencies = [
 
 [[package]]
 name = "lora-builtins-meta"
-version = "0.12.0"
+version = "0.14.0"
 
 [[package]]
 name = "lora-compiler"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -812,7 +812,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -824,6 +824,7 @@ dependencies = [
  "lora-ast",
  "lora-compiler",
  "lora-executor",
+ "lora-io",
  "lora-parser",
  "lora-snapshot",
  "lora-store",
@@ -836,7 +837,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -859,7 +860,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -869,9 +870,20 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "lora-io"
+version = "0.14.0"
+dependencies = [
+ "lora-executor",
+ "lora-store",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
 [[package]]
 name = "lora-node"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -886,7 +898,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "lora-ast",
  "pest",
@@ -897,7 +909,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -909,7 +921,7 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -923,7 +935,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -933,11 +945,12 @@ dependencies = [
  "serde_json",
  "tokio",
  "tower",
+ "tracing",
 ]
 
 [[package]]
 name = "lora-snapshot"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "argon2",
  "blake3",
@@ -952,7 +965,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "crc32fast",
  "js-sys",
@@ -963,7 +976,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -973,7 +986,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -989,7 +1002,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.12.0 → lora_python-0.14.0}/Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
-members = ["crates/lora-ast", "crates/lora-parser", "crates/lora-builtins-meta", "crates/lora-analyzer", "crates/lora-compiler", "crates/lora-store", "crates/lora-snapshot", "crates/lora-wal", "crates/lora-executor", "crates/lora-database", "crates/bindings/lora-python"]
+members = ["crates/lora-ast", "crates/lora-parser", "crates/lora-builtins-meta", "crates/lora-analyzer", "crates/lora-compiler", "crates/lora-store", "crates/lora-snapshot", "crates/lora-io", "crates/lora-wal", "crates/lora-executor", "crates/lora-database", "crates/bindings/lora-python"]
 resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.12.0"
+version = "0.14.0"
 license = "BUSL-1.1"
 authors = ["LoraDB, Inc."]
 repository = "https://github.com/lora-db/lora"
@@ -15,17 +15,18 @@ rust-version = "1.87"
 # Internal crates — versions are kept in lockstep with [workspace.package].version
 # by `scripts/sync-versions.mjs`. Both `path` and `version` are set so that
 # `cargo publish` works (crates.io cannot resolve path-only deps).
-lora-ast = { path = "crates/lora-ast", version = "=0.12.0" }
-lora-parser = { path = "crates/lora-parser", version = "=0.12.0" }
-lora-builtins-meta = { path = "crates/lora-builtins-meta", version = "=0.12.0" }
-lora-analyzer = { path = "crates/lora-analyzer", version = "=0.12.0" }
-lora-compiler = { path = "crates/lora-compiler", version = "=0.12.0" }
-lora-store = { path = "crates/lora-store", version = "=0.12.0" }
-lora-snapshot = { path = "crates/lora-snapshot", version = "=0.12.0", default-features = false }
-lora-wal = { path = "crates/lora-wal", version = "=0.12.0" }
-lora-executor = { path = "crates/lora-executor", version = "=0.12.0", default-features = false }
-lora-database = { path = "crates/lora-database", version = "=0.12.0" }
-lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.12.0" }
+lora-ast = { path = "crates/lora-ast", version = "=0.14.0" }
+lora-parser = { path = "crates/lora-parser", version = "=0.14.0" }
+lora-builtins-meta = { path = "crates/lora-builtins-meta", version = "=0.14.0" }
+lora-analyzer = { path = "crates/lora-analyzer", version = "=0.14.0" }
+lora-compiler = { path = "crates/lora-compiler", version = "=0.14.0" }
+lora-store = { path = "crates/lora-store", version = "=0.14.0" }
+lora-snapshot = { path = "crates/lora-snapshot", version = "=0.14.0", default-features = false }
+lora-io = { path = "crates/lora-io", version = "=0.14.0" }
+lora-wal = { path = "crates/lora-wal", version = "=0.14.0" }
+lora-executor = { path = "crates/lora-executor", version = "=0.14.0", default-features = false }
+lora-database = { path = "crates/lora-database", version = "=0.14.0" }
+lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.14.0" }
 
 # External crates.
 anyhow = "1"
@@ -36,7 +37,7 @@ tokio = "1"
 smallvec = "2.0.0-alpha.12"
 pest = "2"
 pest_derive = "2"
-serde = { version = "1", features = ["derive"] }
+serde = { version = "1", features = ["derive", "rc"] }
 serde_json = "1.0.149"
 regex = "1"
 unicode-normalization = "0.1"

{lora_python-0.12.0 → lora_python-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lora-python
-Version: 0.12.0
+Version: 0.14.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8

{lora_python-0.12.0 → lora_python-0.14.0}/crates/bindings/lora-python/src/errors.rs

@@ -43,7 +43,11 @@ create_exception!(
 /// the same path.
 pub(crate) fn lora_query_err_from_anyhow(err: impl Into<EngineLoraError>) -> PyErr {
     let lora = err.into();
-    LoraQueryError::new_err(format!("{}: {}", lora.code().as_str(), lora.message()))
+    LoraQueryError::new_err(format!(
+        "{}: {}",
+        lora.code().as_str(),
+        lora.public_message()
+    ))
 }
 
 /// Borrowed-by-reference variant for call sites that don't have an
@@ -51,7 +55,11 @@ pub(crate) fn lora_query_err_from_anyhow(err: impl Into<EngineLoraError>) -> PyE
 #[allow(dead_code)]
 pub(crate) fn lora_query_err_from_anyhow_ref(err: &anyhow::Error) -> PyErr {
     let lora = EngineLoraError::from_anyhow_ref(err);
-    LoraQueryError::new_err(format!("{}: {}", lora.code().as_str(), lora.message()))
+    LoraQueryError::new_err(format!(
+        "{}: {}",
+        lora.code().as_str(),
+        lora.public_message()
+    ))
 }
 
 /// Build a [`LoraQueryError`] for a binding-side message that doesn't

{lora_python-0.12.0 → lora_python-0.14.0}/crates/lora-analyzer/src/analyzer/clauses.rs

@@ -54,6 +54,11 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
     pub(super) fn analyze_unwind(&mut self, u: &Unwind) -> Result<ResolvedUnwind, SemanticError> {
         let expr = self.analyze_expr(&u.expr)?;
         let alias = self.declare_fresh_variable(&u.alias.name)?;
+        // UNWIND iterates a list — typically `$rows` from a batched
+        // import, where each element is a map of arbitrary keys. The
+        // analyzer can't know the row shape, so let property access on
+        // the alias skip the graph-catalog check.
+        self.dynamic_property_vars.insert(alias);
 
         Ok(ResolvedUnwind { expr, alias })
     }

{lora_python-0.12.0 → lora_python-0.14.0}/crates/lora-analyzer/src/analyzer/state.rs

@@ -4,12 +4,18 @@ use lora_ast::{
     UpdatingClause,
 };
 use lora_store::GraphCatalog;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 
 pub struct Analyzer<'a, S: GraphCatalog + ?Sized> {
     pub(super) storage: &'a S,
     pub(super) scopes: ScopeStack,
     pub(super) symbols: SymbolTable,
+    /// Variables whose runtime value shape isn't tracked by the analyzer
+    /// (UNWIND-bound elements, anything that may legitimately hold a map
+    /// or list of maps). Property access on these vars must skip the
+    /// graph-catalog check — the caller can't know which keys the data
+    /// carries until rows are bound at execution time.
+    pub(super) dynamic_property_vars: BTreeSet<VarId>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -26,6 +32,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
             storage,
             scopes: ScopeStack::new(),
             symbols: SymbolTable::default(),
+            dynamic_property_vars: BTreeSet::new(),
         }
     }
 
@@ -324,7 +331,13 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
 
     pub(super) fn property_access_allowed(&self, base: &ResolvedExpr, key: &str) -> bool {
         match base {
-            ResolvedExpr::Map(_) => true,
+            // Map literals and query parameters carry their own keys —
+            // there's nothing in the graph catalog to check against.
+            ResolvedExpr::Map(_) | ResolvedExpr::Parameter(_) => true,
+            // Variables whose value shape isn't tracked (UNWIND-bound
+            // row elements, etc.) — the catalog can't speak to keys on
+            // values that come from `$params` at execution time.
+            ResolvedExpr::Variable(id) if self.dynamic_property_vars.contains(id) => true,
             _ => {
                 self.storage.has_property_key(key)
                     || (self.storage.node_count() == 0 && self.storage.relationship_count() == 0)

{lora_python-0.12.0 → lora_python-0.14.0}/crates/lora-analyzer/src/analyzer/tests.rs

@@ -31,6 +31,42 @@ fn create_allows_new_relationship_type_when_graph_is_not_empty() {
     ));
 }
 
+#[test]
+fn unwind_alias_allows_property_access_with_unknown_keys() {
+    // Regression: when the playground import driver runs
+    //     UNWIND $rows AS r CREATE (:Label {`User Id`: r.`User Id`})
+    // against a non-empty graph that has never seen "User Id" as a
+    // property key, the analyzer used to reject `r.\`User Id\`` as an
+    // unknown property. UNWIND-bound vars hold whatever the parameter
+    // payload carries, so property access on them must skip the
+    // catalog check.
+    let mut graph = InMemoryGraph::new();
+    let _ = graph.create_node(vec!["Other".into()], Properties::new());
+
+    let doc = parse_query(
+        "UNWIND $rows AS r CREATE (:People {`User Id`: r.`User Id`, `First Name`: r.`First Name`})",
+    )
+    .unwrap();
+    let mut analyzer = Analyzer::new(&graph);
+    analyzer
+        .analyze(&doc)
+        .expect("UNWIND-bound row variable should allow any property key");
+}
+
+#[test]
+fn parameter_property_access_allowed_with_unknown_keys() {
+    // Parameters are runtime maps the analyzer can't introspect — keys
+    // on `$ctx.foo` must not be gated by the graph catalog either.
+    let mut graph = InMemoryGraph::new();
+    let _ = graph.create_node(vec!["Other".into()], Properties::new());
+
+    let doc = parse_query("RETURN $ctx.user_id AS u").unwrap();
+    let mut analyzer = Analyzer::new(&graph);
+    analyzer
+        .analyze(&doc)
+        .expect("property access on a parameter should skip the catalog check");
+}
+
 // --- Vector function analyzer tests ----------------------------------
 
 #[test]

{lora_python-0.12.0 → lora_python-0.14.0}/crates/lora-database/Cargo.toml

@@ -36,6 +36,7 @@ lora-compiler.workspace = true
 lora-executor = { workspace = true, default-features = false }
 lora-store.workspace = true
 lora-snapshot.workspace = true
+lora-io.workspace = true
 lora-wal.workspace = true
 
 serde_json.workspace = true
@@ -88,3 +89,7 @@ harness = false
 [[bench]]
 name = "index_acceleration"
 harness = false
+
+[[bench]]
+name = "memory"
+harness = false

lora_python-0.14.0/crates/lora-database/benches/memory.rs

@@ -0,0 +1,162 @@
+//! Memory-footprint benchmark for `InMemoryGraph`.
+//!
+//! Run with: `cargo bench -p lora-database --bench memory`
+//!
+//! Unlike the other benches in this directory, this one is *not* a
+//! latency benchmark. It builds representative graph shapes, walks
+//! the new [`MemoryReport`] estimator over each, and prints a
+//! `grep`-friendly summary so a future regression gate can diff two
+//! runs without having to re-derive the methodology.
+//!
+//! Output format (one line per scenario):
+//!
+//! ```text
+//! memreport scenario=chain_100k nodes=100000 rels=99999 \
+//!   total=NNNN graph=NNNN nodes_bytes=NNNN ... bytes_per_node=NNN.N
+//! ```
+//!
+//! The Criterion harness is used only to wire `cargo bench --bench
+//! memory` into the existing workflow; per-scenario timing is *not*
+//! the headline metric (we ignore the iteration count and
+//! re-construct the dataset for every iter to surface allocator
+//! noise, not to micro-measure construction speed).
+
+mod fixtures;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use fixtures::{
+    build_chain, build_node_graph, build_social_graph, build_star, build_vector_graph, BenchDb,
+};
+use lora_database::{InMemoryGraph, MemoryReport};
+use std::collections::BTreeMap;
+use std::time::Duration;
+
+fn bench_config() -> Criterion {
+    Criterion::default()
+        .warm_up_time(Duration::from_millis(50))
+        .measurement_time(Duration::from_millis(200))
+        .sample_size(10)
+}
+
+/// Render one scenario's report as a `memreport` line. Keep the key
+/// order stable so future tooling can `awk` over it.
+fn print_report(scenario: &str, db: &BenchDb) {
+    let report: MemoryReport = db
+        .service
+        .with_store(|s: &InMemoryGraph| s.memory_estimate());
+
+    // Capture the breakdown via the public field set so any future
+    // additions to `MemoryReport` show up in the output the next time
+    // the bench is regenerated.
+    let mut kv: BTreeMap<&str, u128> = BTreeMap::new();
+    kv.insert("total", report.total_bytes() as u128);
+    kv.insert("graph", report.graph_core_bytes() as u128);
+    kv.insert("indexes", report.secondary_index_bytes() as u128);
+    kv.insert("catalogs", report.catalog_bytes() as u128);
+    kv.insert("nodes_bytes", report.nodes_bytes as u128);
+    kv.insert("rels_bytes", report.relationships_bytes as u128);
+    kv.insert("outgoing_bytes", report.outgoing_bytes as u128);
+    kv.insert("incoming_bytes", report.incoming_bytes as u128);
+    kv.insert("label_index_bytes", report.label_index_bytes as u128);
+    kv.insert("type_index_bytes", report.type_index_bytes as u128);
+    kv.insert("property_index_bytes", report.property_index_bytes as u128);
+    kv.insert("sorted_index_bytes", report.sorted_index_bytes as u128);
+    kv.insert("text_index_bytes", report.text_index_bytes as u128);
+    kv.insert("point_index_bytes", report.point_index_bytes as u128);
+    kv.insert("fulltext_index_bytes", report.fulltext_index_bytes as u128);
+    kv.insert("vector_index_bytes", report.vector_index_bytes as u128);
+
+    let mut line = format!(
+        "memreport scenario={} nodes={} rels={} tomb_nodes={} tomb_rels={}",
+        scenario,
+        report.live_node_count,
+        report.live_relationship_count,
+        report.node_tombstone_count,
+        report.relationship_tombstone_count,
+    );
+    for (k, v) in &kv {
+        line.push_str(&format!(" {k}={v}"));
+    }
+    line.push_str(&format!(
+        " bytes_per_node={:.1} bytes_per_rel={:.1}",
+        report.bytes_per_live_node(),
+        report.bytes_per_live_relationship(),
+    ));
+    println!("{line}");
+}
+
+/// Build a graph and run the documented workloads, capturing both
+/// the post-build report and a post-query report — peak-bytes
+/// regression candidates live in the difference, not the absolute
+/// value.
+fn print_with_query(scenario: &str, db: &BenchDb, query: &str) {
+    print_report(&format!("{scenario}.build"), db);
+    let _ = db.service.execute(query, None).unwrap();
+    print_report(&format!("{scenario}.after_query"), db);
+}
+
+fn bench_memory(c: &mut Criterion) {
+    let mut group = c.benchmark_group("memory_estimate");
+
+    // ---- isolated nodes ----
+    {
+        let db = build_node_graph(10_000);
+        print_report("node_only_10k", &db);
+        group.bench_function("node_only_10k_estimate", |b| {
+            b.iter(|| {
+                let _ = db
+                    .service
+                    .with_store(|s: &InMemoryGraph| s.memory_estimate());
+            });
+        });
+    }
+
+    // ---- chains (1 edge / node) ----
+    for &n in &[1_000usize, 10_000, 100_000] {
+        let db = build_chain(n);
+        print_with_query(
+            &format!("chain_{n}"),
+            &db,
+            "MATCH (n:Chain) RETURN count(n) AS c",
+        );
+    }
+
+    // ---- hub-and-spoke (star) ----
+    for &spokes in &[1_000usize, 10_000, 100_000] {
+        let db = build_star(spokes);
+        print_with_query(
+            &format!("star_{spokes}"),
+            &db,
+            "MATCH (h:Hub)-[:ARM]->(s) RETURN count(s) AS c",
+        );
+    }
+
+    // ---- social graph (mixed fanout + properties) ----
+    {
+        let db = build_social_graph(20_000, 8);
+        print_with_query(
+            "social_20k_x8",
+            &db,
+            "MATCH (a:Person)-[:KNOWS]->(b) RETURN count(b) AS c",
+        );
+    }
+
+    // ---- vector workloads ----
+    {
+        let db = build_vector_graph(5_000, 128, "cosine", "flat");
+        print_report("vector_flat_5k_d128", &db);
+    }
+    {
+        let db = build_vector_graph(5_000, 128, "cosine", "hnsw");
+        print_report("vector_hnsw_5k_d128", &db);
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    name = benches;
+    config = bench_config();
+    targets = bench_memory
+);
+criterion_main!(benches);

lora_python-0.14.0/crates/lora-database/benches/memory_baseline.json

@@ -0,0 +1,66 @@
+{
+  "_meta": {
+    "default_tolerance_pct": 10,
+    "last_updated": "2026-05-23",
+    "notes": "Captured from `cargo bench -p lora-database --bench memory -- --quick` on Apple Silicon. Numbers are bytes from `MemoryReport::total_bytes()` after the build phase (or after_query for chain/star/social which run a representative MATCH after building). Tolerance is per-scenario; a regression beyond `total * (1 + tolerance_pct/100)` fails the gate. Bump the baseline whenever an intentional storage-shape change shifts a scenario."
+  },
+  "benchmarks": {
+    "node_only_10k": {
+      "total_bytes": 4896966,
+      "bytes_per_node": 428.9,
+      "tolerance_pct": 10
+    },
+    "chain_1000.build": {
+      "total_bytes": 665387,
+      "bytes_per_node": 213.0,
+      "bytes_per_rel": 100.0,
+      "tolerance_pct": 10
+    },
+    "chain_10000.build": {
+      "total_bytes": 5834195,
+      "bytes_per_node": 213.0,
+      "bytes_per_rel": 100.0,
+      "tolerance_pct": 10
+    },
+    "chain_100000.build": {
+      "total_bytes": 57764195,
+      "bytes_per_node": 213.0,
+      "bytes_per_rel": 100.0,
+      "tolerance_pct": 10
+    },
+    "star_1000.build": {
+      "total_bytes": 416075,
+      "bytes_per_node": 212.0,
+      "bytes_per_rel": 99.0,
+      "tolerance_pct": 10
+    },
+    "star_10000.build": {
+      "total_bytes": 4102499,
+      "bytes_per_node": 212.0,
+      "bytes_per_rel": 99.0,
+      "tolerance_pct": 10
+    },
+    "star_100000.build": {
+      "total_bytes": 41452499,
+      "bytes_per_node": 212.0,
+      "bytes_per_rel": 99.0,
+      "tolerance_pct": 10
+    },
+    "social_20k_x8.build": {
+      "total_bytes": 53593249,
+      "bytes_per_node": 543.6,
+      "bytes_per_rel": 205.0,
+      "tolerance_pct": 10
+    },
+    "vector_flat_5k_d128": {
+      "total_bytes": 6829412,
+      "bytes_per_node": 721.0,
+      "tolerance_pct": 10
+    },
+    "vector_hnsw_5k_d128": {
+      "total_bytes": 10459212,
+      "bytes_per_node": 721.0,
+      "tolerance_pct": 15
+    }
+  }
+}

{lora_python-0.12.0 → lora_python-0.14.0}/crates/lora-database/src/database/execute.rs

@@ -75,10 +75,9 @@ where
     ///    mutation record, and `TxCommit` only when mutations occurred,
     ///    then applies the WAL's configured single-thread flush policy.
     /// 4. On Err, `recorder.abort()` clears the pending batch. The
-    ///    engine has no rollback, so the in-memory state may already
-    ///    be partially mutated; the live handle is quarantined while
-    ///    durable recovery stays atomic because no committed batch was
-    ///    written.
+    ///    staged graph is discarded without publishing, so the live
+    ///    in-memory state and durable WAL both remain at the last
+    ///    successful commit.
     /// 5. The recorder's poisoned flag is polled once. If set, the query
     ///    fails loudly with the durability error so the caller can act on it;
     ///    the WAL refuses further appends until the operator restarts the