flutter_kevy 7.0.0

kevy embedded in Flutter over dart:ffi — the real pure-Rust Redis-compatible engine in your app: TTL, hashes/lists/zsets, pub/sub, persistence. The MMKV shape, and everything MMKV lacks.

7.0.0

Tracks the kevy 7.0.0 engine. No API change in this door; the vendored libkevy_ffi was rebuilt and self-reports 7.0.0. What changes underneath:

• A killed app keeps every write that returned. Appends used to wait in a user-space buffer until the next tick or fsync, so an app killed in between (a crash, the iOS or Android memory killer) lost them. On iOS and macOS the AOF is now written through a memory map; on Android appends go to a small mapped staging file that the next open replays. Power loss is bounded by the fsync policy, as before.
• Writes made after a crash inside a transaction survive the next restart. Since 4.0.0 a crash between a transaction's begin and commit could make the following session's writes disappear at the restart after it.
• A hash field's own TTL survives a background AOF rewrite. Since 3.0.0 fields set with HEXPIRE and its siblings stopped expiring after the store rewrote its log and reopened.
• COPY copies a key of any type. Since 2.0.13 only strings were copied; other types answered WRONGTYPE.
• Streams and geo run in the embedded engine. The stream commands (XADD, XRANGE, XREADGROUP, XACK, XCLAIM, XINFO, …) and the GEO* commands answer through cmd. A BLOCK read is refused with ERR the embedded engine cannot block; call without BLOCK.
• SET … NX|XX EX|PX and the EXPIRE family each run as one operation. Since 4.0.0 SET NX EX set the value and its TTL under two locks.
• Opening is about 2.8× faster and closing returns at once. Closing used to wait up to 100 ms for the background reaper.

Downgrading: 6.4 does not understand the mapped log's zero tail or the staging file. After an app has been killed on 7.0, open and close the store cleanly with 7.0 before installing a 6.4 build. 6.4 also opens a store 7.0 wrote without its indexes, views and tables.

6.4.0

Tracks the kevy 6.4.0 engine. No API change in this door, and no behaviour change underneath it: every command answers exactly as it did in 6.3.0.

6.4.0 is a quality release for the engine's source. What reaches this door is the part that ships in bytes: the vendored libkevy_ffi was rebuilt, so the .so and .xcframework in this package now self-report 6.4.0 rather than the previous engine — which is the property that matters here, since a vendored engine does not say a version, it is one.

6.3.0

Tracks the kevy 6.3.0 engine. No API change in this door; the engine underneath gained one command and answers four replies in their RESP3 shapes.

HRANDFIELD is new — random fields from a hash, distinct for a positive count and a sample with repeats for a negative one, optionally paired with their values.

Under RESP3 (HELLO 3), ZPOPMIN, ZADD ... INCR and GEOPOS now send scores and coordinates as doubles, SPOP key count sends a set, and HRANDFIELD ... WITHVALUES nests each field with its value — all matching Redis 8.10.1, verified command by command against it. A client that negotiates RESP3 and decodes by type was previously reading the RESP2 shapes for those five.

Also fixed: GEOPOS on a wrong-typed key answered with an array header followed by an error, so the error arrived as the array's first element. It answers WRONGTYPE and nothing else, as Redis does.

