chore: release v0.10.0

CHANGELOG.md

@@ -1,5 +1,270 @@
 # Changelog
 
+## v0.10.0 - 2026-10-31
+
+### Added
+
+- *(wire)* probe idle client and peer connections with keepalive
+- *(raft)* carry the history domain with every database image
+- *(query)* answer AS OF past the retention from temporal history
+- *(index)* bound the bytes of implication placement and folding
+- *(index)* key unique entries by their owner
+- *(search)* configure the text index worker's step and retry
+- *(index)* configure the pages of an implication change
+- *(schema)* give labels a catalog identity records store
+- *(schema)* declare type, implied and auxiliary labels
+- *(cluster)* replace a member whose vote no copy proves
+- *(storage)* collect orphan blobs and return their space
+- *(storage)* give blobs owners, a catalog and a guarded lifetime
+- *(storage)* per-table pressure series that go with the table
+- *(vector)* exact scores and domain errors end to end
+- *(storage)* hold the database to a strict total footprint limit
+- *(storage)* hold a temporal unique value per instant of valid time
+- *(modality)* read temporal node versions as known at a system time
+- *(modality)* assert temporal node versions in their history
+- *(storage)* keep node history and write records keyed by their commit
+- *(index)* keep label counts exact across an implication change
+- *(storage)* bind history to the store's deployment before it lands
+- *(vector)* follow a change of what a type implies
+- *(query)* refuse a RETYPE NODE that would move a node's shard
+- *(index)* answer a text search with its view's interpretation
+- *(schema)* change what a type implies through a schema package
+- *(index)* fold what a concluded implication change kept apart
+- *(index)* keep a B-tree index's moved carriers apart under ALTER IMPLIES
+- *(query)* change a node's type with RETYPE NODE
+- *(storage)* judge, repair and drop columnar tables as partitions
+- *(embed)* physical backup of the whole database
+- *(search)* keep both interpretations of a change in one text index
+- *(vector)* score vectors exactly in binary64 with one reduction
+- *(operation)* apply each client write once
+- *(storage)* store index generations under local installations
+- *(migrate)* add the node sizes report module
+- *(migrate)* catalog record migrations, check and journal stats
+- *(migrate)* offline tool to bring a data directory current
+
+### Documentation
+
+- *(cypher)* describe ALTER NODE TYPE SET IMPLIES and test its restart
+- *(cluster)* describe a replacement refused by a changed group
+- *(query)* drop the type-keyed index reason from relabel
+- *(search)* state what settling a scope costs
+- *(storage)* describe the node history partition without a dash
+- *(storage)* name a private helper without linking it
+
+### Fixed
+
+- *(index)* bound the fan-out everywhere and type every index refusal
+- *(server)* map text search refusals like every other service
+- *(search)* refuse text reads of an unknown commit, type not-ready
+- *(query)* keep rows without a vector in a vector ordering
+- *(storage)* refuse a hard limit below the supported minimum
+- *(bench)* read git state without optional locks
+- *(index)* bound held memory in claim restating and the report queue
+- *(index)* reserve room only for claims not held yet
+- *(index)* keep a claim's charge only on what is kept
+- *(index)* charge unique claims and checks for as long as they live
+- *(index)* count a unit's derived fan-out before expanding it
+- *(index)* charge an element's encoding room before it grows
+- *(index)* refuse keys past the store's limit, bound entry fan-out
+- *(index)* charge implication placement memory before taking it
+- *(storage)* keep the engine and dump format versions
+- *(index)* claim a unique value across the parts of a change
+- *(schema)* bind a label's first use through the ordered log
+- *(query)* charge exact dedup memory before allocating it
+- *(embed)* a label's first node is no change for search indexes
+- *(query)* count deleted implied labels and allow redundant implications
+- *(query)* refuse readers of an index still following a change
+- *(query)* activate an implication change once search follows it
+- *(query)* reserve a vector index read's memory before allocating it
+- *(index)* charge catalog changes to the statement and check skipped fields
+- *(index)* walk the catalog by head when publishing or concluding parts
+- *(index)* check every field of an integrity record read for its state
+- *(index)* fold what a cancelled implication change kept apart
+- *(index)* place every changed label and conclude the record read
+- *(search)* refuse reads of a lagging text reader, own write refusal
+- *(index)* bind text settling to one revision and one catalog state
+- *(index)* write text documents under the interpretation held
+- *(index)* judge a label's carriers by the view's own catalog
+- *(index)* bind a text read to the interpretation its index holds
+- *(query)* defer only the retyped nodes' index entries in RETYPE
+- *(embed)* outwait the commits in flight before re-running a statement
+- *(vector)* draw each HNSW level once and finite
+- *(raft)* refuse a member without its vote with a typed error
+- *(storage)* serve a rebuilt tree's history above its copy's floor
+- *(storage)* refuse a rebuild from a damaged checkpoint copy
+- *(storage)* rebuild a partition at its original seqnos
+- *(storage)* rebuild a table only from provable state
+- *(embed)* finish an interrupted table rebuild on open
+- *(query)* plan subqueries with the index access paths
+- *(query)* order by variables the projection drops
+- *(storage)* capture the journal tail after a checkpoint's trees
+- *(query)* subqueries see the outer row; one index search per top-k
+- *(query)* keep each edge's orientation in undirected hops
+- *(replication)* wait for the leader's address, not pauses
+- *(query)* three-valued AND/OR, simple CASE, correlated keys
+- *(query)* charge every tuple expansion of index checks and conflicts
+- *(index)* read a check's reason stored as bytes as the record does
+- *(index)* keep a value's ownership revision while it is held
+- *(index)* reap expired members kept in selection parts
+- *(index)* read a reconciliation page at one snapshot in every mode
+- *(index)* bind text interpretations to their installation
+- *(index)* refuse a change until the previous one is folded
+- *(storage)* stop the log at its first failed write
+- *(storage)* never found a new domain over retained history
+- *(cluster)* take a replacement's membership only once committed
+- *(cluster)* check both members of a replacement in one view
+- *(cluster)* fence a replacement on the membership it checked
+- *(cluster)* apply each change to a joint config left behind
+- *(cluster)* start every membership change from a single config
+- *(cluster)* resume a change left in its joint configuration
+- *(cluster)* refuse a joiner on another member's store as a join
+- *(raft)* bind promises to a member, write copy durably
+- *(raft)* keep the purge point and a loss with the vote; replace a member
+- *(raft)* keep a second copy of the member's vote
+- *(search)* keep a landed text commit when the reader lags
+- *(search)* commit the scope epoch with the documents
+- *(storage)* hold a value per instant while its unique index is built
+- *(storage)* admit the commit timestamp a stamped key carries
+- *(storage)* map a bound too short for a slot past the whole slot
+- *(storage)* refuse only a change of what a typed label implies
+- *(storage)* decide a schema read from the current state
+- *(storage)* save the consensus state below half the space reserve
+- *(storage)* name the key a pending-commit conflict is about
+- *(storage)* close a dropped table's tree before removing its folder
+- *(storage)* admit promise copy writes as recovery work
+- *(storage)* let blob collection run below the free-space reserve
+- *(storage)* flush and capture a table only while it lives
+- *(storage)* no table file is made in a folder being dropped
+- *(storage)* a second drop of a table drops the same table
+- *(storage)* hold a table name until its drop finishes
+- *(storage)* open a checkpoint on its clock, never compacted
+- *(storage)* roll back a torn manifest tail instead of repairing
+- *(storage)* sync a new journal segment's directory
+- *(vector)* keep every HNSW node reachable when lists fill
+- *(vector)* keep cosine exact for every finite vector
+- *(storage)* never copy a checkpoint over a file it holds
+- *(migrate)* find every marked store, Raft snapshot captures too
+
+### Performance
+
+- *(txn)* restate bound trends by moving the claims
+- *(query)* read a node's schemas once per write
+- *(query)* hashed exact DISTINCT, grouping and UNION
+- *(storage)* keep a transaction's writes in key order
+- *(index)* refresh the integrity view without reading the evidence
+- *(query)* build only the node properties a statement reads
+- *(bench)* declare the label the label-scan bench adds
+- *(bench)* measure label kinds on the write path
+- *(query)* look the keys of a correlated index join up in batches
+- *(query)* look a correlated index key up once per distinct key
+- *(index)* record a batch of reports without copying it
+- *(index)* keep no per-node or per-page scratch in reconciliation
+- *(query)* read a property column without allocating
+- index partition trees by discriminant, share index definitions
+- *(storage)* leave a journaled tree's flush syncs to a barrier
+- *(storage)* read a unique value's staged owners by range
+- *(storage)* export a generation's history by its own key range
+- *(storage)* bench flush and compaction of a table
+- *(vector)* reduce four AVX2 blocks vertically
+- *(vector)* score exactly only candidates that can rank
+- *(vector)* no per-evaluation clear of the reduction stack
+- *(vector)* SSE2 exact kernels and cached sums of squares
+- *(query)* bound property delta chains with whole writes
+
+### Refactored
+
+- *(schema)* store canonical labels and judge RETYPE by its result
+- *(index)* open a reconciliation page by holding what it carries
+- *(storage)* keep the table repair record crate-private
+
+### Testing
+
+- *(server)* a failed log write takes the server out of service
+- *(embed)* bench temporal unique admission against the length of history
+- *(embed)* temporal unique ownership and its history survive collection
+- *(embed)* temporal unique ownership is restored after a kill
+- *(embed)* a taker racing a release of a temporal unique value
+- *(embed)* every key shape of a temporal unique index is held per instant
+- *(embed)* temporal unique ownership under derived maintenance and across a reopen
+- *(embed)* an ordinary holder of a shared label holds its value at every instant
+- *(embed)* later facts leave what history knew before
+- *(embed)* a stale certification executor changes nothing
+- *(embed)* catch a change in force before its text index is prepared
+- *(index)* count what reporting to an integrity record allocates
+- *(index)* count a refused compound unique write by the allocator
+- *(index)* size the catalog budget test so only the catalog decides
+- *(index)* stop a fold at an exact step
+- *(index)* a unique value taken on both sides of a change is held once
+- *(index)* a fold interrupted by a close finishes after a reopen
+- *(index)* a settle raced by a rebuild keeps the rebuilt documents
+- *(embed)* cover expiry, merge, restore and failed declarations for label kinds
+- *(embed)* keep an operation's outcome across a replacement
+- *(embed)* accept a cascade the capacity scanner ran first
+- *(embed)* report a table rebuild the open cannot finish
+- *(embed)* refuse an unevaluable query vector in every top-k form
+- *(embed)* measure the index top-k with the vector not returned
+- *(embed)* measure the correlated join one row per key and as a search
+- *(embed)* wait for reports and rebuilds before index checks
+- *(embed)* cover the fallbacks of the batched correlated join
+- *(embed)* wait for the recorded suspicion before a failing check
+- *(embed)* measure a correlated join through a unique index
+- *(embed)* count allocations per vector statement
+- *(embed)* bench the index-served top-k shape, store beside the build
+- *(embed)* measure vector statements end to end
+- *(embed)* keep the cascade's data on hot until it moves it
+- *(embed)* lower a full group to the supported minimum
+- *(embed)* lower the limit below the data, not the transient charge
+- *(index)* pass over a catalog of unrelated definitions in a small budget
+- *(index)* state what the shape agreement test catches
+- *(index)* fail the shape agreement test on a variant it lacks
+- *(index)* leaving a unique value too long to hold writes nothing
+- *(index)* a fold never brings back a posting a writer removed
+- *(index)* measure the report queue's memory apart from its accounting
+- *(query)* tell a woken snapshot read from a timed-out one by margin
+- *(query)* measure the distributed top-k merge
+- *(raft)* a failed log write stops consensus and the node restarts
+- *(raft)* let the refused bound lie above the read one
+- *(raft)* finish a conversion cut short at the marker
+- *(raft)* count journal syncs for an unchanged vote
+- *(raft)* catch an unchanged vote appended to the journal
+- *(raft)* resume a replacement on another leader, refuse old votes
+- *(raft)* run the lost-answer case around the actual leader
+- *(storage)* a power cut never leaves history without its domain
+- *(storage)* name the candidate implication in the admission test
+- *(storage)* build the candidate test schema with its own fields
+- *(storage)* fail every matching op of a persist
+- *(storage)* fail only the persisting partition's files
+- *(storage)* wait for the drop to close the tree, not for a sleep
+- *(storage)* measure the copy's peak from a steady store
+- *(storage)* model clean-stale pages and torn files
+- *(storage)* fail each step of a promise copy write
+- *(storage)* compare table tree paths absolute, as the tree config does
+- *(storage)* compare table tree paths against the endpoints as configured
+- *(storage)* hold a slowed table's rows to the write rate
+- *(storage)* judge each table into its own verdict and one metrics series
+- *(storage)* check the tail-captured segment's bytes on every platform
+- *(vector)* choose the exact kernel set for a bench run
+- *(vector)* measure the production exhaustive scan, not the unused flat index
+- *(vector)* qualify exact vector evaluation before and after
+
+### Bench
+
+- *(raft)* observe the copy's footprint inside a write
+- *(raft)* wait for a leader that confirms its lease
+- *(raft)* give the recovery image a promised term above 1
+- *(raft)* measure recovery, the copy's peak footprint and reads
+- *(raft)* trace each commit against the device's I/O
+- *(raft)* separate leadership seen from confirmed
+- *(raft)* bound each promise cost to its own span
+- *(raft)* measure what keeping consensus promises costs
+- *(storage)* measure statement flushes on a fresh store per series
+
+### Wip
+
+- ALTER NODE TYPE SET IMPLIES with per-label lookup generations
+- keep only a label change's difference apart in the lookup
+- reconcile the label lookup through the implication change
+
 ## v0.9.0 - 2026-10-24
 
 ### Added