barrel-db/barrel

Barrel is an embeddable, edge-AI database system built in Erlang that manages document and vector data with support for federated queries and real-time subscriptions. It provides a comprehensive agent layer for managing shared context spaces, secure capability-based access, and agent handoffs, while offering robust security features like encryption at rest and S3-compatible attachment storage. The system includes a multi-protocol REST server with Model Context Protocol integration and a TypeScript client library for offline-first synchronization and local vector search in browser or Node.js environments.

A new \agent\_layer.erl\ example has been added to the \examples\ directory, illustrating an end-to-end workflow where two agents (Alice and Bob) share a space using capability tokens and session management. The example demonstrates creating a space, writing documents, managing agent sessions, and performing a handoff where Bob accepts a task via a capability token to access the shared context. The \examples/README.md\ has been updated to document this new example and provide instructions on how to compile and run it.

examples · high confidence

The client now includes a dedicated cosine similarity implementation in \cosine.ts\ that matches the server's ranking logic by dividing by vector norms at comparison time, and introduces an embedding pull mechanism in \emb-sync.ts\ to fetch per-document vectors via \\_bulk\_get\. This synchronization pass ensures vectors are retrieved for documents that lack them or have been refetched, while also cleaning up vectors for deleted or tombstoned documents.

clients/barrel-lite/src/vectors · high confidence

New utility scripts have been added to the project to support development and release workflows. The \bench\_ctx\_snapshot.escript\ provides a benchmarking tool to measure the performance of exporting, importing, and querying Barrel context databases with various vector and BM25 configurations. The \check\_doc\_snippets.py\ script validates Erlang code examples in documentation against actual module exports to ensure accuracy. Additionally, \check\_hex\_requirements.py\ verifies that Hex package tarballs include all necessary dependencies declared in \rebar.config\, preventing runtime errors caused by missing packages. A \contexts-demo.sh\ script is also included to demonstrate end-to-end usage of the Barrel contexts feature across multiple server nodes.

scripts · high confidence

New scripts have been added to the barrel-lite client to support integration testing and fixture generation. The \gen\_fixtures.escript\ generates golden JSON fixtures for HLC, version token, version vector, BQL, and vector embedding codecs, ensuring the TypeScript client's assertions match the Erlang backend's behavior. The \start-server.sh\ script boots a headless \barrel\_server\ instance with configurable authentication and CORS settings, enabling integration tests against a real server environment.

clients/barrel-lite/scripts · high confidence

The barrel library introduces several capabilities for data portability and multi-database querying. You can now open databases in read-only mode or import exported database snapshots that are served read-only across multiple nodes, ensuring data integrity via checksums. The library also adds a contexts facade allowing federated BQL queries across local, imported, and remote databases, along with working sets for offline coverage. Additionally, \open/2\ supports a \vectordb =\> none\ option to create plain document-only databases, and \embedder\_info/1\ provides embedding fingerprints to ensure vector compatibility across databases.

apps/barrel · high confidence

The barrel\_spaces application (v1.3.0) introduces a new agent layer that manages shared context containers called spaces. It provides capability tokens (barrel\_caps) for secure, revocable access control with a rights ladder (read, write, admin), and manages agent sessions with sliding TTLs and automatic garbage collection of orphaned messages via a background janitor. Additionally, it supports handoffs, allowing agents to transfer work and context between each other using shared spaces and capability tokens.

_apps/barrel\spaces/src · high confidence

This change adds the barrel-lite package, a TypeScript protocol client that provides an offline-first local document store syncing with the barrel\_server. Users can now persist data locally (using OPFS in browsers or memory in Node), perform local BQL queries, and sync documents and attachments via continuous SSE or polling. It also introduces local vector search capabilities, allowing users to pull document embeddings to the browser and run brute-force cosine ranking on the synced set, alongside standard server-delegated vector and text search. The release includes a multi-tab leader election mechanism, integration and browser E2E test suites, and example demos.

clients/barrel-lite · high confidence

This change adds the barrel-lite client library (version 0.1.0), providing an offline-first local document cache that synchronizes with a remote server over a custom wire protocol. The client supports local vector search using cosine similarity, attachment storage, and a live sync mode that can use either adaptive polling or a continuous Server-Sent Events (SSE) stream. For browser environments, it includes a multi-tab coordination system that uses Web Locks and BroadcastChannel to ensure a single leader manages the store and sync, while other tabs proxy operations via RPC.

