[{"_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/lib.rs","oid","edcac5175495cd142f84495e21439c13a62c75b7","size",21780,"commit","90b43017241f81189453d326d05948f388b34652","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","#![warn(clippy::disallowed_methods, clippy::disallowed_types)]\n\n//! `celld-ltx` provides embeddable streaming replication for a SQLite database.\n//! It captures WAL data as LTX segments, reads and writes replica storage,\n//! restores databases, compacts levels, and reads bundle objects.\n//!\n//! The original replication behavior is a from-scratch Rust reimplementation\n//! of Litestream v0.5.11. The block format follows LTX v0.5.2.\n//!\n//! # Core position and identity helpers\n//!\n//! Ported from litestream@v0.5.11 litestream.go:18-203 and\n//! ltx@v0.5.2 ltx.go:66-145.\n\npub mod bundle;\npub mod client;\nmod codec;\npub mod compaction_level;\npub mod compactor;\npub mod db;\npub mod error;\npub mod host;\npub mod ltx;\nmod lz4_block;\npub mod paged;\npub mod paged_vfs;\npub mod replica;\npub mod replica_compactor;\npub mod replica_url;\npub mod wal;\n\n/// The unstable implementation API supports external verification tools.\n///\n/// This module has no compatibility guarantee.\n#[doc(hidden)]\npub mod internal {\n pub use crate::db::internal as db;\n pub use crate::lz4_block::internal as lz4_block;\n pub use crate::replica::internal as replica;\n\n #[cfg(feature = \"s3\")]\n pub use crate::client::object_store::internal as object_store;\n}\n\n// ── Crate-root re-exports — the ergonomic public surface ────────────────\n//\n// These `pub use` aliases let a host use `celld_ltx::Db`, `celld_ltx::Replica`,\n// and `celld_ltx::restore` without naming the owning module. The original module\n// paths, such as `celld_ltx::db::Db`, remain valid.\n\n// Re-export the error model at the crate root.\npub use error::{new_ltx_error, Error, LTXError, Result};\npub use host::{\n DirectFileSystem, FileSystem, HostDirEntry, HostFile, HostFileIo, HostMetadata, HostTaskError,\n LtxHost,\n};\n\n/// A SQLite database managed for replication (WAL-mode checkpoint takeover plus\n/// the WAL→LTX capture loop). Re-exported from [`crate::db::Db`].\npub use db::Db;\n\n/// SQLite checkpoint mode used by [`Db`] when it checkpoints the WAL.\n/// Re-exported from [`crate::db::CheckpointMode`].\npub use db::CheckpointMode;\n\n/// Connects a managed [`Db`] to a replication destination and drives the\n/// single-replica sync loop. Re-exported from [`crate::replica::Replica`].\npub use replica::Replica;\n\n/// Restores a database from a [`ReplicaClient`] into a fresh file, optionally up\n/// to a target [`TXID`]. Re-exported from [`crate::replica::restore`].\npub use replica::restore;\n\n/// The storage abstraction every replica backend implements.\n/// Re-exported from [`crate::client::ReplicaClient`].\npub use client::ReplicaClient;\n\n/// Metadata describing a single LTX file on a replica (the value type returned by\n/// [`ReplicaClient`] listings). Re-exported from [`crate::ltx::FileInfo`].\npub use ltx::FileInfo;\n\n/// A [`ReplicaClient`] that stores LTX files on the local filesystem.\n/// Re-exported from [`crate::client::file::FileReplicaClient`].\npub use client::file::FileReplicaClient;\n\n/// The bundle overlay (celld-original, self-contained).\n/// Re-exported from [`crate::client::bundle`].\npub use client::bundle::BundleFetcher;\npub use client::bundle::BundleOverlayClient;\npub use client::bundle::LocatedRow;\n\n/// The S3/R2/MinIO [`ReplicaClient`], behind the `s3` feature.\n/// Re-exported from [`crate::client::object_store::ObjectStoreClient`].\n#[cfg(feature = \"s3\")]\npub use client::object_store::ObjectStoreClient;\n\n/// Configuration for the S3/R2/MinIO backend, behind the `s3` feature.\n/// Re-exported from [`crate::client::object_store::ObjectStoreConfig`].\n#[cfg(feature = \"s3\")]\npub use client::object_store::ObjectStoreConfig;\n\n/// Which object-metadata name carries an LTX header timestamp, behind the\n/// `s3` feature. Re-exported from\n/// [`crate::client::object_store::TimestampMetadataKey`].\n#[cfg(feature = \"s3\")]\npub use client::object_store::TimestampMetadataKey;\n\n/// The underlying `object_store` crate, re-exported so a host can name the\n/// shared `Arc` that [`ObjectStoreConfig::build_store`] returns\n/// and hand it to [`ObjectStoreClient::with_store`].\npub use object_store;\n\n// ── Naming constants ──────────────────────────────────────────────────────────\n\n/// Suffix appended to a database path to obtain the Litestream metadata\n/// directory.\n///\n/// Ported from litestream@v0.5.11 litestream.go:19 (`MetaDirSuffix`).\npub const META_DIR_SUFFIX: &str = \"-litestream\";\n\n// ── SQLite checkpoint modes ───────────────────────────────────────────────────\n//\n// Ported from litestream@v0.5.11 litestream.go:22-28.\n\npub const CHECKPOINT_MODE_PASSIVE: &str = \"PASSIVE\";\npub const CHECKPOINT_MODE_FULL: &str = \"FULL\";\npub const CHECKPOINT_MODE_RESTART: &str = \"RESTART\";\npub const CHECKPOINT_MODE_TRUNCATE: &str = \"TRUNCATE\";\n\n// ── SQLite WAL size constants ─────────────────────────────────────────────────\n//\n// Ported from litestream@v0.5.11 litestream.go:95-128.\n\n/// Size of a SQLite WAL file header, in bytes.\npub const WAL_HEADER_SIZE: usize = 32;\n\n/// Size of a SQLite WAL frame header, in bytes.\npub const WAL_FRAME_HEADER_SIZE: usize = 24;\n\n/// Byte offset of the checksum pair inside a WAL header.\npub const WAL_HEADER_CHECKSUM_OFFSET: usize = 24;\n\n/// Byte offset of the checksum pair inside a WAL frame header.\npub const WAL_FRAME_HEADER_CHECKSUM_OFFSET: usize = 16;\n\n// ── TXID ──────────────────────────────────────────────────────────────────────\n\n/// A monotonically increasing transaction identifier.\n///\n/// Represented as a `u64` and formatted as a zero-padded 16-character\n/// lowercase hex string (e.g. `\"0000000000000001\"`). This matches the\n/// on-disk LTX filename convention and `ltx.TXID.String()` in\n/// ltx@v0.5.1 ltx.go:142-144.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]\npub struct TXID(pub u64);\n\nimpl TXID {\n /// The zero TXID.\n pub const ZERO: TXID = TXID(0);\n\n /// Returns the raw `u64` value.\n #[inline]\n pub fn get(self) -> u64 {\n self.0\n }\n}\n\nimpl std::fmt::Display for TXID {\n /// Formats as a 16-digit lowercase hex string, zero-padded.\n ///\n /// Ported from `TXID.String()` in ltx@v0.5.1 ltx.go:142.\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"{:016x}\", self.0)\n }\n}\n\n/// Parses a TXID from its canonical 16-character lowercase hex representation.\n///\n/// Returns an error if the string is not exactly 16 hex characters or contains\n/// any character outside `[0-9a-fA-F]`.\n///\n/// Ported from `ParseTXID` in ltx@v0.5.1 ltx.go:130-138.\n///\n/// Note: Go's `strconv.ParseUint(s, 16, 64)` rejects sign prefixes (`+`, `-`).\n/// Rust's `u64::from_str_radix` accepts a leading `+`, which would be a\n/// behavioural divergence. We pre-validate that every byte is a valid hex\n/// digit to match Go's stricter contract.\npub fn parse_txid(s: &str) -> Result {\n if s.len() != 16 {\n return Err(Error::Other(\n format!(\"invalid formatted transaction id length: {:?}\", s).into(),\n ));\n }\n // Reject any character outside [0-9a-fA-F]. This matches Go's\n // strconv.ParseUint which rejects sign prefixes ('+'/'-') and any\n // non-hex byte, whereas Rust's from_str_radix would accept a leading '+'.\n if !s.bytes().all(|b| b.is_ascii_hexdigit()) {\n return Err(Error::Other(\n format!(\"invalid transaction id format: {:?}\", s).into(),\n ));\n }\n let v = u64::from_str_radix(s, 16)\n .map_err(|_| Error::Other(format!(\"invalid transaction id format: {:?}\", s).into()))?;\n Ok(TXID(v))\n}\n\nimpl From for TXID {\n fn from(v: u64) -> Self {\n TXID(v)\n }\n}\n\nimpl From for u64 {\n fn from(t: TXID) -> Self {\n t.0\n }\n}\n\n// ── Checksum ──────────────────────────────────────────────────────────────────\n\n/// A 64-bit LTX rolling / file checksum.\n///\n/// The high bit is the `ChecksumFlag` sentinel used by the LTX format to\n/// distinguish a real checksum from an absent one.\n///\n/// Ported from ltx@v0.5.1 ltx.go (type alias `Checksum uint64`).\npub type Checksum = u64;\n\n/// Flag bit set on every valid non-zero LTX checksum.\n///\n/// Ported from `ChecksumFlag` in ltx@v0.5.1 ltx.go:55.\npub const CHECKSUM_FLAG: Checksum = 1 << 63;\n\n// ── Pos ──────────────────────────────────────────────────────────────────────\n\n/// Replication position — the TXID plus a rolling post-apply checksum.\n///\n/// Together these two values uniquely identify the state of a database at a\n/// point in the replication log.\n///\n/// Ported from `Pos` / `ParsePos` / `Pos.String` in ltx@v0.5.1 ltx.go:66-109.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]\npub struct Pos {\n /// Transaction ID at this position.\n pub txid: TXID,\n /// Rolling CRC checksum of the database state after applying the\n /// transaction at `txid`.\n pub post_apply_checksum: Checksum,\n}\n\nimpl Pos {\n /// The zero position (no transactions applied yet).\n pub const ZERO: Pos = Pos {\n txid: TXID::ZERO,\n post_apply_checksum: 0,\n };\n\n /// Constructs a new `Pos`.\n ///\n /// Ported from `NewPos` in ltx@v0.5.1 ltx.go:72.\n pub fn new(txid: TXID, post_apply_checksum: Checksum) -> Self {\n Pos {\n txid,\n post_apply_checksum,\n }\n }\n\n /// Returns `true` when this is the zero position.\n ///\n /// Ported from `Pos.IsZero` in ltx@v0.5.1 ltx.go:107.\n pub fn is_zero(self) -> bool {\n self == Pos::ZERO\n }\n}\n\nimpl std::fmt::Display for Pos {\n /// Formats as `\"/\"` — e.g. `\"0000000000000001/8000000000000001\"`.\n ///\n /// Ported from `Pos.String` in ltx@v0.5.1 ltx.go:102.\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"{}/{:016x}\", self.txid, self.post_apply_checksum)\n }\n}\n\n/// Parses a `Pos` from its canonical `\"/\"` string form.\n///\n/// The string must be exactly 33 characters: 16 hex digits, a slash, and\n/// 16 hex digits.\n///\n/// Ported from `ParsePos` in ltx@v0.5.1 ltx.go:80-99.\npub fn parse_pos(s: &str) -> Result {\n if s.len() != 33 {\n return Err(Error::Other(\n format!(\"invalid formatted position length: {:?}\", s).into(),\n ));\n }\n let txid = parse_txid(&s[..16])\n .map_err(|_| Error::Other(format!(\"invalid position txid: {:?}\", &s[..16]).into()))?;\n // Validate that byte 16 is '/' (the separator) even though\n // Go's ParsePos (ltx@v0.5.1 ltx.go:80-99) blindly slices s[:16] and s[17:]\n // without checking the separator byte, so Go would accept e.g.\n // \"0000000000000001X8000000000000001\". We keep the stricter check because:\n // (a) the '/' is mandated by the format doc and Pos.String() always emits it,\n // (b) silently accepting a malformed separator would hide caller bugs, and\n // (c) no production caller requires compatibility with the malformed form.\n // This is the conservative interpretation because it rejects bad input.\n if s.as_bytes()[16] != b'/' {\n return Err(Error::Other(\n format!(\"invalid formatted position (missing /): {:?}\", s).into(),\n ));\n }\n // Same sign-prefix pre-validation as parse_txid: reject non-hex characters\n // so we match Go's strconv.ParseUint contract for the checksum field too.\n let checksum_str = &s[17..];\n if !checksum_str.bytes().all(|b| b.is_ascii_hexdigit()) {\n return Err(Error::Other(\n format!(\"invalid position checksum: {:?}\", checksum_str).into(),\n ));\n }\n let checksum = u64::from_str_radix(checksum_str, 16).map_err(|_| {\n Error::Other(format!(\"invalid position checksum: {:?}\", checksum_str).into())\n })?;\n Ok(Pos {\n txid,\n post_apply_checksum: checksum,\n })\n}\n\n// ── SQLite checksum ───────────────────────────────────────────────────────────\n\n/// Computes a running SQLite WAL checksum over a byte slice.\n///\n/// The slice length **must** be a multiple of 8 bytes (the function panics\n/// otherwise, matching the `assert` in the Go source).\n///\n/// `s0` / `s1` are the running checksum values (pass `(0, 0)` for the first\n/// call, then thread the result through subsequent calls for incremental\n/// checksumming).\n///\n/// `big_endian` selects the byte order used to read 32-bit words from `b`:\n/// `true` = big-endian (WAL headers with magic `0x377f0683`),\n/// `false` = little-endian (WAL headers with magic `0x377f0682`).\n///\n/// Ported from `Checksum` in litestream@v0.5.11 litestream.go:110-119.\n///\n/// # Panics\n/// Panics if `b.len() % 8 != 0`.\npub fn wal_checksum(big_endian: bool, s0: u32, s1: u32, b: &[u8]) -> (u32, u32) {\n assert!(b.len().is_multiple_of(8), \"misaligned checksum byte slice\");\n\n let mut s0 = s0;\n let mut s1 = s1;\n\n // Iterate over 8-byte units and compute checksum.\n // Matches litestream.go Checksum loop exactly.\n let mut i = 0usize;\n while i < b.len() {\n let w0 = if big_endian {\n u32::from_be_bytes([b[i], b[i + 1], b[i + 2], b[i + 3]])\n } else {\n u32::from_le_bytes([b[i], b[i + 1], b[i + 2], b[i + 3]])\n };\n let w1 = if big_endian {\n u32::from_be_bytes([b[i + 4], b[i + 5], b[i + 6], b[i + 7]])\n } else {\n u32::from_le_bytes([b[i + 4], b[i + 5], b[i + 6], b[i + 7]])\n };\n s0 = s0.wrapping_add(w0).wrapping_add(s1);\n s1 = s1.wrapping_add(w1).wrapping_add(s0);\n i += 8;\n }\n (s0, s1)\n}\n\n// ── Forward-slash path cleaning (Go stdlib `path`) ────────────────────────────\n//\n// The LTX path helpers below build object-store keys with Go's `path.Join`\n// (NOT `filepath.Join`): the OS-independent, always-`/` package in\n// `go/src/path/path.go`. `path.Join` concatenates non-empty elements with a\n// single `/` then runs the result through `path.Clean`, which collapses\n// repeated separators, resolves `.`/`..`, and strips trailing slashes. A\n// naive `format!(\"{}/ltx\", root)` skips this cleaning, so a root carrying a\n// trailing slash (e.g. an S3 prefix `\"backups/\"`) would yield a DIFFERENT\n// object key than the real binary (`\"backups//ltx\"` vs `\"backups/ltx\"`),\n// breaking byte compatibility. We port `Clean`/`Join` byte-for-byte.\n\n/// Lexically cleans a slash-separated path.\n///\n/// A faithful port of `Clean` in the Go standard library `path` package\n/// (`go/src/path/path.go`, `func Clean`). It applies these rules iteratively\n/// until no further processing is possible:\n/// 1. Replace multiple slashes with a single slash.\n/// 2. Eliminate each `.` path-name element (the current directory).\n/// 3. Eliminate each inner `..` element along with the non-`..` element\n/// preceding it.\n/// 4. Eliminate `..` elements that begin a rooted path (i.e. `/..` → `/`).\n///\n/// The returned path ends in a slash only if it is the root `\"/\"`. An empty\n/// input returns `\".\"`.\n///\n/// `pub(crate)` so `replica_url::clean_replica_url_path` can reuse Go's\n/// `path.Clean` semantics rather than reimplementing them.\npub(crate) fn path_clean(path: &str) -> String {\n if path.is_empty() {\n return \".\".to_string();\n }\n\n let bytes = path.as_bytes();\n let rooted = bytes[0] == b'/';\n let n = bytes.len();\n\n // Mirror Go's `lazybuf` with an explicit write cursor `w` over a fully\n // allocated buffer (we do not bother with Go's lazy aliasing optimisation,\n // but we DO preserve its cursor semantics, which the previous Vec-length\n // port got wrong). `dotdot` marks the index below which `..` elements may\n // not backtrack. The output is `buf[..w]`, so the byte at index `w` is the\n // next byte to be written — and is logically NOT part of the output yet.\n //\n // The backtrack loop must read `buf[w]` (the byte the cursor lands on),\n // NOT `buf[w-1]`: when it stops on a separator, that separator sits at\n // index `w` and is therefore EXCLUDED from `buf[..w]`. A Vec-length model\n // that inspects `out.last()` (i.e. `buf[w-1]`) instead leaves the surviving\n // separator in the buffer, doubling it before the next element — the bug\n // this rewrite fixes. See `go/src/path/path.go` `func Clean` / `lazybuf`.\n let mut buf: Vec = vec![0u8; n];\n let mut w = 0usize;\n let mut r = 0usize;\n let mut dotdot = 0usize;\n if rooted {\n buf[w] = b'/';\n w += 1;\n r = 1;\n dotdot = 1;\n }\n\n while r < n {\n if bytes[r] == b'/' {\n // empty path element\n r += 1;\n } else if bytes[r] == b'.' && (r + 1 == n || bytes[r + 1] == b'/') {\n // `.` element\n r += 1;\n } else if bytes[r] == b'.'\n && r + 1 < n\n && bytes[r + 1] == b'.'\n && (r + 2 == n || bytes[r + 2] == b'/')\n {\n // `..` element: remove to last `/`\n r += 2;\n if w > dotdot {\n // can backtrack: step back over the just-ended element body,\n // then keep stepping while the byte at the cursor is not '/'.\n // When this stops on a '/', the cursor rests AT that '/', so it\n // is excluded from `buf[..w]` (matching Go's `out.w` semantics).\n w -= 1;\n while w > dotdot && buf[w] != b'/' {\n w -= 1;\n }\n } else if !rooted {\n // cannot backtrack, but not rooted, so append `..` element.\n if w > 0 {\n buf[w] = b'/';\n w += 1;\n }\n buf[w] = b'.';\n w += 1;\n buf[w] = b'.';\n w += 1;\n dotdot = w;\n }\n } else {\n // real path element; add slash if needed\n if (rooted && w != 1) || (!rooted && w != 0) {\n buf[w] = b'/';\n w += 1;\n }\n // copy element\n while r < n && bytes[r] != b'/' {\n buf[w] = bytes[r];\n w += 1;\n r += 1;\n }\n }\n }\n\n // Turn empty string into \".\"\n if w == 0 {\n return \".\".to_string();\n }\n buf.truncate(w);\n // SAFETY-free: `buf` is built only from ASCII `/`, `.`, and bytes copied\n // verbatim from the valid-UTF-8 `path`, so it is always valid UTF-8.\n String::from_utf8(buf).expect(\"path_clean produced valid UTF-8\")\n}\n\n/// Joins any number of path elements into a single slash-separated path,\n/// cleaning the result.\n///\n/// A faithful port of `Join` in the Go standard library `path` package\n/// (`go/src/path/path.go`, `func Join`): empty elements are ignored, and the\n/// joined string is passed through [`path_clean`].\nfn path_join(elem: &[&str]) -> String {\n // Go returns \"\" when the total length of all elements is zero (which, since\n // empty elements are skipped, means every element is empty).\n if elem.iter().all(|e| e.is_empty()) {\n return String::new();\n }\n let mut buf = String::new();\n for &e in elem {\n if !buf.is_empty() || !e.is_empty() {\n if !buf.is_empty() {\n buf.push('/');\n }\n buf.push_str(e);\n }\n }\n path_clean(&buf)\n}\n\n// ── LTX path helpers ──────────────────────────────────────────────────────────\n//\n// Ported from litestream@v0.5.11 litestream.go:184-197.\n\n/// Returns the path to the LTX directory under a given root.\n///\n/// Ported from `LTXDir` in litestream@v0.5.11 litestream.go:185:\n/// `return path.Join(root, \"ltx\")`.\npub fn ltx_dir(root: &str) -> String {\n path_join(&[root, \"ltx\"])\n}\n\n/// Returns the path to the LTX level sub-directory.\n///\n/// Ported from `LTXLevelDir` in litestream@v0.5.11 litestream.go:190-191:\n/// `return path.Join(LTXDir(root), strconv.Itoa(level))`. Note the\n/// composition over the already-cleaned `LTXDir(root)`, which we preserve so\n/// `..` resolution matches Go exactly.\npub fn ltx_level_dir(root: &str, level: u32) -> String {\n path_join(&[<x_dir(root), &level.to_string()])\n}\n\n/// Returns the path to a single LTX file for a given transaction range.\n///\n/// The filename follows the convention `-.ltx` with both\n/// TXIDs formatted as 16-digit lowercase hex.\n///\n/// Ported from `LTXFilePath` in litestream@v0.5.11 litestream.go:195-196:\n/// `return path.Join(LTXLevelDir(root, level), ltx.FormatFilename(minTXID, maxTXID))`\n/// and `FormatFilename` in ltx@v0.5.1 ltx.go:487\n/// (`fmt.Sprintf(\"%s-%s.ltx\", minTXID.String(), maxTXID.String())`).\npub fn ltx_file_path(root: &str, level: u32, min_txid: TXID, max_txid: TXID) -> String {\n let filename = format!(\"{}-{}.ltx\", min_txid, max_txid);\n path_join(&[<x_level_dir(root, level), &filename])\n}\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",1794435704589,"sidebar","expanded"]