shardmap 0.3.2

[package]
name = "shardmap"
version.workspace = true
edition.workspace = true
authors.workspace = true
homepage.workspace = true
license.workspace = true
repository.workspace = true
rust-version.workspace = true
description = "Sharded embedded in-memory map with optional cache, protocol, and server internals"
documentation = "https://docs.rs/shardmap"
keywords = ["cache", "map", "kv", "storage", "sharded"]
categories = ["caching", "data-structures", "database-implementations"]
readme = "README.md"
autobins = false
autotests = false
autobenches = false
include = [
    "Cargo.toml",
    "LICENSE",
    "README.md",
    "SAFETY.md",
    "examples/**",
    "shardcache.toml.example",
    "src/**",
    "tests/**",
    "fuzz/support/**",
]

[lib]
name = "shardmap"

[lints.rust]
unexpected_cfgs = { level = "warn", check-cfg = ["cfg(creusot)"] }

[features]
# Public product surfaces. The default build is the embedded, sharded Rust API.
# Redis/Valkey compatibility and TCP server code stay opt-in so map-only users
# do not compile command families or networking they do not use.
default = ["sharded"]
embedded = []
sharded = ["embedded"]
redis = ["embedded"]
redis-functions = ["redis"]
redis-modules = ["redis"]
redis-module-search = ["redis-modules"]
redis-module-bloom = ["redis-modules"]
redis-module-timeseries = ["redis-modules"]
redis-module-graph = ["redis-modules"]
redis-module-json = ["redis-modules"]
redis-module-ai = ["redis-modules"]
redis-module-gears = ["redis-modules"]
redis-module-cell = ["redis-modules"]
redis-module-neural = ["redis-modules"]
redis-module-tdigest = ["redis-modules"]
redis-module-cthulhu = ["redis-modules"]
redis-module-snowflake = ["redis-modules"]
redis-module-roaring = ["redis-modules"]
redis-module-session-gate = ["redis-modules"]
redis-module-rede = ["redis-modules"]
redis-module-topk = ["redis-modules"]
redis-module-cms = ["redis-modules"]
redis-modules-all = [
    "redis-module-search",
    "redis-module-bloom",
    "redis-module-timeseries",
    "redis-module-graph",
    "redis-module-json",
    "redis-module-ai",
    "redis-module-gears",
    "redis-module-cell",
    "redis-module-neural",
    "redis-module-tdigest",
    "redis-module-cthulhu",
    "redis-module-snowflake",
    "redis-module-roaring",
    "redis-module-session-gate",
    "redis-module-rede",
    "redis-module-topk",
    "redis-module-cms",
]
server = [
    "sharded",
    "dep:bytes-handoff",
    "dep:clap",
    "dep:flume",
    "dep:socket2",
    "dep:tracing-subscriber",
]
redis-server = ["server", "redis", "redis-functions", "redis-modules"]
codec = ["embedded"]

# Runtime and platform integrations.
monoio = ["server", "dep:monoio", "bytes-handoff?/monoio"]
cuda = ["sharded"]
telemetry = ["embedded"]
prefix-eviction = []

# Internal/benchmark knobs. These are intentionally not part of the small public
# feature story; use them only for measured deployments or local experiments.
experimental-no-ttl-point-hot-path = ["no-ttl"]
no-ttl = []
mutable-value-slices = []
shared-parking-lot-lock = []
embedded-read-biased-lock = []
unsafe = []

[dependencies]
bytes = "1"
bytes-handoff = { version = "1.2.0", optional = true }
clap = { workspace = true, optional = true }
core_affinity = { workspace = true }
crc32fast = { workspace = true }
crossbeam-channel = { workspace = true }
crossbeam-utils = { workspace = true }
fast-telemetry = { workspace = true }
hashbrown = { workspace = true }
indextreemap = { workspace = true }
itoa = "1"
log = { workspace = true }
libc = { workspace = true }
lz4_flex = { workspace = true }
memchr = "2"
parking_lot = { workspace = true }
rblock = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
smallvec = "1"
socket2 = { version = "0.5", features = ["all"], optional = true }
thiserror = { workspace = true }
tokio = { workspace = true }
toml = { workspace = true }
tracing = { workspace = true }
tracing-subscriber = { workspace = true, optional = true }
xxhash-rust = { workspace = true }
zstd = { workspace = true }

[dev-dependencies]
tempfile = { workspace = true }

# Runtime-agnostic mpsc used by the tokio fanout acceptor. Monoio and tokio
# direct-shard workers bind their own shard-local listeners instead.
[dependencies.flume]
version = "0.11"
default-features = false
features = ["async"]
optional = true

# Linux-only monoio runtime, gated via SHARDCACHE_USE_MONOIO=1 at runtime.
[target.'cfg(target_os = "linux")'.dependencies]
monoio = { version = "0.2", optional = true }

[target.'cfg(creusot)'.dependencies]
creusot-std = "0.11.0"

[[test]]
name = "redis_tier1_coverage_test"
path = "tests/redis_tier1_coverage_test.rs"

[[test]]
name = "protocol_test"
path = "tests/protocol_test.rs"

[[test]]
name = "embedded_server_test"
path = "tests/embedded_server_test.rs"
required-features = ["redis-server"]

[[test]]
name = "fuzz_harness_test"
path = "tests/fuzz_harness_test.rs"
required-features = ["redis"]

[[test]]
name = "redis_compat_differential_test"
path = "tests/redis_compat_differential_test.rs"
required-features = ["redis-server"]