clients/barrel-lite/src · high confidence

The new barrel\_crypto application provides encryption-at-rest capabilities, including an AES-256-GCM envelope, offset-addressable AES-256-CTR for sector-encrypted flat files, and HKDF-SHA256 key derivation. It introduces the barrel\_keyprovider behaviour to map database keyspace to 256-bit keys, allowing users to opt in to encryption at database open time using a default key or a custom provider (such as a KMS). The library also supports key-check tokens for fail-closed wrong-key detection and ensures safe decryption of unencrypted data.

_apps/barrel\crypto · high confidence

The client now includes a local store layer that caches documents, attachment references, and vector embeddings in a local cache, persisting state via a snapshot-based flush mechanism. This change introduces a content-addressed blob store for deduplicating and storing large binary attachments separately from document JSON, and provides two storage backends: an Origin Private File System (OPFS) adapter for browser environments and an in-memory adapter for Node.js and tests. The local store manages document versions using Hybrid Logical Clocks (HLC) and vector clocks (VV) to support conflict resolution and ensures monotonicity of local writes across reloads.

clients/barrel-lite/src/store · high confidence

Adds the \barrel\_crypto\ application, providing AES-256-GCM envelope encryption for database values and offset-addressable AES-256-CTR sector encryption for mmap'd flat files (such as BM25 and DiskANN indexes). The module includes a key provider abstraction that defaults to deriving per-database keys from the \BARREL\_ENCRYPTION\_KEY\ environment variable using HKDF-SHA256, and supports custom providers for KMS integration. Encryption is disabled by default and can be enabled via configuration, with fail-closed key-check tokens to detect wrong keys at database open.

_apps/barrel\crypto/src · high confidence

This release introduces the Barrel 1.11.0 application, an embeddable edge-AI database that composes document and vector layers. Key additions include live BQL queries that push real-time add/change/remove deltas to subscribers, and a federated query system allowing BQL statements to run across multiple named contexts or working sets. The update also adds a local context catalog for managing these datasets, supports record mode for asynchronous vector indexing, and enables pluggable attachment backends.

apps/barrel/src · high confidence

Barrel Lite now includes a local BQL engine that allows queries to be executed directly on cached documents without contacting the server. This change introduces a full TypeScript implementation of the BQL pipeline—lexer, parser, AST, lowering, and evaluator—mirroring the server's behavior for standard collection queries. Users benefit from faster, offline-capable query results for supported operations, while server-only features like table functions (e.g., vector search) and live subscriptions are explicitly handled by raising errors to ensure correct delegation.

clients/barrel-lite/src/bql · high confidence

The client now supports local attachment management, storing files as content-addressed blobs identified by SHA-256 digests and indexing them by document ID and name. This change introduces a last-write-wins (LWW) conflict resolution strategy for attachment synchronization, where newer timestamps override older ones, with digest byte order serving as a tie-breaker. Users benefit from reliable local attachment persistence, efficient garbage collection of unreferenced blobs, and consistent sync behavior when multiple devices modify the same attachment.

clients/barrel-lite/src/attachments · high confidence

The Barrel-Lite client now includes a complete set of TypeScript codecs for the wire protocol, enabling correct serialization and deserialization of replication data. This adds support for Hybrid Logical Clocks (HLC) with a stateful clock implementation for causal ordering, version vectors for conflict detection and merging, and document version tokens. It also provides platform-neutral utilities for Base64 (standard and URL-safe), byte comparison, hex encoding, and 32-bit float vector encoding, ensuring byte-exact compatibility with the server's Erlang codecs.

clients/barrel-lite/src/codec · high confidence

Users can now store database attachments in external S3-compatible object stores (AWS S3, MinIO, Garage) instead of the default embedded RocksDB instance. This new \barrel\_att\_s3\ backend supports whole-blob and streaming uploads, non-blocking eager-copy branching for database forks, and optional write-conflict detection via conditional writes. It also includes a background sweeper to garbage-collect abandoned multipart uploads and a local change feed to enable bidirectional replication.

_apps/barrel\_att\s3 · high confidence

Added three new benchmark suites in the bench directory to evaluate system performance. The ctx\_ranking suite builds a corpus from OTP source code and measures cross-context ranking quality using vector embeddings and reranking. The ctx\_remote suite measures the latency and cost of federated queries across multiple remote database contexts with varying network delays. The rocksdb\_readonly suite compares the startup time and memory usage of read-only database opens against a standard read-write baseline.

