Commit CRDT writes, coerce VECTOR literals, restore cluster tests

.config/nextest.toml

@@ -212,35 +212,17 @@ server-process-serial = { max-threads = 1 }
 retries = { backoff = "fixed", count = 1, delay = "2s" }
 fail-fast = false
 
-# Four cluster tests are excluded from the CI profile ONLY. They still run under
-# the default profile, which is what a local `cargo nextest run` uses, because
-# they pass locally — CI is the sole environment they fail in.
+# One cluster test is excluded from the CI profile ONLY. It still runs under the
+# default profile, which is what a local `cargo nextest run` uses.
 #
-# All four hang identically: the coordinator never receives a Calvin completion
-# ack and the statement dies with `timed out waiting for Calvin completion`.
-# Raising the internal request deadline from 30s to 120s was tried and did NOT
-# help — they timed out at 120s as well, which is what rules out slowness and
-# establishes a genuine hang. They reproduce on CI on every attempt and have
-# never reproduced locally: not in isolation, not inside the full cluster suite,
-# and not pinned to two cores.
-#
-# This is NOT retry-masking. The `retries` above were already being exhausted
-# against them on every run; excluding makes the gap explicit rather than
-# leaving it to hide in retry noise.
-#
-# `learner_caught_up_via_real_install_snapshot` and
-# `native_implicit_edge_delete_cleans_reverse_cross_node` were passing on CI
-# before this release branch and regressed, so start there. The open suspect is
-# the sequencer catch-up armed at scheduler spawn, which replays the retained
-# sequencer log and may disturb in-flight Calvin transactions. Re-enable by
-# diagnosing the Calvin completion path on a CI run — NOT by widening a timeout.
+# `learner_caught_up_via_real_install_snapshot` fails on CI runners about once in
+# six runs. A newly elected sequencer leader whose log was compacted refuses to
+# propose ("sequencer log was truncated below every retained epoch"), so the
+# sequencer stalls. The joining node then never catches up on the sequencer
+# group, and its authorization lease is withheld. Re-enable it once a leader can
+# seed its epoch from the installed sequencer snapshot. NEVER widen a timeout.
 default-filter = """
-not (
-    test(ollp_implicit_edge_delete_cleans_reverse_cross_node)
-    or test(ollp_implicit_edge_update_moves_edge_cross_node)
-    or test(learner_caught_up_via_real_install_snapshot)
-    or test(native_implicit_edge_delete_cleans_reverse_cross_node)
-)
+not test(learner_caught_up_via_real_install_snapshot)
 """
 
 # CI-only cluster headroom. On CI runners (~2× slower per-core than a dev

nodedb-cluster/src/rpc_codec/data_plane_error.rs

@@ -228,6 +228,15 @@ pub enum DataPlaneErrorCode {
     DatetimeFieldOverflow {
         detail: String,
     },
+    /// The request names an object that does not exist (SQLSTATE `42704`).
+    UndefinedObject {
+        object: String,
+    },
+    /// The object is not in the state the request needs (SQLSTATE `55000`).
+    ObjectNotInPrerequisiteState {
+        object: String,
+        detail: String,
+    },
 }
 
 /// Wire mirror of `nodedb_types::text_search::TextColumnFault`.

nodedb-crdt/src/error.rs

@@ -53,6 +53,9 @@ pub enum CrdtError {
 
     /// Preview requires a quiescent authoritative state and refuses to commit
     /// a caller's pending auto-commit transaction as a side effect of forking.
+    ///
+    /// Every `CrdtState` mutator commits before it returns. This error
+    /// therefore means that invariant broke, never that a client erred.
     #[error("delta preview source has {operations} pending operations")]
     PreviewSourceTransactionPending { operations: usize },
 
@@ -111,6 +114,33 @@ pub enum CrdtError {
         discarded: i32,
     },
 
+    /// The row did not exist at the requested version, so there is no state
+    /// to read or restore there.
+    #[error("document `{row_id}` in collection `{collection}` did not exist at the target version")]
+    RowAbsentAtVersion { collection: String, row_id: String },
+
+    /// A block-list operation named a row that does not exist, or a row that
+    /// is not a map of fields.
+    #[error("row `{row_id}` in collection `{collection}` is absent or is not a map")]
+    BlockListRowAbsent { collection: String, row_id: String },
+
+    /// A block-list path segment is absent, or holds a value of the wrong kind.
+    #[error("block-list path `{list_path}`: segment `{segment}` is absent or has the wrong type")]
+    BlockListPathUnresolved { list_path: String, segment: String },
+
+    /// A block-list path resolves to a plain list. Block lists must be movable
+    /// lists, so concurrent reorders converge without duplicates.
+    #[error("block-list path `{list_path}` is a plain list, not a movable list")]
+    BlockListNotMovable { list_path: String },
+
+    /// A block-list index is past the end of the list.
+    #[error("block-list `{list_path}` index {index} is out of bounds (len {len})")]
+    BlockListIndexOutOfBounds {
+        list_path: String,
+        index: usize,
+        len: usize,
+    },
+
     /// Loro internal error.
     #[error("loro error: {0}")]
     Loro(String),