EpicGames/lore
74.4
Strong · 14 November 2026
358.3k
lines of production code
Rust
primary language
5
measurements over time
What this system is
Features
Add local immutable store stress suite and benchmarking tool
The \lore-storage/examples/store\_stress\ directory now includes a comprehensive stress harness and benchmarking tool for the local immutable and mutable stores. The suite introduces several subcommands: \work\ for running randomized concurrent workloads, \calls\ for simulating multi-process client interactions with shared store directories, \verify\ for post-run integrity checks against a journal, \scenario\ for deterministic crash-window testing, \retention\ for verifying client interleavings, and \bench\ for measuring throughput and latency of hot paths like puts, gets, and queries. This addition provides developers with a robust way to validate store stability, concurrency handling, and performance under stress.
lore-storage/examples · high confidence
Added lore-io benchmarking and diagnostic examples
The lore-io crate now includes a suite of examples for performance analysis and debugging. The \bench\ example provides a comprehensive micro-benchmarking harness that compares the lore-io library against standard blocking I/O and tokio-fs, supporting warm and cold read/write workloads with configurable concurrency and data sizes. Additional tools include \handle-fanout\ to diagnose file handle contention by varying the number of open handles, \pool-sweep\ to analyze the impact of the syscall thread pool size on throughput, and \build-ab\ to facilitate interleaved A/B testing of different binary builds. These examples are designed to help users measure and optimize I/O performance on their specific hardware and workloads.
lore-io/examples · high confidence
Automatic migration of local Oodle-compressed payloads to Zstd
The local immutable store now includes a background migration process that detects payloads still compressed with the deprecated Oodle codec and transparently re-encodes them using Zstd. This ensures data remains readable even if Oodle support is removed from the build, as the system tracks migration progress per group and leaves durably stored upstream payloads untouched while replacing local-only Oodle copies. The migration is resumable, idempotent, and uses a concurrency gate to manage access during the re-encoding pass.
_lore-storage/src/local/immutable\store · high confidence
Define RevisionService API for branch and revision management
Added the \RevisionService\ gRPC definition in \lore-proto/proto/lore/revision/v1/revision.proto\, establishing the contract for branch lifecycle and revision history operations. The service exposes RPCs for creating, deleting, and retrieving branches (\BranchCreate\, \BranchDelete\, \BranchGet\), listing branches with filtering support (\BranchList\), updating branch tips with force or fast-forward merge semantics (\BranchPush\), and managing branch metadata via compare-and-swap (\BranchMetadataGet\, \BranchMetadataSet\). It also includes \RevisionList\ for paginating through a branch's revision history. This proto file defines the request and response message structures for these operations, serving as the interface specification for the revision graph service.
lore-proto/proto/lore/revision · high confidence
Docker support for Lore Server
Lore Server can now be run in Docker containers using two provided images: a source-build image (Dockerfile) and a pre-compiled release image (Dockerfile.release). The configuration is set up for local filesystem storage by default, with data persisted in /data. The server exposes ports 41337 (gRPC/QUIC) and 41339 (HTTP). Documentation is provided in DOCKER.md.
lore-server · high confidence
Initial HTTP server implementation with health checks, presigned URL support, and security hardening
The Lore HTTP server is introduced, providing a new API surface for repository content management, health monitoring, and presigned URL operations. The server includes a health check endpoint that reports service availability based on store status, and a presigned URL system that uses HMAC-SHA256 for token signing and verification. To mitigate stored XSS risks, the server enforces a strict Content-Type allowlist for redeemed presigned content, coercing disallowed types to application/octet-stream and blocking executable document types like HTML and JavaScript. The implementation also adds structured HTTP tracing with correlation IDs and user-agent filtering, and configures transport-level limits for request timeouts and body sizes.
lore-server/src/http · high confidence
Initial OpenTelemetry telemetry stack for lore-server
The lore-server now includes a comprehensive telemetry module that initializes OpenTelemetry providers for logs, metrics, and traces, exporting data via OTLP. This change introduces a \TelemetryInitializer\ that configures log output (file, stdout, or stderr) with JSON, text, or ANSI formatting, sets up batched log and trace processors, and configures periodic metric readers. It also bridges Tokio runtime metrics (task scheduling, queue depths, I/O stats) to OpenTelemetry gauges and histograms, and supports environment-specific resource detection via a pluggable \ResourceDetectorProvider\ trait to attach infrastructure metadata to telemetry signals.
lore-server/src/telemetry · high confidence
Initial definition of the Repository Service API
This change introduces the \RepositoryService\ and \ForwardedRepositoryService\ definitions in the Lore repository protocol. The \RepositoryService\ exposes RPCs for creating, deleting, listing, and retrieving repositories, as well as compare-and-swap operations for managing repository metadata pointers. The \ForwardedRepositoryService\ defines endpoints for \RepositoryCreate\ and \RepositoryGet\ to support request forwarding between Lore Servers.
lore-proto/proto/lore/repository · high confidence
Initial notification client implementation with retry logic and multi-scheme support
This change introduces the \lore-notification\ module, providing the client-side infrastructure for real-time repository notifications. The new \NotificationClient\ establishes gRPC connections to notification services, implementing automatic retry logic for connection and subscription attempts to handle transient failures. It supports multiple URL schemes (https, lore, lores, urc, urcs, grpc, grpcs) via a registered service factory, ensuring compatibility with various endpoint configurations. The client manages subscription lifecycles using cancellation tokens and integrates with the existing error handling and execution context systems.
lore-notification · high confidence
Initial public release documentation and governance framework
The repository now includes the foundational documentation and governance artifacts required for public open-source contribution. This includes a Code of Conduct, Contributor Guide, Governance model, Security policy (with HackerOne integration), and a Maintainers list. To support these standards, the project has added pre-commit hooks for Rust linting (clippy, fmt) and documentation quality (markdownlint, Vale, lychee), along with configuration files for these tools and a license compliance generator (cargo-about).
(repo-wide) · high confidence
Initial release of Lore protocol definitions and Rust bindings
This change introduces the core protocol buffer definitions and generated Rust code for the Lore system, establishing the foundational API surface. It adds service contracts for administration, authentication, environment discovery, locking, notifications, and replication, alongside comprehensive data models for repositories, branches, and revisions. The included Rust bindings in \lore-proto/src\ provide the necessary serialization and client stubs to interact with these services.
lore-proto/src · high confidence
Initial release of the Lore C API
The \lore-capi\ crate is introduced, providing the public C interface for the Lore library. This change adds the build infrastructure (\build.rs\, \cbindgen.toml\) to automatically generate \lore.h\ from Rust source code using cbindgen, including post-processing to ensure C/C++ compatibility and naming conventions. The resulting API exposes core repository operations (clone, commit, branch management), revision control verbs (add, delete, modify, move, cherry-pick), and storage access, along with event-driven callbacks for progress and error reporting. Also in this area: 5 commits (0 fixes) modifying lore-capi; 1 commit (0 fixes) modifying lore-capi; Updated C API interface version to 0.12.1-nightly; OIDC refresh tokens are revoked on logout; New service status query and interactive login progress events; and 1 more.
lore-capi · low confidence · unverified
Initial release of the Lore revision control system
This change introduces the Lore revision control system, providing a comprehensive API for managing code repositories. The \lore/src\ module exposes a C-compatible interface for core version control operations, including branch management (create, info, diff, merge, push), file operations (info, diff, stage, unstage, reset, write), and repository configuration (layers, dependencies, links). It also includes authentication handling (login, user info), analytics event reporting, and a background service architecture to manage repository state and remote synchronization. Also in this area: 9 commits (1 fix) modifying lore; 3 commits (0 fixes) modifying lore; Auth logout now revokes OIDC refresh tokens; New service status query and interactive login progress events.
lore/src · medium confidence · unverified
Initial release of the Lore v1 model protocol definitions
This change introduces the \lore.model.v1\ protobuf schema, defining the core data structures for the Lore system. It establishes the wire format for storage fragments (\Fragment\, \Address\), revision identifiers (\RevisionIdentifier\, \BranchPoint\), and repository metadata (\Repository\, \Branch\). The schema also defines \ItemStatus\ to handle per-item outcomes in streaming RPCs, ensuring that routine failures (like missing fragments) do not terminate the entire stream. This file serves as the foundational contract for the Lore v1 API.
lore-proto/proto/lore/model · high confidence
Initial release of the lore-base library
The lore-base crate is introduced as the foundational library for the Lore system, providing core infrastructure for error handling, runtime management, and utility functions. It establishes a consolidated FFI error type system with structured exit codes for CLI and library consumers, implements a configurable retry mechanism with exponential back-off and jitter for remote operations, and defines a task lifecycle observer to track spawned tasks. Additionally, it includes utilities for cross-platform directory resolution, UTF-8 validation for FFI arguments, and a versioning system that supports post-build stamping of build names into artifacts.
lore-base/src, lore-hashicorp · high confidence
Initial release of the lore-macro proc-macro crate
This change introduces the \lore-macro\ crate, providing procedural macros that generate boilerplate for the Lore command system. The \LoreCommand\ derive macro generates dispatch logic for command variants, including UTF-8 validation for text arguments and optimized local execution paths that avoid unnecessary stack allocations. The \LoreArgs\ derive macro implements argument handling and local invocation for command handlers. Additional macros include \ValidateText\ for enforcing UTF-8 constraints on struct fields, \VariantTypeSize\ for calculating enum variant sizes, \lore\_instrument\ for tracing integration, and \test\_pub\ for conditional test-only visibility.
lore-macro · high confidence
Initial telemetry library with HTTP/gRPC metrics and tracing support
The lore-telemetry crate introduces a comprehensive observability foundation, providing configurable metrics and tracing infrastructure. It includes Tower middleware layers for both HTTP (Axum) and gRPC (Tonic) servers that automatically record request duration, active request counts, and user-agent information, with gRPC specifically tracking handler duration from the end of the request body. The library offers utility traits like InstrumentProvider for standardized metric creation, DropRecord/DropTimeMs for RAII-based metric recording, and Observe/ObserveResult traits for timing asynchronous operations. It also features a UserAgentFilter for sanitizing metric labels and a configuration system for managing exporters, loggers, and trace sampling rates.
lore-telemetry · high confidence
Introduce AWS-backed storage and locking infrastructure
This change adds the \lore-aws\ crate, providing the concrete AWS implementations for the Lore storage and locking systems. It introduces wrappers for S3 and DynamoDB that include telemetry, error handling, and a custom HTTP client to ensure network requests run on the dedicated net runtime. The crate implements the \ImmutableStore\ and \MutableStore\ traits for persistent data storage, a \LockStore\ for distributed locking via DynamoDB, and a \MetadataMigrator\ to handle the migration of legacy fragment metadata from DynamoDB to the new S3-backed state table.
lore-aws · high confidence
Introduce Environment Service for server configuration and OIDC discovery
Clients can now call the new EnvironmentService.EnvironmentGet RPC to discover server-side configuration and auxiliary endpoint URLs (storage, revision, lock, notification, user directory) during connection setup. The response includes tunable configuration knobs such as compression mode and query batch size, and explicitly advertises the OpenID Connect (OIDC) provider details (issuer, client ID, scopes) when OIDC is enabled, allowing clients to determine whether to use the OIDC flow or the legacy auth\_url endpoint.
lore-proto/proto/lore/environment · high confidence
Introduce Lore-backed blob store for Bazel Remote Execution
Added a new Rust library (rbe-lore) and server components that implement the Bazel Remote Execution API (REAPI) backed by the Lore storage system. This change introduces a two-tier caching strategy (local disk and upstream Lore server) for both the Content Addressable Storage (CAS) and Action Cache (AC), enabling efficient blob storage and retrieval for remote build execution. It includes utilities for SHA-256 digest computation, zstd frame handling, and workspace metadata management, along with a CLI tool (lore-rbe-index) to stamp, publish, and seed content into the Lore repository.
contrib/bazel/crates/rbe-proto, contrib/bazel/crates/rbe-server, contrib/bazel/crates/rbe-worker · high confidence
Introduce QUIC transport layer with chunked message handling and parallel response reading
The QUIC transport implementation is added to lore-transport, introducing a new client and server communication path over QUIC. This includes a chunking module that assembles incoming QUIC chunks into complete messages (handling both v4 and legacy headers) and a response reader that processes these responses in parallel, mapping specific QUIC error codes (like NotAuthorized) to user-facing errors. The client supports configuration for TLS certificates, SNI overrides, and Happy Eyeballs connection strategies, while the server exposes connection statistics and handles stream-based request admission.
lore-transport/src/quic · high confidence
Introduce automated third-party notices generation for redistributed binaries
A new generator in the \notices\ directory now produces the OSS third-party notices file shipped with each Lore binary. It uses \cargo-about\ to render license and attribution data for Rust dependencies, then merges in non-Cargo vendored sources (like \rpmalloc\) and applies license-text overrides for crates where the license text could not be resolved automatically (such as \governor\, \asn1-rs-impl\, and \rs-consul\). The process enforces a strict gate that fails if any dependency renders an unfilled license placeholder, ensuring every redistributed binary includes complete and accurate third-party license notices.
notices · high confidence
Introduce chaos engineering client for Lore repositories
The \lore-chaos-client\ library and CLI are added, enabling automated chaos testing of Lore repositories. The tool supports two modes: a single-threaded \Chaos\ runner and a multi-threaded \Parallel\ runner (defaulting to 2 threads). It generates and executes repository operations—such as commits, branch creation, branch switching, and merges—using a seeded \ProbabilityEngine\ to ensure reproducible scenarios. Users can configure iteration counts, time limits, and RNG seeds, and can opt for a \--dry-run\ mode or a \--replay-operations\ mode that executes a sequence of operations from a JSON file. The client also provides an \OperationWriter\ to export generated operations to JSON for later analysis or replay.
lore-chaos-client/src · high confidence
Introduce composable, traceable error handling with strict error-set propagation
The \lore-error-set\ library provides a new error-handling system for Rust, centered on the \\#\[error\_set\]\ macro which generates enums with automatic cross-set mapping and a mandatory \Internal\ catch-all variant. It introduces \Traced\<E\>\ to wrap errors with source-location traces (feature-gated via \track-locations\), and enforces strict compile-time propagation via \ForwardStrict::forward\, which requires the target error set to declare every variant of the source to prevent silent data loss. The library also includes \WrapInternal\ for mapping foreign errors, \FfiError\ for exposing integer codes at boundaries, and \InternalForbiddenOnErrorSets\ to prevent accidental collapse of handleable variants into \Internal\.
lore-error-set/src · high confidence
Introduce dedicated internal gRPC server and request forwarding infrastructure
The server now exposes a new internal gRPC endpoint (previously the replication server) that handles administrative operations like server info and data obliteration, alongside environment configuration retrieval. This internal server also serves as the foundation for a new request forwarding system, allowing the Lore server to delegate specific Repository and Revision service RPCs (such as branch and repository creation/getting) to remote peers. The forwarding implementation includes a dedicated client layer that manages TLS connections, propagates caller identity and authorization headers, and correctly classifies transport errors to ensure unreachable peers are reported as internal client errors rather than peer responses.
lore-server/src/grpc · high confidence
Introduce gRPC storage service with streaming and in-band error handling
The storage API now uses a gRPC \StorageService\ with streaming RPCs for \Get\, \GetMetadata\, \Put\, \Copy\, and new \GetResolved\/\PutResolved\ operations. This design allows batching multiple item requests over a single long-lived stream, with per-item outcomes reported via an in-band \ItemStatus\ field so that a failure on one item does not terminate the entire stream. The service also includes \Query\, \Verify\, and \MutableLoad\/\MutableStore\/\MutableCompareAndSwap\ RPCs for key management and data integrity.
lore-proto/proto/lore/storage · high confidence
Introduce low-level in-memory revision tree API
Added a new low-level API for managing in-memory revision trees, exposing verbs to load, close, commit, add, delete, move, and list children, along with metadata and node info operations. The implementation includes a handle-based registry for concurrent access, an atomic commit mechanism that freezes the tree and advances branch tips, and batch operations for adding and deleting subtrees, all exposed via a documented C-compatible interface. Also in this area: 1 commit (0 fixes) modifying lore, lore-client, lore-io; 9 commits (1 fix) modifying lore; 3 commits (0 fixes) modifying lore.
_lore/src/revision\tree · medium confidence · unverified
Introduces core data model types for the lore storage system
This change adds the foundational type definitions for the lore storage system, including branch management (BranchMetadata, BranchPoint), resource locking (LockResource, LockData), and fragment handling (FragmentFlags for compression and storage states). It also defines store key types (KeyType), verification results (HealResult, VerifyResult), and low-level byte manipulation utilities (TypedBytes) required for the storage layer.
lore-base/src/types · high confidence
Introduction of Lore logging subsystem with atomic level control and daily rotation
The \lore-base\ crate now includes a new logging module (\lore-base/src/log\) that provides a set of logging macros (\lore\_trace\, \lore\_debug\, \lore\_info\, \lore\_warn\, \lore\_error\) and a callback-based dispatch system. A key behavioral detail is that the log level is stored in an atomic variable (\AtomicU32\) rather than behind a lock, allowing for lock-free reads during log emission. The module also introduces a \RotatingLogFile\ writer that supports daily log rotation, multi-process safety via filesystem locking, and automatic cleanup of old log files.
lore-base/src/log · high confidence
Introduction of in-memory lock store for revision resources
The lore-server now includes a local implementation of the lock store mechanism, allowing users to manage locks on repository resources (such as branches and hashes) via an in-memory DashMap. This change introduces the \LocalLockStore\ which supports acquiring, querying, checking status, and unlocking resources, ensuring that resources locked by one owner cannot be locked by another without explicit validation. This provides the foundational infrastructure for resource locking within the revision system.
lore-server/src/lock · high confidence
Lore Server introduces a modular plugin architecture with built-in AWS and HashiCorp support
The Lore Server now supports a compile-time plugin system that allows swappable storage backends and topology discovery mechanisms. This change introduces a \PluginRegistry\ and factory traits for immutable stores, mutable stores, lock stores, and topology services. By default, the server includes built-in plugins for AWS (S3/DynamoDB-backed stores) and HashiCorp Consul (service discovery), enabling operators to configure these backends via TOML settings without modifying server code. This modularization decouples the core server logic from specific infrastructure dependencies. Also in this area: 1 commit (0 fixes) modifying lore-server, lore-transport; 5 commits (2 fixes) modifying lore-server; Configurable initial congestion window for QUIC replica connections; Improved reliability for revision listing and replication copy operations.
lore-server/src · medium confidence · unverified
Low-level revision control API event definitions
The \lore-revision/src/event\ module now exposes the C-compatible event data structures for the low-level revision control API. This includes payloads for loading revision trees, resolving paths, listing children, retrieving node and revision information, and handling batch operations (add, delete, modify, commit). These structs define the shape of data returned to callers for both successful outcomes and error conditions, enabling integration with the \lore\_revision\tree\\*\ verb surface.
lore-revision/src/event · high confidence
New HTTP endpoints for repository content management
The server now exposes a new API area under \/repositories/{repository\_id}/contents\ to manage repository data. Users can upload content via a PUT request to the root of this path, retrieve specific content items via GET requests to \/{address}\, and request temporary access links via POST to \/{address}/presign\. The presign endpoint is restricted to service accounts and enforces a configurable allowlist of content types to prevent misuse.
lore-server/src/http/repositories/repository · high confidence
New JWT authentication and authorization subsystem
The server now supports JWT-based authentication for both HTTP and gRPC endpoints. This change introduces a new \JWKService\ to fetch and cache public keys from JWKS endpoints or via OIDC discovery, handling key rotation and caching with throttling. A \JwtVerifier\ validates tokens, supporting configurable identity claims and resource permission matching via a \ResourceMatcher\. Authentication is enforced through an Axum middleware for HTTP routes and a Tonic interceptor for gRPC services, extracting user identity and permissions into request extensions for downstream authorization checks.
lore-server/src/auth · high confidence
New QUIC observability and admission control for replication and storage services
The QUIC transport layer now includes a dedicated client monitor that exposes detailed connection-level metrics (RTT, congestion window, packet loss, MTU, and UDP I/O) and enhanced stream-level telemetry (latency, pending chunk stalls, and user agent). To protect server resources, the stream handler implements admission control with per-stream request limits, a global connection ceiling, and configurable timeouts that reject excess load with a SlowDown response. These capabilities are integrated into the replication store service and the v4 storage service, ensuring consistent observability and flow control for internal replication and client storage traffic.
lore-server/src/quic · high confidence
New \`\#\[error\_set\]\` proc-macro for composable, traced error enums with FFI support
The \lore-error-set-macro\ crate introduces a new \\#\[error\set\]\ attribute macro that transforms simple Rust enums into comprehensive error types. When applied, the macro automatically generates \Traced\ wrappers for each variant to capture call-site location data, implements standard traits (\std::error::Error\, \Display\, \Debug\), and provides type-safe accessor methods (e.g., \is\\\, \as\\*\). It also includes an \ErrorSet\ trait for cross-error-set mapping and a \FfiError\ derive macro (with \\#\[ffi\_code(N)\]\) to delegate specific integer codes for FFI boundaries, ensuring structured error details and exit-code safety are carried through the application.
lore-error-set-macro · high confidence
New allocation profiling and comparison scripts
Added three new scripts in \scripts/allocations\ to analyze memory usage: \allocount.c\ is a C library that intercepts glibc allocation calls to count them and optionally write size histograms; \attribute.py\ parses allocation dump files to attribute memory usage to specific source lines; and \compare.py\ runs a command under two different builds using the counter library to identify differences in allocation patterns by size.
scripts/allocations · high confidence
New benchmarking and profiling examples for lore-transport
Added \remote\_throughput.rs\ and \chunking\_profile.rs\ examples to \lore-transport/examples\. The \remote\_throughput\ example allows users to measure bulk-fetch throughput against a live remote QUIC service, configurable via environment variables for connection counts, in-flight requests, and address lists, while reporting metrics like MiB/s, latency, and CPU usage. The \chunking\_profile\ example profiles serial and parallel chunk assemblers against each other under various traffic shapes (balanced vs. read-heavy) and reordering conditions, helping users understand performance characteristics of the chunking layer.
lore-transport/examples · high confidence
New content-addressed storage API with range reads, file I/O, and metadata queries
The storage subsystem now exposes a comprehensive set of operations for managing content-addressed data. Users can read content with \lore\_storage\_get\, which supports partial range reads, streaming delivery, and writing directly into caller-supplied buffers. For persistent storage, \lore\_storage\_get\_file\ and \lore\_storage\_get\_file\_resolved\ allow writing content (or resolved mutable keys) to filesystem paths, handling atomic staging via temporary files. The API also includes \lore\_storage\_copy\ for duplicating content between partitions, \lore\_storage\_get\_metadata\ for fetching fragment details without payload bytes, and \lore\_storage\_flush\ for ensuring disk-backed stores are synced. Lifecycle management is handled by \lore\_storage\_close\, which safely drains in-flight operations before flushing and releasing resources. Also in this area: 9 commits (1 fix) modifying lore; 3 commits (0 fixes) modifying lore; New service status query and interactive login progress events; Immutable store copy operations now support durability and replication flags.
lore/src/storage · medium confidence · unverified
New file-system locking and Windows path utilities
The \lore-base\ library now includes a new \fs\ module providing \FSLock\ for acquiring exclusive file and directory locks. The lock implementation uses non-blocking async retries with exponential backoff to avoid parking runtime threads during contention, and includes a warning after 5 seconds if a lock remains held by another process. Additionally, a Windows-specific helper (\win\_path.rs\) converts paths to extended-length (\\\?\\\) wide strings to bypass the 260-character \MAX\_PATH\ limit for direct Win32 API calls.
lore-base/src/fs · high confidence
New gRPC Environment Service to expose server configuration and OIDC details
Clients can now query the server's runtime environment via a new \EnvironmentService\ (v1). The \EnvironmentGet\ response exposes endpoint URLs (auth, repository, storage, etc.), configuration settings (including a forced override of Oodle compression to Zstd), and OIDC provider details (issuer, client ID, scopes). The service also supports a maintenance mode that returns an unavailable status when the server is under maintenance.
lore-server/src/grpc/environment · high confidence
New gRPC Storage v1 API implementation
The gRPC storage service now exposes a new v1 API layer that implements streaming handlers for immutable storage operations (Get, Put, Copy, GetMetadata, GetResolved, PutResolved) and non-streaming handlers for mutable key management (MutableLoad, MutableStore, MutableCompareAndSwap). This implementation introduces specific error-handling behaviors, such as carrying per-item failures in-band for GetResolved and PutResolved to prevent stream termination on expected misses, and enforces cross-partition authorization checks for Copy operations.
lore-server/src/grpc/storage · high confidence
New gRPC Thin Client API for revision inspection and diffing
The server now exposes a new \lore.thin\_client.v1.ThinClientService\ RPC interface, enabling clients to retrieve revision metadata (\RevisionInfo\), stream file-tree listings (\RevisionTree\), and stream 3-way revision diffs (\RevisionDiff\). This service handles revision resolution by signature or branch identifier, supports streaming responses for large trees and diffs, and includes a configurable source-cap (default 100k items) to prevent excessive memory usage during diff generation.
lore-server/src/grpc/thinclient · high confidence
New gRPC handlers for branch lifecycle and metadata operations
The \lore-server/src/grpc/handlers\ directory now includes new handlers for branch creation, deletion, listing, retrieval, protection, and metadata management (get/set), as well as a diff handler. These handlers expose the underlying \lore\_revision\ branch capabilities via gRPC, implementing input validation (e.g., name length limits), read-only field protection for metadata, and link-aware diffing. The branch push handler has also been added to support pushing revisions to branches, including client IP extraction and hook dispatching.
lore-server/src/grpc/handlers · high confidence
New installation, documentation linting, and build-stamping scripts
Users can now install the Lore CLI and loreserver on Windows via a new PowerShell script (scripts/install.ps1) alongside the existing Bash installer (scripts/install.sh), both supporting demo mode and GitHub token authentication. A new documentation linting script (scripts/docs-lint.sh) enforces prose, structure, and link standards using Vale, markdownlint, and lychee. Additionally, a build-stamping script (scripts/stamp-artifacts.sh) embeds the current repository revision into release artifacts for version tracking.
scripts · high confidence
New internal QUIC replication store service with full metadata and query support
The lore-server now exposes a dedicated internal ReplicationStoreService over QUIC, enabling peer-to-peer store replication. This service implements a comprehensive set of operations including immutable Put, Get, Obliterate, Copy, and a new dedicated Query command, while Get and GetMetadata responses now return full StoreGetData information (not just payloads). Clients can identify themselves via a UserAgent field sent during connection initialization, and the service handles connection resilience through automatic client regeneration with congestion window seeding.
_lore-server/src/quic/replication\_store\service · high confidence
New local store stress testing suite
Added a new stress and crash testing harness for the local immutable and mutable stores, including a Python orchestrator (stress.py), a C LD\_PRELOAD shim (crashpoint.c) for injecting file-operation faults and kills, and comprehensive documentation. This suite enables manual validation of store durability, concurrency, and recovery under extreme conditions such as process crashes, simulated I/O errors, disk-full scenarios, and heavy concurrent access, without being built or run in standard CI.
scripts/store-stress · high confidence
New low-level revision operations and API surface
The \lore-revision\ crate now exposes a comprehensive set of low-level revision management capabilities, including amend, bisect, cherry-pick, diff, history, info, restore, revert, and sync. These additions provide users with granular control over revision metadata, history traversal, and content synchronization, while introducing structured event data for tracking progress and outcomes across these operations. Also in this area: 6 commits (1 fix) modifying lore-revision; Improved interactive login feedback and service status reporting.
lore-revision/src/revision · medium confidence · unverified
New persistent cache for revision-list segments
The lore-server now includes a persistent cache for revision-list segments in the \lore-server/src/cache\ module. This feature stores parent-chain revisions at defined step boundaries to accelerate revision identifier lookups, reducing the need for slower full parent-chain walks. The cache uses a best-effort write strategy and distinguishes between missing entries and store overload conditions to maintain performance under pressure.
lore-server/src/cache · high confidence
New server utilities for certificate monitoring, runtime isolation, and store health
The server now includes new utility modules to improve operational visibility and stability. The \cert\_metrics\ module adds background monitoring that reports the time remaining until TLS certificates expire as metrics, helping operators detect expiring credentials before they cause outages. The \core\_hop\ module introduces a Tower layer that ensures request handling logic runs on the core runtime rather than the network runtime, preventing resource contention and ensuring proper isolation of compute-bound tasks. Additionally, the \local\_store\_monitor\ module provides disk space monitoring for local storage paths, including logic to detect temporary or unconfigured store locations and warn users, ensuring storage health is tracked and misconfigurations are flagged early.
lore-server/src/util · high confidence
New storage protocol message handlers and authorization logic
The storage protocol layer now includes dedicated handlers for a comprehensive set of operations: connecting to repositories with JWT-based authentication, copying fragments between repositories (including cross-partition copies with authorization checks), retrieving fragment metadata without payloads, resolving mutable keys to immutable addresses in a single round-trip, and performing compare-and-swap operations on mutable keys. A new authorization module parses and validates start/stop session tokens, while the connect handler integrates JWT verification and repository access control into the connection context. Correlation IDs are now explicitly managed to support request tracing across these new and existing message types. Also in this area: 5 commits (2 fixes) modifying lore-server; Prevent repository identity swap during Connect handshake; Improved reliability for revision listing and replication copy operations.
lore-server/src/protocol/storage · medium confidence · unverified
New storage subsystem modules introduced in lore-storage
The lore-storage crate now includes several new source files that define core storage behaviors: caller\_buffer.rs manages memory buffers for reads, chunker.rs handles content-defined chunking, compress.rs manages compression modes and levels, concurrency.rs handles concurrency limits, conformance.rs provides a battery of tests for store implementations, content.rs defines content sources and handles, defragment.rs handles defragmentation pipelines, error.rs defines storage errors, and errors.rs defines additional error types. These modules collectively provide the foundation for the storage subsystem's data handling, compression, concurrency control, and error management capabilities.
lore-storage/src · high confidence
New store configuration and replication client modules
The \lore-server/src/store\ directory now contains the core implementation for store configuration and replication communication. The new \configuration.rs\ module provides a plugin-based system for creating immutable, mutable, and lock store instances, allowing operators to select storage backends (e.g., AWS, local) via configuration. The \grpc\_replica.rs\ module implements a gRPC-based replication client for write operations, handling streaming requests and response tracking. Additionally, \replica.rs\, \replicated\_store.rs\, and \replica\_factory.rs\ introduce a QUIC-based replication architecture, including a \ReplicatedStore\ that forwards operations to remote servers to reduce cross-region latency, and a \ReplicaFactory\ that manages client connections with locality-aware congestion control (Cubic for same-region, BBR for cross-region).
lore-server/src/store · high confidence
New utility modules for streaming, configuration, encoding, and path handling
The \lore-revision/src/util\ directory now includes a suite of new helper modules that support core repository operations. \collect\_stream.rs\ provides an async utility to drain streaming producers into a vector while capturing a summary value. \config.rs\ introduces a robust TOML configuration system with atomic writes (using temporary files and rename) to prevent data loss on interruption, along with both async and blocking load methods. \encoding.rs\ adds support for detecting and decoding UTF-8, UTF-16 (with BOM and byte-order detection), and refusing unsupported encodings like UTF-32, which is critical for parsing filter files. \path.rs\ centralizes path resolution logic, including absolute path construction relative to a working directory, validation of paths within the repository, and case-insensitive path handling. \fs.rs\ provides filesystem utilities such as executable bit management and metadata extraction. \inflight.rs\ offers a concurrency primitive for deduplicating in-flight requests using broadcast channels. \task\_queue.rs\ implements a rate-limited and concurrency-limited task queue with OpenTelemetry observability. \time.rs\ and \serde.rs\ add retry policy builders and boolean serialization helpers, while \url.rs\ normalizes remote URLs by stripping protocol schemes. Also in this area: 6 commits (0 fixes) modifying lore-revision; 11 commits (1 fix) modifying lore-revision/src; Improved staging accuracy for case-variant directories and dry-run safety; Fixes store-lock deadlock and updates dependencies; Improved interactive login feedback and service status reporting; and 1 more.
lore-revision/src/util · medium confidence · unverified
Support for delegating branch management requests to remote Lore servers
The gRPC handlers for BranchCreate, BranchDelete, BranchGet, and BranchList in the RevisionService now check a configuration flag to determine whether to process the request locally or forward it to a peer server via the new ForwardedRevisionService. This allows a Lore server to act as a proxy, delegating branch management operations to a remote backend when configured, while maintaining the same request/response semantics for the client. Also in this area: 5 commits (2 fixes) modifying lore-server; Resilient file operations and bounded branch listing; Improved reliability for revision listing and replication copy operations.
lore-server/src/grpc/revision · medium confidence · unverified
Support for forwarding Repository RPCs to remote Lore Servers
The Lore Server can now delegate RepositoryCreate and RepositoryGet requests to a remote peer when configured. This location implements the server-side handlers for these forwarded calls: RepositoryCreate executes the standard creation logic using the forwarded caller context, while RepositoryGet independently verifies the end-user JWT and injects it into the request extensions so the RepositoryAuthorizer can perform access checks. This enables distributed repository operations where one server forwards specific repository actions to another.
_lore-server/src/grpc/forwarded\repository · high confidence
Support for nested repository links with staged state management
The \lore-revision\ module now implements full support for nested links, allowing repositories to mount other repositories recursively. This change introduces new operations to add, remove, update, and inspect links, including a new \link info\ command to display link details. It enforces safety by refusing to remove links that have local edits or staged changes, and ensures that link mount points and restores are routed through the filesystem provider operation. The implementation also handles nested link chains, resolves branch tracking across nested scopes, and manages staged states for link additions, removals, and updates. Also in this area: 6 commits (0 fixes) modifying lore-revision; 6 commits (1 fix) modifying lore-revision.
lore-revision/src/link · medium confidence · unverified
Thin client API exposes file metadata and linked-repository tracking in tree and diff responses
The new \lore.thin\_client.v1\ protocol definitions introduce a \ThinClientService\ with streaming RPCs (\RevisionTree\, \RevisionDiff\, \RevisionInfo\, \ContentDiff\) designed for clients without local caching. For users, the \RevisionTree\ response now includes \TreeNode\ entries that expose file size, file mode (executable vs. none), and link tracking status, providing richer filesystem context than before. Additionally, \RevisionDiff\ responses now carry full content addresses (\content\_from\, \content\_to\) and support linked repositories via \DiffPartition\ announcements and \link\_repository\_index\ fields, allowing clients to correctly resolve content across partition boundaries during diffs.
_lore-proto/proto/lore/thin\client · high confidence
Zero-config server startup with Docker support and self-signed TLS
The Lore Server now starts with sensible defaults even when no external configuration files are present, using compiled-in defaults that can be overridden by on-disk files or environment variables. A new Dockerfile and Dockerfile.release enable containerized deployments, with the image generating ephemeral self-signed TLS certificates for QUIC at startup when no certificate is mounted. The server exposes gRPC and QUIC on port 41337 and HTTP on port 41339 by default, with local filesystem storage configured for /data. Also in this area: 5 commits (2 fixes) modifying lore-server.
lore-server/src/topology · medium confidence · unverified
lore-revision: Initial code import and build configuration
The lore-revision component has been added to the repository, bringing in the core Rust source code, a Dockerfile for building the service on Debian with LLVM 16, and a build script that conditionally links the SWFS library on Windows. The import includes a protocol specification document detailing QUIC and gRPC implementations for data transfer and command routing, as well as a clippy configuration that enforces the use of internal I/O drivers and context-aware spawning macros over standard library or Tokio equivalents.
lore-revision · high confidence
lore-transport: OIDC authentication, QUIC throughput profiling, and connection caching improvements
The transport layer now supports OpenID Connect (OIDC) authentication, including a discovery client with issuer validation and per-issuer caching, as well as interactive login polling. It introduces two new examples for performance analysis: \chunking\_profile\ to benchmark serial and parallel QUIC chunk assemblers, and \remote\_throughput\ to measure bulk-fetch performance against live remotes. Connection handling is refined by caching authz tokens only for internally resolved identities (excluding externally supplied tokens) and by splitting the \ensure\_connected\ logic into per-service readiness signals. Also in this area: 1 commit (0 fixes) modifying lore-server, lore-transport; 3 commits (1 fix) modifying lore-transport; Fixes secure storage keyring integration and updates build environment variables.
_lore-transport/src, lore-transport/src/auth, lore-transport/src/grpc, lore-transport/src/quic/storage\service · medium confidence
Behavioural changes
1 commit (0 fixes) modifying contrib/bench
A change to existing behaviour in contrib/bench — 1 commit, 32 files: “Add contrib/bench, a harness for repeatable P4 and Lore benchmarks over a shaped link”.
contrib/bench · medium confidence · unverified
1 commit (0 fixes) modifying lore-server/src/uds, lore-transport/src/uds
A change to existing behaviour in lore-server/src/uds, lore-transport/src/uds — 1 commit, 5 files: “lore: Add a machine-level Lore server for containers over Unix sockets (prototype)”.
lore-server/src/uds, lore-transport/src/uds · medium confidence · unverified
1 commit (0 fixes) modifying scripts/state-stress
A change to existing behaviour in scripts/state-stress — 1 commit, 2 files: “lore-revision: Move node operations on a revision state to a well tested submodule with improved concurrency guarantees”.
scripts/state-stress · medium confidence · unverified
10 commits (0 fixes) modifying lore/src/remote/network
A change to existing behaviour in lore/src/remote/network — 10 commits, 4 files: “Claim the service socket on Windows before serving it”; “lore: Support the service process on Linux and macOS”; “lore: Add a machine-level Lore server for containers over Unix sockets (prototype)”; and 7 more.
lore/src/remote/network · medium confidence · unverified
10 commits (0 fixes) modifying lore/src/service
A change to existing behaviour in lore/src/service — 10 commits, 3 files: “lore: Add the FUSE virtual filesystem provider for Linux”; “SWFS clone”; “lore-revision: Move the mount manager out of the SWFS module”; and 7 more.
lore/src/service · medium confidence · unverified
108 commits (6 fixes) modifying lore-revision/src/fs
A change to existing behaviour in lore-revision/src/fs — 108 commits (6 fixs), 8 files: “lore-revision: Report filesystem writes as an outcome of the file system provider operation instead of upfront declaration”; “lore-revision: Verify a status dirty flag through the filesystem provider”; “lore-revision: Key move detection on an identity links do not offer”; and 105 more.
lore-revision/src/fs · medium confidence · unverified
11 commits (0 fixes) modifying lore-revision/src/lock
A change to existing behaviour in lore-revision/src/lock — 11 commits, 6 files: “Document the lore.h C API surface”; “lore-core: Migrate errors to use internal or forward for error propagation, and enforce correct usage”; “lore-revision: Apply ADR-00027 to locks and file info, and walk a directory on a forced stage”; and 8 more.
lore-revision/src/lock · medium confidence · unverified
11 commits (1 fix) modifying lore-server/src/plugins
A change to existing behaviour in lore-server/src/plugins — 11 commits (1 fix), 5 files: “lore: Run incremental store GC by default (with no gc flag to disable)”; “LEP: Unify store get/query/exist interfaces and a define a contract for the store trait”; “Split network onto a dedicated runtime and remove the rayon compute pool”; and 8 more.
lore-server/src/plugins · medium confidence · unverified
12 commits (1 fix) modifying lore-base/src/allocator
A change to existing behaviour in lore-base/src/allocator — 12 commits (1 fix), 6 files: “Document the lore.h C API surface”; “lore-base: Fix the undefined behaviour in GrowVec that Miri reports”; “lore-base: Keep allocation measuring free while it is off”; and 9 more.
lore-base/src/allocator · medium confidence · unverified
122 commits (6 fixes) modifying lore-revision/src/repository
A change to existing behaviour in lore-revision/src/repository — 122 commits (6 fixs), 11 files: “lore-revision: honor --dry-run in repository delete”; “lore-revision: Report filesystem writes as an outcome of the file system provider operation instead of upfront declaration”; “lore-revision: Refuse to add or materialize nodes with reserved names”; and 119 more.
lore-revision/src/repository · medium confidence · unverified
13 commits (0 fixes) modifying lore-revision/src/dependency
A change to existing behaviour in lore-revision/src/dependency — 13 commits, 5 files: “Document the lore.h C API surface”; “lore-core: Migrate errors to use internal or forward for error propagation, and enforce correct usage”; “lore-revision: Report the remote's refusal where commands masked it”; and 10 more.
lore-revision/src/dependency · medium confidence · unverified
13 commits (1 fix) modifying lore-server/src/quic/quinn
A change to existing behaviour in lore-server/src/quic/quinn — 13 commits (1 fix), 5 files: “lore-integration-tests: Stabilize tests by avoiding losing the port between choosing and binding”; “Split network onto a dedicated runtime and remove the rayon compute pool”; “lore-server: Fix QUIC connection statistics being overwritten by the last connection sampled”; and 10 more.
lore-server/src/quic/quinn · medium confidence · unverified
143 commits (11 fixes) modifying lore-revision/src/file
A change to existing behaviour in lore-revision/src/file — 143 commits (11 fixs), 13 files: “lore-revision: Fix a dirty added file removed before commit”; “lore-revision: Report filesystem writes as an outcome of the file system provider operation instead of upfront declaration”; “lore-revision: Refuse to add or materialize nodes with reserved names”; and 140 more.
lore-revision/src/file · medium confidence · unverified
15 commits (1 fix) modifying lore-revision/src/fs/fuse
A change to existing behaviour in lore-revision/src/fs/fuse — 15 commits (1 fix), 25 files: “lore-revision: Invalidate the FUSE root's children again while an unmount's drain finds lookups left”; “lore-revision: Read a virtual clone's ignore file after its hold, not in it”; “lore: Add the FUSE virtual filesystem provider for Linux”; and 12 more.
lore-revision/src/fs/fuse · medium confidence · unverified
19 commits (1 fix) modifying lore-revision/src/metadata
A change to existing behaviour in lore-revision/src/metadata — 19 commits (1 fix), 7 files: “lore-revision: Add metadata get/set/clear low level revision API verbs”; “Document the lore.h C API surface”; “Attempt at boxing all of lore-revision's public interface futures”; and 16 more.
lore-revision/src/metadata · medium confidence · unverified
2 commits (0 fixes) modifying contrib/aws
A change to existing behaviour in contrib/aws — 2 commits, 17 files: “contrib/aws: Provision the fragment state table and stop creating the metadata table”; “Add Terraform example for AWS deployment”.
contrib/aws · medium confidence · unverified
2 commits (0 fixes) modifying contrib/aws-migrate-0.9.0
A change to existing behaviour in contrib/aws-migrate-0.9.0 — 2 commits, 3 files: “contrib: Add a standalone tool that migrates a whole AWS immutable store onto the fragment state table”; “lore-aws-migrate: Cover the migration end to end against a local stack”.
contrib/aws-migrate-0.9.0 · medium confidence · unverified
2 commits (0 fixes) modifying contrib/bazel
A change to existing behaviour in contrib/bazel — 2 commits, 17 files: “contrib: Add a Bazel remote execution server on Lore's storage API”; “lore: Make storage close wait for its flush, with a skip\_flush opt-out”.
contrib/bazel · medium confidence · unverified
2 commits (0 fixes) modifying contrib/bazel/crates/rbe-lore
A change to existing behaviour in contrib/bazel/crates/rbe-lore — 2 commits, 1 file: “lore: Add put option remote\_query to skip uploading fragments the server holds”; “lore: Make storage close wait for its flush, with a skip\_flush opt-out”.
contrib/bazel/crates/rbe-lore · medium confidence · unverified
20 commits (1 fix) modifying lore-server/src/grpc/repository
A change to existing behaviour in lore-server/src/grpc/repository — 20 commits (1 fix), 10 files: “lore-server: Make server hook pre-handlers async with enforced timeouts”; “lore-revision: Add metadata get/set/clear low level revision API verbs”; “Split network onto a dedicated runtime and remove the rayon compute pool”; and 17 more.
lore-server/src/grpc/repository · medium confidence · unverified
23 commits (0 fixes) modifying lore-server/src/authnz
A change to existing behaviour in lore-server/src/authnz — 23 commits, 8 files: “lore-server: Call RepositoryRegistryService instead of the deprecated Partition RPCs”; “Split network onto a dedicated runtime and remove the rayon compute pool”; “lore-server: Add GlobalGrantsAuthorizer”; and 20 more.
lore-server/src/authnz · medium confidence · unverified
28 commits (1 fix) modifying lore-io/src
A change to existing behaviour in lore-io/src — 28 commits (1 fix), 25 files: “lore-io: Add lore-io crate with owned-buffer positional file I/O API and sync syscall pool backend”; “lore-io, lore-revision: For case verification, ask the filesystem for a name instead of listing its directory”; “lore-io: Add io\_uring and iocp backends with three-engine benchmark”; and 25 more.
lore-io/src · medium confidence · unverified
28 commits (3 fixes) modifying lore-credential/src
A change to existing behaviour in lore-credential/src — 28 commits (3 fixs), 4 files: “lore-transport: Refresh an expired OIDC login with the refresh token grant”; “lore-credential: Stop the keychain thrashing in the credential store”; “Add shared store registry”; and 25 more.
lore-credential/src · medium confidence · unverified
3 commits (0 fixes) modifying lore-revision/native
A change to existing behaviour in lore-revision/native — 3 commits, 4 files: “lore-revision: let SWFS wait for freeze and thaw, and recover a freeze left behind”; “SWFS: move to the SWFS library 2026.07 r3”; “Build with SWFS by default”.
lore-revision/native · medium confidence · unverified
30 commits (0 fixes) modifying lore-revision/src/fs/os
A change to existing behaviour in lore-revision/src/fs/os — 30 commits, 2 files: “lore-revision: Report filesystem writes as an outcome of the file system provider operation instead of upfront declaration”; “lore-revision: Move the OS file system provider state diff to a submodules”; “lore-revision: Keep the ignore file out of every reset”; and 27 more.
lore-revision/src/fs/os · medium confidence · unverified
34 commits (1 fix) modifying lore-revision/src/fs/swfs
A change to existing behaviour in lore-revision/src/fs/swfs — 34 commits (1 fix), 17 files: “lore-revision: Report filesystem writes as an outcome of the file system provider operation instead of upfront declaration”; “lore-revision: Refuse to add or materialize nodes with reserved names”; “lore-capi: Implement \instance move/delete\”; and 31 more.
lore-revision/src/fs/swfs · medium confidence · unverified
4 commits (0 fixes) modifying lore-proto/proto/lore/user
A change to existing behaviour in lore-proto/proto/lore/user — 4 commits, 1 file: “lore-proto: decouple user id/name/repoList resolving from auth to user.proto”; “lore-proto: Add lore.user.v1.RepositoryRegistryService and deprecate the UserService Partition RPCs”; “lore-proto: Remove the deprecated Partition RPCs from lore.user.v1.UserService”; and 1 more.
lore-proto/proto/lore/user · medium confidence · unverified
4 commits (0 fixes) modifying lore-revision/src/errors
A change to existing behaviour in lore-revision/src/errors — 4 commits, 1 file: “lore-revision: say which link a push stopped at and why”; “lore-revision: Report the remote's refusal where commands masked it”; “Initial code copy from private repo”; and 1 more.
lore-revision/src/errors · medium confidence · unverified
4 commits (0 fixes) modifying lore-server/src/hooks
A change to existing behaviour in lore-server/src/hooks — 4 commits, 5 files: “lore-server: Make server hook pre-handlers async with enforced timeouts”; “Initial code copy from private repo”; “lore-server: Move the unit tests from src/ into tests/unit, reaching private items through test-util”; and 1 more.
lore-server/src/hooks · medium confidence · unverified
41 commits (2 fixes) modifying lore-client/src/cli
A change to existing behaviour in lore-client/src/cli — 41 commits (2 fixs), 17 files: “lore: Add lore\_set\_thread\_limit API to bound total thread pool size”; “lore: Run incremental store GC by default (with no gc flag to disable)”; “lore-transport: Log in with the OAuth 2.0 client credentials grant”; and 38 more.
lore-client/src/cli · medium confidence · unverified
419 commits (21 fixes) modifying lore-revision/src
A change to existing behaviour in lore-revision/src — 419 commits (21 fixs), 98 files: “lore-revision: Take node allocation off the single-permit mutex to get higher concurrency in staging”; “lore-revision: Keep one instance registration per root directory”; “lore-revision: Skip directories a wildcard-led re-inclusion cannot reach”; and 416 more.
lore-revision/src · medium confidence · unverified
45 commits (0 fixes) modifying lore/src/remote
A change to existing behaviour in lore/src/remote — 45 commits, 6 files: “lore: Implement tree load and close verbs in low level revision control API”; “lore-revision: Add metadata get/set/clear low level revision API verbs”; “Add shared store registry”; and 42 more.
lore/src/remote · medium confidence · unverified
5 commits (0 fixes) modifying lore-server/examples
A change to existing behaviour in lore-server/examples — 5 commits, 4 files: “lore: Add a machine-level Lore server for containers over Unix sockets (prototype)”; “Initial code copy from private repo”; “lore-server, lore-revision, lore-transport: Make the QUIC congestion controller configurable”; and 2 more.
lore-server/examples · medium confidence · unverified
55 commits (3 fixes) modifying lore-revision/src/store
A change to existing behaviour in lore-revision/src/store — 55 commits (3 fixs), 11 files: “lore-revision: Replace a stale connection in storage handles and remote stores”; “lore-revision: only cache Composite store results to the \local\ store if they came from \durable\”; “Cache remote read results locally whichever store answered”; and 52 more.
lore-revision/src/store · medium confidence · unverified
61 commits (3 fixes) modifying lore-revision/src/state
A change to existing behaviour in lore-revision/src/state — 61 commits (3 fixs), 5 files: “lore-revision: Report the content of a directory that replaced a file so a reset sync can delete it”; “lore-revision: Refuse to add or materialize nodes with reserved names”; “lore-revision: Hold diff items and changes once, and trees by the fields read”; and 58 more.
lore-revision/src/state · medium confidence · unverified
7 commits (0 fixes) modifying contrib/oidc
A change to existing behaviour in contrib/oidc — 7 commits, 28 files: “contrib/oidc: Reword the CI client's actions in the users table”; “contrib/oidc: authentik as OIDC provider”; “contrib/oidc: Keycloak example for Lore Server's OIDC authentication”; and 4 more.
contrib/oidc · medium confidence · unverified
7 commits (0 fixes) modifying lore-fuse
A change to existing behaviour in lore-fuse — 7 commits, 81 files: “lore-revision: Invalidate the FUSE root's children again while an unmount's drain finds lookups left”; “lore-fuse: Close the mount's FUSE device on exec, and make the SIGINT read test independent of dd”; “lore-revision: Read a virtual clone's ignore file after its hold, not in it”; and 4 more.
lore-fuse · medium confidence · unverified
9 commits (1 fix) modifying lore
A change to existing behaviour in lore — 9 commits (1 fix), 89 files: “lore: Make shutdown and connection teardown flush revision trees left open after their storage handle closed”; “lore-revision: SWFS freeze robustness”; “lore-revision: Flush the mutable store only after the immutable store in repository flushes”; and 6 more. Also in this area: 1 commit (0 fixes) modifying lore, lore-client, lore-io; 3 commits (0 fixes) modifying lore; Unit tests for lore moved to tests/unit with sandboxed service isolation.
_contrib/helm, lore/tests/unit/revision\_tree, lore/tests/unit/revision\tree/handle · medium confidence · unverified
95 commits (4 fixes) modifying lore-client/src/cli/commands
A change to existing behaviour in lore-client/src/cli/commands — 95 commits (4 fixs), 13 files: “lore-io: Add lore-io crate with owned-buffer positional file I/O API and sync syscall pool backend”; “lore-revision: Keep one instance registration per root directory”; “lore-revision: honor --dry-run in repository delete”; and 92 more.
lore-client/src/cli/commands · medium confidence · unverified
95 commits (8 fixes) modifying lore-revision/src/branch
A change to existing behaviour in lore-revision/src/branch — 95 commits (8 fixs), 7 files: “lore-revision: Report filesystem writes as an outcome of the file system provider operation instead of upfront declaration”; “lore-revision: Use copy in push if fragment exist in partition”; “lore-revision: End the ancestry walk at the newest shared revision, ordering its lines by revision number”; and 92 more.
lore-revision/src/branch · medium confidence · unverified
Build system updates and artifact version stamping
The lore-base module now includes a build script (build.rs) that compiles the rpmalloc allocator with specific optimizations for ARM64 Linux (Neoverse 512TVB) and MSVC, and adds a new CLI tool (lore-stamp) that writes the build name into finished binary artifacts. This stamping process modifies files in-place to include version information while preserving file size, and handles macOS ad-hoc code signing re-application after stamping.
lore-base · high confidence
Enforced task spawning and path resolution policies via Clippy configuration
The lore-client now enforces strict coding standards through a new clippy.toml configuration. Developers must use the custom \lore\_base::lore\_spawn!\ and \lore\_base::lore\_spawn\_blocking!\ macros instead of standard Tokio spawning functions to ensure the \LORE\_CONTEXT\ is correctly propagated across tasks. Additionally, direct calls to \std::env::current\_dir\ are prohibited in favor of \lore\_revision::util::path::make\_absolute\ to prevent issues with unrelated working directories, and standard print macros are replaced by crate-specific equivalents.
lore-client · high confidence
Enhanced gRPC observability and request validation
The gRPC server now includes new middleware layers that improve monitoring and error handling. A new \GrpcResponseTraceLayer\ logs response status codes and latency for success, server errors, and user errors, while a \LoreTracingLayer\ creates per-request spans enriched with user agent, correlation ID, repository ID, and user identity. Additionally, a \MalformedRequestLayer\ reclassifies requests with missing gRPC message bodies from \Internal\ to \InvalidArgument\ to better distinguish client errors from server faults, and a \PartitionAccessLayer\ enforces partition-level authorization with a dedicated timeout for the authorization check itself.
lore-server/src/grpc/tower · high confidence
Expanded OIDC authentication with multiple grant types and token exchange
The OIDC authentication module now supports a broader range of login methods and token management strategies. Users can authenticate using the device authorization grant (for headless or constrained devices), the OAuth 2.0 client credentials grant (for confidential clients), and token exchange (RFC 8693) to trade external credentials for login tokens or to scope tokens to specific resources/partitions. Additionally, the system now handles refresh token grants to maintain sessions and implements token revocation upon logout. A per-issuer discovery cache with issuer validation and URL security checks ensures reliable and secure provider configuration.
lore-transport/src/auth/oidc · high confidence
Integrate rpmalloc 2.0.1 as explicit memory allocator
The native build now compiles and links the rpmalloc 2.0.1 memory allocator (version 2.0.1, RPMALLOC\_VERSION\_NUMBER 20001) as a static library via build.rs, using first-class heaps (RPMALLOC\_FIRST\_CLASS\_HEAPS=1) and disabling process-wide malloc overrides (ENABLE\_OVERRIDE=0). Statistics and leak detection are disabled by default, and the build targets Linux aarch64 with -mcpu=neoverse-512tvb and enables C11 atomics on MSVC. This provides a cross-platform, lock-free, thread-caching allocator for the native layer without replacing the system malloc.
lore-base/native · high confidence
Introduce lazy progressive bucket layout with automatic fan-out for local stores
The local storage implementation now uses a lazy progressive bucket layout that automatically scales the number of buckets per group (from 1 up to 256) as data density increases, replacing the previous flat 256-bucket structure. This change improves read/write concurrency and reduces lock contention by spreading entries across more buckets only when necessary, based on configurable thresholds. The new layout is managed through a two-phase commit process with level markers and pending state files to ensure consistency during fan-out transitions, and it is supported by both \LocalImmutableStore\ and \LocalMutableStore\ with appropriate settings for initial level and threshold configuration.
lore-storage/src/local · high confidence
OIDC-compliant authentication and user info resolution
The \lore-revision\ module now implements full OIDC login flows, including interactive polling (RFC 8628), refresh token grants, and client credentials, while resolving user identities via the \UserService\ or local JWT tokens. This change introduces specific error handling for authentication states (e.g., \NotSupported\ when no auth endpoint is configured) and ensures tokens are stored and verified securely, with dry-run modes skipping persistent storage.
lore-revision/src/auth · high confidence
Presigned URL redemption now includes Cache-Control headers and rejects non-GET methods
The presigned URL endpoint now sets a Cache-Control header (public, immutable, max-age=\<remaining\_ttl\>) on responses, allowing clients and intermediaries to cache the content for the duration of the token's validity. Additionally, the route now explicitly rejects HEAD requests and any other non-GET methods with a 405 Method Not Allowed response, preventing unintended execution of the redemption pipeline.
lore-server/src/http/presigned · high confidence
Protocol layer introduces client identification and Oodle-to-Zstd transcoding
The protocol module now includes a \ClientIdentify\ message that allows QUIC clients to report a user agent, which is validated, normalized, and attached to the connection context for improved telemetry and tracing. Additionally, an ingress filter automatically transcodes incoming Oodle-compressed fragments to Zstd (or stores them uncompressed if Zstd is not beneficial) to standardize storage formats, a process that can be disabled via the \LORE\_DISABLE\_CONVERT\_OODLE\_ON\_PUT\ environment variable.
lore-server/src/protocol · high confidence
Replication store protocol now uses dedicated message handlers for copy, get, metadata, query, put, and obliterate
The replication store service in lore-server now handles replication operations through distinct, typed QUIC message handlers (Copy, Get, GetMetadata, Query, Put, Obliterate) instead of a generic or monolithic request path. Each operation has its own request structure, parsing logic, and response serialization, ensuring that get and get\_metadata requests return full StoreGetData information (including fragment, match\_made, partition, and payload where applicable) and that query requests return precise StoreMatchResult arrays with local/durable storage flags. This change improves protocol clarity, reduces ambiguity for clients, and enforces strict wire-format validation for all replication store interactions.
_lore-server/src/protocol/replication\store · high confidence
Updated vendored quinn-proto to version 0.11.19 with BBR congestion control improvements
The vendored quinn-proto library has been updated from version 0.11.15 to 0.11.19. This update introduces a refined BBR congestion controller that maintains a 10-second windowed minimum RTT (floored at 0.25 ms) and bounds the congestion window during the STARTUP phase to prevent excessive buffering. Additionally, the vendor includes new memory-efficient token logging via Bloom filters, enhanced connection ID generation and validation, and updated transport configuration defaults.
vendor/quinn-proto · high confidence
lore-proto: Make protoc optional with pregenerated fallback
The lore-proto build system now allows compilation without the protoc compiler installed. If protoc is unavailable, the crate falls back to using pregenerated source files committed under src/grpc, ensuring the library builds in environments where the code generator is not present. When protoc is available, it generates bindings for the full set of proto files (including model, admin, lock, storage, revision, repository, thin\_client, environment, user, auth\_api, and rebac\_api) using prost and tonic.
lore-proto · high confidence
Test coverage
1 commit adding/updating tests in (repo-wide); 1 commit adding/updating tests in lore-server/tests; 1 commit adding/updating tests in lore/tests/state\_scenarios; 10 commits adding/updating tests in lore-base/tests/unit; 10 commits adding/updating tests in lore-server/tests/unit/quic; 11 commits adding/updating tests in lore-client/tests; 11 commits adding/updating tests in lore-credential/tests; 12 commits adding/updating tests in lore-server/tests/unit/protocol/storage; 14 commits adding/updating tests in lore-server/tests/unit/store; 15 commits adding/updating tests in lore-server/tests/unit/grpc/handlers; 15 commits adding/updating tests in lore-server/tests/unit/grpc/revision; 17 commits adding/updating tests in lore/tests/unit; 22 commits adding/updating tests in lore-io/tests; 23 commits adding/updating tests in lore-transport/tests/unit/auth; 25 commits adding/updating tests in lore-transport/tests/unit; 28 commits adding/updating tests in lore-server/tests/unit; 288 commits adding/updating tests in scripts/test; 3 commits adding/updating tests in lore-server/tests/unit/cache; 3 commits adding/updating tests in lore-server/tests/unit/grpc/environment; 3 commits adding/updating tests in lore-server/tests/unit/protocol/replication\_store; 329 commits adding/updating tests in lore-revision/tests; 4 commits adding/updating tests in lore/tests/unit/auth; 5 commits adding/updating tests in lore-server/tests/unit/plugins; 50 commits adding/updating tests in scripts/test/link; 6 commits adding/updating tests in lore-io/tests/unit; 6 commits adding/updating tests in lore-server/tests/unit/grpc/forwarded\_repository; 6 commits adding/updating tests in lore-server/tests/unit/grpc/thinclient; 6 commits adding/updating tests in lore-server/tests/unit/http; 6 commits adding/updating tests in lore-server/tests/unit/quic/replication\_store\_service; 7 commits adding/updating tests in lore-base/tests; 7 commits adding/updating tests in lore-server/tests/unit/grpc/repository; 7 commits adding/updating tests in lore-transport/tests; 8 commits adding/updating tests in lore-server/tests/unit/authnz; 8 commits adding/updating tests in lore-transport/tests/unit/grpc; 8 commits adding/updating tests in lore-transport/tests/unit/quic; 8 commits adding/updating tests in lore/tests/unit/remote; 9 commits adding/updating tests in lore-proto/tests; 9 commits adding/updating tests in lore-server/tests/unit/auth; Added integration tests for AWS, DynamoDB, and HashiCorp Consul storage backends; Added integration tests for Lore library core behaviors; Added regression tests for Lore service and server behaviors; Added test infrastructure for lore parsers, OIDC authentication, and thin-client gRPC interactions; Added tests for OIDC authentication and discovery caching; Added tests for OIDC authentication and discovery caching; Added tests for lore-storage internals; Added tests for the lore-error-set error handling library; Added unit tests for lore library components; Added unit tests for probability engine merge logic; Added unit tests for storage handle lifecycle and concurrency.
Dependencies
148 commits updating dependencies (37 manifests)
A dependency / build maintenance change in (dependencies) — 148 commits (7 fixs), 37 files: “lore-io: Add lore-io crate with owned-buffer positional file I/O API and sync syscall pool backend”; “lore-revision: Keep one instance registration per root directory”; “lore-server: carry the whole content address on a thin-client revision diff”; and 145 more.
(dependencies) · high confidence · unverified
Vendor glob-match and update quinn-proto to 0.11.19
The project now vendors the \glob-match\ library, which provides a high-performance glob matching engine with support for wildcards, character classes, and brace expansion, including a fix for \\\\ backtracking issues found in the upstream version. Additionally, the vendored \quinn-proto\ library has been updated from version 0.11.15 to 0.11.19, bringing in the latest QUIC transport protocol state machine improvements.
vendor · high confidence
Housekeeping
Initial code copy from private repo
This entry reflects the initial import of the codebase from a private repository. The diff shows the addition of numerous new files across multiple modules, including CLI progress bar logic, HashiCorp Consul integration, server-side correlation ID handling, legacy gRPC service definitions, and test certificates. As this is a raw copy of existing code rather than a specific product change or feature addition, it does not alter user-facing behavior.
(repo-wide) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 72 → 74 (+2.8)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 73 → 73 (-0.0)
- Architecture 93 → 92 (-0.8)
- Maturity 88 → 93 (+5.4)
- Readiness 82 → 83 (+0.9)
- Security 60 → 66 (+5.2)
- Domain Modelling 100 → 100 (+0.0)
- Event Sourcing 100 → 100 (+0.0)
- Performance 100 → 100 (+0.0)
Resolved (378)
- Campaign.parse_work (cognitive 20) (scripts/store-stress/stress.py)
- Campaign.parse_work (cyclomatic 22) (scripts/store-stress/stress.py)
- ClassTooLong: StorageClient (lore-transport/src/quic/storage_service/client.rs)
- Classify ADR enforcement: ADR-00001: Use FastCDC, a well-documented content-defined chunking strategy (docs/developing/decisions/00001-fast-cdc.md)
- Classify ADR enforcement: ADR-00002: Use mutable store for branch tracking (docs/developing/decisions/00002-branch-tracking-in-mutable-store.md)
- Classify ADR enforcement: ADR-00003: Auth tokens for sub-repos (docs/developing/decisions/00003-auth-tokens-for-sub-repos.md)
- Classify ADR enforcement: ADR-00004: S3 storage options (docs/developing/decisions/00004-s3-storage-options.md)
- Classify ADR enforcement: ADR-00005: Web server frameworks for Rust (docs/developing/decisions/00005-web-framework.md)
- Classify ADR enforcement: ADR-00006: Reconsider S3 storage model (docs/developing/decisions/00006-s3-storage-options-reconsidered.md)
- Classify ADR enforcement: ADR-00007: AWS mutable store options (docs/developing/decisions/00007-aws-mutable-store-options.md)
- Classify ADR enforcement: ADR-00008: Optimize AWS store fragment association lookups (docs/developing/decisions/00008-aws-store-fragment-associations.md)
- Classify ADR enforcement: ADR-00009: Lore library JavaScript binding options (docs/developing/decisions/00009-lore-library-js-bindings.md)
- Classify ADR enforcement: ADR-00010: Increasing fragment max size (docs/developing/decisions/00010-fragment-max-size.md)
- Classify ADR enforcement: ADR-00011: CLI frontend decisions (docs/developing/decisions/00011-lore-cli-frontend.md)
- Classify ADR enforcement: ADR-00012: Log dispatch in core library (docs/developing/decisions/00012-log-dispatch.md)
- Classify ADR enforcement: ADR-00013: Plugin dependency strategy for Lore Server modularization (docs/developing/decisions/00013-plugin-dependency-strategy.md)
- Classify ADR enforcement: ADR-00014: Use mutable store for anchor tracking (docs/developing/decisions/00014-anchor-tracking-in-mutable-store.md)
- Classify ADR enforcement: ADR-00015: Log macro separation into lore-log crate with callback dispatch (docs/developing/decisions/00015-log-crate-separation.md)
- Classify ADR enforcement: ADR-00016: Switch default compression to Zstd level 6 (docs/developing/decisions/00016-compression-algorithm-selection.md)
- Classify ADR enforcement: ADR-00017: FFI error detail on the Complete event (docs/developing/decisions/00017-ffi-error-detail-on-complete-event.md)
- …and 358 more
New (907)
- ADR lacks an enforcement field (docs/developing/decisions/00026-concurrent-read-only-instance-operations.md)
- ADR lacks an enforcement field (docs/developing/decisions/00027-ignore-filter-applies-to-untracked-paths-only.md)
- ADR lacks an enforcement field (docs/developing/decisions/00028-state-node-operations-behind-one-write-boundary.md)
- ADR lacks an enforcement field (docs/developing/decisions/00029-instance-local-modified-time-records.md)
- ADR lacks an enforcement field (docs/developing/decisions/00030-exclusive-repository-lock-holders.md)
- ADR lacks an enforcement field (docs/developing/decisions/00036-swfs-serve-links-and-layers.md)
- AwsMutableStore::compare_and_swap_typed (cognitive 17) (lore-aws/src/store/mutable_store.rs)
- Boundary-crossing change coupling: realize.rs ↔ helpers.rs (lore-revision/src/fs/realize.rs)
- ClassTooLong: FuseFilesystem (lore-revision/src/fs/fuse/filesystem.rs)
- ClassTooLong: FuseMountManager (lore-revision/src/fs/fuse/mount_manager.rs)
- ClassTooLong: FuseOperation (lore-revision/src/fs/fuse/operation.rs)
- ClassTooLong: InstanceOperationImpl (lore-revision/src/fs/filesystem_provider.rs)
- ClassTooLong: NodeBlock (lore-revision/src/state/block.rs)
- ClassTooLong: RepositoryContext (lore-revision/src/repository.rs)
- CompositeOperation::next (cognitive 20) (lore-revision/src/store/composite.rs)
- Connect::handle_auth (cognitive 24) (lore-server/src/protocol/storage/connect.rs)
- Directories::copy (cognitive 16) (lore-revision/src/fs/hold.rs)
- Directories::place (cognitive 33) (lore-revision/src/fs/hold.rs)
- Directories::place (cyclomatic 23) (lore-revision/src/fs/hold.rs)
- Directories::remove_node (cognitive 24) (lore-revision/src/fs/hold.rs)
- …and 887 more
Changes since last survey
- 255 commits — 241 feature/other, 14 fixes
By area
- lore-revision/src — 80 commits
- lore-revision/tests — 35 commits
- lore-server/src — 16 commits
- scripts/test — 15 commits
- docs/developing — 13 commits
- docs/proposals — 10 commits
- lore-server/tests — 9 commits
- (root) — 7 commits
- contrib/oidc — 7 commits
- lore-transport/src — 7 commits
- docs/release-notes — 6 commits
- lore-io/src — 5 commits
- lore-storage/src — 5 commits
- docs/release-notes.md — 3 commits
- lore-aws/src — 3 commits
- lore-integration-tests/tests — 3 commits
- lore/src — 3 commits
- lore/tests — 3 commits
- (repo) — 2 commits
- lore-base/src — 2 commits
Notable commits
- fix: Add critical fixes to the Unreal Editor tutorial
- fix: Fix RevisionDiff returning no changes when one revision is merged into the other
- fix: Fix duplicate puts in unit tests
- fix: Fix status after ignored files are force staged
- fix: Fix the shared-store size comparison flake in test_create_two_repos
- fix: chore: fix clippy on main for Rust 1.100 and on macOS
- fix: helm: run several servers on the AWS backend, with fixed-topology ignore_address
- fix: lore-revision: Fix binary metadata for empty files
- fix: lore-revision: Fix link update refusals, link removal in merges, and moves over local edits
- fix: lore-revision: Fix lore --force dirty marking deletions the view excludes
- fix: lore-revision: Fix merges under a view for re-pinned links and type changes out of view
- fix: lore-revision: Fix reset reading the staged tree at another revision's node ids
- fix: lore-transport: Fix flaky OIDC unit tests if reusing a port
- fix: test: Fix the FUSE lookup latency test hang and the smoke tests that fail over virtual clones
- change: Add LEP: home nodes for fragment reads in a Lore Server cluster
- change: Add Lore tutorial for Unreal Engine 5.9 Preview
- change: Add contrib/bench, a harness for repeatable P4 and Lore benchmarks over a shaped link
- change: Add obliterate scope and failed-sync checks to test_obliterate.py
- change: Add round robin read replica selection to the composite store
- change: Apply instance ignore rules only to untracked paths
- …and 235 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
EpicGames/lore 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.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit d3c31145bbc2f5c0d690419b9345415565ecfea0 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.