bench · high confidence

The \clients/barrel-lite/src/sync\ module introduces a complete synchronization engine for the Barrel Lite client. It implements a pull loop that applies remote documents with idempotent skip, fast-forward, and deterministic last-write-wins conflict resolution, alongside a push loop that batches dirty records and handles server-side conflicts. Live synchronization is provided via an adaptive polling scheduler that adjusts intervals based on activity and errors, while a continuous changes stream client enables real-time wake signals for live sync. The engine also includes an SSE frame parser for handling server-sent events, a checkpoint system for resuming pulls, and exposes status and change events to the application layer.

clients/barrel-lite/src/sync · high confidence

The Barrel Lite client now includes a dedicated sync wire transport layer that handles communication with the server's sync endpoints. This introduces structured error handling via a \SyncError\ class with specific error codes (such as network, unauthorized, clock\_skew) to allow callers to branch logic without string-matching messages. It also adds support for server-side sync filters, allowing clients to specify path patterns, channels, and complex query conditions to limit the data pulled during replication. The transport manages the handshake with the server's hybrid logical clock (HLC) to ensure consistent conflict resolution and provides methods for fetching changes, diffing document versions, and retrieving or storing documents and local checkpoints.

clients/barrel-lite/src/wire · high confidence

The vector store now supports encryption at rest via RocksDB EncryptedEnv, requiring a 256-bit key and enforcing a fail-closed policy if the key is wrong or if attempting to encrypt an existing plaintext store. A new read-only mode allows stores to be opened for search and stats without creating or rewriting any files, failing if the store is missing or requires a column-family upgrade. Additionally, an optional document backend seam (barrel\_vectordb\_docdb\_backend) lets users route vector text and metadata to an external barrel\_docdb instance, keeping the vector index local while sharing a source of truth for documents.

_apps/barrel\vectordb · high confidence

The database now supports pluggable attachment backends, allowing storage to be configured via \att\_opts.backend\ (defaulting to a RocksDB BlobDB instance, with a \none\ backend available to skip the \~74MB RocksDB WAL/MANIFEST floor for databases that never store attachments). Additionally, a new BQL (Barrel Query Language) engine is introduced, providing a PartiQL-like SQL dialect for querying documents, including support for table functions (vector, BM25, hybrid), UNNEST, and streaming execution.

_apps/barrel\docdb/src · high confidence

The benchmarking tooling in apps/barrel\_docdb/bench now includes a new writer benchmark (barrel\_bench\_writer) that supports concurrent write operations, detailed profiling via tprof, and process sampling to analyze database server and client performance. A new writer\_compare.sh script allows comparing performance metrics across different repository checkouts. The build process has been updated to compile the benchmark against the umbrella repository's compiled output rather than resolving barrel\_docdb as an external git dependency, simplifying the setup for local development and testing.

_apps/barrel\docdb/bench · high confidence

The barrel\_server application (version 1.11.0) introduces an embeddable route table (\barrel\_server\api\) that allows host applications to mount the Barrel REST/JSON surface under a custom sub-path with their own middleware. The standalone server now supports multi-protocol serving (HTTP/1.1, HTTP/2, and HTTP/3) with configurable TLS and mutual TLS (mTLS) listeners. Security is enhanced with a new bearer-token authentication middleware supporting global tokens, capability tokens (\bsp\...\), and signed requests, alongside CORS support. The server also exposes a new \/mcp\ endpoint for Model Context Protocol integration, providing tools for agent-layer operations (spaces, sessions, handoffs) and contexts.

_apps/barrel\server/src · high confidence

The barrel\_faiss application version has been updated from 0.2.1 to 1.0.1. Additionally, the Hex package configuration has been refined to explicitly include build inputs (such as c\_src, do\_cmake.sh, and do\_faiss.sh) that are otherwise omitted by default, ensuring the NIF is built correctly when published. The GitHub link has also been updated to point to the main barrel umbrella repository.

_apps/barrel\faiss/src · high confidence

The barrel\_docdb documentation is now generated using the Erlang ex\_doc toolchain instead of the previous MkDocs setup. This change removes the MkDocs configuration file and custom HTML overrides, replacing them with ex\_doc configuration in rebar.config that defines the guide structure, API reference, and branding styles. Users viewing the documentation will see the same content but generated via the standard Erlang/Elixir documentation pipeline, with the README updated to point to the new documentation location.

