Implement LazyArray.splice(), implement unshift/shift/push/pop in terms of splice (also, this fixes a bug with pop where the LazyArray.length was not updated)

Fix bug with not marking array or object dirty after deleting a property

Fix several bugs with opening database when the root straddles a block boundary

Use (Transaction|LazyValue).get_json() instead of logjson.logjson_to_json() and (Transaction|LazyValue).set_json() instead of Transaction.json_to_logjson()

Fix bug with modifying the cache values causing Transaction.rollback() to fail

Fix bug in Database.Transaction() of not awaiting this.mutex.acquire()

Implement log file rotation

Add immediate flush when Database.write_list_len exceeds Database.block_size, fix bugs in kick() routine to respect cache pinning and improve synchronization

Implement Database.block_size (previously hard coded to 0x1000), change Database.eof1 to Database.eof + Database.write_list_len

Make default_value be in JSON not logjson format (faster and more convenient)

Add json_to_logjson and logjson_to_json command line utilities

Fix minor bugs

Add packaging

Rename abstract parent class of Lazy(Array|Object) from Lazy to LazyValue

Break into separate source files per object

Move a.mjs, b.mjs, json and logjson files into /tests

Make writing use blocks >= 16 kbytes where possible

Add write list

Add read cache

Make snapped references to Lazy(Array|Object) in the tree be stored as the Lazy(Array|Object) ref directly rather than [ptr, len, ref], since ptr, len not used

Rename LazyXXX.flush() to LazyXXX.commit(), make LazyXXX.commit() write itself to disk instead of relying on parent to do so (because there is no longer any need for special handling of the root object to put < > around it since the < > will now surround a [ptr, len] record rather than the root object itself), fix semantics of LazyArray.delete() and LazyArray.pop() so length behaves like Array

Remove the awkward ptr === -1 logic in commit(), flush() routines, since it is now guaranteed that if ptr === -1 the subtree must have been dirty and written

When placing a Lazy(Array|Object) into the tree, copy its [ptr, len] into the parent if available, this means that if a subtree is moved from one spot to another the subtree will only need to be rewritten if modified as well (if subtree is not modified, parent can just use a reference to the existing on-disk subtree)

Store the [ptr, len] reference in the Lazy(Array|Object) instead of dirty flag (when set to null instead of [ptr, len] it means that the contents are dirty)

Rationalize how root is stored to make it more like an item of an array or object (if primitive, stored directly, otherwise as a [ptr, len] reference array)

Implement Database.(read|write)() to reduce duplication and allow caching later

Make a Transaction object, temporarily removes caching ability (Transaction object and all cached read/write data is thrown away at the end of a transaction)

Make LazyXXX an inner object of Database, so that LazyXXX.database is set at construction time, doesn't change thereafter, and must match when building trees

Rename (F|f)ile to (D|d)atabase

Reinstate primitive object optimization

Implement dirty flag, to prepare for reinstating primitive object optimization

Allow for nonexistent root item, make get() default value be written back

Get lazy writing working

Temporarily remove optimization of writing primitive JSON values directly, so that all children of array or object consist of a [ptr, len] redirection record

Get lazy reading working

Put methods into a class called logjson.File

Initial commit, can read and write a JSON tree in log style and append to a log