[{"_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/ltx.rs","oid","45758631ef99b393bc8345044e7fb28a3a60cfa7","size",19619,"commit","90b43017241f81189453d326d05948f388b34652","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","//! ltx.rs — LTX (Lite Transaction) file reader/writer + CRC64-ISO checksums.\n//!\n//! Ported from ltx@v0.5.2 `ltx.go`, `checksum.go`, `encoder.go`, `decoder.go`\n//! and litestream@v0.5.11 `v3.go`. `reference/ltx-format.md` describes the\n//! authoritative byte layout.\n//!\n//! The reader decodes a complete LTX file with either v0.5.2 LZ4 blocks or the\n//! older LZ4 frames. It verifies the CRC64-ISO file checksum and the rolling\n//! snapshot checksum. The v0.5.2 writer emits exact upstream bytes, while the\n//! default writer preserves the legacy layout during the staged rollout.\n\nuse crate::error::{Error, Result};\nuse crate::{Checksum, Pos, CHECKSUM_FLAG, TXID};\nuse std::time::SystemTime;\n\n// ── Constants (ltx@v0.5.2 ltx.go:18-55) ──────────────────────────────────────\n\n/// First 4 bytes of every LTX file.\npub const MAGIC: &[u8; 4] = b\"LTX1\";\n/// Current LTX file format version.\npub const VERSION: i32 = 3;\npub const HEADER_SIZE: usize = 100;\npub const PAGE_HEADER_SIZE: usize = 6;\npub const TRAILER_SIZE: usize = 16;\npub const CHECKSUM_SIZE: usize = 8;\n\n/// Header flag: checksums are not tracked for this file.\npub const HEADER_FLAG_NO_CHECKSUM: u32 = 1 << 1;\npub const HEADER_FLAG_MASK: u32 = HEADER_FLAG_NO_CHECKSUM;\n\n/// A four-byte compressed-size field follows the page header, and the page\n/// uses raw LZ4 block compression. Files written before ltx v0.5.2 omit this\n/// flag and contain one LZ4 frame per page.\npub const PAGE_HEADER_FLAG_SIZE: u16 = 1 << 0;\npub const PAGE_HEADER_FLAG_MASK: u16 = PAGE_HEADER_FLAG_SIZE;\n\n/// SQLite PENDING_BYTE offset; the lock page derives from it.\npub const PENDING_BYTE: i64 = 0x4000_0000;\n\nfn corrupt(msg: impl Into) -> Error {\n // Wrap a format error as LTXCorrupted, matching litestream's classification\n // of malformed LTX content (litestream.go ErrLTXCorrupted).\n let _ = msg;\n Error::LTXCorrupted\n}\n\n/// Returns the lock page number for a given page size (ltx.go:494).\n///\n/// `page_size` is expected to be a validated SQLite page size (a power of two in\n/// `[512, 65536]`); for any such value the result is identical to Go's\n/// `LockPgno` (`PENDING_BYTE / page_size + 1`). A `page_size` of `0` — which\n/// only reaches here via an unvalidated/adversarial header — would make the\n/// underlying integer divide panic in both Go and Rust, so we guard it and\n/// return `0` (never a real page number) instead of dividing. All in-crate\n/// callers validate the header first, mirroring Go's `DecodeHeader`-before-\n/// `LockPgno` ordering, so this guard is reached only by a direct external call.\npub fn lock_pgno(page_size: u32) -> u32 {\n if page_size == 0 {\n return 0;\n }\n (PENDING_BYTE / page_size as i64) as u32 + 1\n}\n\n// ── CRC64-ISO (checksum.go:177 `crc64.MakeTable(crc64.ISO)`) ──────────────────\n\n/// Streaming CRC64-ISO hasher matching Go's `hash/crc64` digest semantics\n/// (CRC-64/GO-ISO). `crc-fast` keeps the exact streaming result while using\n/// SIMD folding on the architectures that celld ships.\n#[derive(Clone)]\npub struct Crc64 {\n digest: crc_fast::Digest,\n}\n\nimpl Default for Crc64 {\n fn default() -> Self {\n Self::new()\n }\n}\n\nimpl Crc64 {\n pub fn new() -> Self {\n Self {\n digest: crc_fast::Digest::new(crc_fast::CrcAlgorithm::Crc64GoIso),\n }\n }\n\n pub fn update(&mut self, data: &[u8]) {\n self.digest.update(data);\n }\n\n pub fn sum64(&self) -> u64 {\n self.digest.finalize()\n }\n}\n\n/// CRC64 checksum of a single page combined with its page number, with the\n/// ChecksumFlag set (checksum.go:106-116). Input is `BE_u32(pgno) ++ data`.\npub fn checksum_page(pgno: u32, data: &[u8]) -> Checksum {\n let mut h = Crc64::new();\n h.update(&pgno.to_be_bytes());\n h.update(data);\n CHECKSUM_FLAG | h.sum64()\n}\n\n// ── Header / PageHeader / Trailer ─────────────────────────────────────────────\n\n/// LTX file header (100 bytes). Ported from ltx@v0.5.1 ltx.go:179-326.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]\npub struct Header {\n pub version: i32,\n pub flags: u32,\n pub page_size: u32,\n pub commit: u32,\n pub min_txid: TXID,\n pub max_txid: TXID,\n pub timestamp: i64,\n pub pre_apply_checksum: Checksum,\n pub wal_offset: i64,\n pub wal_size: i64,\n pub wal_salt1: u32,\n pub wal_salt2: u32,\n pub node_id: u64,\n}\n\nimpl Header {\n /// True if this header begins a complete database snapshot (MinTXID == 1).\n pub fn is_snapshot(&self) -> bool {\n self.min_txid == TXID(1)\n }\n\n /// True if checksum tracking is disabled for this file.\n pub fn no_checksum(&self) -> bool {\n self.flags & HEADER_FLAG_NO_CHECKSUM != 0\n }\n\n /// Decodes a header from a 100-byte slice (ltx.go:302-326). All big-endian.\n pub fn parse(b: &[u8]) -> Result

{\n if b.len() < HEADER_SIZE {\n return Err(corrupt(\"short header\"));\n }\n if &b[0..4] != MAGIC {\n return Err(corrupt(\"bad magic\"));\n }\n Ok(Header {\n version: VERSION,\n flags: u32_be(&b[4..]),\n page_size: u32_be(&b[8..]),\n commit: u32_be(&b[12..]),\n min_txid: TXID(u64_be(&b[16..])),\n max_txid: TXID(u64_be(&b[24..])),\n timestamp: u64_be(&b[32..]) as i64,\n pre_apply_checksum: u64_be(&b[40..]),\n wal_offset: u64_be(&b[48..]) as i64,\n wal_size: u64_be(&b[56..]) as i64,\n wal_salt1: u32_be(&b[64..]),\n wal_salt2: u32_be(&b[68..]),\n node_id: u64_be(&b[72..]),\n })\n }\n\n /// Encodes the header to 100 bytes (ltx.go:283-299).\n pub fn marshal(&self) -> [u8; HEADER_SIZE] {\n let mut b = [0u8; HEADER_SIZE];\n b[0..4].copy_from_slice(MAGIC);\n b[4..8].copy_from_slice(&self.flags.to_be_bytes());\n b[8..12].copy_from_slice(&self.page_size.to_be_bytes());\n b[12..16].copy_from_slice(&self.commit.to_be_bytes());\n b[16..24].copy_from_slice(&self.min_txid.0.to_be_bytes());\n b[24..32].copy_from_slice(&self.max_txid.0.to_be_bytes());\n b[32..40].copy_from_slice(&(self.timestamp as u64).to_be_bytes());\n b[40..48].copy_from_slice(&self.pre_apply_checksum.to_be_bytes());\n b[48..56].copy_from_slice(&(self.wal_offset as u64).to_be_bytes());\n b[56..64].copy_from_slice(&(self.wal_size as u64).to_be_bytes());\n b[64..68].copy_from_slice(&self.wal_salt1.to_be_bytes());\n b[68..72].copy_from_slice(&self.wal_salt2.to_be_bytes());\n b[72..80].copy_from_slice(&self.node_id.to_be_bytes());\n b\n }\n\n /// Validates header invariants (ltx.go:208-267).\n pub fn validate(&self) -> Result<()> {\n if self.version != VERSION {\n return Err(corrupt(\"invalid version\"));\n }\n if self.flags != (self.flags & HEADER_FLAG_MASK) {\n return Err(corrupt(\"invalid flags\"));\n }\n if !is_valid_page_size(self.page_size) {\n return Err(corrupt(\"invalid page size\"));\n }\n if self.min_txid == TXID(0) {\n return Err(corrupt(\"minimum transaction id required\"));\n }\n if self.max_txid == TXID(0) {\n return Err(corrupt(\"maximum transaction id required\"));\n }\n if self.min_txid > self.max_txid {\n return Err(corrupt(\"transaction ids out of order\"));\n }\n if self.wal_offset < 0 {\n return Err(corrupt(\"wal offset cannot be negative\"));\n }\n if self.wal_size < 0 {\n return Err(corrupt(\"wal size cannot be negative\"));\n }\n if (self.wal_salt1 != 0 || self.wal_salt2 != 0) && self.wal_offset == 0 {\n return Err(corrupt(\"wal offset required if salt exists\"));\n }\n if self.wal_offset == 0 && self.wal_size != 0 {\n return Err(corrupt(\"wal offset required if wal size exists\"));\n }\n if self.is_snapshot() {\n if self.pre_apply_checksum != 0 {\n return Err(corrupt(\"pre-apply checksum must be zero on snapshots\"));\n }\n } else if self.no_checksum() {\n if self.pre_apply_checksum != 0 {\n return Err(corrupt(\"pre-apply checksum not allowed\"));\n }\n } else {\n if self.pre_apply_checksum == 0 {\n return Err(corrupt(\"pre-apply checksum required on non-snapshot files\"));\n }\n if self.pre_apply_checksum & CHECKSUM_FLAG == 0 {\n return Err(corrupt(\"invalid pre-apply checksum format\"));\n }\n }\n Ok(())\n }\n}\n\n/// Per-page header (6 bytes). Ported from ltx.go:408-447.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]\npub struct PageHeader {\n pub pgno: u32,\n pub flags: u16,\n}\n\nimpl PageHeader {\n pub fn is_zero(&self) -> bool {\n self.pgno == 0 && self.flags == 0\n }\n\n pub fn parse(b: &[u8]) -> Result {\n if b.len() < PAGE_HEADER_SIZE {\n return Err(corrupt(\"short page header\"));\n }\n Ok(PageHeader {\n pgno: u32_be(&b[0..]),\n flags: u16_be(&b[4..]),\n })\n }\n\n pub fn marshal(&self) -> [u8; PAGE_HEADER_SIZE] {\n let mut b = [0u8; PAGE_HEADER_SIZE];\n b[0..4].copy_from_slice(&self.pgno.to_be_bytes());\n b[4..6].copy_from_slice(&self.flags.to_be_bytes());\n b\n }\n\n pub fn validate(&self) -> Result<()> {\n if self.pgno == 0 {\n return Err(corrupt(\"page number required\"));\n }\n if self.flags != (self.flags & PAGE_HEADER_FLAG_MASK) {\n return Err(corrupt(\"invalid page header flags\"));\n }\n Ok(())\n }\n}\n\n/// File trailer (16 bytes). Ported from ltx.go:348-393.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]\npub struct Trailer {\n pub post_apply_checksum: Checksum,\n pub file_checksum: Checksum,\n}\n\nimpl Trailer {\n /// Validates the checksum fields against the header checksum mode.\n pub fn validate(&self, header: Header) -> Result<()> {\n if header.no_checksum() {\n if self.post_apply_checksum != 0 {\n return Err(corrupt(\"post-apply checksum not allowed\"));\n }\n } else if self.post_apply_checksum == 0 || self.post_apply_checksum & CHECKSUM_FLAG == 0 {\n return Err(corrupt(\"invalid post-apply checksum\"));\n }\n\n if self.file_checksum == 0 || self.file_checksum & CHECKSUM_FLAG == 0 {\n return Err(corrupt(\"invalid file checksum\"));\n }\n Ok(())\n }\n\n pub fn parse(b: &[u8]) -> Result {\n if b.len() < TRAILER_SIZE {\n return Err(corrupt(\"short trailer\"));\n }\n Ok(Trailer {\n post_apply_checksum: u64_be(&b[0..]),\n file_checksum: u64_be(&b[8..]),\n })\n }\n\n pub fn marshal(&self) -> [u8; TRAILER_SIZE] {\n let mut b = [0u8; TRAILER_SIZE];\n b[0..8].copy_from_slice(&self.post_apply_checksum.to_be_bytes());\n b[8..16].copy_from_slice(&self.file_checksum.to_be_bytes());\n b\n }\n}\n\n/// True if `sz` is a power of two in [512, 65536] (ltx.go:399-406).\npub fn is_valid_page_size(sz: u32) -> bool {\n let mut i = 512u32;\n while i <= 65536 {\n if sz == i {\n return true;\n }\n i *= 2;\n }\n false\n}\n\n/// Formats an LTX filename for a transaction range (ltx.go:487-489).\npub fn format_filename(min_txid: TXID, max_txid: TXID) -> String {\n format!(\"{}-{}.ltx\", min_txid, max_txid)\n}\n\n/// Parses a `-.ltx` filename (ltx.go:450-459).\npub fn parse_filename(name: &str) -> Result<(TXID, TXID)> {\n let stem = name\n .strip_suffix(\".ltx\")\n .ok_or_else(|| corrupt(\"invalid ltx filename\"))?;\n let (a, b) = stem\n .split_once('-')\n .ok_or_else(|| corrupt(\"invalid ltx filename\"))?;\n if a.len() != 16 || b.len() != 16 {\n return Err(corrupt(\"invalid ltx filename\"));\n }\n let min = u64::from_str_radix(a, 16).map_err(|_| corrupt(\"invalid ltx filename\"))?;\n let max = u64::from_str_radix(b, 16).map_err(|_| corrupt(\"invalid ltx filename\"))?;\n Ok((TXID(min), TXID(max)))\n}\n\n// ── FileInfo ──────────────────────────────────────────────────────────────────\n\n/// Metadata about an LTX file on a replica. Ported from ltx@v0.5.1 ltx.go:571-596.\n///\n/// `pre_apply_checksum`/`post_apply_checksum` are populated when known (e.g. by\n/// decoding) and are zero when a file is discovered by a bare directory/bucket\n/// listing. Listings use the file mtime or object-store LastModified time, and\n/// write results use the LTX header timestamp.\n#[derive(Debug, Clone, PartialEq, Eq, Default)]\npub struct FileInfo {\n pub level: i32,\n pub min_txid: TXID,\n pub max_txid: TXID,\n pub pre_apply_checksum: Checksum,\n pub post_apply_checksum: Checksum,\n pub size: i64,\n pub created_at: Option,\n}\n\nimpl FileInfo {\n /// Replication position *after* this file is applied (ltx.go:591-596).\n pub fn pos(&self) -> Pos {\n Pos::new(self.max_txid, self.post_apply_checksum)\n }\n\n /// Replication position *before* this file is applied (ltx.go:583-588).\n pub fn pre_apply_pos(&self) -> Pos {\n Pos::new(\n TXID(self.min_txid.0.saturating_sub(1)),\n self.pre_apply_checksum,\n )\n }\n}\n\n// ── Decoder ──────────────────────────────────────────────────────────────────\n\n/// The verified result of decoding a complete LTX file.\n#[derive(Debug, Clone)]\npub struct DecodedFile {\n pub header: Header,\n pub trailer: Trailer,\n /// Page numbers in file (write) order.\n pub pgnos: Vec,\n}\n\ntype DecodedPages = Vec<(u32, Vec)>;\n\n/// Decodes and fully verifies an in-memory LTX file: header, LZ4-framed pages,\n/// page index, trailer, the CRC64-ISO file checksum, and — for snapshots — the\n/// rolling post-apply checksum. Returns `Error::ChecksumMismatch` /\n/// `Error::LTXCorrupted` on any inconsistency.\n///\n/// Ported from the read+verify path in decoder.go:68-219.\npub fn decode_file(bytes: &[u8]) -> Result {\n decode_file_inner(bytes, false).map(|(file, _)| file)\n}\n\n/// Decodes a complete LTX file and retains each decompressed page.\npub(crate) fn decode_file_with_pages(bytes: &[u8]) -> Result<(DecodedFile, DecodedPages)> {\n decode_file_inner(bytes, true)\n}\n\nfn decode_file_inner(bytes: &[u8], retain_pages: bool) -> Result<(DecodedFile, DecodedPages)> {\n let mut decoder = crate::codec::Decoder::new(std::io::Cursor::new(bytes));\n decoder.decode_header()?;\n let header = decoder.header;\n let mut page_numbers = Vec::new();\n let mut pages = Vec::new();\n let mut data = vec![0; header.page_size as usize];\n\n while let Some(page) = decoder.decode_page(&mut data)? {\n page_numbers.push(page.pgno);\n if retain_pages {\n pages.push((page.pgno, data.clone()));\n }\n }\n decoder.close()?;\n\n Ok((\n DecodedFile {\n header,\n trailer: decoder.trailer,\n pgnos: page_numbers,\n },\n pages,\n ))\n}\n\n/// Decodes and verifies a complete LTX file, returning each page's\n/// `(pgno, decompressed_data)` in write order.\n///\n/// The decoder retains the pages from its verification pass, so it does not\n/// decompress the file a second time.\npub fn decode_file_pages(bytes: &[u8]) -> Result)>> {\n decode_file_with_pages(bytes).map(|(_, pages)| pages)\n}\n\n/// Reconstructs the full SQLite database image from a **snapshot** LTX file\n/// (every page `1..=commit`, with the lock page zero-filled).\n///\n/// Ported from `Decoder.DecodeDatabaseTo` in ltx@v0.5.1 decoder.go:223-268. The\n/// CRC64 of this image must equal the live database's CRC64. Errors if the file\n/// is not a snapshot or a page is missing.\npub fn decode_database_image(bytes: &[u8]) -> Result> {\n // Verify the whole file before `lock_pgno` or `commit` is used. This rejects\n // a zero page size and keeps the reconstruction panic-free on bad input.\n let (decoded, pages) = decode_file_with_pages(bytes)?;\n let header = decoded.header;\n if !header.is_snapshot() {\n return Err(corrupt(\n \"cannot decode non-snapshot LTX file to SQLite database\",\n ));\n }\n let page_size = header.page_size as usize;\n let lock = lock_pgno(header.page_size);\n\n // Materialize the pages, keyed by page number.\n let mut by_pgno: std::collections::HashMap> = std::collections::HashMap::new();\n for (pgno, data) in pages {\n by_pgno.insert(pgno, data);\n }\n\n let mut image = Vec::with_capacity(header.commit as usize * page_size);\n for pgno in 1..=header.commit {\n if pgno == lock {\n image.extend(std::iter::repeat_n(0u8, page_size));\n continue;\n }\n let data = by_pgno\n .get(&pgno)\n .ok_or_else(|| corrupt(\"missing page in snapshot\"))?;\n image.extend_from_slice(data);\n }\n Ok(image)\n}\n\n// ── Encoder (round-trip; byte-fidelity vs the real binary is D1's job) ────────\n\n/// Encodes a complete LTX file with the legacy LZ4 frame representation.\n///\n/// This function preserves the current celld write format during the staged\n/// v0.5.2 reader rollout. [`decode_file`] accepts this representation and the\n/// v0.5.2 block representation.\npub fn encode_file(\n header: &Header,\n pages: &[(u32, Vec)],\n post_apply_checksum: Checksum,\n) -> Result> {\n encode_file_with_mode(header, pages, post_apply_checksum, false)\n}\n\n/// Encodes a complete LTX file with the byte-exact v0.5.2 block\n/// representation.\npub fn encode_file_v0_5_2(\n header: &Header,\n pages: &[(u32, Vec)],\n post_apply_checksum: Checksum,\n) -> Result> {\n encode_file_with_mode(header, pages, post_apply_checksum, true)\n}\n\nfn encode_file_with_mode(\n header: &Header,\n pages: &[(u32, Vec)],\n post_apply_checksum: Checksum,\n use_v0_5_2: bool,\n) -> Result> {\n let mut encoder = if use_v0_5_2 {\n crate::codec::Encoder::new_block(Vec::new())\n } else {\n crate::codec::Encoder::new_legacy(Vec::new())\n };\n encoder.encode_header(*header)?;\n for (page_number, data) in pages {\n encoder.encode_page(\n PageHeader {\n pgno: *page_number,\n flags: 0,\n },\n data,\n )?;\n }\n encoder.close(post_apply_checksum)?;\n Ok(encoder.writer)\n}\n\n// ── small byte / varint helpers ──────────────────────────────────────────────\n\nfn u16_be(b: &[u8]) -> u16 {\n u16::from_be_bytes([b[0], b[1]])\n}\nfn u32_be(b: &[u8]) -> u32 {\n u32::from_be_bytes([b[0], b[1], b[2], b[3]])\n}\nfn u64_be(b: &[u8]) -> u64 {\n u64::from_be_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]])\n}\n\n// ── Tests ─────────────────────────────────────────────────────────────────────\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",1794541926985,"sidebar","expanded"]