_apps/barrel\docdb · high confidence

The Faiss NIFs now reject invalid metric types instead of silently defaulting to L2, preventing incorrect search results. Search operations guard against excessively large 'k' values to avoid memory overflows or unreasonable allocations, returning a clear error if the request is too large. Additionally, string construction for index descriptions and paths is moved inside try blocks to ensure exceptions do not escape the NIF boundary, and the 'close' operation is marked as CPU-bound to prevent VM blocking. Finally, the resource type is re-initialized on upgrade to ensure post-upgrade operations resolve correctly.

_apps/barrel\_faiss/c\src · high confidence

The reranker now fails fast if the Python sidecar process exits unexpectedly during startup (e.g., due to import errors or OOM), rather than waiting for a full timeout. Additionally, shell commands executed within the virtual environment are now run in a dedicated owner process to prevent port messages from cluttering the caller's mailbox, and the \decode\_response\ function is exposed for unit testing.

_apps/barrel\rerank/src · high confidence

barrel\_embed now shares a single local model process across all databases using the same model, reducing resource usage and startup time. The library also exposes model identity (name and revision) via the new describe/2 and release/1 functions, and improves reliability by replacing deprecated error handling with try/catch and increasing timeouts for Python port commands.

_apps/barrel\embed/src · high confidence

The barrel\_embed documentation system has switched from MkDocs to ExDoc. This change removes the MkDocs configuration and custom theme overrides, and updates the build configuration to generate documentation via ExDoc. The documentation source files have been reorganized, with the changelog moved to the project root, and the README updated to reflect the new documentation URL and version. Users should now access the documentation via the HexDocs page or the new barrel-db.eu/docs/lib/embed/ path.

_apps/barrel\embed · high confidence

The barrel\_rerank library has been updated to version 1.0.0, introducing a critical behavioral change where Python venv shell commands now run in a short-lived owner process rather than the caller's process. This prevents orphaned port messages from cluttering the caller's mailbox and resolves hanging issues during Python startup failures. Additionally, the package includes a comprehensive documentation overhaul with new branding, dark mode support, and an API reference, while the dependency version in the README has been updated to 1.0.0.

_apps/barrel\rerank · high confidence

The barrel\_server release 1.11.0 introduces three key changes to the sync and space handling behavior. First, the \/db/:db/\sync/\\ routes now support CBOR encoding (content type \application/cbor\) for replication payloads, allowing documents that JSON cannot carry to be synced; clients accepting only JSON will receive a 406 for such documents instead of a 500 error. Second, sync routes no longer automatically create databases; attempting to sync to a non-existent database now returns a 404 \not\_found\, requiring the database to be created explicitly via \PUT /db/:db\ first. Third, when accessing a database through the server, spaces are opened using the recorded mode and vector path from \barrel\_spaces:open\_space/2\, ensuring consistent space configuration regardless of which route opens it first, rather than relying on the server's open options.

_apps/barrel\server · high confidence

The barrel\_spaces app now supports creating spaces in 'record mode' via the \embedding\ option in \create\_space/1\ and \open\_space/2\, which stores embedding policy details (provider, model, dimensions, distance, fingerprint) in the space document rather than the embedder configuration, allowing spaces to reopen in record mode on any node with a matching fingerprint. Additionally, spaces can now be created without a vector store by passing \vectordb =\> none\, enabling plain database usage. The app also ensures replication compatibility by storing \token\_hash\ as lowercase hex in grant documents, making them valid JSON for HTTP replication, and requires barrel \~\> 1.11.

_apps/barrel\spaces · high confidence

This release addresses two critical stability issues in the FAISS NIF bindings. First, the \search\ function now validates the \k\ parameter and allocates result buffers within a protected try block, preventing Virtual Machine crashes when an oversized \k\ is requested. Second, the \on\_upgrade\ callback has been updated to properly re-open index resource types, ensuring that unknown metric atoms are rejected rather than silently defaulting to L2, and that the \close\ operation executes on a dirty scheduler to maintain data integrity during upgrades.

_apps/barrel\faiss · high confidence

When the bound database closes, a shard now waits for its subscription retry instead of immediately resubscribing, and it correctly re-follows the database once it is reopened. This prevents noisy or premature reconnection attempts during database downtime. This fix requires barrel\_docdb 1.7.1 or later to function correctly.

_apps/barrel\ngram · high confidence

