All Classes and Interfaces
Class
Description
No-op adapter for
MapInterceptor.Detects and analyzes access patterns in cache operations.
Access record.
Distribution statistics.
Pattern types detected in access data.
Temporal pattern information.
Tracks key access frequencies for hot-key preloading.
Aggregate access distribution statistics.
Access statistics for a single key.
Generic aggregation interface for map-reduce style operations.
Factory methods for built-in map value aggregators.
Asynchronous functional interface for loading values in cache-aside pattern.
Async wrapper for LoomClient using CompletableFuture and a bounded executor.
Asynchronous read-through cache that implements the cache-aside pattern with non-blocking loads.
REST controller for the default CP atomic values.
Extracts attribute values from map keys and values using reflection.
Authorization configuration for LoomCache.
Builder for AuthConfig instances.
CIDR endpoint restriction for a role.
Fine-grained permission rule scoped by structure type, instance name, and action.
Authorization metadata extracted from a single operation.
A named role with a set of permissions.
Thrown when authentication fails.
Enumeration of authentication error types.
Server-side authorization handler.
Cached authorization state for a connection.
Built-in aggregator that computes the average of numeric values in the map.
Thrown when a cache write cannot be persisted to the configured backing store.
Backpressure and flow control mechanism for distributed cache networking.
Immutable snapshot of backpressure statistics for a single peer.
Thrown when a peer is backpressured (cannot accept messages).
JCache entry processor extension that can supply a specialized backup processor.
Processor for updates that run on backup replicas
after the primary processor completes.
Server-side handler for
MessageType.BATCH_EXECUTE messages.Batch execution statistics record.
Execution statistics for batch operations.
A single operation within a batch (see LoomBatch in the client module).
Result of deserializing a batch — includes flags and the operation list.
Built-in aggregator that averages numeric values exactly as
BigDecimal.Built-in aggregator that sums numeric values exactly as
BigDecimal.Built-in aggregator that sums integral numeric values exactly as
BigInteger.Shared handling for exceptions that are intentionally contained at subsystem boundaries.
Applies browser process isolation headers consistently to REST and actuator responses.
Comprehensive cache analytics aggregating metrics from all data structures.
Overview metrics record for dashboard display.
Data structure metrics record.
Time series metric types.
Time series data point.
Represents a single cache entry accessed within an entry processor.
JPA entity representing a cached key-value pair in the database.
Listener interface for cache entry lifecycle events.
Manages cache entry listeners with support for synchronous and asynchronous modes,
event filtering, and listener statistics.
Listener configuration with mode and event type filter.
Listener statistics snapshot.
Processes map entries in-place with strong atomicity guarantees.
Represents a mutable entry in the map during processing.
Spring Data JPA repository for cache entry persistence.
Functional interface for loading values in cache-aside pattern.
Interface for loading cache data from external sources.
Manages read-through and bulk cache loading strategies.
Loader statistics snapshot.
Thread-safe cache operation metrics.
A single cache cluster node — Consistency-by-default architecture.
Spring Boot configuration for the embedded cache node.
Standalone main class to start a cache node from command line.
Tracks cache statistics including hits, misses, puts, removals, and evictions.
Statistics snapshot record.
Warms cache from various sources for fast startup.
Manages write-through and write-behind cache strategies.
Configuration for write-behind mode.
Write-behind statistics snapshot.
Thrown when memory or entry limits are exceeded.
Predicts future resource needs based on historical growth trends.
Snapshot of capacity metrics at a point in time.
Scaling recommendation action.
Scaling recommendation record.
Handles certificate reloading with validation and metrics.
Watches keystore and truststore files for modifications using Java NIO WatchService.
Maps TLS certificate Common Names (CN) to permission levels.
Permission levels for certificate-based authorization.
Immutable client configuration used by failover clients.
Credentials sent in the client
AUTH message.Ordered blue/green client failover configuration.
BLK-2026-04-22-010: small helper that sets/clears the SLF4J MDC fields
the client logs use for cross-process trace reconstruction.
AutoCloseable MDC scope; safe to nest.
Client-side cache of the server's partition-to-group ownership snapshot.
Client reconnect behavior after the last member connection is lost.
Request context propagation for LoomClient using ThreadLocal.
Fluent builder for constructing scoped context with specific values.
Client-side request deduplicator that prevents duplicate sends and coalesces
identical in-flight requests.
Record representing a request coalescing key.
Statistics for request deduplication.
Record representing an in-flight request.
Client cluster routing mode.
Type-safe, locale-independent serializer for client proxy classes.
Configuration for periodic client statistics uploads.
Wire payload for periodic client statistics uploads.
Stores the latest client statistics snapshot uploaded by each client.
Abstraction for time measurement to enable testability.
Immutable cluster configuration.
Cluster-wide dynamic configuration management with Raft replication.
REST controller for cluster status, health checks, and Raft consensus information.
Operator-selected policy for restoring persisted cluster data on startup.
Cluster-wide health monitor that aggregates health status from all subsystems.
Alert severity levels.
Cluster-wide health aggregation.
Health alert record.
Health snapshot for historical tracking.
Listener for health state changes.
Sealed interface for health status.
Node is degraded but operational.
Node is healthy.
Node is unhealthy and may be unavailable.
Health information for a single node.
Snapshot of the cluster state: all known members + their liveness.
Cluster-wide operational state.
Wraps a message and its associated connection context for pipelined command execution.
Pool of virtual threads that execute commands while preserving FIFO order per connection.
Functional interface for command execution.
A named field inside a compact schema.
Field kinds supported by LoomCache compact serialization.
Typed reader used by application compact serializers.
Immutable compact schema with a stable fingerprint.
Schema-carrying compact serialization service.
Application serializer for LoomCache compact serialization.
Typed writer used by application compact serializers.
Built-in aggregator that returns the maximum value by natural ordering.
Built-in aggregator that returns the minimum value by natural ordering.
Composite discovery strategy that combines multiple discovery mechanisms.
Represents a single serialized membership-change command in the Raft cluster.
Immutable configuration entry with version tracking and audit information.
Statistics about ClusterConfigManager operations.
Migrates configuration across schema versions.
Exception thrown when configuration migration fails.
Immutable snapshot of all configuration entries at a point in time.
Type-safe validation for configuration values.
Functional interface for custom validators.
Wraps a TCP connection to a peer with automatic resource management and metrics.
Thrown when a connection cannot be established or maintained.
Enumeration of connection error types.
Monitors health status of active connections with latency, error rate, and idle time tracking.
Immutable record containing health information for a single connection.
Degraded status: connection showing concerning metrics but still operational.
Functional interface for health check callbacks.
Record containing comprehensive metrics for all monitored connections.
Sealed interface representing the health status of a connection.
Healthy status: connection operating normally.
Unhealthy status: connection exceeds critical thresholds and may be closed.
Unknown status: no health data collected yet.
Per-node connection pool that manages multiple socket connections.
Pool health report record
Pool statistics record (totalCreated, totalDestroyed, activeCount, idleCount, waitingCount)
Connection pool performance and health metrics.
Immutable snapshot of connection pool metrics at a point in time.
Identifies a Consistency group (Consistent/Partition-tolerant group) with a name and unique ID.
Enumeration of consistency levels for read operations.
Thrown when a session-bound AP data structure can no longer guarantee
read-your-writes or monotonic reads for the caller's session.
Tracks client session state for session-aware CP primitives.
Consistency Subsystem — manages Raft-based strongly consistent distributed primitives.
Handles Consistency Subsystem operations over the network.
Consistent Hash Ring with Virtual Nodes.
Continuous Query Cache — a server-side filtered view of a
DistributedMap
that auto-updates via map change events.Listener for changes to the CQC filtered view.
Snapshot of CQC statistics.
Built-in aggregator that counts entries in the map.
REST controller for the default PN-counter CRDT.
Server-side handler for the CQC (Continuous Query Cache) wire protocol.
Active CQC subscription.
Composite key identifying a single subscription.
Manager for CRDT instances across the distributed cache.
CRDT Statistics record.
Supplies credentials for LoomCache client
AUTH handshakes.Context passed to a
CredentialsFactory when the client needs AUTH credentials.Handles queries that span multiple Raft groups using scatter-gather.
Partitions a transaction's conditions and operations by their target Raft group.
Executes transactions atomically via Raft command serialization.
Submits a transaction through Raft consensus for linearizable execution.
Extension point for user-provided WAN merge policies.
Embedded HTML dashboard for the LoomCache management UI.
Named JDBC data connection that declarative map stores can reference.
Handles all data-structure operations received over the binary protocol.
Central registry for all distributed data structures on a node.
Represents a delta (incremental) snapshot capturing only changed and deleted
data structures since the last full or delta snapshot.
Reject-all merge policy.
Cluster peer discovery configuration.
Health checker for validating discovered peer addresses.
Result of a discovery validation check.
A strategy for discovering peer addresses in a LoomCache cluster.
Built-in aggregator that collects distinct values from the map.
Manages distributed entry listener subscriptions and broadcasts.
Named distributed executor service for submitting serializable tasks to cluster nodes.
Distributed ordered list with configurable consistency mode.
Consistency mode for a distributed list.
Listener interface for change events.
Distributed Map — the core data structure for key-value caching.
Statistics snapshot of map operations and performance.
Per-key metadata describing which node/time last wrote the value.
Per-map configuration for a
DistributedMap instance.Fluent builder for
DistributedMapConfig.Eviction policy applied when the map reaches
maxSize.Distributed MultiMap — a map where each key can have multiple values.
MultiMapStatistics record for capturing aggregate metrics.
Compact stats record used by enhanced tests (keyCount, valueCount, avgValuesPerKey).
Event emitted when the client creates a local proxy for a distributed object.
Listener for client-side distributed-object proxy lifecycle events.
Lifecycle listener for distributed objects managed by
DataStructureRegistry.Distributed Priority Queue — priority queue backed by ConcurrentSkipListMap.
Priority entry key combining priority, value, and sequence for stable ordering.
Persistence snapshot entry preserving both priority and FIFO sequence.
Statistics snapshot of the priority queue.
Distributed Queue — FIFO queue backed by ConcurrentLinkedQueue.
Queue statistics record — tracks cumulative and current queue metrics.
Distributed Ring Buffer — a fixed-capacity circular buffer.
Distributed Set — an unordered collection of unique elements.
SetStatistics record for capturing aggregate metrics.
Distributed Topic — pub/sub messaging between nodes and clients.
A distributed publish-subscribe topic implementation using virtual threads for async dispatch.
A message paired with its sequence number.
A topic message with sequence number, timestamp, payload and publisher ID.
Distributed tracing system for LoomCache with W3C Trace Context compatibility.
Immutable span data structure.
Functional interface for exporting completed spans.
Sealed interface for span status.
Span failed with an error.
Span completed successfully.
Span timed out.
Timestamped annotation event within a span.
Trace context for propagation across thread boundaries.
DNS-based discovery strategy for discovering peers via DNS name resolution with resilience.
Defines the durability guarantee level for WAL operations.
A Raft-replicated record for durable task execution.
Applies dynamic configuration changes to running components without requiring restart.
Functional interface for applying configuration changes.
Statistics snapshot of election activity.
In-process cache instance for embedded LoomCache usage.
Builder for EmbeddedLoomCache instances.
TLS configuration split by network endpoint role.
Optional MapStore extension for loading values with per-entry metadata.
Predicate used to filter distributed map entry events before listener invocation.
Serializable entry processor contract used by the client wire API.
Processes an entry in the cache atomically.
Mutable entry view presented to a processor.
Security boundary for serialized EntryProcessor payloads.
Executor for processing map entries atomically using CacheEntryProcessor.
Metadata-aware MapStore extension for values that carry per-entry expiry.
Environment variable-based discovery strategy.
Distributed event journal for durable, ordered event sourcing.
Overflow policy when the journal reaches capacity.
Listener for receiving journal events in subscription contexts.
Notifies listeners before and after eviction events.
Event describing an eviction.
Listener interface for eviction events.
Reason for eviction.
Strategy interface for eviction policies in DistributedMap.
Local protocol handler for executor service operations.
Immutable statistics snapshot for a named
DistributedExecutorService.Security boundary for executor task payloads.
Efficient expiration scheduler using a DelayQueue for event timing.
Represents a scheduled expiration task for a cache entry.
Merge policy that keeps the entry that will expire later.
Manages various expiry policies for cache entries.
Accessed policy - entries expire based on last access time.
Combined policy - entries expire at the earliest of multiple policies.
Created policy - entries expire based on creation time.
Eternal policy - entries never expire.
Base expiry policy interface.
Modified policy - entries expire based on last modification time.
Blue/green failover wrapper that connects to one configured cluster at a time.
Feature flags for LoomCache protocol versions.
Represents a fencing token used to prevent stale lock holders from accessing resources.
Generates monotonically increasing fencing tokens for lock acquisitions.
FIFO (First In, First Out) eviction strategy.
File-based discovery strategy that reads peers from a local file.
Bounded helper for suppressing repetitive warning logs while preserving a
periodic summary of how many equivalent messages were skipped.
Declarative built-in JDBC MapStore configuration for a String/String map.
Class-free view over a Compact payload.
Global exception handler for all REST controllers.
Structured error response returned to clients.
Process-wide serializer registry with Kryo as the default implementation.
Coordinates orderly shutdown of all LoomCache components.
Phase: Shutdown is complete.
Phase: Stop accepting new connections and mark servers as shutting down.
Phase: Flush write-behind caches and pending data structures.
Interface for components that can be gracefully shut down.
Functional interface for receiving shutdown progress notifications.
Sealed interface defining the phases of graceful shutdown.
Record representing the current progress of shutdown.
Phase: Take a final snapshot of system state for recovery.
Phase: Stop background threads and shut down services.
Thrown when a component or phase cannot complete a graceful shutdown safely.
Manages cross-group lock acquisition with deadlock prevention.
Grow-only Set CRDT (G-Set).
Health checking loop for distributed cache cluster.
Simple HTTP server providing health check and readiness endpoints.
Resource bounds for the JDK
HttpServer used by the health endpoints.Wire payload for the
PROTOCOL_HELLO / PROTOCOL_HELLO_ACK
handshake opcodes.Merge policy that keeps the entry with the higher successful-read count.
Writes operator-triggered Hot Backup snapshots to a separate backup directory.
Periodically triggers operator Hot Backup snapshots at a fixed delay.
LoomCache JCache extension interface.
Optional layer-3 reachability probe configuration for member failure detection.
Manages server-side request deduplication for idempotent operations.
Record representing a cached response with metadata.
Record representing an idempotency key (client ID + request ID).
Statistics for idempotency tracking.
Built-in projection that returns the entire Map.Entry unchanged.
Serializable function hook for server-side data-structure operations.
Client-side configuration for adding an index to a distributed map.
Configuration for an index on a map column.
Client-side index type for map index declarations.
Enumeration of index types supported by the query engine.
Snapshot delivered to an
InitialMembershipListener when it is registered.Membership listener that also receives the client's current member snapshot on registration.
In-memory trace exporter for testing and debugging.
Thrown when a map interceptor aborts an operation by failing during execution.
Thrown when a configuration value is invalid or missing.
JMX management interface for per-cache configuration.
Thread-safe implementation of
JCacheConfigMXBean backed by a
LoomJCache and its runtime management flags.Adapter that exposes either a local
DistributedMap or the real cluster protocol
path as a typed <K, V> store for JCache.JMX management interface for per-cache statistics.
Thread-safe implementation of
JCacheStatisticsMXBean backed by a
CacheStatisticsManager.Built-in JDBC-backed MapStore for declarative
data-connection-ref usage.Executes SQL JOIN operations.
Scheduled compactor for event journals.
Represents a single entry in the distributed event journal.
Statistics for a distributed event journal.
Manages a single journal subscription with backpressure and lifecycle control.
Simple JSON serialization/deserialization helper without external dependencies.
Authenticates REST requests carrying
Authorization: Bearer <jwt>.Configuration for the opt-in REST JWT issuer.
Issues short-lived HMAC-signed JWTs for authenticated REST principals.
Thread-safe Kryo serializer using a Kryo Pool.
Kubernetes API-backed peer discovery.
Configuration for Kubernetes API based peer discovery.
Merge policy that keeps the entry with the latest recorded access time.
Last-write-wins (LWW) merge policy with deterministic same-millisecond
tie-break (BLK-2026-04-22-011).
Thrown when a write request's pending status becomes uncertain due to leadership change.
Leader lease with clock skew protection for safe linearizable reads.
Represents an etcd-style time-bound TTL lease.
Configuration for leader lease with clock skew protection.
Manages etcd-style time-bound TTL leases.
Information about a lease (snapshot).
LFU (Least Frequently Used) eviction strategy using frequency buckets.
Event emitted when a client lifecycle state changes.
Listener for client lifecycle state changes.
Client lifecycle states published to
LifecycleListeners.Linearizable distributed atomic long with strong consistency via Raft.
Linearizable distributed atomic reference with strong consistency via Raft.
Distributed countdown latch for synchronizing multiple threads on a shared counter.
WARNING: JVM-LOCAL ONLY — NOT a distributed lock.
Distributed semaphore for controlling access to a limited resource pool.
REST controller for the default DistributedList.
REST controller for the default CP lock.
Raised when a client attempts to release or use a CP lock after it no longer owns it.
Thrown when lock acquisition times out.
A single entry in the Raft replicated log.
Statistics snapshot of the RaftLog state.
Spring Boot 4 application for the LoomCache distributed cache.
Client-side distributed atomic long proxy.
Client-side distributed atomic reference proxy backed by the CP subsystem.
Spring Boot auto-configuration for LoomCache client and server.
Fluent builder for batching multiple data-structure operations into a single
server-side execution.
Fluent builder for map operations within a batch.
Fluent builder for queue operations within a batch.
Fluent builder for set operations within a batch.
Simplified entry point for the LoomCache client SDK.
Represents a cache entry lifecycle event.
Legacy event type enumeration preserved for backwards compatibility.
Spring
CacheManager implementation backed by LoomCache.JMX management view for a LoomCache node.
Thread-safe MXBean implementation backed by live LoomCache components.
JSR-107
CachingProvider implementation and SPI entry point for
LoomCache JCache managers.LoomCache Client SDK with smart/unisocket routing, near cache, and production-grade resilience.
Listener interface for receiving entry events from the cache.
Enables the auto-configured Loom client by default for client-only apps, but
requires an explicit opt-in when the embedded server is enabled.
JMX management view for a LoomCache cluster from the local member's live view.
Cluster-scoped MXBean backed by the local member's membership and Raft snapshots.
Immutable centralized configuration for a LoomCache node.
Client-side Consistency Subsystem factory for creating CP primitives.
Distributed cache client exception.
Base exception for all LoomCache errors.
Client facade for a named distributed executor service.
Client-side grow-only set CRDT proxy.
Spring Boot Actuator
HealthIndicator for LoomCache.Client-side distributed Snowflake ID generator proxy.
JCache-compatible (JSR-107) cache wrapper.
JCache-compatible configuration for a LoomCache cache instance.
Expiry policy types as per JCache specification.
JCache-compatible (JSR-107) cache manager.
Client-side distributed countdown latch proxy backed by the CP subsystem.
Client-side distributed linearizable lock proxy.
Client-side distributed list proxy.
Client-side last-writer-wins register CRDT proxy.
Client-side distributed map proxy.
Statistics snapshot for a LoomMap operation.
LoomCache metrics instrumentation using Micrometer.
Client-side distributed multimap proxy.
Client-side observed-remove set CRDT proxy.
Client-side session-bound PN-counter proxy.
Client-side distributed priority queue proxy.
BLK-2026-04-22-008: deployment profile flag controlling whether v2.0 GA enforces
production-only safety constraints or runs in permissive development/test mode.
Spring Boot @ConfigurationProperties for LoomCache client and server configuration.
Authentication and authorization settings for cluster and client access.
Cluster configuration.
Spring Session configuration for distributed session storage.
Multi-Raft-group sharding configuration (v2.0).
Spring Cache abstraction configuration.
TLS/mTLS configuration for cluster communication.
Client-side proxy for a continuous query cache — a locally materialized,
predicate-filtered view over a distributed
LoomMap.Listener for changes applied to the locally cached view.
Snapshot of this query cache's observability counters.
Client-side distributed queue proxy.
Client-side reliable-topic proxy with replay by retained sequence.
Client-side distributed ringbuffer proxy.
Allowlist used by
ObjectInputFilter for Spring-side caching and session
deserialization.Global object-serialization SPI for LoomCache payloads.
ServiceLoader provider for a process-wide
LoomSerializer.Custom Spring condition that checks if loomcache.server.enabled=true.
Client-side distributed set proxy.
Spring
Cache implementation backed by a LoomCache distributed map.Client-side SQL query result.
Client-side distributed topic proxy (publish-subscribe).
Client-side facade for a transaction.
Version information for LoomCache nodes.
LRU (Least Recently Used) eviction strategy using LinkedHashMap.
Last-Writer-Wins Register CRDT (LWW-Register).
Management REST API handler for the lightweight web UI dashboard.
REST controller for DistributedMap operations.
In-memory secondary index on a map column.
Synchronous interceptor for
DistributedMap operations.Generic predicate for filtering distributed map entries by key and value.
Binary payload codec for
MessageType.MAP_PUT_WITH_TTL.Wire-format codec for the
MessageType.MAP_REPLACE_CAS value field.Decoded CAS payload: the expected
oldValue and the replacement newValue.Kryo-serializable snapshot of a DistributedMap.
Service Provider Interface (SPI) for plugging an external persistent backing
store into a
DistributedMap.Adapter that exposes a
MapStore as a
CacheWriterIntegration.BackingStoreWriter, letting JCache
(JSR-107) write-through / write-behind reuse the same SPI as
DistributedMap.setMapStore(MapStore, MapStoreConfig).Configuration for wiring a
MapStore into a
DistributedMap.Preload strategy.
Built-in aggregator that finds the maximum numeric value in the map.
Optional topology/member attributes attached to a discovered peer.
Event emitted when the client observes a member join or leave its active view.
Public SPI for selecting executor target members from a cluster membership snapshot.
Listener for client-observed membership changes.
Protocol-level membership change tracking for cluster membership management.
Reason for member leaving the cluster.
Sealed interface for membership events.
The cluster leader has changed.
A member has joined the cluster.
A member has left the cluster.
A previously suspected member has recovered.
A member is suspected to have failed.
Listener for membership events.
Membership statistics.
Current snapshot of cluster membership.
Information about a cluster member.
State of a cluster member.
Estimates memory usage of cache entries and maps.
Monitors JVM heap usage and cache memory consumption.
Memory usage statistics.
Memory threshold configuration.
softLimit: 80% of heap — triggers background eviction
hardLimit: 90% of heap — rejects new writes
Strategy for resolving conflicts when an incoming WAN replication event
meets an existing local value.
A replication entry with timestamp, writer-id, read-hit, access-time, and
expiration-time metadata for merge policies.
Classloader-backed factory for WAN merge policies.
The core message object for all LoomCache communication.
Encodes/decodes Messages to/from the LoomCache binary wire protocol.
Interface for handling incoming cache protocol messages and peer disconnections.
Listener for messages published to a distributed topic.
All operation codes for the LoomCache binary protocol.
Value carrier used by metadata-aware map stores.
Aggregates high-cardinality per-key metrics into lower-cardinality rollup metrics.
Aggregation rule: defines how to roll up metrics matching a pattern.
Aggregation type.
Manages metric label cardinality to prevent memory explosion from unbounded labels.
Simple HTTP server that exposes Micrometer metrics in Prometheus text exposition format or JSON.
Sanitizes metric names and label values to prevent cardinality explosion.
Handles chunked data transfer for partition migrations with integrity checking and flow control.
Record representing a single chunk with metadata.
Operator-facing SPI for observing partition migration lifecycle events.
Tracks the progress of an ongoing partition rebalance migration.
The lifecycle states of a partition migration.
Built-in aggregator that finds the minimum numeric value in the map.
Built-in projection that extracts multiple attributes from values.
UDP multicast-based discovery for local area networks.
REST controller for the default DistributedMultiMap.
MurmurHash3 (32-bit) — fast, non-cryptographic hash for key distribution.
Mutable entry implementation that wraps a map entry and tracks modifications.
Client-side near-cache for frequently accessed entries.
Cache efficiency metrics.
Cache entry metadata.
Interface for eviction policies.
Configuration for NearCache.
Near cache statistics.
Controls how the near cache chooses an entry when it must evict for capacity.
Manages near-cache invalidation subscriptions and broadcasts.
Strategy for near-cache invalidation with resilience.
Invalidation strategy mode.
Callback interface for poll-based invalidation.
Controls how the near cache treats writes issued by the local client.
Configures keys-only persistence for near-cache restart warmup.
Configures periodic near-cache anti-entropy checks for missed invalidations.
Record representing a cache node endpoint with health and weight information.
Tracks node health based on success/failure rates.
Node health status enum.
Identity of a cache cluster node.
Default telemetry bridge used when OpenTelemetry is unavailable.
Thrown when a non-leader node receives a write request.
Marker for entry processors whose user code may run on the server offload pool.
OpenAPI description for the Spring Boot REST API surface.
Optional bridge to OpenTelemetry tracing.
Tracks all cache operations with type, latency, and success/failure status.
Latency percentiles record.
Operation record.
Operation types.
Sliding window time ranges.
Observed-Remove Set CRDT (OR-Set).
Configuration for the optional OpenTelemetry bridge.
Stateful map-entry predicate that returns one page of matching entries at a time.
Immutable snapshot of the current partition-to-group mapping.
Key contract for colocating related entries on the same partition.
Network partition detector for cluster health monitoring.
Configuration record for the partition detector.
Detector statistics for monitoring.
Diagnostics snapshot for partition status.
Event representing a partition change (detected or healed).
Recovery plan for an asymmetric partial network partition.
Sealed interface for partition status.
Full partition: complete network split with clear majority/minority.
All nodes are healthy and reachable.
Asymmetric partition detected: some nodes can reach others but not vice versa.
Replica placement-group configuration.
Partition replica placement grouping mode.
Strategy hook for deriving the partition key for non-
PartitionAware keys.Coordinates partition migration when cluster topology changes.
Parsed chunk-level DATA metadata + payload.
Atomically commits a full partition ownership table.
Partition migration pipeline for data redistribution during cluster topology changes.
Value plus absolute expiry metadata for a migrated map entry.
Sends partition data to the target node.
Progress record for tracking migration advancement.
Migration state enum representing the lifecycle of a migration task.
Statistics record for migration pipeline metrics.
Task record representing a single partition migration.
Commits a partition ownership change through Raft consensus.
Describes a single partition migration from one Raft group to another.
Handles partition migration between Raft groups when groups are added or removed.
Routes keys to the correct Raft group based on partition assignment.
Maps 16384 partition slots to owner node IDs using consistent hashing.
Wire payload for the
PARTITION_TABLE_REQUEST /
PARTITION_TABLE_RESPONSE opcodes introduced in
BLK-2026-04-22-007 Day 2.Rejects mutating REST data operations while the cluster is in PASSIVE read-only mode.
Unconditional overwrite merge policy.
Immutable record representing a discovered peer address in the cluster.
Narrow dispatch interface used by the 2PC coordinator and participants to send
cross-node messages without depending on the concrete
TcpServer.Per-client/per-key rate limiter that maintains separate rate limiters for each client.
Aggregate statistics across all clients.
Configuration for per-client rate limiters.
Persistent Raft Log that wraps RaftLog with WAL persistence.
Phi-Accrual Failure Detector — adaptive failure detection that calculates
a continuous suspicion level (phi) based on inter-arrival times of heartbeats.
Bounded in-flight helper for batching asynchronous client operations from one caller thread.
Positive-Negative Counter (PN-Counter) CRDT.
Sealed interface for filter predicates.
Predicate that combines two predicates with AND logic.
Predicate that tests BETWEEN: field BETWEEN low AND high (inclusive)
Predicate that tests equality: field == value
Predicate that always returns false.
Predicate that tests greater than or equal: field >= value
Predicate that tests greater than: field > value
Predicate that tests case-insensitive LIKE pattern matching with SQL wildcards.
Predicate that tests IN: field IN (values...)
Join predicate that tests equality between a left and right column.
Predicate variant for join conditions that need access to both source rows.
Predicate that tests less than or equal: field invalid input: '<'= value
Predicate that tests less than: field invalid input: '<' value
Predicate that tests LIKE pattern matching with SQL wildcards (% and _).
Predicate that tests inequality: field !
Predicate that negates another predicate.
Predicate that combines two predicates with OR logic.
Predicate wrapper that carries an explicit partition key for query routing.
Predicate that tests Java regex matching against a field's string value.
Predicate that always returns true.
Fluent predicate builder for distributed map queries.
Entry-level fluent predicate operations.
Factory class providing the full predicate set for distributed map queries.
Sealed interface defining preload policies for cache warming.
Preload all keys from the previous session.
Preload the N most accessed keys from the previous session.
Preload keys matching a regex pattern.
Preload keys based on explicit priority values.
Declarative per-priority-queue configuration.
Interface for extracting subsets of entry data.
Loads configuration from .properties files and maps them to LoomConfig.
Feature bits advertised in the
HelloPayload feature bitmap.Client-side opt-in initiator for the
PROTOCOL_HELLO /
PROTOCOL_HELLO_ACK handshake introduced in BLK-2026-04-22-007
Day 1.Outcome of a successful handshake.
Server-side handler for the
PROTOCOL_HELLO opcode introduced in
BLK-2026-04-22-007 Day 1.Negotiates protocol version during peer handshake.
Exception thrown when version negotiation fails.
Controls which diagnostic endpoints remain public on the REST surface.
Insert-only merge policy.
Analyzes SQL queries to identify optimization opportunities and potential issues.
Analysis result for a query.
REST controller for querying distributed maps.
Executes QueryPlan against a DistributedMap.
Caches query results for identical queries within a TTL window.
Statistics about cache performance.
Handles SQL query operations over the network.
Shared SQL/query safety limits.
Query optimizer for the SQL query engine.
Column pruning optimization: only loads columns needed by SELECT, WHERE, and ORDER BY.
Constant folding optimization: evaluates constant expressions at compile time.
Cost estimate for a query plan.
Index selection optimization: chooses the best index for WHERE clause predicates.
Limit push-down optimization: pushes LIMIT closer to the scan when possible.
Sealed interface for optimization rules.
Optimized query plan with metadata.
Predicate push-down optimization: moves predicates closer to the data source.
Cost estimator for query execution.
LRU cache for parsed and optimized query plans.
Table statistics for cost estimation.
Represents a parsed SQL query in executable form.
Aggregate function specification (e.g., COUNT, SUM, AVG, MIN, MAX).
Join specification for SQL JOIN operations.
OrderBy clause specifying column and sort direction.
Profiles query execution stages to identify bottlenecks.
Record representing a single profiling entry for a stage.
Complete query profile with stage information and bottleneck identification.
Query execution stages.
Statistics about query execution performance.
Declarative per-queue configuration.
REST controller for DistributedQueue operations.
Service Provider Interface (SPI) for backing a
DistributedQueue with
an external persistent store.Thrown when quorum is lost (majority of nodes down).
Ensures partition replicas are distributed across racks for fault tolerance.
Represents the cluster topology for placement calculations.
Constraints for rack-aware placement.
Simple implementation of ClusterTopology.
Manages multiple independent Raft groups for horizontal scalability.
Narrow interface for routing operations to per-key or per-name Raft groups.
Health check and diagnostic utility for Raft consensus nodes.
Immutable status record of Raft node at a point in time.
Utility class for checking Raft safety invariants at runtime.
Result of an invariant check.
The Raft replicated log.
Immutable pair of (index, term) from the Raft log.
Persistent storage for Raft metadata: currentTerm, votedFor, and the
highest commit index durably represented in the local state machine.
Recovered Raft metadata.
Raft consensus node performance metrics.
Immutable snapshot of Raft metrics at a point in time.
Full Raft consensus node implementation.
Narrow query/submit interface over a Raft consensus node.
The possible states a Raft node can be in.
Distributed tracing instrumentation for Raft consensus operations.
Random eviction strategy.
Production-quality rate limiter supporting multiple policies and per-client limiting.
Token bucket rate limiter with thread-safe non-blocking and blocking acquisition modes.
Builder for fluent RateLimiter construction.
Per-client metrics snapshot.
Snapshot of rate limiter state including metrics and rates.
Immutable snapshot of rate limiter metrics.
Statistics record for rate limiter metrics.
Sealed interface for rate limit policies.
Fixed window policy: allow X requests per window duration.
Sliding window policy: allow X requests in the last D duration.
Token bucket policy: accumulate tokens at specified rate, burst capacity.
BLK-2026-04-22-008: in-process token-bucket rate limiter for the REST surface.
Configuration for REST request rate limiting.
A filter that wraps a DataOperationHandler to add read request coalescing.
Cache entry processor that signals read-only intent.
Readonly marker interface for entries processed by read-only processors.
Read-only wrapper implementation of Entry that throws UnsupportedOperationException
on mutation attempts.
Manages read replicas that receive replicated data but do not participate in Raft votes.
Aggregated stats about all replicas.
Information about a read replica.
Enumeration of read replica states.
Routes read requests to appropriate replicas based on consistency level.
Aggregated stats about read routing.
Token-bearing route for a STRONG read.
Read-through cache that implements the cache-aside pattern.
An immutable plan describing partition moves needed to rebalance across Raft groups.
Bounds persistence recovery phases so startup cannot block indefinitely.
Listener interface for reliable message delivery with sequence tracking and acknowledgment.
Reliable Topic — Ringbuffer-backed pub/sub with message replay.
Listener for receiving messages from a ReliableTopic.
Reliable message listener with sequence tracking and replay support.
A message stored in the ReliableTopic's ringbuffer.
Policy applied when a publish arrives while the retained ringbuffer window is full.
Snapshot of ReliableTopic statistics.
REST controller for the default ReliableTopic.
Thread-safe wrapper around
SSLContext that supports hot-reload of certificates.Binary codec for
ReplicatedTransactionCommand.Serialized cross-group transaction payload replicated through Raft.
Raised when a replicated transaction was submitted for Raft commit but the caller
could not confirm whether the cluster committed and applied it.
Synchronous Primary-Backup Replication Manager.
Holds parsed replication data from a REPL_SYNC message.
Statistics snapshot of replication activity.
Continuous replication stream from leader to a single read replica.
Callback interface for sending entries to the replica.
Aggregated stats about the replication stream.
Coalesces identical concurrent read requests to reduce redundant work.
Statistics snapshot for the coalescer.
A coalescing key uniquely identifies a read request.
Statistics for a coalescing group.
Request context propagation using Java 25 ScopedValues.
Fluent builder for creating a scoped context.
Bridge to synchronize ScopedValue-based RequestContext with SLF4J's MDC.
HTTP request router for the REST API.
Typed client-input failure for request bodies that exceed the REST router limit.
Deprecated.
REST ingress is de-scoped pending proper authentication and Raft
consensus integration.
Enforces REST user lockout for HTTP Basic authentication failures.
Tracks consecutive REST authentication failures and temporary user lockouts.
Configuration for REST user lockout after consecutive authentication failures.
Blocks REST data operations that would otherwise access embedded-node state outside the binary/Raft path.
Controls whether REST endpoints may invoke local data-structure APIs.
Sealed interface for journal retention policies.
Composite retention policy.
Size-based retention policy.
Time-based retention policy.
Configurable retry policy with exponential backoff, jitter, and statistics tracking.
Statistics snapshot for retry operations.
REST controller for the default DistributedRingbuffer.
Raised when a ringbuffer read requests a sequence older than the retained head.
Service Provider Interface (SPI) for backing a
DistributedRingbuffer
with an external persistent store.Role levels for mTLS-based authorization.
Result of a cursor-based scan operation on a data structure (Map, Set).
Metadata for a scheduled task within a
DistributedExecutorService.Schedule types for recurring or delayed task execution in a
DistributedExecutorService.Spring Security configuration that enforces
@RolesAllowed annotations
on controller endpoints via JSR-250 method security.Decision returned by a
SecurityInterceptor before an operation runs.Global security hook invoked around external client operations.
Immutable operation metadata exposed to
SecurityInterceptor instances.Result metadata observed by
SecurityInterceptor.after(SecurityOperationContext, SecurityOperationResult).Applies no-store cache headers to sensitive REST responses.
Wire-serializable predicate for
MessageType.CQC_SUBSCRIBE.Matches every entry.
Matches entries whose key equals the operand.
Matches entries whose key starts with the operand.
Matches entries whose value contains the operand as a substring.
Matches entries whose value equals the operand.
Thrown when serialization or deserialization of data fails.
Statistics tracker for serialization operations.
Manages CP session lifecycle: creation, heartbeat, expiration, and cleanup.
Represents a session managed by the SessionManager.
Callback invoked when a resource (e.g., lock or semaphore permit) is released
due to session expiration.
Enumeration of possible states for a CP session.
Statistics about active and historical CP sessions.
REST controller for DistributedSet operations.
Wraps
DataStructureRegistry with per-Raft-group state isolation.Built-in projection that extracts a single attribute from values using a function.
Tracks per-slot metrics for LoomCache's consistent hashing partitions.
Per-slot statistics.
Diagnostic plugin that samples active operation threads and records commands
whose execution exceeds a configured threshold.
Optional diagnostic plugin configuration for detecting slow cache operations.
Logs and analyzes slow queries in a bounded circular buffer.
A query pattern with statistics.
Record representing a single slow query log entry.
Statistics about slow queries grouped by normalized SQL pattern.
Interface for data structures that can be snapshotted and restored.
Serialized snapshot bytes plus an optional dirty-state token for rollback.
A chain of snapshots: one full (base) snapshot followed by zero or more delta snapshots.
Manages snapshots for WAL log compaction.
Snapshot record containing index, term, timestamp, checksum, and data.
Snapshot metadata without full data payload.
Schedules and manages state machine snapshots for Raft log compaction.
Statistics about snapshot scheduler activity.
Snapshot storage for Raft log compaction.
Snapshot metadata record with SHA-256 checksum for validation.
Distributed ID generator using Snowflake-like 64-bit ID format.
Exception thrown when system clock rolls backward.
Layer-4 hook invoked for accepted inbound TCP sockets before LoomCache registers the connection.
Comprehensive span management for distributed tracing.
Span record containing all span information.
Span event record.
Span kind enumeration.
Span status enumeration.
Enumeration of SQL column types supported by the query engine.
Catalog metadata for a SQL index declared through DDL.
Catalog metadata for a SQL mapping.
Calcite-backed SQL parser for basic SELECT queries and catalog DDL.
Parsed CREATE INDEX DDL statement.
Parsed CREATE MAPPING DDL statement.
Parsed CREATE TYPE DDL statement.
Parsed CREATE VIEW DDL statement.
Parsed DELETE DML statement.
Parsed EXPLAIN statement for a SELECT query.
Parsed INSERT INTO DML statement.
Parse error with position information.
Parsed SHOW catalog statement.
Parsed SINK INTO DML statement.
Concrete syntax error implementation.
Parsed UPDATE DML statement.
Represents a SQL query result set.
Represents a single row in a SQL result set.
Catalog metadata for a user-defined SQL type declared through DDL.
Catalog metadata for a virtual SQL view declared through DDL.
Factory for creating SSLContext, SSLServerSocket, SSLSocket, and optional
Netty SslContext instances from LoomCache TlsConfig.
Thrown when a linearizable read cannot be served (lease expired).
Manages state machine snapshots for Raft log compaction.
Full snapshot of all data structures.
Metadata for a state machine snapshot.
Fixed credentials factory for username/password or gateway-forwarded role payloads.
Static discovery strategy using a fixed list of seed addresses.
UTF-8 decoder for protocol/config surfaces that must fail on malformed bytes.
Statistics for a journal subscription.
Built-in aggregator that sums numeric values from the map.
Scalable Weakly-consistent Infection-style Membership (SWIM) protocol detector.
Gossip message with dissemination tracking.
Gossip message types for the SWIM protocol.
Information about a cluster member.
Sealed interface for member state in the protocol.
Member is alive and reachable.
Member is confirmed dead.
Member is suspected dead; waiting for confirmation via suspicion timeout.
Metrics holder for SWIM protocol statistics.
System clock implementation using
System.nanoTime().Immutable snapshot of a distributed task's metadata and state.
Lifecycle states for a distributed task submitted to a
DistributedExecutorService.PartitionMigrationPipeline.MigrationDataSender that ships partition
data to a target node over TCP with per-chunk ACK + retry (Session 10 ESC-12).TCP server using Java 25 virtual threads.
Bandwidth statistics for the server.
Information about a single connection.
Server health status snapshot.
Server-wide statistics snapshot.
Test clock with manual time advancement for deterministic testing.
Multi-tier eviction strategy for efficient memory management.
Candidate for eviction.
Result of eviction operation.
Thrown when an operation exceeds the configured timeout.
Immutable TLS/mTLS configuration for LoomCache nodes and clients.
Builder for TlsConfig with validation.
TLS provider selection for LoomCache.
Issues short-lived Bearer tokens for authenticated REST callers.
Response body returned by
POST /token.Configuration for a distributed topic.
REST controller for DistributedTopic operations.
Overload policy for reliable-topic publishes when the retained ringbuffer window is full.
Raised when a topic poll requests a sequence that the server has already evicted.
Thread-safe statistics for a distributed topic.
Routes read and write requests based on topology awareness.
Represents a network endpoint for a cache node.
Statistics for topology-aware routing.
Configuration for topology-aware request routing.
Represents the physical topology location of a node in a distributed cluster.
Analyzer for distributed traces.
Functional interface for visiting trace nodes.
Trace tree node representing a span and its children.
Trace statistics.
Propagates trace context across distributed cache nodes.
Interface for exporting spans to tracing backends.
Sampling strategies for distributed traces.
Always sample all traces.
Never sample any traces.
Sample based on a probability rate (0.0 to 1.0).
Rate-limited sampler (N spans per second).
Configuration for distributed tracing in LoomCache.
OpenTelemetry distributed tracing integration for LoomCache.
Span interface representing a unit of work in a distributed trace.
Intercepts cache protocol messages and instruments them with distributed tracing.
Functional interface for message handlers.
Represents an atomic compare-and-swap transaction (etcd-style mini-transaction).
Fluent builder for constructing transactions.
Condition to evaluate in the IF branch of a transaction.
Types of conditions that can be evaluated in the IF branch.
Operation to execute in the THEN or ELSE branch of a transaction.
Types of operations that can be executed in THEN/ELSE branches.
Transactional context enabling cross-data-structure batch operations with explicit
transaction boundaries and automatic rollback support.
Enumeration representing the state of a transaction.
REST controller for managing server-side transactions.
Stateless evaluator for transaction conditions and operations.
Executor for atomic compare-and-swap transactions on a DistributedMap.
Dispatches TX_* wire messages to the
TransactionManager.Owns pessimistic transactional map-key lock state.
Manages active transactions, including timeout monitoring and statistics tracking.
Statistics about transaction execution.
Sealed interface representing operations that can be buffered in a transaction.
Map delete operation: remove key.
Map put operation: associates key with value in a distributed map.
Map putIfAbsent operation: insert value only if key doesn't exist.
MultiMap put operation: add value for key.
MultiMap remove operation: remove value for key.
Queue offer operation: append to queue.
Queue poll operation: remove from front of queue.
Set add operation: add a member.
Set remove operation: remove a member.
Wire-level op codes used inside a
MessageType.TX_OPERATION body.Shared decoded representation of one transaction operation on the wire.
Result of executing an atomic transaction.
Interface for receiving TTL-related events from the
TtlManager.Centralized manager for TTL (Time-To-Live) policies across all distributed cache data structures.
Statistics about TTL management.
Sealed interface defining various TTL (Time-To-Live) policies for cache entries.
Adaptive TTL policy: TTL based on access frequency.
Eternal policy: entries never expire.
Fixed TTL policy: entries have a constant TTL regardless of access.
Per-key TTL policy: each key has its own individually set TTL.
Sliding TTL policy: TTL resets on each access.
Sealed command types for the cross-group 2PC protocol introduced in
BLK-2026-04-22-001 Phase C.
Durable coordinator DECIDE record, replicated through raft-0's own log
BEFORE the coordinator fans TX_DECIDE_GROUP out to the participant groups.
Durable coordinator PREPARE record, replicated through raft-0's own log.
Acknowledgment from a participant that it applied the coordinator's decision.
Phase-2 decision broadcast from the coordinator to each participant.
Query from a recovering participant to the coordinator: "what decision did
you make for this transaction?"
Coordinator decision in phase 2.
Internal writer callback used by
TwoPhaseCommands.writeFrame(TwoPhaseCommands.Kind, TwoPhaseCommands.FrameWriter).Wire kind tag — serialized as the first byte of every frame.
Phase-1 vote from a participant group back to the coordinator.
Transaction phase-1 request from coordinator to a participant group.
Participant vote in phase 1.
Coordinator side of the cross-group 2-phase commit protocol introduced in
BLK-2026-04-22-001 Phase C.
Participant side of the cross-group 2-phase commit protocol introduced in
BLK-2026-04-22-001 Phase C.
Raised when a mutating operation was sent but the client cannot prove whether
it committed.
Immutable validation result for configuration values.
Manages version compatibility and feature negotiation across LoomCache nodes.
Adapts message encoding/decoding to be version-aware.
Background WAL compaction service.
Snapshot boundary and state to use for one automatic compaction.
Compaction statistics record.
Write-Ahead Log (WAL) reader for recovering Raft log entries from disk.
Recovery metadata returned after reading a WAL file.
Statistics tracked by the WAL writer.
Write-Ahead Log (WAL) writer for persisting Raft log entries.
Statistics for compression and batch operations.
WAN batch acknowledgment mode.
Receives and applies remote WAN replication events to local data structures.
Strategy for resolving conflicts when both local and remote clusters
have concurrent writes to the same key.
Acknowledgment for a processed WAN batch.
Deterministic Merkle digest for WAN-replicated map state.
Batches and ships WAN replication events to a remote cluster.
A single WAN replication event.
Protocol handler for WAN replication messages over the binary protocol.
Central orchestrator for WAN (Wide Area Network) replication.
Type of data change event replicated over WAN.
Summary of a Merkle-based WAN delta-sync plan.
WAN replication mode.
Replication statistics for a single WAN target.
Configuration for cache warming operations.
Callback interface for monitoring cache warming progress.
Real-time progress metrics during a cache warming operation.
Final result of a cache warming operation.
A watch event representing a key mutation (put or delete).
Event type enumeration.
Callback interface for receiving watch events on key mutations.
Manages active watches on keys and key prefixes.
Enumeration of event types for streaming events.
Statistics snapshot for event streaming.
Optional transport compression negotiated by PROTOCOL_HELLO.
Type-tagged value codec shared by client facades and server-side processors.
Write-behind cache that buffers writes and flushes asynchronously using a daemon thread.
Configuration for WriteBehindCache.
Callback interface for flushing writes to the backend.
Write-Through Cache Store.
Unified configuration loader supporting both YAML (.yml/.yaml) and properties (.properties) formats.