The native code turns binary IDs into UUID strings while it loads data. It was creating several temporary arrays and strings for every ID, so I replaced that with a small reusable table and direct string building, reducing garbage without changing the UUIDs consumers receive.
When a relationship query starts with two complete sets of data, the old code treated them as if each side had changed separately. That made it do the join twice and then throw away the duplicate work, so I added a special path that builds the answer once; ordinary incremental updates still use the old behaviour.
When loading a large set of related records, the code kept looking up and copying the same table description for each record. I cache that description for the duration of the load, so the query does less repeated work while returning exactly the same records.
I added a benchmark for a sync case where the server already knows some of the client’s data. It keeps the amount of data being rebuilt constant, varies how much is already known, and checks that the client still receives the exact right versions; this lets us measure how much network data can be avoided.
I added a way for the persisted-read benchmark to say where its time went: opening the storage, opening Jazz, preparing the query, and building the first result. The existing benchmark result is still recorded, so the new numbers explain the old measurement rather than replacing it.
Some transactions arrive in several messages. If the final message arrived after earlier pieces had been cached, the code could rebuild the current view from just that last piece, so old rows disappeared; I now reload all pieces before rebuilding the indexes.
An access-control query can prove that a row is allowed through more than one policy route. Those repeated proofs were being counted as separate result rows before sorting and limiting the answer, so I changed the query to keep one proof per row and policy route before applying the limit; normal joins still keep their duplicate rows when duplicates are meaningful.
I refreshed the performance roadmap to match the investigations and benchmark receipts that now exist. It separates completed work from open questions and records the places where measurements showed no improvement.
I added a repeatable benchmark that measures how a selective lookup behaves as the underlying table grows. It records the exact result, the number of rows read during each phase, and the current implementation's known limit, so future improvements can be checked against a clear baseline.
I changed lookups that follow linked records so safe filters are applied earlier, reducing the rows carried through the rest of the query. When limits or offsets make reordering unsafe, the lookup keeps its original order.
I fixed a query path that found the right index but then lost that choice and scanned the whole table. The lookup now keeps the specific index binding, so it reads the small candidate set while returning the same ordered results.
I made the browser and native versions of Jazz agree on the shape of a couple of error values. This keeps optional remote stack traces intact and gives WebSocket callbacks the types the code actually uses.
I removed old permission examples from the Jazz docs that no longer matched how the system works. This keeps the documentation from teaching people an outdated way of checking permissions.
I updated the Next.js versions used by the examples, tests, and homepage to the patched 15.5.21 release. I also tidied the surrounding dependency pins and formatting issues so the change could be checked consistently.
I stopped Jazz's client type definitions from exposing details that change between Better Auth releases. This keeps normal Better Auth type checking working while preserving Jazz's own account and action types, with checks for the 1.6 setup.
I made Jazz check integer values before passing them to native code. It now gives clear errors for fractions, non-finite values, and numbers outside the signed 32-bit range, with documentation and boundary tests.
I updated the repository's Next.js users to the patched 15.5.21 release and centralised the version pins. I also fixed the formatting and lint issues needed to validate the update.
I fixed Jazz's Better Auth client types so they no longer expose version-specific internals from Better Auth. That keeps normal Better Auth inference working while retaining Jazz-specific account and action types, and adds a compatibility check.
I fixed a problem where deletes in migrated data could lose the row's earlier history. I made Jazz resolve that history from the row's origin records and rebuild the right branch state, with tests for deletes, renames, permissions, and recovery.
I fixed a TypeScript inference issue where chaining column modifiers could throw away specialised types. The stored, displayed, and inserted value types now stay distinct and accurate, with regression tests.