Added browser-based smoke tests for OPFS persistence and multi-tab coordination; Added comprehensive test suites for the Barrel database facade; Added test coverage for Barrel-Lite core components; Added test suites for BQL, attachment storage, and backend selection; Added test suites for barrel\_spaces capabilities, handoffs, sessions, and lifecycle; Added test suites for server REST API, authentication, audit, and context features; Added tests for embedding provider configuration, request building, and process pooling; Added tests for encryption primitives and file-sector cipher; Added tests for response decoding and port isolation in barrel\_rerank; End-to-end test harness for replication and S3 attachment backends; Integration test suite for Barrel-Lite client against real server.

The Barrel repository has been reorganized into a comprehensive umbrella project. New applications have been added to the default build: \barrel\ (the main embeddable database facade), \barrel\_crypto\ (encryption primitives), and \barrel\_ngram\ (substring search). Two new opt-in profiles, \server\ and \s3\, allow building \barrel\_server\ (HTTP/MCP interface) and \barrel\_att\_s3\ (S3 attachments) respectively. The default build now includes \barrel\_spaces\ (agent layer). Dependency versions have been updated in \rebar.lock\, including \hackney\ (4.4.0→4.8.4), \rocksdb\ (3.0.0→3.1.2), \quic\ (1.6.5→2.0.3), and \h2\ (0.10.1→0.12.3). The \gen\_batch\_server\ dependency has been removed. The \rebar.config\ now configures umbrella-level xref and dialyzer checks, and the root release version is set to 1.11.0.

(repo-wide) · high confidence