And CONFIG SET notify-keyspace-events works over the wire. Keyspace notifications have always worked from the config file, but there was no RESP path to them — clients that set this on connect (Spring Data's expiry listener, the socket.io adapter) met "unknown parameter".

6.2.2

Tracks the kevy 6.2.2 engine. No API change in this door. The engine fix underneath: a persistence directory is now one engine's — a second open is refused instead of corrupting the first one's append-only log — and the replay summary survives a file that grew during replay.

6.2.1

Tracks the kevy 6.2.1 engine. No API change in this door, and no change in the engine either: 6.2.1 exists because two Rust client crates (kevy-client, kevy-client-async) had gone three releases without reaching crates.io, and every kevy package now carries one version and moves together. This door moves with them.

6.2.0

Tracks the kevy 6.2.0 engine. No API change in this door.

• -0 and 0 are one score now, as they are in Redis. A member stored at -0 used to sort before members scored 0; it now ties with them and the member name breaks the tie, which is what Redis has always answered. ZSCORE is unchanged — it returned 0 before and returns 0 now.
• ZADD is substantially faster when it changes nothing. Re-adding a member at a score it already has no longer removes it from the ordered index and puts it back: +52.8% at eight thousand members, +55.3% at two hundred thousand.

6.1.0

Tracks the kevy 6.1.0 engine. No API change in this door.

• The engine this door ships no longer names who built it. Every prebuilt libkevy_ffi.so carried the build machine's home directory — 27 paths per Android library — because a toolchain with the rust-src component resolves std's panic locations to the local source tree. packaging/android/build-*jnilibs.sh remaps it away now, and the alignment gate refuses an artifact that names its builder.

6.0.0

Tracks the kevy 6.0.0 engine. No API change in this door.

• Fourteen commands reach the server wire. SETBIT, GETBIT, BITCOUNT, BITPOS, BITOP, GETRANGE, SETRANGE, LINSERT, COPY, TOUCH, TIME, GETEX, ZREVRANGE, HINCRBYFLOAT. The engine had always implemented them and this door's embedded half had always answered them; a RESP client got unknown command. That is closed, so the two halves of this door now answer the same set.

• A range past the end is empty. GETRANGE k 99 200 on a shorter value, and ZREVRANGE z 5 10 on a smaller set, answered the last element where Redis answers nothing. Both halves of this door shared the mistake, which is why comparing them did not find it — a three-way differential against a real valkey did.

• MGET answers nil for a wrong-typed key rather than failing the whole call, which is what its own documentation always said.

The vendored engine is rebuilt and self-reports 6.0.0.

5.4.1, 5.4.0

No entries were written for these. The door shipped with the version bumped and its changelog left at 5.3.0, which is what tools/check_door_changelogs.py now refuses: dart pub publish warns about it, and a warning nobody reads is how two releases went by.

5.3.0

Tracks the kevy 5.3.0 engine. No API change in this door — 5.3's core deliverable is the engine's own test system (a three-tier audited suite), and its one product fix is in kevy-cli, which this door does not ship. The vendored engine is rebuilt and self-reports 5.3.0.

5.2.0

Tracks the kevy 5.2.0 engine. No API change in this door.

• Lua dialect corrections. The embedded scripting engine moved to luna-core 3.0.0: each Lua dialect now serves its own table surface and error wording, and the string.rep denial-of-service fix from the 5.1 line is pinned by a dedicated gate.

5.1.0

Tracks the kevy 5.1.0 engine. No API change in this door — the vendored engine is what moved.

• Fixes a corruption path. In 5.0.0 a compressed value could read back as a decode error after the value log compacted it: the encoder tagged a literal-only frame as dictionary-dependent when the dictionary carried a shared Huffman table, and its own decoder then refused it. The CRC covers the bytes that were written, so nothing catches it at write time. If you enable compression or value logging, this is the reason to move.
• Tail latency: the reactor no longer stalls on the rewrite hand-off, and the durability queue no longer drains on every tick.
• Replication generations are random identities rather than counters, so two nodes can no longer collide on one.

5.0.0

Tracks the kevy 5.0.0 engine — the tail-latency release. Element-level copy-on-write for collections, off-thread rewrite completion, and group-committed durability. Data directories from 4.x open unchanged.

4.0.0

• First tracked release of the kevy Flutter door, aligned with the kevy 4.x engine.
• KevyDb over dart:ffi: scalar get/set/getText/setText with TTL, incrBy, expire, pttlMs, keys, flushAll, and cmd() to every verb.
• Persistence: KevyDb.open(dir) (AOF + snapshot) and in-memory stores.
• Pub/sub: publish, subscribe/psubscribe → KevySub.
• KevySub.waitNext(timeoutMs) — blocking receive that parks in the kernel (kevy_sub_wait) instead of spinning the polled next().