What litedb-org/LiteDB shipped
Written by FoxPlug from the repository's own releases; not affiliated with Litedb. Paste your own repository in the box below and FoxPlug writes the same weekly update for your product. This page is an automatic summary of the releases, pull requests and commits in github.com/litedb-org/LiteDB; Litedb did not write it and does not use or endorse FoxPlug. Every line links to the change it describes.
Get a weekly update like this for your product, free
Week of October 26, 2026
What shipped
- Page allocation publication is now crash-consistent, so a commit from one transaction can no longer publish another transaction's speculative page count or free-list changes. Pull request #3127
- The engine now stops before releasing the WAL writer when a torn write, failed flush, failed cleanup or uncertain confirmation leaves the WAL unsafe to extend. Pull request #3061
- Legacy WAL conversion now validates input and drains every committed frame before replacing the WAL, or refuses to open with both files unchanged. Pull request #3058
- TIMEOUT set after opening a Direct database with a nonempty WAL now applies to collection and transaction-admission waits instead of falling back to the old header value. Pull request #3126
- An obsolete Shared writer hold is no longer left behind after a rolled-back transaction is retried and committed, so other threads and processes stop waiting on the original owner. Pull request #3125
- Stream open, checkpoint and dispose no longer touch caller-owned streams, and disposal with an open transaction rolls it back and releases the engine's use of the stream. Pull request #3059
- LINQ queries now translate numeric unary minus and bitwise complement, while rejecting narrowing or checked conversions that would otherwise be silently dropped before negation. Pull request #2971
- Windows test cleanup now waits for dead child processes to release file handles before recovery or explicit cleanup proceeds. Pull request #3129
- The broad engine CI session is split into engine-shared, three allocation sessions and the engine complement to keep each session within the 300-second budget on Windows runners. Pull request #3130
- Testing and debug builds gained reachability markers and shared invariant oracles, with malformed marker counts rejected during aggregation. Pull request #3104
Why it matters
This week tightened crash safety around the WAL and page allocation, so torn writes and abandoned transactions no longer leave the database in an unsafe state. It also fixed several cases where settings and caller-owned resources did not behave as documented, including TIMEOUT after WAL restore, stream disposal and stale writer holds after retries.
Changelog entry
- Keep page allocation publication crash-consistent. Pull request #3127
- Stop the engine on torn WAL writes and failed transaction safepoints. Pull request #3061
- Validate legacy WAL input and drain it completely before conversion. Pull request #3058
- Honor TIMEOUT after WAL restore. Pull request #3126
- Release obsolete Shared writer hold after transaction retry. Pull request #3125
- Keep caller streams unchanged by stream open, checkpoint and dispose. Pull request #3059
- Translate unary minus and bitwise complement in LINQ queries. Pull request #2971
- Wait for dead child processes to release file handles before Windows test cleanup. Pull request #3129
- Split the engine CI test partition to keep each session within the 300-second budget. Pull request #3130
- Add reachability markers, invariant oracles and the oracle smoke. Pull request #3104
This week in LiteDB: crash-consistent page allocation publication, engine stop on unsafe WAL writes, full legacy WAL validation before conversion, TIMEOUT honored after WAL restore, no stale writer hold after retries, and unary minus and bitwise complement in LINQ queries.
This week's work on LiteDB focused on crash safety and predictable behavior. Page allocation publication is now crash-consistent, so a commit cannot publish another transaction's speculative page count or free-list changes. The engine stops before releasing the WAL writer when a torn write, failed flush or uncertain confirmation leaves the WAL unsafe to extend. Legacy WAL conversion drains every committed frame or refuses to open with both files unchanged. TIMEOUT now applies after WAL restore, disposal no longer touches caller-owned streams, and a retried transaction no longer leaves a stale Shared writer hold. LINQ queries now translate unary minus and bitwise complement while rejecting conversions that would be silently dropped.
Week of October 19, 2026
What shipped
- Fixed read snapshots inside transactions so they no longer read pages reused for another collection, preventing LiteException 999 and incorrect document reads. Pull request #3102
- FileStorage now rejects loaded chunks whose cumulative bytes exceed the declared file length, including exact-length reads and seeks into the final chunk. Pull request #2970
- Prevented stale dropped-index bytes from released 5.0.21 databases being decoded as vector metadata. Pull request #3060
- Kept GROUP BY projection, HAVING, and order bindings private to each query execution so caller parameter documents are not modified. Pull request #2976
- Added opt-in per-mapper attribute registration with DataAnnotations support for [Key] and [NotMapped]. Pull request #2722
- Added pooled buffer serialization overloads while retaining the byte-array API and no-Advance-on-failure behavior. Pull request #2699
- Hashed Unix shared mutex names that exceed the runtime limit while keeping supported short names unchanged. Pull request #3054
- Added fork-aware known-bad proof provenance and capability-gated net proofs, with validation of pack-known-bad PR and repository arguments before fetch or build. Pull request #3103
- Verified the released v4 and v5 database corpus and resolved binary fixtures as part of the historical contract work. Pull request #3056
- Changed CI test runtime installation to use explicit versions instead of the aka.ms channel link that fails with HTTP 409. Pull request #3128
Why it matters
This week brings fixes for transaction read correctness and FileStorage bounds checks that affect data safety, along with protection against misreading stale index bytes in existing databases. Mapper and serializer additions give developers opt-in attribute mapping and pooled buffer overloads without breaking existing APIs, while several changes harden query isolation and Unix path handling.
Changelog entry
- Fixed read snapshots inside transactions reading pages reused for another collection. Pull request #3102
- FileStorage now rejects chunks whose cumulative bytes exceed the declared file length. Pull request #2970
- Prevented stale 5.0.21 dropped-index bytes from being decoded as vector metadata. Pull request #3060
- Kept GROUP BY projection, HAVING and order bindings private to each query execution. Pull request #2976
- Added opt-in per-mapper DataAnnotations support for [Key] and [NotMapped]. Pull request #2722
- Added pooled buffer serialization overloads while retaining the byte-array API. Pull request #2699
- Hashed Unix shared mutex names beyond the runtime limit while preserving short names. Pull request #3054
- Added fork-aware known-bad proof provenance and capability-gated net proofs. Pull request #3103
- Verified the released v4 and v5 database corpus and resolved binary fixtures. Pull request #3056
- CI now installs test runtimes by explicit version instead of the aka.ms channel link. Pull request #3128
This week: transaction read snapshots fixed, FileStorage now rejects chunks over the declared file length, stale 5.0.21 index bytes no longer read as vector metadata, GROUP BY bindings stay private, plus DataAnnotations [Key]/[NotMapped] support and pooled BSON serialization over
This week's LiteDB changes include a fix for read snapshots inside transactions that could read pages reused for another collection, which previously caused LiteException 999 and incorrect document reads. FileStorage now rejects loaded chunks whose cumulative bytes exceed the declared file length, including exact-length reads and seeks into the final chunk. Stale dropped-index bytes from released 5.0.21 databases are no longer decoded as vector metadata. GROUP BY projection, HAVING and order bindings are now private to each query execution. Mapper adds opt-in per-mapper DataAnnotations support for [Key] and [NotMapped], and the serializer gains pooled buffer overloads while retaining the byte-array API.
Week of September 28, 2026
What shipped
- Added a guard that requires explicit acknowledgement before constructing LiteDatabase in prerelease builds, compiled out of stable releases. Pull request #3038
- Fixed TransactionMonitor.ReleaseTransaction to clear thread-local slots and trim cache before releasing the admission lease, preventing exceptions in persisted commits. Pull request #3039
- Fixed SharedEngine to preserve writer ownership during same-connection teardown callbacks that recursively dispose the engine. Pull request #3077
- Prevented Shared peer calls from waiting on their own outer ownership, addressing a concurrency audit finding. Pull request #3072
- Refined mutex probe behavior with zero-timeout waits and improved documentation of pooled thread clean checks and cached wrapper behavior. Release
- Added GitHub-side machinery to make safety rules and coverage accounting checkable in CI using existing documentation and fuzz targets. Pull request #3045
- Made SharedReaderPin test prove distinct repeated handoffs by coordinating owner updates with ready, release, and completion signals. Pull request #3033
- Fixed last-reader close test to wait for peer release, resolving CI failures on macOS.NET 8 and.NET 9. Pull request #3075
- Stabilized Shared CI coverage by isolating timing-sensitive tests and splitting process-heavy tests into their own partition. Pull request #3026
Why it matters
This week addresses critical concurrency issues in Shared connections and transaction handling that could cause data corruption or exceptions. The additions of safety evidence checks and prerelease guards improve confidence in the database's behavior under concurrent access patterns.
Changelog entry
- Require explicit process-wide risk acknowledgement before constructing LiteDatabase in prerelease builds Pull request #3038
- Fix TransactionMonitor.ReleaseTransaction to clear slots and trim cache before releasing admission lease Pull request #3039
- Preserve Shared writer ownership during same-connection teardown callbacks Pull request #3077
- Refuse Shared peer calls that wait for their own outer ownership Pull request #3072
- Refine mutex probe with zero-timeout waits and improve documentation Release
- Make safety evidence and coverage accounting checkable in CI Pull request #3045
- Improve SharedReaderPin test to prove distinct repeated handoffs Pull request #3033
- Fix last-reader close test race condition on macOS.NET 8/9 Pull request #3075
- Stabilize Shared CI coverage by isolating timing-sensitive tests Pull request #3026
- Document page-view exception in storage-ownership rule Release
- Register Shared evidence and retain original handle validation workflows Release
LiteDB prerelease now requires explicit acknowledgement before construction. Fixed transaction monitor release order and Shared connection concurrency issues. Safety rules now machine-checkable in CI.
LiteDB's prerelease improvements focus on concurrent access safety. Changes include transaction monitor release ordering fixes, Shared connection peer call prevention, and new CI machinery to verify safety rules automatically. Prerelease builds now require explicit risk acknowledgement before database construction.
Week of September 21, 2026
What shipped
- Shared mode now retains read-only snapshots across repeated queries and avoids reopening under the database mutex, with automatic optimization on.NET 8+ and a production fallback. Pull request #3016
- Shared-mode hardening and performance improvements added, including native fsync, faster writes, and an experimental coordinator mode. Pull request #3003
- Shared operations reduced mutex handoffs and now reuse reader lease slots with scoped ownership and a cross-process turnstile for pinned writers. Pull request #3013
- Version 13 snapshot-aware checkpoints and verified WAL slot reuse allow checkpoint to backfill safe pages while readers retain original snapshots. Pull request #3000
- Compact document storage added with lazy v12 promotion to reduce storage consumed by repeated field names and BSON array index strings. Pull request #2999
- CRC32C checksums added for WAL frames and data pages to verify complete transactions and protect checkpoint publication against partial writes. Pull request #2998
- Systematic fuzzing infrastructure added with the deterministic LiteDB.Fuzz runner for reproducible differential, model-based, corruption, recovery, and crash fuzzing. Pull request #2951
- PR CI workflow reduced from 47 jobs to 6 runnable jobs covering Linux and Windows with.NET 8,.NET 10, and.NET Framework 4.8.1. Pull request #2964
Why it matters
This week focused on performance and reliability in shared mode, storage efficiency improvements, and a major addition of systematic fuzzing infrastructure. The checksum and checkpoint work strengthens crash safety, while the compact storage format reduces overhead for typical workloads.
Changelog entry
- Shared: Restore mapped reads with bounded writer pressure to retain snapshots across repeated queries Pull request #3016
- Shared: Add native fsync, faster writes, and experimental coordinator mode Pull request #3003
- Shared: Reduce mutex handoffs and reuse reader lease slots with scoped ownership Pull request #3013
- Shared: Optimize reader-slot selection with bounded free list instead of scan Pull request #3014
- Add v13 snapshot-aware checkpoints and verified WAL slot reuse Pull request #3000
- Add compact document storage with lazy v12 promotion and transactional schema pages Pull request #2999
- Add CRC32C checksums for WAL recovery and data page verification Pull request #2998
- Add systematic fuzzing infrastructure with deterministic LiteDB.Fuzz runner Pull request #2951
- Reduce PR CI jobs from 47 to 6 runnable jobs Pull request #2964
LiteDB dev: shared-mode snapshot retention, compact document storage, v13 checksums and verified WAL recovery, plus deterministic fuzzing infrastructure for reproducible testing.
LiteDB development this week focused on shared-mode performance, storage efficiency, and crash safety. Read snapshots now persist across queries, compact storage reduces field-name overhead, CRC32C checksums verify WAL recovery, and new deterministic fuzzing catches concurrency and recovery issues. These changes improve both performance and reliability for typical workloads.
Week of September 14, 2026
What shipped
- Borrowed BSON execution and late materialization reduces allocations by deferring document materialization until after residual filters reject candidates. Pull request #2910
- Shared query IR with optimizations for both LINQ and SQL execution paths, building on audited prior work. Pull request #2944
- One BsonMapper per database context prevents unrelated databases from sharing mutable mapper state. Pull request #2949
- 28 bugfixes covering BSON conversion, JSON handling, mapper dispatch, query projection, and index operations. Pull request #2916
- 47 additional bugfixes addressing query binding, LINQ translation, dictionary mapping, string comparison, and scan behavior. Pull request #2917
- 14 independent storage and transaction bugfixes including durable WAL commits, encryption rebuild, and validation before tail repair. Pull request #2918
- Dropping secondary indexes now properly reclaims pages back to free-page lists. Pull request #2955
- Deleted pages persisted before commit now correctly link their tail to the prior head during transaction safepoints. Pull request #2956
- Scalar range comparisons now honor the active execution collation. Pull request #2943
- Guid and ObjectId serialization now uses spans to eliminate per-call allocations. Pull request #2697
Why it matters
This week shipped major correctness fixes from a comprehensive fuzzing and audit effort, including storage integrity repairs, transaction safety improvements, and memory allocation reductions. The work addresses fundamental issues in query execution, mapper isolation, and page management that affect reliability across the database.
Changelog entry
- Query: Borrowed BSON execution with late materialization reduces allocations for residual filters Pull request #2910
- API: LiteDatabase now uses one BsonMapper per context instead of shared global instance Pull request #2949
- Storage: Dropping secondary indexes now reclaims pages to free-page lists Pull request #2955
- Storage: Deleted pages persisted before commit now correctly link to prior head Pull request #2956
- Query: Unified query IR for optimized LINQ and SQL execution Pull request #2944
- Query: Scalar range comparisons honor execution collation Pull request #2943
- Fix: 28 BSON, JSON, mapper, projection, and index handling issues Pull request #2916
- Fix: 47 query binding, LINQ translation, and scan behavior issues Pull request #2917
- Fix: 14 storage and transaction bugfixes including durable WAL and encryption Pull request #2918
- Perf: Guid and ObjectId serialization now uses spans, eliminating per-call allocations Pull request #2697
- Docs: Corrected root BSON size limit documentation and explained embedded document counting Pull request #2911
- Fix: SQL REBUILD without options no longer throws NullReferenceException Pull request #2915
- API: BsonValue.AsArray and AsDocument now support CLR array, list, and dictionary inputs Pull request #2755
- Perf: ObjectId hex formatting optimized with stack-allocated buffers Pull request #2698
- CI: Added test coverage for legacy.NET Framework targets (net462, net481) Pull request #2903
LiteDB this week: fixed storage integrity bugs from fuzzing, optimized query execution with late materialization, isolated database mapper instances, and reduced allocations in serialization.
LiteDB development this week focused on correctness and performance fundamentals. Storage integrity repairs fix page reclamation and transaction safety bugs uncovered by fuzzing. Query execution now defers document materialization until after filtering, reducing allocations. Database instances now maintain isolated mapper state instead of sharing mutable global state. Serialization paths for GUIDs and ObjectIds now use stack-allocated spans. The changes span 28 safe fixes, 47 additional fixes, and 14 independent storage/transaction bugfixes.