The barrel-lite TypeScript client is introduced with a new package manifest and lockfile, establishing a Node.js \>=20 environment and adding development dependencies for TypeScript (^6.0.3), Vitest (^4.1.10), Playwright (^1.61.1), and Node types (^26.1.0) to support local builds and browser-based testing. Concurrently, the barrel\_docdb application removes its MkDocs documentation stack (mkdocs, mkdocs-material, pymdown-extensions) from requirements.txt, indicating a shift away from the previous static site generation tooling.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 73 → 56 (-16.7)
• Rubric changed (rubric-2026.09.12 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 82 → 82 (-0.1)
• Architecture 98 → 98 (-0.3)
• Maturity 71 → 71 (-0.0)
• Readiness 77 → 77 (+0.6)
• Security 68 → 71 (+2.8)
• Event-Driven 35 (new)
• Event Sourcing 100 → 100 (+0.0)
• Performance 85 (new)

• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (apps/barrel_crypto/README.md)
• Documentation: no project overview (README.md)
• Documentation: written for insiders (docs/guides/timeline.md)
• Duplicated block (10 lines × 2) (apps/barrel_ngram/src/barrel_ngram_registry.erl)
• Duplicated block (15 lines × 4) (apps/barrel_embed/src/barrel_embed_clip.erl)
• Duplicated block (5 lines × 2) (apps/barrel_docdb/src/barrel_att_store_blob.erl)
• Duplicated block (6 lines × 3) (apps/barrel_docdb/src/barrel_query_sub.erl)
• Duplicated block (8 lines × 2) (apps/barrel_embed/src/barrel_embed_sup.erl)
• Duplicated block (8 lines × 2) (apps/barrel_ngram/src/barrel_ngram_query.erl)
• Duplicated block (9–12 lines × 2) (apps/barrel_docdb/src/barrel_changes.erl)
• Hotspot: apps/barrel_att_s3/src/barrel_att_s3_store.erl (apps/barrel_att_s3/src/barrel_att_s3_store.erl)
• Hotspot: apps/barrel_docdb/src/barrel_bql.erl (apps/barrel_docdb/src/barrel_bql.erl)
• Hotspot: apps/barrel_docdb/src/barrel_bql_exec.erl (apps/barrel_docdb/src/barrel_bql_exec.erl)
• Hotspot: apps/barrel_docdb/src/barrel_bql_lower.erl (apps/barrel_docdb/src/barrel_bql_lower.erl)
• Hotspot: apps/barrel_docdb/src/barrel_rep_filter.erl (apps/barrel_docdb/src/barrel_rep_filter.erl)
• Hotspot: apps/barrel_ngram/src/barrel_ngram_regex.erl (apps/barrel_ngram/src/barrel_ngram_regex.erl)
• Hotspot: apps/barrel_server/src/barrel_server_auth.erl (apps/barrel_server/src/barrel_server_auth.erl)
• Hotspot: apps/barrel_vectordb/src/barrel_vectordb_bm25_disk_file.erl (apps/barrel_vectordb/src/barrel_vectordb_bm25_disk_file.erl)
• …and 10 more

• Critical CVE: [GHSA redacted] (apps/barrel_vectordb/priv/requirements-full.txt)
• Dependency hygiene PARTLY measured — Python dependencies read, no exact pin to grade for currency
• Documentation: no architecture or design documentation (apps/barrel/README.md)
• Documentation: no installation or build instructions (apps/barrel/README.md)
• Documentation: no project overview (apps/barrel_rerank/README.md)
• Documentation: no usage examples (apps/barrel/README.md)
• Duplicated block (11 lines × 2) (apps/barrel_ngram/src/barrel_ngram_fs.erl)
• Duplicated block (13 lines × 2) (apps/barrel_docdb/src/barrel_db_server.erl)
• Duplicated block (13 lines × 2) (apps/barrel_docdb/src/barrel_rocksdb_ro.erl)
• Duplicated block (15 lines × 4) (apps/barrel_embed/src/barrel_embed_clip.erl)
• Duplicated block (19 lines × 2) (apps/barrel_embed/priv/barrel_embed/server.py)
• Duplicated block (25 lines × 2) (apps/barrel_embed/priv/barrel_embed/server.py)
• Duplicated block (27–30 lines × 2) (apps/barrel_docdb/src/barrel_db_server.erl)
• Duplicated block (34–37 lines × 2) (apps/barrel_docdb/src/barrel_db_server.erl)
• Duplicated block (5 lines × 2) (apps/barrel_docdb/src/barrel_rocksdb_ro.erl)
• Duplicated block (6 lines × 2) (apps/barrel_docdb/src/barrel_rocksdb_ro.erl)
• Duplicated block (7 lines × 2) (apps/barrel_embed/priv/barrel_embed/providers/clip.py)
• Duplicated block (7 lines × 2) (apps/barrel_ngram/src/barrel_ngram_query.erl)
• Duplicated block (8–16 lines × 3) (apps/barrel_docdb/src/barrel_db_server.erl)
• Duplicated block (9–10 lines × 3) (apps/barrel_embed/priv/barrel_embed/providers/clip.py)
• …and 21 more

• 28 commits — 28 feature/other, 0 fixes

• apps/barrel — 9 commits
• apps/barrel_docdb — 6 commits
• apps/barrel_vectordb — 3 commits
• apps/barrel_embed — 2 commits
• apps/barrel_server — 2 commits
• .github/workflows — 1 commit
• apps/barrel_att_s3 — 1 commit
• apps/barrel_ngram — 1 commit
• apps/barrel_spaces — 1 commit
• docs/experiments — 1 commit
• docs/guides — 1 commit

• change: Bounded queries that report the state that answered (#51)
• change: Context catalog and remote query client (#55)
• change: Contexts and working sets over REST and MCP (#58)
• change: Contexts design, experiment results and the ngram packages report (#59)
• change: Embedding fingerprint on databases and vector answers (#52)
• change: Export a database and import it read only elsewhere (#54)
• change: Federated queries over contexts (#57)
• change: Make BM25 survive store reopen (#47)
• change: Read-only barrel opens, database leases and holds (#53)
• change: Read-only docdb and vectordb opens, import sidecar, observed version (#50)
• change: Release barrel_ngram 0.11.1, barrel 1.10.0 and barrel_server 1.10.0, docs for contexts (#63)
• change: Remove timing dependence from the test suites (#62)
• change: Test the S3 attachment backend against RustFS and Garage (#64)
• change: Working sets, retrieved-set slices and offline coverage (#56)
• change: barrel 1.11.0, barrel_spaces 1.3.0: a plain database can skip the vector store (#72)
• change: barrel and barrel_server 1.10.1: hackney 4.8, livery 0.10.3, quic 2 (#66)
• change: barrel_docdb 1.7.1, barrel_ngram 0.11.2: a changes stream stops cleanly when its database closes (#67)
• change: barrel_docdb 1.8.0, barrel_spaces 1.3.0, barrel_server 1.11.0: replicate documents JSON cannot carry (#68)
• change: barrel_docdb 1.8.0: a replication task pauses when its database closes and resumes when it reopens (#69)
• change: barrel_docdb: a faster writer per database (#61)
• …and 8 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

barrel-db/barrel was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.