[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10,"_11":12},"actionData","errors","root",{"_179":-5,"_182":183,"_184":185},"routes/shell",{"_41":42,"_178":-5,"_179":-5,"_180":181},"routes/repo",{"_34":-7,"_35":36,"_37":38,"_39":40,"_41":42,"_43":32,"_44":32,"_45":32,"_46":32,"_47":32,"_48":32,"_49":50,"_51":50,"_52":32,"_53":-7,"_54":-7,"_55":56,"_57":58,"_59":60,"_61":-5,"_62":63,"_64":65,"_66":67,"_68":69},"routes/repo.blob",{"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":-5,"_26":27,"_28":29,"_29":30,"_31":32,"_33":14},"ref","main","path","crates/ltx/src/error.rs","oid","f12a7482c7d00b7a69b1185a7731211b5e5d57bc","size",13980,"commit","90b43017241f81189453d326d05948f388b34652","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","//! error.rs — thiserror-based error model + `Result` alias.\n//!\n//! Ported from litestream@v0.5.11 litestream.go:32-93\n//!\n//! The sentinel errors (`ErrNoSnapshots`, `ErrChecksumMismatch`,\n//! `ErrLTXCorrupted`, `ErrLTXMissing`) and the structured `LTXError` type with\n//! its `IsAutoRecoverable` logic are direct ports of the equivalent Go values.\n\nuse std::io;\nuse thiserror::Error;\n\n/// Crate-wide `Result` alias.\npub type Result = std::result::Result;\n\n/// Top-level error enum for `celld-ltx`.\n///\n/// Variants map 1-to-1 to the sentinel errors and error categories in\n/// `litestream.go`; additional variants cover I/O and other infrastructure.\n#[derive(Debug, Error)]\npub enum Error {\n /// No snapshot is available for restore.\n ///\n /// Corresponds to `ErrNoSnapshots` in litestream.go:33.\n #[error(\"no snapshots available\")]\n NoSnapshots,\n\n /// The replica's rolling checksum does not match what was expected.\n ///\n /// Corresponds to `ErrChecksumMismatch` in litestream.go:34.\n #[error(\"invalid replica, checksum mismatch\")]\n ChecksumMismatch,\n\n /// An LTX file's contents are corrupt (bad magic, truncated, bad CRC, etc.).\n ///\n /// Corresponds to `ErrLTXCorrupted` in litestream.go:35.\n #[error(\"ltx file corrupted\")]\n LTXCorrupted,\n\n /// An expected LTX file is absent from the replica.\n ///\n /// Corresponds to `ErrLTXMissing` in litestream.go:36.\n #[error(\"ltx file missing\")]\n LTXMissing,\n\n /// The requested transaction does not exist on the replica (no backup chain\n /// reaches it).\n ///\n /// Corresponds to `ErrTxNotAvailable` in store.go:27.\n #[error(\"transaction not available\")]\n TxNotAvailable,\n\n /// Structured LTX error with operation context and recovery hints.\n ///\n /// Corresponds to `LTXError` in litestream.go:40-93.\n #[error(\"{0}\")]\n Ltx(#[from] Box),\n\n /// Underlying I/O error.\n #[error(\"io error: {0}\")]\n Io(#[from] io::Error),\n /// The object store refused the credential (HTTP 403).\n #[error(\"the object store refused the credential\")]\n Forbidden,\n\n /// Any other error not yet given a dedicated variant.\n #[error(\"{0}\")]\n Other(#[from] Box),\n}\n\n// ── LTXError ─────────────────────────────────────────────────────────────────\n\n/// Structured error for LTX file operations.\n///\n/// Provides operation context, file path, TXID range, and an optional\n/// human-readable recovery hint. Ported from `LTXError` in\n/// litestream@v0.5.11 litestream.go:40-93.\n#[derive(Debug)]\npub struct LTXError {\n /// Operation that failed (e.g., `\"open\"`, `\"read\"`, `\"validate\"`).\n pub op: String,\n /// File path, if known.\n pub path: String,\n /// LTX compaction level (0 = L0).\n pub level: i32,\n /// Minimum transaction ID in the file.\n pub min_txid: u64,\n /// Maximum transaction ID in the file.\n pub max_txid: u64,\n /// Underlying cause.\n pub err: Box,\n /// Human-readable recovery hint (empty when not applicable).\n pub hint: String,\n}\n\nimpl std::fmt::Display for LTXError {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n // Matches the Go Error() method:\n // if e.Path != \"\" { return e.Op + \" ltx file \" + e.Path + \": \" + e.Err.Error() }\n // return e.Op + \" ltx file: \" + e.Err.Error()\n if self.path.is_empty() {\n write!(f, \"{} ltx file: {}\", self.op, self.err)\n } else {\n write!(f, \"{} ltx file {}: {}\", self.op, self.path, self.err)\n }\n }\n}\n\nimpl std::error::Error for LTXError {\n fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {\n Some(self.err.as_ref())\n }\n}\n\nimpl LTXError {\n /// Returns `true` when the error represents local state corruption that\n /// can be fixed by resetting and re-downloading from the remote replica.\n ///\n /// Returns `false` for transient OS errors (permission denied, I/O error)\n /// that should be retried with back-off instead.\n ///\n /// Ported from `LTXError.IsAutoRecoverable` in litestream.go:63-71.\n ///\n /// Uses chain-walking (via `source()`) to mirror Go's `errors.Is` semantics:\n /// a context-wrapped sentinel (e.g. `Error::Other(Box::new(Error::LTXCorrupted))`,\n /// mirroring `fmt.Errorf(\"%w: bad data\", ErrLTXCorrupted)`) is still\n /// recognized as auto-recoverable.\n pub fn is_auto_recoverable(&self) -> bool {\n let err_ref: &dyn std::error::Error = self.err.as_ref();\n // os.IsNotExist equivalent: walk chain for io::ErrorKind::NotFound\n if chain_contains_not_found(err_ref) {\n return true;\n }\n // errors.Is(e.Err, ErrLTXMissing) — walk chain for marker or sentinel\n if chain_contains::(err_ref)\n || chain_contains_error_variant(err_ref, ErrorVariantKind::LTXMissing)\n {\n return true;\n }\n // errors.Is(e.Err, ErrLTXCorrupted) || errors.Is(e.Err, ErrChecksumMismatch)\n // Walk chain for marker types or bare sentinel variants.\n if chain_contains::(err_ref)\n || chain_contains_error_variant(err_ref, ErrorVariantKind::LTXCorrupted)\n || chain_contains::(err_ref)\n || chain_contains_error_variant(err_ref, ErrorVariantKind::ChecksumMismatch)\n {\n return true;\n }\n false\n }\n}\n\n// ── Chain-walking helpers ─────────────────────────────────────────────────────\n//\n// Go's `errors.Is` walks the full error chain via `Unwrap()`. Rust's\n// `std::error::Error::source()` is the equivalent. The helpers below replicate\n// that chain-walking so that a context-wrapped sentinel (e.g.\n// `Error::Other(Box::new(Error::LTXCorrupted))`) is still detected as a\n// recoverable cause — matching litestream.go:63-70.\n\n/// Returns `true` if any error in the `source()` chain can be downcast to `E`.\nfn chain_contains(err: &(dyn std::error::Error + 'static)) -> bool {\n if err.downcast_ref::().is_some() {\n return true;\n }\n if let Some(src) = err.source() {\n return chain_contains::(src);\n }\n false\n}\n\n/// Returns `true` if any error in the `source()` chain is an `io::Error` with\n/// kind `ErrorKind::NotFound`.\nfn chain_contains_not_found(err: &(dyn std::error::Error + 'static)) -> bool {\n if let Some(io_err) = err.downcast_ref::() {\n if io_err.kind() == io::ErrorKind::NotFound {\n return true;\n }\n }\n if let Some(src) = err.source() {\n return chain_contains_not_found(src);\n }\n false\n}\n\n/// Discriminator for which `Error` sentinel variant we are searching for.\n#[derive(Clone, Copy)]\nenum ErrorVariantKind {\n LTXCorrupted,\n LTXMissing,\n ChecksumMismatch,\n}\n\n/// Returns `true` if any error in the `source()` chain is an `Error` enum\n/// variant matching `kind`.\n///\n/// This handles the case where an `Error` sentinel is wrapped inside\n/// `Error::Other(...)`, mirroring Go's `errors.Is(err, ErrLTXCorrupted)`.\nfn chain_contains_error_variant(\n err: &(dyn std::error::Error + 'static),\n kind: ErrorVariantKind,\n) -> bool {\n if let Some(e) = err.downcast_ref::() {\n let matches = match kind {\n ErrorVariantKind::LTXCorrupted => matches!(e, Error::LTXCorrupted),\n ErrorVariantKind::LTXMissing => matches!(e, Error::LTXMissing),\n ErrorVariantKind::ChecksumMismatch => matches!(e, Error::ChecksumMismatch),\n };\n if matches {\n return true;\n }\n }\n if let Some(src) = err.source() {\n return chain_contains_error_variant(src, kind);\n }\n false\n}\n\n// ── Marker error types for downcast detection ─────────────────────────────────\n//\n// The Go code uses `errors.Is` against sentinel `var` values. Rust's\n// `thiserror` approach is to use concrete unit-struct error types that we can\n// `downcast_ref` to. These are internal implementation details; callers use\n// the public `new_ltx_error` constructor which accepts `Error` values and\n// wraps them appropriately.\n\n/// Marker wrapping `Error::LTXMissing` so `LTXError::is_auto_recoverable` can\n/// detect it via `downcast_ref`.\n#[derive(Debug)]\nstruct LTXMissingMarker;\nimpl std::fmt::Display for LTXMissingMarker {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n f.write_str(\"ltx file missing\")\n }\n}\nimpl std::error::Error for LTXMissingMarker {}\n\n/// Marker wrapping `Error::LTXCorrupted`.\n#[derive(Debug)]\nstruct LTXCorruptedMarker;\nimpl std::fmt::Display for LTXCorruptedMarker {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n f.write_str(\"ltx file corrupted\")\n }\n}\nimpl std::error::Error for LTXCorruptedMarker {}\n\n/// Marker wrapping `Error::ChecksumMismatch`.\n#[derive(Debug)]\nstruct ChecksumMismatchMarker;\nimpl std::fmt::Display for ChecksumMismatchMarker {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n f.write_str(\"invalid replica, checksum mismatch\")\n }\n}\nimpl std::error::Error for ChecksumMismatchMarker {}\n\n// ── Public constructor ─────────────────────────────────────────────────────────\n\n/// Creates a new [`LTXError`] with appropriate recovery hints based on the\n/// underlying error kind.\n///\n/// Ported from `NewLTXError` in litestream@v0.5.11 litestream.go:74-93.\n///\n/// Uses chain-walking (matching Go's `errors.Is` semantics) so that a\n/// context-wrapped sentinel — e.g. `Error::Other(Box::new(Error::LTXCorrupted))`,\n/// mirroring `fmt.Errorf(\"%w: bad data\", ErrLTXCorrupted)` — is still\n/// classified and hinted correctly.\n///\n/// # Arguments\n/// * `op` – Operation name (e.g. `\"open\"`, `\"read\"`).\n/// * `path` – File path (empty string if unknown).\n/// * `level` – LTX compaction level.\n/// * `min_txid` – Minimum TXID in the file.\n/// * `max_txid` – Maximum TXID in the file.\n/// * `err` – Cause; accepts `Error` or any boxed error.\npub fn new_ltx_error(\n op: impl Into,\n path: impl Into,\n level: i32,\n min_txid: u64,\n max_txid: u64,\n err: Error,\n) -> LTXError {\n let op = op.into();\n let path = path.into();\n\n // Choose the boxed inner error and hint based on the error kind.\n // We use chain-walking helpers (matching Go's errors.Is semantics) so that\n // a context-wrapped sentinel — e.g. Error::Other(Box::new(Error::LTXCorrupted))\n // mirroring fmt.Errorf(\"%w: bad data\", ErrLTXCorrupted) — is classified\n // correctly. The marker wrappers ensure is_auto_recoverable() can detect the\n // kind via downcast_ref after the boxed error is stored.\n //\n // Ported from NewLTXError litestream@v0.5.11 litestream.go:74-93.\n let err_as_std: &dyn std::error::Error = &err;\n\n let (inner, hint): (Box, String) =\n if chain_contains_not_found(err_as_std) {\n let hint = \"LTX file is missing. This can happen after VACUUM, manual checkpoint, \\\n or state corruption. Run 'litestream reset ' or delete the \\\n .sqlite-litestream directory and restart.\"\n .to_string();\n // Preserve the original NotFound error for source() chain fidelity.\n (\n Box::new(io::Error::new(io::ErrorKind::NotFound, err.to_string())),\n hint,\n )\n } else if matches!(&err, Error::LTXMissing)\n || chain_contains::(err_as_std)\n || chain_contains_error_variant(err_as_std, ErrorVariantKind::LTXMissing)\n {\n let hint = \"LTX file is missing. This can happen after VACUUM, manual checkpoint, \\\n or state corruption. Run 'litestream reset ' or delete the \\\n .sqlite-litestream directory and restart.\"\n .to_string();\n (Box::new(LTXMissingMarker), hint)\n } else if matches!(&err, Error::LTXCorrupted)\n || chain_contains::(err_as_std)\n || chain_contains_error_variant(err_as_std, ErrorVariantKind::LTXCorrupted)\n {\n let hint = \"LTX file is corrupted. Delete the .sqlite-litestream directory and \\\n restart to recover from replica.\"\n .to_string();\n (Box::new(LTXCorruptedMarker), hint)\n } else if matches!(&err, Error::ChecksumMismatch)\n || chain_contains::(err_as_std)\n || chain_contains_error_variant(err_as_std, ErrorVariantKind::ChecksumMismatch)\n {\n let hint = \"LTX file is corrupted. Delete the .sqlite-litestream directory and \\\n restart to recover from replica.\"\n .to_string();\n (Box::new(ChecksumMismatchMarker), hint)\n } else {\n (Box::new(OpaqueError(err.to_string())), String::new())\n };\n\n LTXError {\n op,\n path,\n level,\n min_txid,\n max_txid,\n err: inner,\n hint,\n }\n}\n\n/// Thin wrapper so we can box an arbitrary `Error` string for the catch-all arm.\n#[derive(Debug)]\nstruct OpaqueError(String);\nimpl std::fmt::Display for OpaqueError {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n f.write_str(&self.0)\n }\n}\nimpl std::error::Error for OpaqueError {}\n","editable",false,"branch","documentNavigation","repo","denoland/celld","repoId","a23b8a10-92cf-4dc4-a7ab-a04e58298dde","ownerId","org:42048915","site","nexthub","private","admin","settings","maintainer","triage","starred","stars",1,"watchers","watching","pinned","notify","views",[134,135,136,137,138,139,140,141,142,143,144,145,146],"navigation",{"_55":56,"_91":92,"_93":94,"_95":96,"_97":98,"_99":100,"_101":102},"sources",[],"viewer","meta",{"_83":84,"_85":86,"_87":88,"_43":32,"_89":14,"_90":32,"_49":50,"_51":50},"branches",[14],"tags",[70,71,72,73,74,75,76,77,78,79,80,81,82],"cloneUrl","https://git.nexthub.sh/denoland/celld.git","v0.0.1","v0.0.2","v0.1.0","v0.2.0","v0.2.1","v0.3.0","v0.4.0","v0.4.1","v0.5.0","v0.5.1","v0.6.0","v0.6.1","v0.6.2","description","self-hosted, distributed Durable Objects","owner","denoland","section","","head","empty","pins",[116,117,118],"documents",{"_111":112,"_113":114},"code",{"_108":109,"_110":104},"automations",{"_106":50,"_107":-5},"delivery",{"_103":104,"_105":-5},"tag","7gTA52Z9a1vO6FP6eCQPix9zO4O","releases",0,"applications","workflows","deployments","commits",13,"changes","counts",{"_115":114},"total",38,"issue",{"_119":110,"_121":132,"_15":110,"_123":133,"_53":125,"_126":32,"_127":125,"_128":104},{"_119":129,"_121":130,"_15":129,"_123":131,"_53":125,"_126":32,"_127":125,"_128":104},{"_119":120,"_121":122,"_15":120,"_123":124,"_53":125,"_126":32,"_127":125,"_128":114},"id","issues","name","Issues","filters",{},true,"saved","pinnable","count","tasks","Tasks",{},"Changes",{},{"_119":110,"_121":132,"_15":110,"_123":177,"_53":125,"_126":32,"_127":125},{"_119":129,"_121":130,"_15":129,"_123":176,"_53":125,"_126":32,"_127":125},{"_119":120,"_121":122,"_15":120,"_123":175,"_53":125,"_126":32,"_127":125},{"_119":172,"_121":173,"_15":172,"_123":174,"_53":32,"_126":32,"_127":125},{"_119":169,"_121":170,"_15":169,"_123":171,"_53":32,"_126":32,"_127":125},{"_119":106,"_121":167,"_15":97,"_123":168,"_53":32,"_126":32,"_127":125},{"_119":107,"_121":164,"_15":165,"_123":166,"_53":32,"_126":32,"_127":125},{"_119":103,"_121":162,"_15":103,"_123":163,"_53":32,"_126":32,"_127":125},{"_119":158,"_121":159,"_15":160,"_123":161,"_53":32,"_126":32,"_127":125},{"_119":93,"_121":156,"_15":93,"_123":157,"_53":32,"_126":32,"_127":32},{"_119":153,"_121":154,"_15":153,"_123":155,"_53":32,"_126":32,"_127":32},{"_119":150,"_121":151,"_15":150,"_123":152,"_53":32,"_126":32,"_127":32},{"_119":147,"_121":148,"_15":147,"_123":149,"_53":32,"_126":32,"_127":32},"decisions","Decisions",{},"changelog","Changelog",{},"roadmap","Roadmap",{},"Documents",{},"activity","Activity","insights",{},"Releases",{},"Deployments","automations/deployments",{},"Workflows",{},"discussions","Discussions",{},"goals","Goals",{},{},{},{},"groups","user","agents",[],"now",1794435657204,"sidebar","expanded"]