I fixed a database transaction bug where setting up a change could fail after it had already staged work. The transaction now rolls back that staged work and keeps the original error, including when the rollback itself also fails. I added tests covering both supported transaction modes.
I fixed an authentication bug where one listener throwing an error stopped the remaining listeners from hearing about the new state. The code now notifies every listener, then rethrows the first error so callers still see the failure. Token renewal also continues when an observer fails, and I added regression tests for these cases.
I fixed grouped query results so they are sorted by their actual group keys before pagination, instead of by hidden internal IDs. This keeps pages stable for reads and live updates, while preserving explicit sort directions and group identity.
I made Node backends reject local-first login tokens by default in production, matching the sync server. Development and test environments still accept them, and callers can explicitly enable or disable the behaviour. I also updated the documentation and examples to explain the setting.
I fixed grouped query results where a missing value could appear differently in a fresh read and a live update. Empty groups now keep the same public shape and identity when rows change, including when a value changes from missing to present and back. This keeps counts and sums in sync without changing stored data.
I reorganised the TypeScript SDK and example-app tests around shared behaviours instead of repeating the same setup for every framework and read mode. The suites still cover each framework's mounting, cleanup, pagination, persistence, and query behaviour, but now do the common work once. This keeps the tests smaller while preserving the important differences between the examples.
I moved account-selection durability into the account manager so opening a session waits until the selected account has really been saved. Storage failures are now reported to the caller and can be retried, instead of being logged and allowing an unsaved selection to continue. The change also keeps re-entrant and replacement selections from completing the wrong operation.
I combined the separate pieces of state used while a subscription is being registered and while it is live. One owner now cleans up both pieces together, preventing an old seed from surviving after its subscription has gone away. The existing activation order, re-registration behaviour, and listener semantics remain unchanged.
I fixed a transport deadlock where a large upload queue could stop the client from reading the acknowledgements needed to clear that queue. The client now keeps processing incoming messages while deferring outgoing work, so uploads can recover without losing their order. I also tightened the stress-test helpers and added coverage for subscriptions continuing to receive updates during backpressure.
I gathered the repeated rules for clearing Jazz's query caches into three operations on the query service. This means future cache changes have one clear place to update, while each existing call site keeps the same caches and clearing order as before. Public APIs and stored or network formats are unchanged.
I added read-only computed columns that are calculated from other fields when a row is read, without storing another copy of the result. Jazz discovers which fields a computation needs and keeps those values up to date in reads and subscriptions. Stored transforms remain writable, while computed values cannot accidentally be written or used as storage fields.
I added a public way to capture the current state of a Jazz branch and use it as a frozen base for later reads. A draft can now keep seeing the captured values while the live branch continues to change, including when the app is offline. The new snapshot type and helpers are available across the supported native runtimes without changing the existing storage or sync formats.
I added a way for a transformed column to use other fields from the same row when it reads or writes a value. This means, for example, that a price field can understand whether another field stores the amount in cents or dollars, fetching that context when it is not part of the caller's selection while keeping the public result shape unchanged. Existing transforms that only use their own value continue to work as before.
I restacked the offline encrypted chat work and made conditional writes safe around cancellation. A write that has started keeps ownership until it finishes, while a cancellation before admission leaves no stuck operation behind.
I updated offline account and space initialisation to current main. Cached catalogues can no longer be mistaken for complete history, and mismatched owners or storage formats are refused before a runtime is opened.
I brought the E13 work up to current main while retaining the evidence that an in-progress creation belongs to one owner across reopen and settlement. Malformed or non-exclusive evidence is still rejected without a migration.
I brought the end-to-end encrypted E12 work up to date with the latest main branch and the checked E03–E11 layers. This keeps the feature history and boundaries intact while carrying the latest fixes through the stack.
I aligned the unreleased end-to-end encrypted cell format with the current native format and removed an unnecessary compatibility layer. I also made cancellation release its reservation safely and let foreground hand-offs finish pending work before transferring control.
I stopped declarative query binding from copying the same input data when it could safely reuse it. I added a regression check to make sure the original input stays isolated and invalid inputs still fail clearly.
I changed the part of Jazz that prepares queries so it can move finished pieces into the result when nothing else needs them, instead of always copying them. If another piece still shares the data, it keeps the safe copying fallback.