Fixup

.github/workflows/ci.yaml

@@ -14,8 +14,7 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: 1.67.0
+          toolchain: stable
-          default: true
           components: rustfmt
       - uses: Swatinem/rust-cache@v1
       - run: ./scripts/ci/fmt
@@ -28,8 +27,7 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: 1.67.0
+          toolchain: stable
-          default: true
           components: clippy
       - uses: Swatinem/rust-cache@v1
       - run: ./scripts/ci/lint
@@ -42,14 +40,9 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: 1.67.0
+          toolchain: stable
-          default: true
       - uses: Swatinem/rust-cache@v1
-      - name: Build rust docs
+      - run: ./scripts/ci/docs
-        run: ./scripts/ci/rust-docs
-        shell: bash
-      - name: Install doxygen
-        run: sudo apt-get install -y doxygen
         shell: bash
 
   cargo-deny:
@@ -64,50 +57,23 @@ jobs:
       - uses: actions/checkout@v2
       - uses: EmbarkStudios/cargo-deny-action@v1
         with:
-          arguments: '--manifest-path ./rust/Cargo.toml'
           command: check ${{ matrix.checks }}
 
   wasm_tests:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Install wasm-bindgen-cli
+      - name: Install wasm-pack
-        run: cargo install wasm-bindgen-cli wasm-opt
+        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-      - name: Install wasm32 target
-        run: rustup target add wasm32-unknown-unknown
       - name: run tests
         run: ./scripts/ci/wasm_tests
-  deno_tests:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: denoland/setup-deno@v1
-        with:
-          deno-version: v1.x
-      - name: Install wasm-bindgen-cli
-        run: cargo install wasm-bindgen-cli wasm-opt
-      - name: Install wasm32 target
-        run: rustup target add wasm32-unknown-unknown
-      - name: run tests
-        run: ./scripts/ci/deno_tests
-
-  js_fmt:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: install
-        run: yarn global add prettier
-      - name: format
-        run: prettier -c javascript/.prettierrc javascript
 
   js_tests:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Install wasm-bindgen-cli
+      - name: Install wasm-pack
-        run: cargo install wasm-bindgen-cli wasm-opt
+        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-      - name: Install wasm32 target
-        run: rustup target add wasm32-unknown-unknown
       - name: run tests
         run: ./scripts/ci/js_tests
 
@@ -118,8 +84,7 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: nightly-2023-01-26
+          toolchain: stable
-          default: true
       - uses: Swatinem/rust-cache@v1
       - name: Install CMocka
         run: sudo apt-get install -y libcmocka-dev
@@ -127,8 +92,6 @@ jobs:
         uses: jwlawson/actions-setup-cmake@v1.12
         with:
           cmake-version: latest
-      - name: Install rust-src
-        run: rustup component add rust-src
       - name: Build and test C bindings
         run: ./scripts/ci/cmake-build Release Static
         shell: bash
@@ -138,14 +101,15 @@ jobs:
     strategy:
       matrix:
         toolchain:
-          - 1.67.0
+          - stable
+          - nightly
+    continue-on-error: ${{ matrix.toolchain == 'nightly' }}
     steps:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
           toolchain: ${{ matrix.toolchain }}
-          default: true
       - uses: Swatinem/rust-cache@v1
       - run: ./scripts/ci/build-test
         shell: bash
@@ -157,8 +121,7 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: 1.67.0
+          toolchain: stable
-          default: true
       - uses: Swatinem/rust-cache@v1
       - run: ./scripts/ci/build-test
         shell: bash
@@ -170,8 +133,8 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: 1.67.0
+          toolchain: stable
-          default: true
       - uses: Swatinem/rust-cache@v1
       - run: ./scripts/ci/build-test
         shell: bash
+

.github/workflows/docs.yaml

@@ -23,30 +23,22 @@ jobs:
         uses: Swatinem/rust-cache@v1
 
       - name: Clean docs dir
-        run: rm -rf docs
-        shell: bash
-
-      - name: Clean Rust docs dir
         uses: actions-rs/cargo@v1
         with:
           command: clean
-          args: --manifest-path ./rust/Cargo.toml --doc
+          args: --doc
 
-      - name: Build Rust docs
+      - name: Build docs
         uses: actions-rs/cargo@v1
         with:
           command: doc
-          args: --manifest-path ./rust/Cargo.toml --workspace --all-features --no-deps
+          args: --workspace --all-features --no-deps
-
-      - name: Move Rust docs
-        run: mkdir -p docs && mv rust/target/doc/* docs/.
-        shell: bash
 
       - name: Configure root page
-        run: echo '<meta http-equiv="refresh" content="0; url=automerge">' > docs/index.html
+        run: echo '<meta http-equiv="refresh" content="0; url=automerge">' > target/doc/index.html
 
       - name: Deploy docs
         uses: peaceiris/actions-gh-pages@v3
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./docs
+          publish_dir: ./target/doc

.github/workflows/release.yaml

@@ -1,214 +0,0 @@
-name: Release
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  check_if_wasm_version_upgraded:
-    name: Check if WASM version has been upgraded
-    runs-on: ubuntu-latest
-    outputs:
-      wasm_version: ${{ steps.version-updated.outputs.current-package-version }}
-      wasm_has_updated: ${{ steps.version-updated.outputs.has-updated }}
-    steps:
-      - uses: JiPaix/package-json-updated-action@v1.0.5
-        id: version-updated
-        with:
-          path: rust/automerge-wasm/package.json
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  publish-wasm:
-    name: Publish WASM package
-    runs-on: ubuntu-latest
-    needs:
-      - check_if_wasm_version_upgraded
-    # We create release only if the version in the package.json has been upgraded
-    if: needs.check_if_wasm_version_upgraded.outputs.wasm_has_updated == 'true'
-    steps:
-      - uses: actions/setup-node@v3
-        with:
-          node-version: '16.x'
-          registry-url: 'https://registry.npmjs.org'
-      - uses: denoland/setup-deno@v1
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          ref: ${{ github.ref }}
-      - name: Get rid of local github workflows
-        run: rm -r .github/workflows
-      - name: Remove tmp_branch if it exists
-        run: git push origin :tmp_branch || true
-      - run: git checkout -b tmp_branch
-      - name: Install wasm-bindgen-cli
-        run: cargo install wasm-bindgen-cli wasm-opt
-      - name: Install wasm32 target
-        run: rustup target add wasm32-unknown-unknown
-      - name: run wasm js tests
-        id: wasm_js_tests
-        run: ./scripts/ci/wasm_tests
-      - name: run wasm deno tests
-        id: wasm_deno_tests
-        run: ./scripts/ci/deno_tests
-      - name: build release
-        id: build_release
-        run: |
-          npm --prefix $GITHUB_WORKSPACE/rust/automerge-wasm run release
-      - name: Collate deno release files
-        if: steps.wasm_js_tests.outcome == 'success' && steps.wasm_deno_tests.outcome == 'success'
-        run: |
-          mkdir $GITHUB_WORKSPACE/deno_wasm_dist
-          cp $GITHUB_WORKSPACE/rust/automerge-wasm/deno/* $GITHUB_WORKSPACE/deno_wasm_dist
-          cp $GITHUB_WORKSPACE/rust/automerge-wasm/index.d.ts $GITHUB_WORKSPACE/deno_wasm_dist
-          cp $GITHUB_WORKSPACE/rust/automerge-wasm/README.md $GITHUB_WORKSPACE/deno_wasm_dist
-          cp $GITHUB_WORKSPACE/rust/automerge-wasm/LICENSE $GITHUB_WORKSPACE/deno_wasm_dist
-          sed -i '1i /// <reference types="./index.d.ts" />' $GITHUB_WORKSPACE/deno_wasm_dist/automerge_wasm.js
-      - name: Create npm release
-        if: steps.wasm_js_tests.outcome == 'success' && steps.wasm_deno_tests.outcome == 'success'
-        run: |
-          if [ "$(npm --prefix $GITHUB_WORKSPACE/rust/automerge-wasm show . version)" = "$VERSION" ]; then
-            echo "This version is already published"
-            exit 0
-          fi
-          EXTRA_ARGS="--access public"
-          if [[ $VERSION == *"alpha."* ]] || [[ $VERSION == *"beta."* ]] || [[ $VERSION == *"rc."* ]]; then
-            echo "Is pre-release version"
-            EXTRA_ARGS="$EXTRA_ARGS --tag next"
-          fi
-          if [ "$NODE_AUTH_TOKEN" = "" ]; then
-            echo "Can't publish on NPM, You need a NPM_TOKEN secret."
-            false
-          fi
-          npm publish $GITHUB_WORKSPACE/rust/automerge-wasm  $EXTRA_ARGS
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
-          VERSION: ${{ needs.check_if_wasm_version_upgraded.outputs.wasm_version }}
-      - name: Commit wasm deno release files
-        run: |
-          git config --global user.name "actions"
-          git config --global user.email actions@github.com
-          git add $GITHUB_WORKSPACE/deno_wasm_dist
-          git commit -am "Add deno release files"
-          git push origin tmp_branch
-      - name: Tag wasm release
-        if: steps.wasm_js_tests.outcome == 'success' && steps.wasm_deno_tests.outcome == 'success'
-        uses: softprops/action-gh-release@v1
-        with:
-          name: Automerge Wasm v${{ needs.check_if_wasm_version_upgraded.outputs.wasm_version }}
-          tag_name: js/automerge-wasm-${{ needs.check_if_wasm_version_upgraded.outputs.wasm_version }}
-          target_commitish: tmp_branch
-          generate_release_notes: false
-          draft: false
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      - name: Remove tmp_branch
-        run: git push origin :tmp_branch
-  check_if_js_version_upgraded:
-    name: Check if JS version has been upgraded
-    runs-on: ubuntu-latest
-    outputs:
-      js_version: ${{ steps.version-updated.outputs.current-package-version }}
-      js_has_updated: ${{ steps.version-updated.outputs.has-updated }}
-    steps:
-      - uses: JiPaix/package-json-updated-action@v1.0.5
-        id: version-updated
-        with:
-          path: javascript/package.json
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  publish-js:
-    name: Publish JS package
-    runs-on: ubuntu-latest
-    needs:
-      - check_if_js_version_upgraded
-      - check_if_wasm_version_upgraded
-      - publish-wasm
-    # We create release only if the version in the package.json has been upgraded and after the WASM release
-    if: |
-      (always() && ! cancelled()) &&
-      (needs.publish-wasm.result == 'success' || needs.publish-wasm.result == 'skipped') && 
-      needs.check_if_js_version_upgraded.outputs.js_has_updated == 'true'
-    steps:
-      - uses: actions/setup-node@v3
-        with:
-          node-version: '16.x'
-          registry-url: 'https://registry.npmjs.org'
-      - uses: denoland/setup-deno@v1
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          ref: ${{ github.ref }}
-      - name: Get rid of local github workflows
-        run: rm -r .github/workflows
-      - name: Remove js_tmp_branch if it exists
-        run: git push origin :js_tmp_branch || true
-      - run: git checkout -b js_tmp_branch
-      - name: check js formatting
-        run: |
-          yarn global add prettier
-          prettier -c javascript/.prettierrc javascript
-      - name: run js tests
-        id: js_tests
-        run: |
-          cargo install wasm-bindgen-cli wasm-opt
-          rustup target add wasm32-unknown-unknown
-          ./scripts/ci/js_tests
-      - name: build js release
-        id: build_release
-        run: |
-          npm --prefix $GITHUB_WORKSPACE/javascript run build
-      - name: build js deno release
-        id: build_deno_release
-        run: |
-          VERSION=$WASM_VERSION npm --prefix $GITHUB_WORKSPACE/javascript run deno:build
-        env:
-          WASM_VERSION: ${{ needs.check_if_wasm_version_upgraded.outputs.wasm_version }}
-      - name: run deno tests
-        id: deno_tests
-        run: |
-          npm --prefix $GITHUB_WORKSPACE/javascript run deno:test
-      - name: Collate deno release files
-        if: steps.js_tests.outcome == 'success' && steps.deno_tests.outcome == 'success'
-        run: |
-          mkdir $GITHUB_WORKSPACE/deno_js_dist
-          cp $GITHUB_WORKSPACE/javascript/deno_dist/* $GITHUB_WORKSPACE/deno_js_dist
-      - name: Create npm release
-        if: steps.js_tests.outcome == 'success' && steps.deno_tests.outcome == 'success'
-        run: |
-          if [ "$(npm --prefix $GITHUB_WORKSPACE/javascript show . version)" = "$VERSION" ]; then
-            echo "This version is already published"
-            exit 0
-          fi
-          EXTRA_ARGS="--access public"
-          if [[ $VERSION == *"alpha."* ]] || [[ $VERSION == *"beta."* ]] || [[ $VERSION == *"rc."* ]]; then
-            echo "Is pre-release version"
-            EXTRA_ARGS="$EXTRA_ARGS --tag next"
-          fi
-          if [ "$NODE_AUTH_TOKEN" = "" ]; then
-            echo "Can't publish on NPM, You need a NPM_TOKEN secret."
-            false
-          fi
-          npm publish $GITHUB_WORKSPACE/javascript $EXTRA_ARGS
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
-          VERSION: ${{ needs.check_if_js_version_upgraded.outputs.js_version }}
-      - name: Commit js deno release files
-        run: |
-          git config --global user.name "actions"
-          git config --global user.email actions@github.com
-          git add $GITHUB_WORKSPACE/deno_js_dist
-          git commit -am "Add deno js release files"
-          git push origin js_tmp_branch
-      - name: Tag JS release
-        if: steps.js_tests.outcome == 'success' && steps.deno_tests.outcome == 'success'
-        uses: softprops/action-gh-release@v1
-        with:
-          name: Automerge v${{ needs.check_if_js_version_upgraded.outputs.js_version }}
-          tag_name: js/automerge-${{ needs.check_if_js_version_upgraded.outputs.js_version }}
-          target_commitish: js_tmp_branch
-          generate_release_notes: false
-          draft: false
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      - name: Remove js_tmp_branch
-        run: git push origin :js_tmp_branch

.gitignore

@@ -1,6 +1,5 @@
+/target
 /.direnv
 perf.*
 /Cargo.lock
 build/
-.vim/*
-/target

Cargo.toml

@@ -3,15 +3,14 @@ members = [
     "automerge",
     "automerge-c",
     "automerge-cli",
-    "automerge-test",
     "automerge-wasm",
     "edit-trace",
 ]
-resolver = "2"
 
 [profile.release]
+debug = true
 lto = true
-codegen-units = 1
+opt-level = 3
 
 [profile.bench]
 debug = true

Makefile

@@ -0,0 +1,13 @@
+rust:
+	cd automerge && cargo test
+
+wasm:
+	cd automerge-wasm && yarn
+	cd automerge-wasm && yarn build
+	cd automerge-wasm && yarn test
+	cd automerge-wasm && yarn link
+
+js: wasm
+	cd automerge-js && yarn
+	cd automerge-js && yarn link "automerge-wasm"
+	cd automerge-js && yarn test

README.md

@@ -1,147 +1,110 @@
-# Automerge
+# Automerge RS
 
 <img src='./img/sign.svg' width='500' alt='Automerge logo' />
 
 [![homepage](https://img.shields.io/badge/homepage-published-informational)](https://automerge.org/)
 [![main docs](https://img.shields.io/badge/docs-main-informational)](https://automerge.org/automerge-rs/automerge/)
 [![ci](https://github.com/automerge/automerge-rs/actions/workflows/ci.yaml/badge.svg)](https://github.com/automerge/automerge-rs/actions/workflows/ci.yaml)
-[![docs](https://github.com/automerge/automerge-rs/actions/workflows/docs.yaml/badge.svg)](https://github.com/automerge/automerge-rs/actions/workflows/docs.yaml)
 
-Automerge is a library which provides fast implementations of several different
+This is a rust implementation of the [Automerge](https://github.com/automerge/automerge) file format and network protocol.
-CRDTs, a compact compression format for these CRDTs, and a sync protocol for
-efficiently transmitting those changes over the network. The objective of the
-project is to support [local-first](https://www.inkandswitch.com/local-first/) applications in the same way that relational
-databases support server applications - by providing mechanisms for persistence
-which allow application developers to avoid thinking about hard distributed
-computing problems. Automerge aims to be PostgreSQL for your local-first app.
 
-If you're looking for documentation on the JavaScript implementation take a look
+If you are looking for the origional `automerge-rs` project that can be used as a wasm backend to the javascript implementation, it can be found [here](https://github.com/automerge/automerge-rs/tree/automerge-1.0).
-at https://automerge.org/docs/hello/. There are other implementations in both
-Rust and C, but they are earlier and don't have documentation yet. You can find
-them in `rust/automerge` and `rust/automerge-c` if you are comfortable
-reading the code and tests to figure out how to use them.
-
-If you're familiar with CRDTs and interested in the design of Automerge in
-particular take a look at https://automerge.org/docs/how-it-works/backend/
-
-Finally, if you want to talk to us about this project please [join the
-Slack](https://join.slack.com/t/automerge/shared_invite/zt-e4p3760n-kKh7r3KRH1YwwNfiZM8ktw)
 
 ## Status
 
-This project is formed of a core Rust implementation which is exposed via FFI in
+This project has 4 components:
-javascript+WASM, C, and soon other languages. Alex
-([@alexjg](https://github.com/alexjg/)]) is working full time on maintaining
-automerge, other members of Ink and Switch are also contributing time and there
-are several other maintainers. The focus is currently on shipping the new JS
-package. We expect to be iterating the API and adding new features over the next
-six months so there will likely be several major version bumps in all packages
-in that time.
 
-In general we try and respect semver.
+1. _automerge_ - a rust implementation of the library. This project is the most mature and being used in a handful of small applications.
+2. _automerge-wasm_ - a js/wasm interface to the underlying rust library. This api is generally mature and in use in a handful of projects as well.
+3. _automerge-js_ - this is a javascript library using the wasm interface to export the same public api of the primary automerge project. Currently this project passes all of automerge's tests but has not been used in any real project or packaged as an NPM. Alpha testers welcome.
+4. _automerge-c_ - this is a c library intended to be an ffi integration point for all other languages. It is currently a work in progress and not yet ready for any testing.
 
-### JavaScript
+## How?
 
-A stable release of the javascript package is currently available as
+The current iteration of automerge-rs is complicated to work with because it
-`@automerge/automerge@2.0.0` where. pre-release verisions of the `2.0.1` are
+adopts the frontend/backend split architecture of the JS implementation. This
-available as `2.0.1-alpha.n`. `2.0.1*` packages are also available for Deno at
+architecture was necessary due to basic operations on the automerge opset being
-https://deno.land/x/automerge
+too slow to perform on the UI thread. Recently @orionz has been able to improve
+the performance to the point where the split is no longer necessary. This means
+we can adopt a much simpler mutable API.
 
-### Rust
+The architecture is now built around the `OpTree`. This is a data structure
+which supports efficiently inserting new operations and realising values of
+existing operations. Most interactions with the `OpTree` are in the form of
+implementations of `TreeQuery` - a trait which can be used to traverse the
+optree and producing state of some kind. User facing operations are exposed on
+an `Automerge` object, under the covers these operations typically instantiate
+some `TreeQuery` and run it over the `OpTree`.
 
-The rust codebase is currently oriented around producing a performant backend
+## Development
-for the Javascript wrapper and as such the API for Rust code is low level and
-not well documented. We will be returning to this over the next few months but
-for now you will need to be comfortable reading the tests and asking questions
-to figure out how to use it. If you are looking to build rust applications which
-use automerge you may want to look into
-[autosurgeon](https://github.com/alexjg/autosurgeon)
 
-## Repository Organisation
+Please feel free to open issues and pull requests.
 
-- `./rust` - the rust rust implementation and also the Rust components of
+### Running CI
-  platform specific wrappers (e.g. `automerge-wasm` for the WASM API or
-  `automerge-c` for the C FFI bindings)
-- `./javascript` - The javascript library which uses `automerge-wasm`
-  internally but presents a more idiomatic javascript interface
-- `./scripts` - scripts which are useful to maintenance of the repository.
-  This includes the scripts which are run in CI.
-- `./img` - static assets for use in `.md` files
 
-## Building
+The steps CI will run are all defined in `./scripts/ci`. Obviously CI will run
+everything when you submit a PR, but if you want to run everything locally
+before you push you can run `./scripts/ci/run` to run everything.
 
-To build this codebase you will need:
+### Running the JS tests
 
-- `rust`
+You will need to have [node](https://nodejs.org/en/), [yarn](https://yarnpkg.com/getting-started/install), [rust](https://rustup.rs/) and [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/) installed.
-- `node`
-- `yarn`
-- `cmake`
-- `cmocka`
 
-You will also need to install the following with `cargo install`
+To build and test the rust library:
 
-- `wasm-bindgen-cli`
+```shell
-- `wasm-opt`
+  $ cd automerge
-- `cargo-deny`
+  $ cargo test
-
-And ensure you have added the `wasm32-unknown-unknown` target for rust cross-compilation.
-
-The various subprojects (the rust code, the wrapper projects) have their own
-build instructions, but to run the tests that will be run in CI you can run
-`./scripts/ci/run`.
-
-### For macOS
-
-These instructions worked to build locally on macOS 13.1 (arm64) as of
-Nov 29th 2022.
-
-```bash
-# clone the repo
-git clone https://github.com/automerge/automerge-rs
-cd automerge-rs
-
-# install rustup
-curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-
-# install homebrew
-/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-
-# install cmake, node, cmocka
-brew install cmake node cmocka
-
-# install yarn
-npm install --global yarn
-
-# install javascript dependencies
-yarn --cwd ./javascript
-
-# install rust dependencies
-cargo install wasm-bindgen-cli wasm-opt cargo-deny
-
-# get nightly rust to produce optimized automerge-c builds
-rustup toolchain install nightly
-rustup component add rust-src --toolchain nightly
-
-# add wasm target in addition to current architecture
-rustup target add wasm32-unknown-unknown
-
-# Run ci script
-./scripts/ci/run
 ```
 
-If your build fails to find `cmocka.h` you may need to teach it about homebrew's
+To build and test the wasm library:
-installation location:
 
-```
+```shell
-export CPATH=/opt/homebrew/include
+  ## setup
-export LIBRARY_PATH=/opt/homebrew/lib
+  $ cd automerge-wasm
-./scripts/ci/run
+  $ yarn
+
+  ## building or testing
+  $ yarn build
+  $ yarn test
+
+  ## without this the js library wont automatically use changes
+  $ yarn link
+
+  ## cutting a release or doing benchmarking
+  $ yarn release
 ```
 
-## Contributing
+To test the js library. This is where most of the tests reside.
 
-Please try and split your changes up into relatively independent commits which
+```shell
-change one subsystem at a time and add good commit messages which describe what
+  ## setup
-the change is and why you're making it (err on the side of longer commit
+  $ cd automerge-js
-messages). `git blame` should give future maintainers a good idea of why
+  $ yarn
-something is the way it is.
+  $ yarn link "automerge-wasm"
+
+  ## testing
+  $ yarn test
+```
+
+And finally, to build and test the C bindings with CMake:
+
+```shell
+## setup
+$ cd automerge-c
+$ mkdir -p build
+$ cd build
+$ cmake -S .. -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF
+## building and testing
+$ cmake --build .
+```
+To add debugging symbols, replace `Release` with `Debug`.
+To build a shared library instead of a static one, replace `OFF` with `ON`.
+
+The C bindings can be built and tested on any platform for which CMake is
+available but the steps for doing so vary across platforms and are too numerous
+to list here.
+
+## Benchmarking
+
+The `edit-trace` folder has the main code for running the edit trace benchmarking.

TODO.md

@@ -0,0 +1,32 @@
+### next steps:
+  1. C API
+  2. port rust command line tool
+  3. fast load
+
+### ergonomics:
+  1. value() -> () or something that into's a value
+
+### automerge:
+  1. single pass (fast) load
+  2. micro-patches / bare bones observation API / fully hydrated documents
+
+### future:
+  1. handle columns with unknown data in and out
+  2. branches with different indexes
+
+### Peritext
+  1. add mark / remove mark -- type, start/end elemid (inclusive,exclusive)
+  2. track any formatting ops that start or end on a character
+  3. ops right before the character, ops right after that character
+  4. query a single character - character, plus marks that start or end on that character
+     what is its current formatting,
+     what are the ops that include that in their span,
+     None = same as last time, Set( bold, italic ),
+     keep these on index
+  5. op probably belongs with the start character - possible packed at the beginning or end of the list
+
+### maybe:
+  1. tables
+
+### no:
+  1. cursors

automerge-c/.gitignore

@@ -0,0 +1,3 @@
+automerge
+automerge.h
+automerge.o

automerge-c/CMakeLists.txt

@@ -0,0 +1,135 @@
+cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
+
+set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+
+# Parse the library name, project name and project version out of Cargo's TOML file.
+set(CARGO_LIB_SECTION OFF)
+
+set(LIBRARY_NAME "")
+
+set(CARGO_PKG_SECTION OFF)
+
+set(CARGO_PKG_NAME "")
+
+set(CARGO_PKG_VERSION "")
+
+file(READ Cargo.toml TOML_STRING)
+
+string(REPLACE ";" "\\\\;" TOML_STRING "${TOML_STRING}")
+
+string(REPLACE "\n" ";" TOML_LINES "${TOML_STRING}")
+
+foreach(TOML_LINE IN ITEMS ${TOML_LINES})
+    string(REGEX MATCH "^\\[(lib|package)\\]$" _ ${TOML_LINE})
+
+    if(CMAKE_MATCH_1 STREQUAL "lib")
+        set(CARGO_LIB_SECTION ON)
+
+        set(CARGO_PKG_SECTION OFF)
+    elseif(CMAKE_MATCH_1 STREQUAL "package")
+        set(CARGO_LIB_SECTION OFF)
+
+        set(CARGO_PKG_SECTION ON)
+    endif()
+
+    string(REGEX MATCH "^name += +\"([^\"]+)\"$" _ ${TOML_LINE})
+
+    if(CMAKE_MATCH_1 AND (CARGO_LIB_SECTION AND NOT CARGO_PKG_SECTION))
+        set(LIBRARY_NAME "${CMAKE_MATCH_1}")
+    elseif(CMAKE_MATCH_1 AND (NOT CARGO_LIB_SECTION AND CARGO_PKG_SECTION))
+        set(CARGO_PKG_NAME "${CMAKE_MATCH_1}")
+    endif()
+
+    string(REGEX MATCH "^version += +\"([^\"]+)\"$" _ ${TOML_LINE})
+
+    if(CMAKE_MATCH_1 AND CARGO_PKG_SECTION)
+        set(CARGO_PKG_VERSION "${CMAKE_MATCH_1}")
+    endif()
+
+    if(LIBRARY_NAME AND (CARGO_PKG_NAME AND CARGO_PKG_VERSION))
+        break()
+    endif()
+endforeach()
+
+project(${CARGO_PKG_NAME} VERSION ${CARGO_PKG_VERSION} LANGUAGES C DESCRIPTION "C bindings for the Automerge Rust backend.")
+
+include(CTest)
+
+option(BUILD_SHARED_LIBS "Enable the choice of a shared or static library.")
+
+include(CMakePackageConfigHelpers)
+
+include(GNUInstallDirs)
+
+string(MAKE_C_IDENTIFIER ${PROJECT_NAME} SYMBOL_PREFIX)
+
+string(TOUPPER ${SYMBOL_PREFIX} SYMBOL_PREFIX)
+
+set(CARGO_TARGET_DIR "${CMAKE_CURRENT_BINARY_DIR}/Cargo/target")
+
+add_subdirectory(src)
+
+# Generate and install the configuration header.
+math(EXPR INTEGER_PROJECT_VERSION_MAJOR "${PROJECT_VERSION_MAJOR} * 100000")
+
+math(EXPR INTEGER_PROJECT_VERSION_MINOR "${PROJECT_VERSION_MINOR} * 100")
+
+math(EXPR INTEGER_PROJECT_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
+
+math(EXPR INTEGER_PROJECT_VERSION "${INTEGER_PROJECT_VERSION_MAJOR} + ${INTEGER_PROJECT_VERSION_MINOR} + ${INTEGER_PROJECT_VERSION_PATCH}")
+
+configure_file(
+    ${CMAKE_MODULE_PATH}/config.h.in
+    config.h
+    @ONLY
+    NEWLINE_STYLE LF
+)
+
+install(
+    FILES ${CMAKE_BINARY_DIR}/config.h
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}
+)
+
+if(BUILD_TESTING)
+    add_subdirectory(test)
+
+    enable_testing()
+endif()
+
+# Generate and install .cmake files
+set(PROJECT_CONFIG_NAME "${PROJECT_NAME}-config")
+
+set(PROJECT_CONFIG_VERSION_NAME "${PROJECT_CONFIG_NAME}-version")
+
+write_basic_package_version_file(
+    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_CONFIG_VERSION_NAME}.cmake
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY ExactVersion
+)
+
+# The namespace label starts with the title-cased library name.
+string(SUBSTRING ${LIBRARY_NAME} 0 1 NS_FIRST)
+
+string(SUBSTRING ${LIBRARY_NAME} 1 -1 NS_REST)
+
+string(TOUPPER ${NS_FIRST} NS_FIRST)
+
+string(TOLOWER ${NS_REST} NS_REST)
+
+string(CONCAT NAMESPACE ${NS_FIRST} ${NS_REST} "::")
+
+# \note CMake doesn't automate the exporting of an imported library's targets
+#       so the package configuration script must do it.
+configure_package_config_file(
+    ${CMAKE_MODULE_PATH}/${PROJECT_CONFIG_NAME}.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_CONFIG_NAME}.cmake
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+)
+
+install(
+    FILES
+        ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_CONFIG_NAME}.cmake
+        ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_CONFIG_VERSION_NAME}.cmake
+    DESTINATION
+        ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+)

automerge-c/Cargo.toml

@@ -4,11 +4,10 @@ version = "0.1.0"
 authors = ["Orion Henry <orion.henry@gmail.com>", "Jason Kankiewicz <jason.kankiewicz@gmail.com>"]
 edition = "2021"
 license = "MIT"
-rust-version = "1.57.0"
 
 [lib]
-name = "automerge_core"
+name = "automerge"
-crate-type = ["staticlib"]
+crate-type = ["cdylib", "staticlib"]
 bench = false
 doc = false
 
@@ -19,4 +18,4 @@ libc = "^0.2"
 smol_str = "^0.1.21"
 
 [build-dependencies]
-cbindgen = "^0.24"
+cbindgen = "^0.20"

automerge-c/Makefile

@@ -0,0 +1,30 @@
+
+CC=gcc
+CFLAGS=-I.
+DEPS=automerge.h
+LIBS=-lpthread -ldl -lm
+LDIR=../target/release
+LIB=../target/release/libautomerge.a
+DEBUG_LIB=../target/debug/libautomerge.a
+
+all: $(DEBUG_LIB) automerge
+
+debug: LDIR=../target/debug
+debug: automerge $(DEBUG_LIB)
+
+automerge: automerge.o $(LDIR)/libautomerge.a
+	$(CC) -o $@ automerge.o $(LDIR)/libautomerge.a $(LIBS) -L$(LDIR)
+
+$(DEBUG_LIB): src/*.rs
+	cargo build
+
+$(LIB): src/*.rs
+	cargo build --release
+
+%.o: %.c $(DEPS)
+	$(CC) -c -o $@ $< $(CFLAGS)
+
+.PHONY: clean
+
+clean:
+	rm -f *.o automerge $(LIB) $(DEBUG_LIB)

automerge-c/README.md

@@ -0,0 +1,95 @@
+
+## Methods we need to support
+
+### Basic management 
+
+  1. `AMcreate()`
+  1. `AMclone(doc)`
+  1. `AMfree(doc)`
+  1. `AMconfig(doc, key, val)` // set actor
+  1. `actor = get_actor(doc)`
+
+### Transactions
+
+  1. `AMpendingOps(doc)`
+  1. `AMcommit(doc, message, time)`
+  1. `AMrollback(doc)`
+
+### Write 
+
+  1. `AMset{Map|List}(doc, obj, prop, value)`
+  1. `AMinsert(doc, obj, index, value)`
+  1. `AMpush(doc, obj, value)`
+  1. `AMdel{Map|List}(doc, obj, prop)`
+  1. `AMinc{Map|List}(doc, obj, prop, value)`
+  1. `AMspliceText(doc, obj, start, num_del, text)`
+
+### Read
+
+  1. `AMkeys(doc, obj, heads)`
+  1. `AMlength(doc, obj, heads)`
+  1. `AMvalues(doc, obj, heads)`
+  1. `AMtext(doc, obj, heads)`
+
+### Sync
+
+  1. `AMgenerateSyncMessage(doc, state)`
+  1. `AMreceiveSyncMessage(doc, state, message)`
+  1. `AMinitSyncState()`
+
+### Save / Load
+
+  1. `AMload(data)`
+  1. `AMloadIncremental(doc, data)`
+  1. `AMsave(doc)`
+  1. `AMsaveIncremental(doc)`
+
+### Low Level Access
+
+  1. `AMapplyChanges(doc, changes)`
+  1. `AMgetChanges(doc, deps)`
+  1. `AMgetChangesAdded(doc1, doc2)`
+  1. `AMgetHeads(doc)`
+  1. `AMgetLastLocalChange(doc)`
+  1. `AMgetMissingDeps(doc, heads)`
+
+### Encode/Decode
+
+  1. `AMencodeChange(change)`
+  1. `AMdecodeChange(change)`
+  1. `AMencodeSyncMessage(change)`
+  1. `AMdecodeSyncMessage(change)`
+  1. `AMencodeSyncState(change)`
+  1. `AMdecodeSyncState(change)`
+
+## Open Question - Memory management
+
+Most of these calls return one or more items of arbitrary length.  Doing memory management in C is tricky.  This is my proposed solution...
+
+### 
+
+  ```
+    // returns 1 or zero opids
+    n = automerge_set(doc, "_root", "hello", datatype, value);
+    if (n) {
+      automerge_pop(doc, &obj, len);
+    }
+
+    // returns n values
+    n = automerge_values(doc, "_root", "hello");
+    for (i = 0; i<n ;i ++) {
+      automerge_pop_value(doc, &value, &datatype, len);
+    }
+  ```
+
+  There would be one pop method per object type.  Users allocs and frees the buffers.  Multiple return values would result in multiple pops. Too small buffers would error and allow retry.
+
+
+### Formats
+
+Actors - We could do (bytes,len) or a hex encoded string?.  
+ObjIds - We could do flat bytes of the ExId struct but lets do human readable strings for now - the struct would be faster but opque
+Heads - Might as well make it a flat buffer `(n, hash, hash, ...)`
+Changes - Put them all in a flat concatenated buffer
+Encode/Decode - to json strings?
+

automerge-c/automerge.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "automerge.h"
+
+#define MAX_BUFF_SIZE 4096
+
+int main() {
+  int n = 0;
+  int data_type = 0;
+  char buff[MAX_BUFF_SIZE];
+  char obj[MAX_BUFF_SIZE];
+  AMresult* res = NULL;
+
+  printf("begin\n");
+
+  AMdoc* doc  = AMcreate();
+
+  printf("AMconfig()...");
+  AMconfig(doc, "actor", "aabbcc");
+  printf("pass!\n");
+
+  printf("AMmapSetStr()...\n");
+  res = AMmapSetStr(doc, NULL, "string", "hello world");
+  if (AMresultStatus(res) != AM_STATUS_COMMAND_OK)
+  {
+        printf("AMmapSet() failed: %s\n", AMerrorMessage(res));
+        return 1;
+  }
+  AMclear(res);
+  printf("pass!\n");
+
+  AMdestroy(doc);
+  printf("end\n");
+}

automerge-c/build.rs

@@ -0,0 +1,25 @@
+extern crate cbindgen;
+
+use std::{env, path::PathBuf};
+
+fn main() {
+    let crate_dir = PathBuf::from(
+        env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR env var is not defined"),
+    );
+
+    let config = cbindgen::Config::from_file("cbindgen.toml")
+        .expect("Unable to find cbindgen.toml configuration file");
+
+    //    let mut config: cbindgen::Config = Default::default();
+    //    config.language = cbindgen::Language::C;
+
+    if let Ok(writer) = cbindgen::generate_with_config(&crate_dir, config) {
+        writer.write_to_file(crate_dir.join("automerge.h"));
+
+        // Also write the generated header into the target directory when
+        // specified (necessary for an out-of-source build a la CMake).
+        if let Ok(target_dir) = env::var("CARGO_TARGET_DIR") {
+            writer.write_to_file(PathBuf::from(target_dir).join("automerge.h"));
+        }
+    }
+}

automerge-c/cbindgen.toml

@@ -0,0 +1,39 @@
+after_includes = """\n
+/**
+ * \\defgroup enumerations Public Enumerations
+     Symbolic names for integer constants.
+ */
+
+/**
+ * \\memberof AMdoc
+ * \\def AM_ROOT
+ * \\brief The root object of an `AMdoc` struct.
+ */
+#define AM_ROOT NULL
+"""
+autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */"
+documentation = true
+documentation_style = "doxy"
+header = """
+/** \\file
+ * All constants, functions and types in the Automerge library's C API.
+ */
+ """
+include_guard = "automerge_h"
+includes = []
+language = "C"
+line_length = 140
+no_includes = true
+style = "both"
+sys_includes = ["stdbool.h", "stddef.h", "stdint.h"]
+usize_is_size_t = true
+
+[enum]
+derive_const_casts = true
+enum_class = true
+must_use = "MUST_USE_ENUM"
+prefix_with_name = true
+rename_variants = "ScreamingSnakeCase"
+
+[export]
+item_types = ["enums", "structs", "opaque", "constants", "functions"]

automerge-c/cmake/config.h.in

@@ -0,0 +1,14 @@
+#ifndef @SYMBOL_PREFIX@_CONFIG_INCLUDED
+#define @SYMBOL_PREFIX@_CONFIG_INCLUDED
+
+/* This header is auto-generated by CMake. */
+
+#define @SYMBOL_PREFIX@_VERSION @INTEGER_PROJECT_VERSION@
+
+#define @SYMBOL_PREFIX@_MAJOR_VERSION (@SYMBOL_PREFIX@_VERSION / 100000)
+
+#define @SYMBOL_PREFIX@_MINOR_VERSION ((@SYMBOL_PREFIX@_VERSION / 100) % 1000)
+
+#define @SYMBOL_PREFIX@_PATCH_VERSION (@SYMBOL_PREFIX@_VERSION % 100)
+
+#endif  /* @SYMBOL_PREFIX@_CONFIG_INCLUDED */

automerge-c/cmake/file_regex_replace.cmake

@@ -1,6 +1,4 @@
-# This CMake script is used to perform string substitutions within a generated
+cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
-# file.
-cmake_minimum_required(VERSION 3.23 FATAL_ERROR)
 
 if(NOT DEFINED MATCH_REGEX)
     message(FATAL_ERROR "Variable \"MATCH_REGEX\" is not defined.")

automerge-c/cmake/file_touch.cmake

@@ -1,6 +1,4 @@
-# This CMake script is used to force Cargo to regenerate the header file for the
+cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
-# core bindings after the out-of-source build directory has been cleaned.
-cmake_minimum_required(VERSION 3.23 FATAL_ERROR)
 
 if(NOT DEFINED CONDITION)
     message(FATAL_ERROR "Variable \"CONDITION\" is not defined.")

automerge-c/src/CMakeLists.txt

@@ -0,0 +1,220 @@
+cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
+
+find_program (
+    CARGO_CMD
+    "cargo"
+    PATHS "$ENV{CARGO_HOME}/bin"
+    DOC "The Cargo command"
+)
+
+if(NOT CARGO_CMD)
+    message(FATAL_ERROR "Cargo (Rust package manager) not found! Install it and/or set the CARGO_HOME environment variable.")
+endif()
+
+string(TOLOWER "${CMAKE_BUILD_TYPE}" BUILD_TYPE_LOWER)
+
+if(BUILD_TYPE_LOWER STREQUAL debug)
+    set(CARGO_BUILD_TYPE "debug")
+
+    set(CARGO_FLAG "")
+else()
+    set(CARGO_BUILD_TYPE "release")
+
+    set(CARGO_FLAG "--release")
+endif()
+
+set(CARGO_CURRENT_BINARY_DIR "${CARGO_TARGET_DIR}/${CARGO_BUILD_TYPE}")
+
+set(
+    CARGO_OUTPUT
+        ${CARGO_TARGET_DIR}/${LIBRARY_NAME}.h
+        ${CARGO_CURRENT_BINARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}${LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}
+        ${CARGO_CURRENT_BINARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${LIBRARY_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}
+)
+
+if(WIN32)
+    # \note The basename of an import library output by Cargo is the filename
+    #       of its corresponding shared library.
+    list(APPEND CARGO_OUTPUT ${CARGO_CURRENT_BINARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}${LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX})
+endif()
+
+add_custom_command(
+    OUTPUT ${CARGO_OUTPUT}
+    COMMAND
+        # \note cbindgen won't regenerate its output header file after it's
+        #       been removed but it will after its configuration file has been
+        #       updated.
+        ${CMAKE_COMMAND} -DCONDITION=NOT_EXISTS -P ${CMAKE_SOURCE_DIR}/cmake/file_touch.cmake -- ${CARGO_TARGET_DIR}/${LIBRARY_NAME}.h ${CMAKE_SOURCE_DIR}/cbindgen.toml
+    COMMAND
+        ${CMAKE_COMMAND} -E env CARGO_TARGET_DIR=${CARGO_TARGET_DIR} ${CARGO_CMD} build ${CARGO_FLAG}
+    MAIN_DEPENDENCY
+        lib.rs
+    DEPENDS
+        doc.rs
+        result.rs
+        utils.rs
+        ${CMAKE_SOURCE_DIR}/build.rs
+        ${CMAKE_SOURCE_DIR}/Cargo.toml
+        ${CMAKE_SOURCE_DIR}/cbindgen.toml
+    WORKING_DIRECTORY
+        ${CMAKE_SOURCE_DIR}
+    COMMENT
+        "Producing the library artifacts with Cargo..."
+    VERBATIM
+)
+
+add_custom_target(
+    ${LIBRARY_NAME}_artifacts
+    DEPENDS ${CARGO_OUTPUT}
+)
+
+# \note cbindgen's naming behavior isn't fully configurable.
+add_custom_command(
+    TARGET ${LIBRARY_NAME}_artifacts
+    POST_BUILD
+    COMMAND
+        # Compensate for cbindgen's variant struct naming.
+        ${CMAKE_COMMAND} -DMATCH_REGEX=AM\([^_]+_[^_]+\)_Body -DREPLACE_EXPR=AM\\1 -P ${CMAKE_SOURCE_DIR}/cmake/file_regex_replace.cmake -- ${CARGO_TARGET_DIR}/${LIBRARY_NAME}.h
+    COMMAND
+        # Compensate for cbindgen's union tag enum type naming.
+        ${CMAKE_COMMAND} -DMATCH_REGEX=AM\([^_]+\)_Tag -DREPLACE_EXPR=AM\\1Variant -P ${CMAKE_SOURCE_DIR}/cmake/file_regex_replace.cmake -- ${CARGO_TARGET_DIR}/${LIBRARY_NAME}.h
+    COMMAND
+        # Compensate for cbindgen's translation of consecutive uppercase letters to "ScreamingSnakeCase".
+        ${CMAKE_COMMAND} -DMATCH_REGEX=A_M\([^_]+\)_ -DREPLACE_EXPR=AM_\\1_ -P ${CMAKE_SOURCE_DIR}/cmake/file_regex_replace.cmake -- ${CARGO_TARGET_DIR}/${LIBRARY_NAME}.h
+    WORKING_DIRECTORY
+        ${CMAKE_SOURCE_DIR}
+    COMMENT
+        "Compensating for hard-coded cbindgen naming behaviors..."
+    VERBATIM
+)
+
+if(BUILD_SHARED_LIBS)
+    if(WIN32)
+        set(LIBRARY_DESTINATION "${CMAKE_INSTALL_BINDIR}")
+    else()
+        set(LIBRARY_DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+    endif()
+
+    set(LIBRARY_DEFINE_SYMBOL "${SYMBOL_PREFIX}_EXPORTS")
+
+    # \note The basename of an import library output by Cargo is the filename
+    #       of its corresponding shared library.
+    set(LIBRARY_IMPLIB "${CARGO_CURRENT_BINARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}${LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    set(LIBRARY_LOCATION "${CARGO_CURRENT_BINARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}${LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+
+    set(LIBRARY_NO_SONAME "${WIN32}")
+
+    set(LIBRARY_SONAME "${CMAKE_SHARED_LIBRARY_PREFIX}${LIBRARY_NAME}${CMAKE_${CMAKE_BUILD_TYPE}_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+
+    set(LIBRARY_TYPE "SHARED")
+else()
+    set(LIBRARY_DEFINE_SYMBOL "")
+
+    set(LIBRARY_DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+
+    set(LIBRARY_IMPLIB "")
+
+    set(LIBRARY_LOCATION "${CARGO_CURRENT_BINARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${LIBRARY_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    set(LIBRARY_NO_SONAME "TRUE")
+
+    set(LIBRARY_SONAME "")
+
+    set(LIBRARY_TYPE "STATIC")
+endif()
+
+add_library(${LIBRARY_NAME} ${LIBRARY_TYPE} IMPORTED GLOBAL)
+
+set_target_properties(
+    ${LIBRARY_NAME}
+    PROPERTIES
+        # \note Cargo writes a debug build into a nested directory instead of
+        #       decorating its name.
+        DEBUG_POSTFIX ""
+        DEFINE_SYMBOL "${LIBRARY_DEFINE_SYMBOL}"
+        IMPORTED_IMPLIB "${LIBRARY_IMPLIB}"
+        IMPORTED_LOCATION "${LIBRARY_LOCATION}"
+        IMPORTED_NO_SONAME "${LIBRARY_NO_SONAME}"
+        IMPORTED_SONAME "${LIBRARY_SONAME}"
+        LINKER_LANGUAGE C
+        PUBLIC_HEADER "${CARGO_TARGET_DIR}/${LIBRARY_NAME}.h"
+        SOVERSION "${PROJECT_VERSION_MAJOR}"
+        VERSION "${PROJECT_VERSION}"
+        # \note Cargo exports all of the symbols automatically.
+        WINDOWS_EXPORT_ALL_SYMBOLS "TRUE"
+)
+
+target_compile_definitions(${LIBRARY_NAME} INTERFACE $<TARGET_PROPERTY:${LIBRARY_NAME},DEFINE_SYMBOL>)
+
+target_include_directories(
+    ${LIBRARY_NAME}
+    INTERFACE
+        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}>"
+)
+
+set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
+
+set(THREADS_PREFER_PTHREAD_FLAG TRUE)
+
+find_package(Threads REQUIRED)
+
+set(LIBRARY_DEPENDENCIES Threads::Threads ${CMAKE_DL_LIBS})
+
+if(WIN32)
+    list(APPEND LIBRARY_DEPENDENCIES Bcrypt userenv ws2_32)
+else()
+    list(APPEND LIBRARY_DEPENDENCIES m)
+endif()
+
+target_link_libraries(${LIBRARY_NAME} INTERFACE ${LIBRARY_DEPENDENCIES})
+
+install(
+    FILES $<TARGET_PROPERTY:${LIBRARY_NAME},IMPORTED_IMPLIB>
+    TYPE LIB
+    # \note The basename of an import library output by Cargo is the filename
+    #       of its corresponding shared library.
+    RENAME "${CMAKE_STATIC_LIBRARY_PREFIX}${LIBRARY_NAME}${CMAKE_${CMAKE_BUILD_TYPE}_POSTFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    OPTIONAL
+)
+
+set(LIBRARY_FILE_NAME "${CMAKE_${LIBRARY_TYPE}_LIBRARY_PREFIX}${LIBRARY_NAME}${CMAKE_${CMAKE_BUILD_TYPE}_POSTFIX}${CMAKE_${LIBRARY_TYPE}_LIBRARY_SUFFIX}")
+
+install(
+    FILES $<TARGET_PROPERTY:${LIBRARY_NAME},IMPORTED_LOCATION>
+    RENAME "${LIBRARY_FILE_NAME}"
+    DESTINATION ${LIBRARY_DESTINATION}
+)
+
+install(
+    FILES $<TARGET_PROPERTY:${LIBRARY_NAME},PUBLIC_HEADER>
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}
+)
+
+find_package(Doxygen OPTIONAL_COMPONENTS dot)
+
+if(DOXYGEN_FOUND)
+    set(DOXYGEN_GENERATE_LATEX YES)
+
+    set(DOXYGEN_PDF_HYPERLINKS YES)
+
+    set(DOXYGEN_PROJECT_LOGO "${CMAKE_SOURCE_DIR}/img/brandmark.png")
+
+    set(DOXYGEN_SORT_BRIEF_DOCS YES)
+
+    set(DOXYGEN_USE_MDFILE_AS_MAINPAGE "${CMAKE_SOURCE_DIR}/README.md")
+
+    doxygen_add_docs(
+        ${LIBRARY_NAME}_docs
+        "${CARGO_TARGET_DIR}/${LIBRARY_NAME}.h"
+        "${CMAKE_SOURCE_DIR}/README.md"
+        USE_STAMP_FILE
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Producing documentation with Doxygen..."
+    )
+
+    # \note A Doxygen input file isn't a file-level dependency so the Doxygen
+    #       command must instead depend upon a target that outputs the file or
+    #       it will just output an error message when it can't be found.
+    add_dependencies(${LIBRARY_NAME}_docs ${LIBRARY_NAME}_artifacts)
+endif()

automerge-c/src/doc.rs

@@ -0,0 +1,85 @@
+use automerge as am;
+use std::collections::BTreeSet;
+use std::ops::{Deref, DerefMut};
+
+use crate::result::AMobjId;
+use automerge::transaction::Transactable;
+
+/// \struct AMdoc
+/// \brief A JSON-like CRDT.
+#[derive(Clone)]
+pub struct AMdoc {
+    body: am::AutoCommit,
+    obj_ids: BTreeSet<AMobjId>,
+}
+
+impl AMdoc {
+    pub fn new(body: am::AutoCommit) -> Self {
+        Self {
+            body,
+            obj_ids: BTreeSet::new(),
+        }
+    }
+
+    pub fn insert_object(
+        &mut self,
+        obj: &am::ObjId,
+        index: usize,
+        value: am::ObjType,
+    ) -> Result<&AMobjId, am::AutomergeError> {
+        match self.body.insert_object(obj, index, value) {
+            Ok(ex_id) => {
+                let obj_id = AMobjId::new(ex_id);
+                self.obj_ids.insert(obj_id.clone());
+                match self.obj_ids.get(&obj_id) {
+                    Some(obj_id) => Ok(obj_id),
+                    None => Err(am::AutomergeError::Fail),
+                }
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    pub fn put_object<O: AsRef<am::ObjId>, P: Into<am::Prop>>(
+        &mut self,
+        obj: O,
+        prop: P,
+        value: am::ObjType,
+    ) -> Result<&AMobjId, am::AutomergeError> {
+        match self.body.put_object(obj, prop, value) {
+            Ok(ex_id) => {
+                let obj_id = AMobjId::new(ex_id);
+                self.obj_ids.insert(obj_id.clone());
+                match self.obj_ids.get(&obj_id) {
+                    Some(obj_id) => Ok(obj_id),
+                    None => Err(am::AutomergeError::Fail),
+                }
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    pub fn drop_obj_id(&mut self, obj_id: &AMobjId) -> bool {
+        self.obj_ids.remove(obj_id)
+    }
+}
+
+impl Deref for AMdoc {
+    type Target = am::AutoCommit;
+
+    fn deref(&self) -> &Self::Target {
+        &self.body
+    }
+}
+
+impl DerefMut for AMdoc {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.body
+    }
+}
+
+impl From<AMdoc> for *mut AMdoc {
+    fn from(b: AMdoc) -> Self {
+        Box::into_raw(Box::new(b))
+    }
+}

automerge-c/src/result.rs

@@ -0,0 +1,212 @@
+use automerge as am;
+use std::ffi::CString;
+use std::ops::Deref;
+
+/// \struct AMobjId
+/// \brief An object's unique identifier.
+#[derive(Clone, Eq, Ord, PartialEq, PartialOrd)]
+pub struct AMobjId(am::ObjId);
+
+impl AMobjId {
+    pub fn new(obj_id: am::ObjId) -> Self {
+        Self(obj_id)
+    }
+}
+
+impl AsRef<am::ObjId> for AMobjId {
+    fn as_ref(&self) -> &am::ObjId {
+        &self.0
+    }
+}
+
+impl Deref for AMobjId {
+    type Target = am::ObjId;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+/// \memberof AMvalue
+/// \struct AMbyteSpan
+/// \brief A contiguous sequence of bytes.
+///
+#[repr(C)]
+pub struct AMbyteSpan {
+    /// A pointer to the byte at position zero.
+    /// \warning \p src is only valid until the `AMfreeResult()` function is called
+    ///          on the `AMresult` struct hosting the array of bytes to which
+    ///          it points.
+    src: *const u8,
+    /// The number of bytes in the sequence.
+    count: usize,
+}
+
+impl From<&Vec<u8>> for AMbyteSpan {
+    fn from(v: &Vec<u8>) -> Self {
+        AMbyteSpan {
+            src: (*v).as_ptr(),
+            count: (*v).len(),
+        }
+    }
+}
+
+impl From<&mut am::ActorId> for AMbyteSpan {
+    fn from(actor: &mut am::ActorId) -> Self {
+        let slice = actor.to_bytes();
+        AMbyteSpan {
+            src: slice.as_ptr(),
+            count: slice.len(),
+        }
+    }
+}
+
+/// \struct AMvalue
+/// \brief A discriminated union of value type variants for an `AMresult` struct.
+///
+/// \enum AMvalueVariant
+/// \brief A value type discriminant.
+///
+/// \var AMvalue::tag
+/// The variant discriminator of an `AMvalue` struct.
+///
+/// \var AMvalue::actor_id
+/// An actor ID as an `AMbyteSpan` struct.
+///
+/// \var AMvalue::boolean
+/// A boolean.
+///
+/// \var AMvalue::bytes
+/// An array of bytes as an `AMbyteSpan` struct.
+///
+/// \var AMvalue::counter
+/// A CRDT counter.
+///
+/// \var AMvalue::f64
+/// A 64-bit float.
+///
+/// \var AMvalue::change_hash
+/// A change hash as an `AMbyteSpan` struct.
+///
+/// \var AMvalue::int_
+/// A 64-bit signed integer.
+///
+/// \var AMvalue::obj_id
+/// An object identifier.
+///
+/// \var AMvalue::str
+/// A UTF-8 string.
+///
+/// \var AMvalue::timestamp
+/// A Lamport timestamp.
+///
+/// \var AMvalue::uint
+/// A 64-bit unsigned integer.
+#[repr(C)]
+pub enum AMvalue<'a> {
+    /// An actor ID variant.
+    ActorId(AMbyteSpan),
+    /// A boolean variant.
+    Boolean(libc::c_char),
+    /// An array of bytes variant.
+    Bytes(AMbyteSpan),
+    /*
+    /// A changes variant.
+    Changes(_),
+    */
+    /// A CRDT counter variant.
+    Counter(i64),
+    /// A 64-bit float variant.
+    F64(f64),
+    /// A change hash variant.
+    ChangeHash(AMbyteSpan),
+    /// A 64-bit signed integer variant.
+    Int(i64),
+    /*
+    /// A keys variant.
+    Keys(_),
+    */
+    /// A nothing variant.
+    Nothing,
+    /// A null variant.
+    Null,
+    /// An object identifier variant.
+    ObjId(&'a AMobjId),
+    /// A UTF-8 string variant.
+    Str(*const libc::c_char),
+    /// A Lamport timestamp variant.
+    Timestamp(i64),
+    /*
+    /// A transaction variant.
+    Transaction(_),
+    */
+    /// A 64-bit unsigned integer variant.
+    Uint(u64),
+}
+
+/// \struct AMresult
+/// \brief A discriminated union of result variants.
+///
+pub enum AMresult<'a> {
+    ActorId(am::ActorId),
+    Changes(Vec<am::Change>),
+    Error(CString),
+    ObjId(&'a AMobjId),
+    Nothing,
+    Scalars(Vec<am::Value<'static>>, Option<CString>),
+}
+
+impl<'a> AMresult<'a> {
+    pub(crate) fn err(s: &str) -> Self {
+        AMresult::Error(CString::new(s).unwrap())
+    }
+}
+
+impl<'a> From<Result<am::ActorId, am::AutomergeError>> for AMresult<'a> {
+    fn from(maybe: Result<am::ActorId, am::AutomergeError>) -> Self {
+        match maybe {
+            Ok(actor_id) => AMresult::ActorId(actor_id),
+            Err(e) => AMresult::Error(CString::new(e.to_string()).unwrap()),
+        }
+    }
+}
+
+impl<'a> From<Result<&'a AMobjId, am::AutomergeError>> for AMresult<'a> {
+    fn from(maybe: Result<&'a AMobjId, am::AutomergeError>) -> Self {
+        match maybe {
+            Ok(obj_id) => AMresult::ObjId(obj_id),
+            Err(e) => AMresult::Error(CString::new(e.to_string()).unwrap()),
+        }
+    }
+}
+
+impl<'a> From<Result<(), am::AutomergeError>> for AMresult<'a> {
+    fn from(maybe: Result<(), am::AutomergeError>) -> Self {
+        match maybe {
+            Ok(()) => AMresult::Nothing,
+            Err(e) => AMresult::Error(CString::new(e.to_string()).unwrap()),
+        }
+    }
+}
+
+impl<'a> From<Result<Option<(am::Value<'static>, am::ObjId)>, am::AutomergeError>>
+    for AMresult<'a>
+{
+    fn from(maybe: Result<Option<(am::Value<'static>, am::ObjId)>, am::AutomergeError>) -> Self {
+        match maybe {
+            // \todo Ensure that it's alright to ignore the `am::ObjId` value.
+            Ok(Some((value, _))) => AMresult::Scalars(vec![value], None),
+            Ok(None) => AMresult::Nothing,
+            Err(e) => AMresult::Error(CString::new(e.to_string()).unwrap()),
+        }
+    }
+}
+
+impl<'a> From<Result<am::Value<'static>, am::AutomergeError>> for AMresult<'a> {
+    fn from(maybe: Result<am::Value<'static>, am::AutomergeError>) -> Self {
+        match maybe {
+            Ok(value) => AMresult::Scalars(vec![value], None),
+            Err(e) => AMresult::Error(CString::new(e.to_string()).unwrap()),
+        }
+    }
+}

automerge-c/src/utils.rs

@@ -0,0 +1,7 @@
+use crate::AMresult;
+
+impl<'a> From<AMresult<'a>> for *mut AMresult<'a> {
+    fn from(b: AMresult<'a>) -> Self {
+        Box::into_raw(Box::new(b))
+    }
+}

automerge-c/test/CMakeLists.txt

@@ -0,0 +1,51 @@
+cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
+
+find_package(cmocka REQUIRED)
+
+add_executable(
+    test_${LIBRARY_NAME}
+        group_state.c
+        amdoc_property_tests.c
+        amlistput_tests.c
+        ammapput_tests.c
+        macro_utils.c
+        main.c
+)
+
+set_target_properties(test_${LIBRARY_NAME} PROPERTIES LINKER_LANGUAGE C)
+
+# \note An imported library's INTERFACE_INCLUDE_DIRECTORIES property can't
+#       contain a non-existent path so its build-time include directory
+#       must be specified for all of its dependent targets instead.
+target_include_directories(
+    test_${LIBRARY_NAME}
+    PRIVATE "$<BUILD_INTERFACE:${CARGO_TARGET_DIR}>"
+)
+
+target_link_libraries(test_${LIBRARY_NAME} PRIVATE cmocka ${LIBRARY_NAME})
+
+add_dependencies(test_${LIBRARY_NAME} ${LIBRARY_NAME}_artifacts)
+
+if(BUILD_SHARED_LIBS AND WIN32)
+    add_custom_command(
+        TARGET test_${LIBRARY_NAME}
+        POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                ${CARGO_CURRENT_BINARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}${LIBRARY_NAME}${CMAKE_${CMAKE_BUILD_TYPE}_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}
+                ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Copying the DLL built by Cargo into the test directory..."
+        VERBATIM
+    )
+endif()
+
+add_test(NAME test_${LIBRARY_NAME} COMMAND test_${LIBRARY_NAME})
+
+add_custom_command(
+    TARGET test_${LIBRARY_NAME}
+    POST_BUILD
+    COMMAND
+        ${CMAKE_CTEST_COMMAND} --config $<CONFIG> --output-on-failure
+    COMMENT
+        "Running the test(s)..."
+    VERBATIM
+)

automerge-c/test/amdoc_property_tests.c

@@ -0,0 +1,110 @@
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* third-party */
+#include <cmocka.h>
+
+/* local */
+#include "group_state.h"
+
+typedef struct {
+    GroupState* group_state;
+    char const* actor_id_str;
+    uint8_t* actor_id_bytes;
+    size_t actor_id_size;
+} TestState;
+
+static void hex_to_bytes(char const* hex_str, uint8_t* bytes, size_t const count) {
+    unsigned int byte;
+    char const* next = hex_str;
+	for (size_t index = 0; *next && index != count; next += 2, ++index) {
+		if (sscanf(next, "%02x", &byte) == 1) {
+            bytes[index] = (uint8_t)byte;
+        }
+	}
+}
+
+static int setup(void** state) {
+    TestState* test_state = calloc(1, sizeof(TestState));
+    group_setup((void**)&test_state->group_state);
+    test_state->actor_id_str = "000102030405060708090a0b0c0d0e0f";
+    test_state->actor_id_size = strlen(test_state->actor_id_str) / 2;
+    test_state->actor_id_bytes = malloc(test_state->actor_id_size);
+    hex_to_bytes(test_state->actor_id_str, test_state->actor_id_bytes, test_state->actor_id_size);
+    *state = test_state;
+    return 0;
+}
+
+static int teardown(void** state) {
+    TestState* test_state = *state;
+    group_teardown((void**)&test_state->group_state);
+    free(test_state->actor_id_bytes);
+    free(test_state);
+    return 0;
+}
+
+static void test_AMputActor(void **state) {
+    TestState* test_state = *state;
+    GroupState* group_state = test_state->group_state;
+    AMresult* res = AMsetActor(
+        group_state->doc,
+        test_state->actor_id_bytes,
+        test_state->actor_id_size
+    );
+    if (AMresultStatus(res) != AM_STATUS_OK) {
+        fail_msg("%s", AMerrorMessage(res));
+    }
+    assert_int_equal(AMresultSize(res), 0);
+    AMvalue value = AMresultValue(res, 0);
+    assert_int_equal(value.tag, AM_VALUE_NOTHING);
+    AMfreeResult(res);
+    res = AMgetActor(group_state->doc);
+    if (AMresultStatus(res) != AM_STATUS_OK) {
+        fail_msg("%s", AMerrorMessage(res));
+    }
+    assert_int_equal(AMresultSize(res), 1);
+    value = AMresultValue(res, 0);
+    assert_int_equal(value.tag, AM_VALUE_ACTOR_ID);
+    assert_int_equal(value.actor_id.count, test_state->actor_id_size);
+    assert_memory_equal(value.actor_id.src, test_state->actor_id_bytes, value.actor_id.count);
+    AMfreeResult(res);
+}
+
+static void test_AMputActorHex(void **state) {
+    TestState* test_state = *state;
+    GroupState* group_state = test_state->group_state;
+    AMresult* res = AMsetActorHex(
+        group_state->doc,
+        test_state->actor_id_str
+    );
+    if (AMresultStatus(res) != AM_STATUS_OK) {
+        fail_msg("%s", AMerrorMessage(res));
+    }
+    assert_int_equal(AMresultSize(res), 0);
+    AMvalue value = AMresultValue(res, 0);
+    assert_int_equal(value.tag, AM_VALUE_NOTHING);
+    AMfreeResult(res);
+    res = AMgetActorHex(group_state->doc);
+    if (AMresultStatus(res) != AM_STATUS_OK) {
+        fail_msg("%s", AMerrorMessage(res));
+    }
+    assert_int_equal(AMresultSize(res), 1);
+    value = AMresultValue(res, 0);
+    assert_int_equal(value.tag, AM_VALUE_STR);
+    assert_int_equal(strlen(value.str), test_state->actor_id_size * 2);
+    assert_string_equal(value.str, test_state->actor_id_str);
+    AMfreeResult(res);
+}
+
+int run_AMdoc_property_tests(void) {
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test_setup_teardown(test_AMputActor, setup, teardown),
+        cmocka_unit_test_setup_teardown(test_AMputActorHex, setup, teardown),
+    };
+
+    return cmocka_run_group_tests(tests, NULL, NULL);
+}

automerge-c/test/amlistput_tests.c

@@ -0,0 +1,235 @@
+#include <float.h>
+#include <limits.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+/* third-party */
+#include <cmocka.h>
+
+/* local */
+#include "group_state.h"
+#include "macro_utils.h"
+
+#define test_AMlistPut(suffix, mode) test_AMlistPut ## suffix ## _ ## mode
+
+#define static_void_test_AMlistPut(suffix, mode, member, scalar_value)        \
+static void test_AMlistPut ## suffix ## _ ## mode(void **state) {             \
+    GroupState* group_state = *state;                                         \
+    AMresult* res = AMlistPut ## suffix(                                      \
+        group_state->doc, AM_ROOT, 0, !strcmp(#mode, "insert"), scalar_value  \
+    );                                                                        \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 0);                                   \
+    AMvalue value = AMresultValue(res, 0);                                    \
+    assert_int_equal(value.tag, AM_VALUE_NOTHING);                            \
+    AMfreeResult(res);                                                        \
+    res = AMlistGet(group_state->doc, AM_ROOT, 0);                            \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 1);                                   \
+    value = AMresultValue(res, 0);                                            \
+    assert_int_equal(value.tag, AMvalue_discriminant(#suffix));               \
+    assert_true(value.member == scalar_value);                                \
+    AMfreeResult(res);                                                        \
+}
+
+#define test_AMlistPutBytes(mode) test_AMlistPutBytes ## _ ## mode
+
+#define static_void_test_AMlistPutBytes(mode, bytes_value)                    \
+static void test_AMlistPutBytes_ ## mode(void **state) {                      \
+    static size_t const BYTES_SIZE = sizeof(bytes_value) / sizeof(uint8_t);   \
+                                                                              \
+    GroupState* group_state = *state;                                         \
+    AMresult* res = AMlistPutBytes(                                           \
+        group_state->doc,                                                     \
+        AM_ROOT,                                                              \
+        0,                                                                    \
+        !strcmp(#mode, "insert"),                                             \
+        bytes_value,                                                          \
+        BYTES_SIZE                                                            \
+    );                                                                        \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 0);                                   \
+    AMvalue value = AMresultValue(res, 0);                                    \
+    assert_int_equal(value.tag, AM_VALUE_NOTHING);                            \
+    AMfreeResult(res);                                                        \
+    res = AMlistGet(group_state->doc, AM_ROOT, 0);                            \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 1);                                   \
+    value = AMresultValue(res, 0);                                            \
+    assert_int_equal(value.tag, AM_VALUE_BYTES);                              \
+    assert_int_equal(value.bytes.count, BYTES_SIZE);                          \
+    assert_memory_equal(value.bytes.src, bytes_value, BYTES_SIZE);            \
+    AMfreeResult(res);                                                        \
+}
+
+#define test_AMlistPutNull(mode) test_AMlistPutNull_ ## mode
+
+#define static_void_test_AMlistPutNull(mode)                                  \
+static void test_AMlistPutNull_ ## mode(void **state) {                       \
+    GroupState* group_state = *state;                                         \
+    AMresult* res = AMlistPutNull(                                            \
+        group_state->doc, AM_ROOT, 0, !strcmp(#mode, "insert"));              \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 0);                                   \
+    AMvalue value = AMresultValue(res, 0);                                    \
+    assert_int_equal(value.tag, AM_VALUE_NOTHING);                            \
+    AMfreeResult(res);                                                        \
+    res = AMlistGet(group_state->doc, AM_ROOT, 0);                            \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 1);                                   \
+    value = AMresultValue(res, 0);                                            \
+    assert_int_equal(value.tag, AM_VALUE_NULL);                               \
+    AMfreeResult(res);                                                        \
+}
+
+#define test_AMlistPutObject(label, mode) test_AMlistPutObject_ ## label ## _ ## mode
+
+#define static_void_test_AMlistPutObject(label, mode)                         \
+static void test_AMlistPutObject_ ## label ## _ ## mode(void **state) {       \
+    GroupState* group_state = *state;                                         \
+    AMresult* res = AMlistPutObject(                                          \
+        group_state->doc,                                                     \
+        AM_ROOT,                                                              \
+        0,                                                                    \
+        !strcmp(#mode, "insert"),                                             \
+        AMobjType_tag(#label)                                                 \
+    );                                                                        \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 1);                                   \
+    AMvalue value = AMresultValue(res, 0);                                    \
+    assert_int_equal(value.tag, AM_VALUE_OBJ_ID);                             \
+    /**                                                                       \
+     * \note The `AMresult` struct can be deallocated immediately when its    \
+     *       value is a pointer to an opaque struct because its lifetime      \
+     *       is tied to the `AMdoc` struct instead.                           \
+     */                                                                       \
+    AMfreeResult(res);                                                        \
+    assert_non_null(value.obj_id);                                            \
+    assert_int_equal(AMobjSize(group_state->doc, value.obj_id), 0);           \
+    AMfreeObjId(group_state->doc, value.obj_id);                              \
+}
+
+#define test_AMlistPutStr(mode) test_AMlistPutStr ## _ ## mode
+
+#define static_void_test_AMlistPutStr(mode, str_value)                        \
+static void test_AMlistPutStr_ ## mode(void **state) {                        \
+    static size_t const STR_LEN = strlen(str_value);                          \
+                                                                              \
+    GroupState* group_state = *state;                                         \
+    AMresult* res = AMlistPutStr(                                             \
+        group_state->doc,                                                     \
+        AM_ROOT,                                                              \
+        0,                                                                    \
+        !strcmp(#mode, "insert"),                                             \
+        str_value                                                             \
+    );                                                                        \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 0);                                   \
+    AMvalue value = AMresultValue(res, 0);                                    \
+    assert_int_equal(value.tag, AM_VALUE_NOTHING);                            \
+    AMfreeResult(res);                                                        \
+    res = AMlistGet(group_state->doc, AM_ROOT, 0);                            \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 1);                                   \
+    value = AMresultValue(res, 0);                                            \
+    assert_int_equal(value.tag, AM_VALUE_STR);                                \
+    assert_int_equal(strlen(value.str), STR_LEN);                             \
+    assert_memory_equal(value.str, str_value, STR_LEN + 1);                   \
+    AMfreeResult(res);                                                        \
+}
+
+static uint8_t const BYTES_VALUE[] = {INT8_MIN, INT8_MAX / 2, INT8_MAX};
+
+static_void_test_AMlistPutBytes(insert, BYTES_VALUE)
+
+static_void_test_AMlistPutBytes(update, BYTES_VALUE)
+
+static_void_test_AMlistPut(Counter, insert, counter, INT64_MAX)
+
+static_void_test_AMlistPut(Counter, update, counter, INT64_MAX)
+
+static_void_test_AMlistPut(F64, insert, f64, DBL_MAX)
+
+static_void_test_AMlistPut(F64, update, f64, DBL_MAX)
+
+static_void_test_AMlistPut(Int, insert, int_, INT64_MAX)
+
+static_void_test_AMlistPut(Int, update, int_, INT64_MAX)
+
+static_void_test_AMlistPutNull(insert)
+
+static_void_test_AMlistPutNull(update)
+
+static_void_test_AMlistPutObject(List, insert)
+
+static_void_test_AMlistPutObject(List, update)
+
+static_void_test_AMlistPutObject(Map, insert)
+
+static_void_test_AMlistPutObject(Map, update)
+
+static_void_test_AMlistPutObject(Text, insert)
+
+static_void_test_AMlistPutObject(Text, update)
+
+static_void_test_AMlistPutStr(insert, "Hello, world!")
+
+static_void_test_AMlistPutStr(update, "Hello, world!")
+
+static_void_test_AMlistPut(Timestamp, insert, timestamp, INT64_MAX)
+
+static_void_test_AMlistPut(Timestamp, update, timestamp, INT64_MAX)
+
+static_void_test_AMlistPut(Uint, insert, uint, UINT64_MAX)
+
+static_void_test_AMlistPut(Uint, update, uint, UINT64_MAX)
+
+int run_AMlistPut_tests(void) {
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test(test_AMlistPutBytes(insert)),
+        cmocka_unit_test(test_AMlistPutBytes(update)),
+        cmocka_unit_test(test_AMlistPut(Counter, insert)),
+        cmocka_unit_test(test_AMlistPut(Counter, update)),
+        cmocka_unit_test(test_AMlistPut(F64, insert)),
+        cmocka_unit_test(test_AMlistPut(F64, update)),
+        cmocka_unit_test(test_AMlistPut(Int, insert)),
+        cmocka_unit_test(test_AMlistPut(Int, update)),
+        cmocka_unit_test(test_AMlistPutNull(insert)),
+        cmocka_unit_test(test_AMlistPutNull(update)),
+        cmocka_unit_test(test_AMlistPutObject(List, insert)),
+        cmocka_unit_test(test_AMlistPutObject(List, update)),
+        cmocka_unit_test(test_AMlistPutObject(Map, insert)),
+        cmocka_unit_test(test_AMlistPutObject(Map, update)),
+        cmocka_unit_test(test_AMlistPutObject(Text, insert)),
+        cmocka_unit_test(test_AMlistPutObject(Text, update)),
+        cmocka_unit_test(test_AMlistPutStr(insert)),
+        cmocka_unit_test(test_AMlistPutStr(update)),
+        cmocka_unit_test(test_AMlistPut(Timestamp, insert)),
+        cmocka_unit_test(test_AMlistPut(Timestamp, update)),
+        cmocka_unit_test(test_AMlistPut(Uint, insert)),
+        cmocka_unit_test(test_AMlistPut(Uint, update)),
+    };
+
+    return cmocka_run_group_tests(tests, group_setup, group_teardown);
+}

automerge-c/test/ammapput_tests.c

@@ -0,0 +1,190 @@
+#include <float.h>
+#include <limits.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+/* third-party */
+#include <cmocka.h>
+
+/* local */
+#include "group_state.h"
+#include "macro_utils.h"
+
+#define test_AMmapPut(suffix) test_AMmapPut ## suffix
+
+#define static_void_test_AMmapPut(suffix, member, scalar_value)               \
+static void test_AMmapPut ## suffix(void **state) {                           \
+    GroupState* group_state = *state;                                         \
+    AMresult* res = AMmapPut ## suffix(                                       \
+        group_state->doc,                                                     \
+        AM_ROOT,                                                              \
+        #suffix,                                                              \
+        scalar_value                                                          \
+    );                                                                        \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 0);                                   \
+    AMvalue value = AMresultValue(res, 0);                                    \
+    assert_int_equal(value.tag, AM_VALUE_NOTHING);                            \
+    AMfreeResult(res);                                                        \
+    res = AMmapGet(group_state->doc, AM_ROOT, #suffix);                       \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 1);                                   \
+    value = AMresultValue(res, 0);                                            \
+    assert_int_equal(value.tag, AMvalue_discriminant(#suffix));               \
+    assert_true(value.member == scalar_value);                                \
+    AMfreeResult(res);                                                        \
+}
+
+#define test_AMmapPutObject(label) test_AMmapPutObject_ ## label
+
+#define static_void_test_AMmapPutObject(label)                                \
+static void test_AMmapPutObject_ ## label(void **state) {                     \
+    GroupState* group_state = *state;                                         \
+    AMresult* res = AMmapPutObject(                                           \
+        group_state->doc,                                                     \
+        AM_ROOT,                                                              \
+        #label,                                                               \
+        AMobjType_tag(#label)                                                 \
+    );                                                                        \
+    if (AMresultStatus(res) != AM_STATUS_OK) {                                \
+        fail_msg("%s", AMerrorMessage(res));                                  \
+    }                                                                         \
+    assert_int_equal(AMresultSize(res), 1);                                   \
+    AMvalue value = AMresultValue(res, 0);                                    \
+    assert_int_equal(value.tag, AM_VALUE_OBJ_ID);                             \
+    /**                                                                       \
+     * \note The `AMresult` struct can be deallocated immediately when its    \
+     *       value is a pointer to an opaque struct because its lifetime      \
+     *       is tied to the `AMdoc` struct instead.                           \
+     */                                                                       \
+    AMfreeResult(res);                                                        \
+    assert_non_null(value.obj_id);                                            \
+    assert_int_equal(AMobjSize(group_state->doc, value.obj_id), 0);           \
+    AMfreeObjId(group_state->doc, value.obj_id);                                                             \
+}
+
+static void test_AMmapPutBytes(void **state) {
+    static char const* const KEY = "Bytes";
+    static uint8_t const BYTES_VALUE[] = {INT8_MIN, INT8_MAX / 2, INT8_MAX};
+    static size_t const BYTES_SIZE = sizeof(BYTES_VALUE) / sizeof(uint8_t);
+
+    GroupState* group_state = *state;
+    AMresult* res = AMmapPutBytes(
+        group_state->doc,
+        AM_ROOT,
+        KEY,
+        BYTES_VALUE,
+        BYTES_SIZE
+    );
+    if (AMresultStatus(res) != AM_STATUS_OK) {
+        fail_msg("%s", AMerrorMessage(res));
+    }
+    assert_int_equal(AMresultSize(res), 0);
+    AMvalue value = AMresultValue(res, 0);
+    assert_int_equal(value.tag, AM_VALUE_NOTHING);
+    AMfreeResult(res);
+    res = AMmapGet(group_state->doc, AM_ROOT, KEY);
+    if (AMresultStatus(res) != AM_STATUS_OK) {
+        fail_msg("%s", AMerrorMessage(res));
+    }
+    assert_int_equal(AMresultSize(res), 1);
+    value = AMresultValue(res, 0);
+    assert_int_equal(value.tag, AM_VALUE_BYTES);
+    assert_int_equal(value.bytes.count, BYTES_SIZE);
+    assert_memory_equal(value.bytes.src, BYTES_VALUE, BYTES_SIZE);
+    AMfreeResult(res);
+}
+
+static_void_test_AMmapPut(Counter, counter, INT64_MAX)
+
+static_void_test_AMmapPut(F64, f64, DBL_MAX)
+
+static_void_test_AMmapPut(Int, int_, INT64_MAX)
+
+static void test_AMmapPutNull(void **state) {
+    static char const* const KEY = "Null";
+
+    GroupState* group_state = *state;
+    AMresult* res = AMmapPutNull(group_state->doc, AM_ROOT, KEY);
+    if (AMresultStatus(res) != AM_STATUS_OK) {
+        fail_msg("%s", AMerrorMessage(res));
+    }
+    assert_int_equal(AMresultSize(res), 0);
+    AMvalue value = AMresultValue(res, 0);
+    assert_int_equal(value.tag, AM_VALUE_NOTHING);
+    AMfreeResult(res);
+    res = AMmapGet(group_state->doc, AM_ROOT, KEY);
+    if (AMresultStatus(res) != AM_STATUS_OK) {
+        fail_msg("%s", AMerrorMessage(res));
+    }
+    assert_int_equal(AMresultSize(res), 1);
+    value = AMresultValue(res, 0);
+    assert_int_equal(value.tag, AM_VALUE_NULL);
+    AMfreeResult(res);
+}
+
+static_void_test_AMmapPutObject(List)
+
+static_void_test_AMmapPutObject(Map)
+
+static_void_test_AMmapPutObject(Text)
+
+static void test_AMmapPutStr(void **state) {
+    static char const* const KEY = "Str";
+    static char const* const STR_VALUE = "Hello, world!";
+    size_t const STR_LEN = strlen(STR_VALUE);
+
+    GroupState* group_state = *state;
+    AMresult* res = AMmapPutStr(
+        group_state->doc,
+        AM_ROOT,
+        KEY,
+        STR_VALUE
+    );
+    if (AMresultStatus(res) != AM_STATUS_OK) {
+        fail_msg("%s", AMerrorMessage(res));
+    }
+    assert_int_equal(AMresultSize(res), 0);
+    AMvalue value = AMresultValue(res, 0);
+    assert_int_equal(value.tag, AM_VALUE_NOTHING);
+    AMfreeResult(res);
+    res = AMmapGet(group_state->doc, AM_ROOT, KEY);
+    if (AMresultStatus(res) != AM_STATUS_OK) {
+        fail_msg("%s", AMerrorMessage(res));
+    }
+    assert_int_equal(AMresultSize(res), 1);
+    value = AMresultValue(res, 0);
+    assert_int_equal(value.tag, AM_VALUE_STR);
+    assert_int_equal(strlen(value.str), STR_LEN);
+    assert_memory_equal(value.str, STR_VALUE, STR_LEN + 1);
+    AMfreeResult(res);
+}
+
+static_void_test_AMmapPut(Timestamp, timestamp, INT64_MAX)
+
+static_void_test_AMmapPut(Uint, uint, UINT64_MAX)
+
+int run_AMmapPut_tests(void) {
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test(test_AMmapPutBytes),
+        cmocka_unit_test(test_AMmapPut(Counter)),
+        cmocka_unit_test(test_AMmapPut(F64)),
+        cmocka_unit_test(test_AMmapPut(Int)),
+        cmocka_unit_test(test_AMmapPutNull),
+        cmocka_unit_test(test_AMmapPutObject(List)),
+        cmocka_unit_test(test_AMmapPutObject(Map)),
+        cmocka_unit_test(test_AMmapPutObject(Text)),
+        cmocka_unit_test(test_AMmapPutStr),
+        cmocka_unit_test(test_AMmapPut(Timestamp)),
+        cmocka_unit_test(test_AMmapPut(Uint)),
+    };
+
+    return cmocka_run_group_tests(tests, group_setup, group_teardown);
+}

automerge-c/test/group_state.c

@@ -0,0 +1,18 @@
+#include <stdlib.h>
+
+/* local */
+#include "group_state.h"
+
+int group_setup(void** state) {
+    GroupState* group_state = calloc(1, sizeof(GroupState));
+    group_state->doc = AMallocDoc();
+    *state = group_state;
+    return 0;
+}
+
+int group_teardown(void** state) {
+    GroupState* group_state = *state;
+    AMfreeDoc(group_state->doc);
+    free(group_state);
+    return 0;
+}

automerge-c/test/group_state.h

@@ -0,0 +1,15 @@
+#ifndef GROUP_STATE_INCLUDED
+#define GROUP_STATE_INCLUDED
+
+/* local */
+#include "automerge.h"
+
+typedef struct {
+    AMdoc* doc;
+} GroupState;
+
+int group_setup(void** state);
+
+int group_teardown(void** state);
+
+#endif

automerge-c/test/macro_utils.c

@@ -0,0 +1,23 @@
+#include <string.h>
+
+/* local */
+#include "macro_utils.h"
+
+AMvalueVariant AMvalue_discriminant(char const* suffix) {
+    if (!strcmp(suffix, "Bytes"))          return AM_VALUE_BYTES;
+    else if (!strcmp(suffix, "Counter"))   return AM_VALUE_COUNTER;
+    else if (!strcmp(suffix, "F64"))       return AM_VALUE_F64;
+    else if (!strcmp(suffix, "Int"))       return AM_VALUE_INT;
+    else if (!strcmp(suffix, "Null"))      return AM_VALUE_NULL;
+    else if (!strcmp(suffix, "Str"))       return AM_VALUE_STR;
+    else if (!strcmp(suffix, "Timestamp")) return AM_VALUE_TIMESTAMP;
+    else if (!strcmp(suffix, "Uint"))      return AM_VALUE_UINT;
+    else return AM_VALUE_NOTHING;
+}
+
+AMobjType AMobjType_tag(char const* obj_type_label) {
+    if (!strcmp(obj_type_label, "List"))      return AM_OBJ_TYPE_LIST;
+    else if (!strcmp(obj_type_label, "Map"))  return AM_OBJ_TYPE_MAP;
+    else if (!strcmp(obj_type_label, "Text")) return AM_OBJ_TYPE_TEXT;
+    else return 0;
+}

automerge-c/test/macro_utils.h

@@ -0,0 +1,23 @@
+#ifndef MACRO_UTILS_INCLUDED
+#define MACRO_UTILS_INCLUDED
+
+/* local */
+#include "automerge.h"
+
+/**
+ * \brief Gets the `AMvalue` discriminant corresponding to a function name suffix.
+ *
+ * \param[in] suffix A string.
+ * \return An `AMvalue` variant discriminant enum tag.
+ */
+AMvalueVariant AMvalue_discriminant(char const* suffix);
+
+/**
+ * \brief Gets the `AMobjType` tag corresponding to a object type label.
+ *
+ * \param[in] obj_type_label A string.
+ * \return An `AMobjType` enum tag.
+ */
+AMobjType AMobjType_tag(char const* obj_type_label);
+
+#endif

automerge-c/test/main.c

@@ -0,0 +1,21 @@
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <stdint.h>
+
+/* third-party */
+#include <cmocka.h>
+
+extern int run_AMdoc_property_tests(void);
+
+extern int run_AMlistPut_tests(void);
+
+extern int run_AMmapPut_tests(void);
+
+int main(void) {
+    return (
+        run_AMdoc_property_tests() +
+        run_AMlistPut_tests() +
+        run_AMmapPut_tests()
+    );
+}

automerge-cli/Cargo.lock

@@ -0,0 +1,857 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "ansi_term"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "159bb86af3a200e19a068f4224eae4c8bb2d0fa054c7e5d1cacd5cef95e684cd"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "automerge"
+version = "0.1.0"
+dependencies = [
+ "flate2",
+ "fxhash",
+ "hex",
+ "itertools",
+ "js-sys",
+ "leb128",
+ "nonzero_ext",
+ "rand",
+ "serde",
+ "sha2",
+ "smol_str",
+ "thiserror",
+ "tinyvec",
+ "tracing",
+ "unicode-segmentation",
+ "uuid",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "automerge-cli"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "atty",
+ "automerge",
+ "clap",
+ "colored_json",
+ "combine",
+ "duct",
+ "maplit",
+ "serde_json",
+ "thiserror",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf7fe51849ea569fd452f37822f606a5cabb684dc918707a0193fd4664ff324"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a45a46ab1f2412e53d3a0ade76ffad2025804294569aae387231a0cd6e0899"
+
+[[package]]
+name = "byteorder"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+
+[[package]]
+name = "bytes"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clap"
+version = "3.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced1892c55c910c1219e98d6fc8d71f6bddba7905866ce740066d8bfea859312"
+dependencies = [
+ "atty",
+ "bitflags",
+ "clap_derive",
+ "indexmap",
+ "lazy_static",
+ "os_str_bytes",
+ "strsim",
+ "termcolor",
+ "textwrap",
+]
+
+[[package]]
+name = "clap_derive"
+version = "3.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da95d038ede1a964ce99f49cbe27a7fb538d1da595e4b4f70b8c8f338d17bf16"
+dependencies = [
+ "heck",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "colored_json"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd32eb54d016e203b7c2600e3a7802c75843a92e38ccc4869aefeca21771a64"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "libc",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "combine"
+version = "4.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50b727aacc797f9fc28e355d21f34709ac4fc9adecfe470ad07b8f4464f53062"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2fb860ca6fafa5552fb6d0e816a69c8e49f0908bf524e30a90d97c85892d506"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "duct"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fc6a0a59ed0888e0041cf708e66357b7ae1a82f1c67247e1f93b5e0818f7d8d"
+dependencies = [
+ "libc",
+ "once_cell",
+ "os_pipe",
+ "shared_child",
+]
+
+[[package]]
+name = "either"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
+[[package]]
+name = "flate2"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6988e897c1c9c485f43b47a529cef42fde0547f9d8d41a7062518f1d8fc53f"
+dependencies = [
+ "cfg-if",
+ "crc32fast",
+ "libc",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd48d33ec7f05fbfa152300fdad764757cbded343c1aa1cff2fbaf4134851803"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
+[[package]]
+name = "heck"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "indexmap"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+
+[[package]]
+name = "js-sys"
+version = "0.3.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a38fc24e30fd564ce974c02bf1d337caddff65be6cc4735a1f7eab22a7440f04"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "leb128"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
+
+[[package]]
+name = "libc"
+version = "0.2.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "maplit"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
+dependencies = [
+ "adler",
+ "autocfg",
+]
+
+[[package]]
+name = "nonzero_ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44a1290799eababa63ea60af0cbc3f03363e328e58f32fb0294798ed3e85f444"
+
+[[package]]
+name = "once_cell"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+
+[[package]]
+name = "os_pipe"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb233f06c2307e1f5ce2ecad9f8121cffbbee2c95428f44ea85222e460d0d213"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "os_str_bytes"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"
+
+[[package]]
+name = "serde"
+version = "1.0.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e8d9fa5c3b304765ce1fd9c4c8a3de2c8db365a5b91be52f186efc675681d95"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55deaec60f81eefe3cce0dc50bda92d6d8e88f2a27df7c5033b42afeb1ed2676"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shared_child"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6be9f7d5565b1483af3e72975e2dee33879b3b86bd48c0929fccf6585d79e65a"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
+
+[[package]]
+name = "smol_str"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61d15c83e300cce35b7c8cd39ff567c1ef42dde6d4a1a38dbdbf9a59902261bd"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "syn"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+
+[[package]]
+name = "thiserror"
+version = "1.0.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "854babe52e4df1653706b98fcfc05843010039b406875930a70e4d9644e5c417"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa32fd3f627f367fe16f893e2597ae3c05020f8bba2666a4e6ea73d377e5714b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+
+[[package]]
+name = "tracing"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6c650a8ef0cd2dd93736f033d21cbd1224c5a967aa0c258d00fcf7dafef9b9f"
+dependencies = [
+ "cfg-if",
+ "log",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8276d9a4a3a558d7b7ad5303ad50b53d58264641b82914b7ada36bd762e7a716"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03cfcb51380632a72d3111cb8d3447a8d908e577d31beeac006f836383d29a23"
+dependencies = [
+ "lazy_static",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6923477a48e41c1951f1999ef8bb5a3023eb723ceadafe78ffb65dc366761e3"
+dependencies = [
+ "lazy_static",
+ "log",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e0ab7bdc962035a87fba73f3acca9b8a8d0034c2e6f60b84aeaaddddc155dce"
+dependencies = [
+ "ansi_term",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing-core",
+ "tracing-log",
+]
+
+[[package]]
+name = "typenum"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e8820f5d777f6224dc4be3632222971ac30164d4a258d595640799554ebfd99"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "uuid"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"
+dependencies = [
+ "getrandom",
+ "serde",
+]
+
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25f1af7423d8588a3d840681122e72e6a24ddbcb3f0ec385cac0d12d24256c06"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b21c0df030f5a177f3cba22e9bc4322695ec43e7257d865302900290bcdedca"
+dependencies = [
+ "bumpalo",
+ "lazy_static",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4203d69e40a52ee523b2529a773d5ffc1dc0071801c87b3d270b471b80ed01"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa8a30d46208db204854cadbb5d4baf5fcf8071ba5bf48190c3e59937962ebc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d958d035c4438e28c70e4321a2911302f10135ce78a9c7834c0cab4123d06a2"
+
+[[package]]
+name = "web-sys"
+version = "0.3.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c060b319f29dd25724f09a2ba1418f142f539b2be99fbf4d2d5a8f7330afb8eb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

automerge-cli/Cargo.toml

@@ -4,7 +4,6 @@ version = "0.1.0"
 authors = ["Alex Good <alex@memoryandthought.me>"]
 edition = "2018"
 license = "MIT"
-rust-version = "1.57.0"
 
 [[bin]]
 name = "automerge"
@@ -13,18 +12,17 @@ bench = false
 doc = false
 
 [dependencies]
-clap = {version = "~4", features = ["derive"]}
+clap = {version = "~3.1", features = ["derive"]}
 serde_json = "^1.0"
 anyhow = "1.0"
+atty = "^0.2"
 thiserror = "^1.0"
 combine = "^4.5"
 maplit = "^1.0"
+colored_json = "^2.1"
 tracing-subscriber = "~0.3"
 
 automerge = { path = "../automerge" }
-is-terminal = "0.4.1"
-termcolor = "1.1.3"
-serde = "1.0.150"
 
 [dev-dependencies]
 duct = "^0.13"

automerge-cli/src/examine.rs

@@ -1,8 +1,6 @@
 use automerge as am;
 use thiserror::Error;
 
-use crate::{color_json::print_colored_json, SkipVerifyFlag};
-
 #[derive(Error, Debug)]
 pub enum ExamineError {
     #[error("Error reading change file: {:?}", source)]
@@ -22,28 +20,21 @@ pub enum ExamineError {
     },
 }
 
-pub(crate) fn examine(
+pub fn examine(
     mut input: impl std::io::Read,
     mut output: impl std::io::Write,
-    skip: SkipVerifyFlag,
     is_tty: bool,
 ) -> Result<(), ExamineError> {
     let mut buf: Vec<u8> = Vec::new();
     input
         .read_to_end(&mut buf)
         .map_err(|e| ExamineError::ReadingChanges { source: e })?;
-    let doc = skip
+    let doc = am::Automerge::load(&buf)
-        .load(&buf)
         .map_err(|e| ExamineError::ApplyingInitialChanges { source: e })?;
-    let uncompressed_changes: Vec<_> = doc
+    let uncompressed_changes: Vec<_> = doc.get_changes(&[]).iter().map(|c| c.decode()).collect();
-        .get_changes(&[])
-        .unwrap()
-        .iter()
-        .map(|c| c.decode())
-        .collect();
     if is_tty {
         let json_changes = serde_json::to_value(uncompressed_changes).unwrap();
-        print_colored_json(&json_changes).unwrap();
+        colored_json::write_colored_json(&json_changes, &mut output).unwrap();
         writeln!(output).unwrap();
     } else {
         let json_changes = serde_json::to_string_pretty(&uncompressed_changes).unwrap();

automerge-cli/src/export.rs

@@ -1,8 +1,5 @@
 use anyhow::Result;
 use automerge as am;
-use automerge::ReadDoc;
-
-use crate::{color_json::print_colored_json, SkipVerifyFlag};
 
 pub(crate) fn map_to_json(doc: &am::Automerge, obj: &am::ObjId) -> serde_json::Value {
     let keys = doc.keys(obj);
@@ -31,7 +28,7 @@ fn list_to_json(doc: &am::Automerge, obj: &am::ObjId) -> serde_json::Value {
     let len = doc.length(obj);
     let mut array = Vec::new();
     for i in 0..len {
-        let val = doc.get(obj, i);
+        let val = doc.get(obj, i as usize);
         match val {
             Ok(Some((am::Value::Object(o), exid)))
                 if o == am::ObjType::Map || o == am::ObjType::Table =>
@@ -53,13 +50,11 @@ fn list_to_json(doc: &am::Automerge, obj: &am::ObjId) -> serde_json::Value {
 fn scalar_to_json(val: &am::ScalarValue) -> serde_json::Value {
     match val {
         am::ScalarValue::Str(s) => serde_json::Value::String(s.to_string()),
-        am::ScalarValue::Bytes(b) | am::ScalarValue::Unknown { bytes: b, .. } => {
+        am::ScalarValue::Bytes(b) => serde_json::Value::Array(
-            serde_json::Value::Array(
             b.iter()
                 .map(|byte| serde_json::Value::Number((*byte).into()))
                 .collect(),
-            )
+        ),
-        }
         am::ScalarValue::Int(n) => serde_json::Value::Number((*n).into()),
         am::ScalarValue::Uint(n) => serde_json::Value::Number((*n).into()),
         am::ScalarValue::F64(n) => serde_json::Number::from_f64(*n)
@@ -72,23 +67,22 @@ fn scalar_to_json(val: &am::ScalarValue) -> serde_json::Value {
     }
 }
 
-fn get_state_json(input_data: Vec<u8>, skip: SkipVerifyFlag) -> Result<serde_json::Value> {
+fn get_state_json(input_data: Vec<u8>) -> Result<serde_json::Value> {
-    let doc = skip.load(&input_data).unwrap(); // FIXME
+    let doc = am::Automerge::load(&input_data).unwrap(); // FIXME
     Ok(map_to_json(&doc, &am::ObjId::Root))
 }
 
-pub(crate) fn export_json(
+pub fn export_json(
     mut changes_reader: impl std::io::Read,
     mut writer: impl std::io::Write,
-    skip: SkipVerifyFlag,
     is_tty: bool,
 ) -> Result<()> {
     let mut input_data = vec![];
     changes_reader.read_to_end(&mut input_data)?;
 
-    let state_json = get_state_json(input_data, skip)?;
+    let state_json = get_state_json(input_data)?;
     if is_tty {
-        print_colored_json(&state_json).unwrap();
+        colored_json::write_colored_json(&state_json, &mut writer).unwrap();
         writeln!(writer).unwrap();
     } else {
         writeln!(
@@ -107,10 +101,7 @@ mod tests {
 
     #[test]
     fn cli_export_with_empty_input() {
-        assert_eq!(
+        assert_eq!(get_state_json(vec![]).unwrap(), serde_json::json!({}))
-            get_state_json(vec![], Default::default()).unwrap(),
-            serde_json::json!({})
-        )
     }
 
     #[test]
@@ -124,7 +115,7 @@ mod tests {
         let mut backend = initialize_from_json(&initial_state_json).unwrap();
         let change_bytes = backend.save();
         assert_eq!(
-            get_state_json(change_bytes, Default::default()).unwrap(),
+            get_state_json(change_bytes).unwrap(),
             serde_json::json!({"sparrows": 15.0})
         )
     }
@@ -151,7 +142,7 @@ mod tests {
         */
         let change_bytes = backend.save();
         assert_eq!(
-            get_state_json(change_bytes, Default::default()).unwrap(),
+            get_state_json(change_bytes).unwrap(),
             serde_json::json!({
                 "birds": {
                     "wrens": 3.0,

automerge-cli/src/main.rs

@@ -1,15 +1,10 @@
 use std::{fs::File, path::PathBuf, str::FromStr};
 
 use anyhow::{anyhow, Result};
-use clap::{
+use clap::Parser;
-    builder::{BoolishValueParser, TypedValueParser, ValueParserFactory},
-    Parser,
-};
-use is_terminal::IsTerminal;
 
-mod color_json;
+//mod change;
 mod examine;
-mod examine_sync;
 mod export;
 mod import;
 mod merge;
@@ -21,50 +16,12 @@ struct Opts {
     cmd: Command,
 }
 
-#[derive(clap::ValueEnum, Clone, Debug)]
+#[derive(Debug)]
 enum ExportFormat {
     Json,
     Toml,
 }
 
-#[derive(Copy, Clone, Default, Debug)]
-pub(crate) struct SkipVerifyFlag(bool);
-
-impl SkipVerifyFlag {
-    fn load(&self, buf: &[u8]) -> Result<automerge::Automerge, automerge::AutomergeError> {
-        if self.0 {
-            automerge::Automerge::load(buf)
-        } else {
-            automerge::Automerge::load_unverified_heads(buf)
-        }
-    }
-}
-
-#[derive(Clone)]
-struct SkipVerifyFlagParser;
-impl ValueParserFactory for SkipVerifyFlag {
-    type Parser = SkipVerifyFlagParser;
-
-    fn value_parser() -> Self::Parser {
-        SkipVerifyFlagParser
-    }
-}
-
-impl TypedValueParser for SkipVerifyFlagParser {
-    type Value = SkipVerifyFlag;
-
-    fn parse_ref(
-        &self,
-        cmd: &clap::Command,
-        arg: Option<&clap::Arg>,
-        value: &std::ffi::OsStr,
-    ) -> Result<Self::Value, clap::Error> {
-        BoolishValueParser::new()
-            .parse_ref(cmd, arg, value)
-            .map(SkipVerifyFlag)
-    }
-}
-
 impl FromStr for ExportFormat {
     type Err = anyhow::Error;
 
@@ -86,15 +43,12 @@ enum Command {
         format: ExportFormat,
 
         /// Path that contains Automerge changes
+        #[clap(parse(from_os_str))]
         changes_file: Option<PathBuf>,
 
         /// The file to write to. If omitted assumes stdout
-        #[clap(long("out"), short('o'))]
+        #[clap(parse(from_os_str), long("out"), short('o'))]
         output_file: Option<PathBuf>,
-
-        /// Whether to verify the head hashes of a compressed document
-        #[clap(long, action = clap::ArgAction::SetFalse)]
-        skip_verifying_heads: SkipVerifyFlag,
     },
 
     Import {
@@ -102,37 +56,69 @@ enum Command {
         #[clap(long, short, default_value = "json")]
         format: ExportFormat,
 
+        #[clap(parse(from_os_str))]
         input_file: Option<PathBuf>,
 
         /// Path to write Automerge changes to
-        #[clap(long("out"), short('o'))]
+        #[clap(parse(from_os_str), long("out"), short('o'))]
         changes_file: Option<PathBuf>,
     },
 
-    /// Read an automerge document and print a JSON representation of the changes in it to stdout
+    /// Read an automerge document from a file or stdin, perform a change on it and write a new
-    Examine {
+    /// document to stdout or the specified output file.
+    Change {
+        /// The change script to perform. Change scripts have the form <command> <path> [<JSON value>].
+        /// The possible commands are 'set', 'insert', 'delete', and 'increment'.
+        ///
+        /// Paths look like this: $["mapkey"][0]. They always lways start with a '$', then each
+        /// subsequent segment of the path is either a string in double quotes to index a key in a
+        /// map, or an integer index to address an array element.
+        ///
+        /// Examples
+        ///
+        /// ## set
+        ///
+        /// > automerge change 'set $["someobject"] {"items": []}' somefile
+        ///
+        /// ## insert
+        ///
+        /// > automerge change 'insert $["someobject"]["items"][0] "item1"' somefile
+        ///
+        /// ## increment
+        ///
+        /// > automerge change 'increment $["mycounter"]'
+        ///
+        /// ## delete
+        ///
+        /// > automerge change 'delete $["someobject"]["items"]' somefile
+        script: String,
+
+        /// The file to change, if omitted will assume stdin
+        #[clap(parse(from_os_str))]
         input_file: Option<PathBuf>,
-        skip_verifying_heads: SkipVerifyFlag,
+
+        /// Path to write Automerge changes to, if omitted will write to stdout
+        #[clap(parse(from_os_str), long("out"), short('o'))]
+        output_file: Option<PathBuf>,
     },
 
-    /// Read an automerge sync messaage and print a JSON representation of it
+    /// Read an automerge document and print a JSON representation of the changes in it to stdout
-    ExamineSync { input_file: Option<PathBuf> },
+    Examine { input_file: Option<PathBuf> },
 
     /// Read one or more automerge documents and output a merged, compacted version of them
     Merge {
         /// The file to write to. If omitted assumes stdout
-        #[clap(long("out"), short('o'))]
+        #[clap(parse(from_os_str), long("out"), short('o'))]
         output_file: Option<PathBuf>,
-
         /// The file(s) to compact. If empty assumes stdin
         input: Vec<PathBuf>,
     },
 }
 
 fn open_file_or_stdin(maybe_path: Option<PathBuf>) -> Result<Box<dyn std::io::Read>> {
-    if std::io::stdin().is_terminal() {
+    if atty::is(atty::Stream::Stdin) {
         if let Some(path) = maybe_path {
-            Ok(Box::new(File::open(path).unwrap()))
+            Ok(Box::new(File::open(&path).unwrap()))
         } else {
             Err(anyhow!(
                 "Must provide file path if not providing input via stdin"
@@ -144,9 +130,9 @@ fn open_file_or_stdin(maybe_path: Option<PathBuf>) -> Result<Box<dyn std::io::Re
 }
 
 fn create_file_or_stdout(maybe_path: Option<PathBuf>) -> Result<Box<dyn std::io::Write>> {
-    if std::io::stdout().is_terminal() {
+    if atty::is(atty::Stream::Stdout) {
         if let Some(path) = maybe_path {
-            Ok(Box::new(File::create(path).unwrap()))
+            Ok(Box::new(File::create(&path).unwrap()))
         } else {
             Err(anyhow!("Must provide file path if not piping to stdout"))
         }
@@ -163,22 +149,16 @@ fn main() -> Result<()> {
             changes_file,
             format,
             output_file,
-            skip_verifying_heads,
         } => {
             let output: Box<dyn std::io::Write> = if let Some(output_file) = output_file {
-                Box::new(File::create(output_file)?)
+                Box::new(File::create(&output_file)?)
             } else {
                 Box::new(std::io::stdout())
             };
             match format {
                 ExportFormat::Json => {
                     let mut in_buffer = open_file_or_stdin(changes_file)?;
-                    export::export_json(
+                    export::export_json(&mut in_buffer, output, atty::is(atty::Stream::Stdout))
-                        &mut in_buffer,
-                        output,
-                        skip_verifying_heads,
-                        std::io::stdout().is_terminal(),
-                    )
                 }
                 ExportFormat::Toml => unimplemented!(),
             }
@@ -195,30 +175,23 @@ fn main() -> Result<()> {
             }
             ExportFormat::Toml => unimplemented!(),
         },
-        Command::Examine {
+        Command::Change { ..
-            input_file,
+            //input_file,
-            skip_verifying_heads,
+            //output_file,
+            //script,
         } => {
+            unimplemented!()
+/*
+            let in_buffer = open_file_or_stdin(input_file)?;
+            let mut out_buffer = create_file_or_stdout(output_file)?;
+                        change::change(in_buffer, &mut out_buffer, script.as_str())
+                            .map_err(|e| anyhow::format_err!("Unable to make changes: {:?}", e))
+*/
+        }
+        Command::Examine { input_file } => {
             let in_buffer = open_file_or_stdin(input_file)?;
             let out_buffer = std::io::stdout();
-            match examine::examine(
+            match examine::examine(in_buffer, out_buffer, atty::is(atty::Stream::Stdout)) {
-                in_buffer,
-                out_buffer,
-                skip_verifying_heads,
-                std::io::stdout().is_terminal(),
-            ) {
-                Ok(()) => {}
-                Err(e) => {
-                    eprintln!("Error: {:?}", e);
-                }
-            }
-            Ok(())
-        }
-        Command::ExamineSync { input_file } => {
-            let in_buffer = open_file_or_stdin(input_file)?;
-            let out_buffer = std::io::stdout();
-            match examine_sync::examine_sync(in_buffer, out_buffer, std::io::stdout().is_terminal())
-            {
                 Ok(()) => {}
                 Err(e) => {
                     eprintln!("Error: {:?}", e);

automerge-js/.gitignore

@@ -0,0 +1,2 @@
+/node_modules
+/yarn.lock

automerge-js/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "automerge-js",
+  "version": "0.1.0",
+  "main": "src/index.js",
+  "license": "MIT",
+  "scripts": {
+    "test": "mocha --bail --full-trace"
+  },
+  "devDependencies": {
+    "mocha": "^9.1.1"
+  },
+  "dependencies": {
+    "automerge-wasm": "file:../automerge-wasm",
+    "fast-sha256": "^1.3.0",
+    "pako": "^2.0.4",
+    "uuid": "^8.3"
+  }
+}

automerge-js/src/constants.js

@@ -0,0 +1,18 @@
+// Properties of the document root object
+//const OPTIONS   = Symbol('_options')   // object containing options passed to init()
+//const CACHE     = Symbol('_cache')     // map from objectId to immutable object
+const STATE      = Symbol('_state')     // object containing metadata about current state (e.g. sequence numbers)
+const HEADS      = Symbol('_heads')     // object containing metadata about current state (e.g. sequence numbers)
+const OBJECT_ID  = Symbol('_objectId')     // object containing metadata about current state (e.g. sequence numbers)
+const READ_ONLY  = Symbol('_readOnly')     // object containing metadata about current state (e.g. sequence numbers)
+const FROZEN     = Symbol('_frozen')     // object containing metadata about current state (e.g. sequence numbers)
+
+// Properties of all Automerge objects
+//const OBJECT_ID = Symbol('_objectId')  // the object ID of the current object (string)
+//const CONFLICTS = Symbol('_conflicts') // map or list (depending on object type) of conflicts
+//const CHANGE    = Symbol('_change')    // the context object on proxy objects used in change callback
+//const ELEM_IDS  = Symbol('_elemIds')   // list containing the element ID of each list element
+
+module.exports = {
+  STATE, HEADS, OBJECT_ID, READ_ONLY, FROZEN
+}

automerge-js/src/counter.js

@@ -1,16 +1,12 @@
-import { Automerge, type ObjID, type Prop } from "@automerge/automerge-wasm"
-import { COUNTER } from "./constants"
 /**
  * The most basic CRDT: an integer value that can be changed only by
  * incrementing and decrementing. Since addition of integers is commutative,
  * the value trivially converges.
  */
-export class Counter {
+class Counter {
-  value: number
+  constructor(value) {
-
-  constructor(value?: number) {
     this.value = value || 0
-    Reflect.defineProperty(this, COUNTER, { value: true })
+    Object.freeze(this)
   }
 
   /**
@@ -21,7 +17,7 @@ export class Counter {
    * concatenating it with another string, as in `x + ''`.
    * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf
    */
-  valueOf(): number {
+  valueOf() {
     return this.value
   }
 
@@ -30,7 +26,7 @@ export class Counter {
    * this method is called e.g. when you do `['value: ', x].join('')` or when
    * you use string interpolation: `value: ${x}`.
    */
-  toString(): string {
+  toString() {
     return this.valueOf().toString()
   }
 
@@ -38,7 +34,7 @@ export class Counter {
    * Returns the counter value, so that a JSON serialization of an Automerge
    * document represents the counter simply as an integer.
    */
-  toJSON(): number {
+  toJSON() {
     return this.value
   }
 }
@@ -48,31 +44,12 @@ export class Counter {
  * callback.
  */
 class WriteableCounter extends Counter {
-  context: Automerge
-  path: Prop[]
-  objectId: ObjID
-  key: Prop
-
-  constructor(
-    value: number,
-    context: Automerge,
-    path: Prop[],
-    objectId: ObjID,
-    key: Prop
-  ) {
-    super(value)
-    this.context = context
-    this.path = path
-    this.objectId = objectId
-    this.key = key
-  }
-
   /**
    * Increases the value of the counter by `delta`. If `delta` is not given,
    * increases the value of the counter by 1.
    */
-  increment(delta: number): number {
+  increment(delta) {
-    delta = typeof delta === "number" ? delta : 1
+    delta = typeof delta === 'number' ? delta : 1
     this.context.increment(this.objectId, this.key, delta)
     this.value += delta
     return this.value
@@ -82,8 +59,8 @@ class WriteableCounter extends Counter {
    * Decreases the value of the counter by `delta`. If `delta` is not given,
    * decreases the value of the counter by 1.
    */
-  decrement(delta: number): number {
+  decrement(delta) {
-    return this.increment(typeof delta === "number" ? -delta : -1)
+    return this.increment(typeof delta === 'number' ? -delta : -1)
   }
 }
 
@@ -94,14 +71,14 @@ class WriteableCounter extends Counter {
  * the property name (key in map, or index in list) where the counter is
  * located.
 */
-export function getWriteableCounter(
+function getWriteableCounter(value, context, path, objectId, key) {
-  value: number,
+  const instance = Object.create(WriteableCounter.prototype)
-  context: Automerge,
+  instance.value = value
-  path: Prop[],
+  instance.context = context
-  objectId: ObjID,
+  instance.path = path
-  key: Prop
+  instance.objectId = objectId
-): WriteableCounter {
+  instance.key = key
-  return new WriteableCounter(value, context, path, objectId, key)
+  return instance
 }
 
-//module.exports = { Counter, getWriteableCounter }
+module.exports = { Counter, getWriteableCounter }

automerge-js/src/index.js

@@ -0,0 +1,372 @@
+const AutomergeWASM = require("automerge-wasm")
+const uuid = require('./uuid')
+
+let { rootProxy, listProxy, textProxy, mapProxy } = require("./proxies")
+let { Counter  } = require("./counter")
+let { Text } = require("./text")
+let { Int, Uint, Float64  } = require("./numbers")
+let { STATE, HEADS, OBJECT_ID, READ_ONLY, FROZEN  } = require("./constants")
+
+function init(actor) {
+  if (typeof actor != 'string') {
+    actor = null
+  }
+  const state = AutomergeWASM.create(actor)
+  return rootProxy(state, true);
+}
+
+function clone(doc) {
+  const state = doc[STATE].clone()
+  return rootProxy(state, true);
+}
+
+function free(doc) {
+  return doc[STATE].free()
+}
+
+function from(data, actor) {
+    let doc1 = init(actor)
+    let doc2 = change(doc1, (d) => Object.assign(d, data))
+    return doc2
+}
+
+function change(doc, options, callback) {
+  if (callback === undefined) {
+    // FIXME implement options
+    callback = options
+    options = {}
+  }
+  if (typeof options === "string") {
+    options = { message: options }
+  }
+  if (doc === undefined || doc[STATE] === undefined || doc[OBJECT_ID] !== "_root") {
+    throw new RangeError("must be the document root");
+  }
+  if (doc[FROZEN] === true) {
+    throw new RangeError("Attempting to use an outdated Automerge document")
+  }
+  if (!!doc[HEADS] === true) {
+    throw new RangeError("Attempting to change an out of date document");
+  }
+  if (doc[READ_ONLY] === false) {
+    throw new RangeError("Calls to Automerge.change cannot be nested")
+  }
+  const state = doc[STATE]
+  const heads = state.getHeads()
+  try {
+    doc[HEADS] = heads
+    doc[FROZEN] = true
+    let root = rootProxy(state);
+    callback(root)
+    if (state.pendingOps() === 0) {
+      doc[FROZEN] = false
+      doc[HEADS] = undefined
+      return doc
+    } else {
+      state.commit(options.message, options.time)
+      return rootProxy(state, true);
+    }
+  } catch (e) {
+    //console.log("ERROR: ",e)
+    doc[FROZEN] = false
+    doc[HEADS] = undefined
+    state.rollback()
+    throw e
+  }
+}
+
+function emptyChange(doc, options) {
+  if (options === undefined) {
+    options = {}
+  }
+  if (typeof options === "string") {
+    options = { message: options }
+  }
+
+  if (doc === undefined || doc[STATE] === undefined || doc[OBJECT_ID] !== "_root") {
+    throw new RangeError("must be the document root");
+  }
+  if (doc[FROZEN] === true) {
+    throw new RangeError("Attempting to use an outdated Automerge document")
+  }
+  if (doc[READ_ONLY] === false) {
+    throw new RangeError("Calls to Automerge.change cannot be nested")
+  }
+
+  const state = doc[STATE]
+  state.commit(options.message, options.time)
+  return rootProxy(state, true);
+}
+
+function load(data, actor) {
+  const state = AutomergeWASM.load(data, actor)
+  return rootProxy(state, true);
+}
+
+function save(doc) {
+  const state = doc[STATE]
+  return state.save()
+}
+
+function merge(local, remote) {
+  if (local[HEADS] === true) {
+    throw new RangeError("Attempting to change an out of date document");
+  }
+  const localState = local[STATE]
+  const heads = localState.getHeads()
+  const remoteState = remote[STATE]
+  const changes = localState.getChangesAdded(remoteState)
+  localState.applyChanges(changes)
+  local[HEADS] = heads
+  return rootProxy(localState, true)
+}
+
+function getActorId(doc) {
+  const state = doc[STATE]
+  return state.getActorId()
+}
+
+function conflictAt(context, objectId, prop) {
+      let values = context.getAll(objectId, prop)
+      if (values.length <= 1) {
+        return
+      }
+      let result = {}
+      for (const conflict of values) {
+        const datatype = conflict[0]
+        const value = conflict[1]
+        switch (datatype) {
+          case "map":
+            result[value] = mapProxy(context, value, [ prop ], true)
+            break;
+          case "list":
+            result[value] = listProxy(context, value, [ prop ], true)
+            break;
+          case "text":
+            result[value] = textProxy(context, value, [ prop ], true)
+            break;
+          //case "table":
+          //case "cursor":
+          case "str":
+          case "uint":
+          case "int":
+          case "f64":
+          case "boolean":
+          case "bytes":
+          case "null":
+            result[conflict[2]] = value
+            break;
+          case "counter":
+            result[conflict[2]] = new Counter(value)
+            break;
+          case "timestamp":
+            result[conflict[2]] = new Date(value)
+            break;
+          default:
+            throw RangeError(`datatype ${datatype} unimplemented`)
+        }
+      }
+      return result
+}
+
+function getConflicts(doc, prop) {
+  const state = doc[STATE]
+  const objectId = doc[OBJECT_ID]
+  return conflictAt(state, objectId, prop)
+}
+
+function getLastLocalChange(doc) {
+  const state = doc[STATE]
+  try {
+    return state.getLastLocalChange()
+  } catch (e) {
+    return
+  }
+}
+
+function getObjectId(doc) {
+  return doc[OBJECT_ID]
+}
+
+function getChanges(oldState, newState) {
+  const o = oldState[STATE]
+  const n = newState[STATE]
+  const heads = oldState[HEADS]
+  return n.getChanges(heads || o.getHeads())
+}
+
+function getAllChanges(doc) {
+  const state = doc[STATE]
+  return state.getChanges([])
+}
+
+function applyChanges(doc, changes) {
+  if (doc === undefined || doc[STATE] === undefined || doc[OBJECT_ID] !== "_root") {
+    throw new RangeError("must be the document root");
+  }
+  if (doc[FROZEN] === true) {
+    throw new RangeError("Attempting to use an outdated Automerge document")
+  }
+  if (doc[READ_ONLY] === false) {
+    throw new RangeError("Calls to Automerge.change cannot be nested")
+  }
+  const state = doc[STATE]
+  const heads = state.getHeads()
+  state.applyChanges(changes)
+  doc[HEADS] = heads
+  return [rootProxy(state, true)];
+}
+
+function getHistory(doc) {
+  const actor = getActorId(doc)
+  const history = getAllChanges(doc)
+  return history.map((change, index) => ({
+      get change () {
+        return decodeChange(change)
+      },
+      get snapshot () {
+        const [state] = applyChanges(init(), history.slice(0, index + 1))
+        return state
+      }
+    })
+  )
+}
+
+function equals() {
+  if (!isObject(val1) || !isObject(val2)) return val1 === val2
+  const keys1 = Object.keys(val1).sort(), keys2 = Object.keys(val2).sort()
+  if (keys1.length !== keys2.length) return false
+  for (let i = 0; i < keys1.length; i++) {
+    if (keys1[i] !== keys2[i]) return false
+    if (!equals(val1[keys1[i]], val2[keys2[i]])) return false
+  }
+  return true
+}
+
+function encodeSyncMessage(msg) {
+  return AutomergeWASM.encodeSyncMessage(msg)
+}
+
+function decodeSyncMessage(msg) {
+  return AutomergeWASM.decodeSyncMessage(msg)
+}
+
+function encodeSyncState(state) {
+  return AutomergeWASM.encodeSyncState(AutomergeWASM.importSyncState(state))
+}
+
+function decodeSyncState(state) {
+  return AutomergeWASM.exportSyncState(AutomergeWASM.decodeSyncState(state))
+}
+
+function generateSyncMessage(doc, inState) {
+  const state = doc[STATE]
+  const syncState = AutomergeWASM.importSyncState(inState)
+  const message = state.generateSyncMessage(syncState)
+  const outState = AutomergeWASM.exportSyncState(syncState)
+  return [ outState, message ]
+}
+
+function receiveSyncMessage(doc, inState, message) {
+  const syncState = AutomergeWASM.importSyncState(inState)
+  if (doc === undefined || doc[STATE] === undefined || doc[OBJECT_ID] !== "_root") {
+    throw new RangeError("must be the document root");
+  }
+  if (doc[FROZEN] === true) {
+    throw new RangeError("Attempting to use an outdated Automerge document")
+  }
+  if (!!doc[HEADS] === true) {
+    throw new RangeError("Attempting to change an out of date document");
+  }
+  if (doc[READ_ONLY] === false) {
+    throw new RangeError("Calls to Automerge.change cannot be nested")
+  }
+  const state = doc[STATE]
+  const heads = state.getHeads()
+  state.receiveSyncMessage(syncState, message)
+  const outState = AutomergeWASM.exportSyncState(syncState)
+  doc[HEADS] = heads
+  return [rootProxy(state, true), outState, null];
+}
+
+function initSyncState() {
+  return AutomergeWASM.exportSyncState(AutomergeWASM.initSyncState(change))
+}
+
+function encodeChange(change) {
+  return AutomergeWASM.encodeChange(change)
+}
+
+function decodeChange(data) {
+  return AutomergeWASM.decodeChange(data)
+}
+
+function encodeSyncMessage(change) {
+  return AutomergeWASM.encodeSyncMessage(change)
+}
+
+function decodeSyncMessage(data) {
+  return AutomergeWASM.decodeSyncMessage(data)
+}
+
+function getMissingDeps(doc, heads) {
+  const state = doc[STATE]
+  return state.getMissingDeps(heads)
+}
+
+function getHeads(doc) {
+  const state = doc[STATE]
+  return doc[HEADS] || state.getHeads()
+}
+
+function dump(doc) {
+  const state = doc[STATE]
+  state.dump()
+}
+
+function toJS(doc) {
+  if (typeof doc === "object") {
+    if (doc instanceof Uint8Array) {
+      return doc
+    }
+    if (doc === null) {
+      return doc
+    }
+    if (doc instanceof Array) {
+      return doc.map((a) => toJS(a))
+    }
+    if (doc instanceof Text) {
+      return doc.map((a) => toJS(a))
+    }
+    let tmp = {}
+    for (index in doc) {
+      tmp[index] = toJS(doc[index])
+    }
+    return tmp
+  } else {
+    return doc
+  }
+}
+
+module.exports = {
+    init, from, change, emptyChange, clone, free,
+    load, save, merge, getChanges, getAllChanges, applyChanges,
+    getLastLocalChange, getObjectId, getActorId, getConflicts,
+    encodeChange, decodeChange, equals, getHistory, getHeads, uuid,
+    generateSyncMessage, receiveSyncMessage, initSyncState,
+    decodeSyncMessage, encodeSyncMessage, decodeSyncState, encodeSyncState,
+    getMissingDeps,
+    dump, Text, Counter, Int, Uint, Float64, toJS,
+}
+
+// depricated
+// Frontend, setDefaultBackend, Backend
+
+// more...
+/*
+for (let name of ['getObjectId', 'getObjectById',
+       'setActorId',
+       'Text', 'Table', 'Counter', 'Observable' ]) {
+    module.exports[name] = Frontend[name]
+}
+*/

automerge-js/src/numbers.js

@@ -0,0 +1,33 @@
+// Convience classes to allow users to stricly specify the number type they want
+
+class Int {
+  constructor(value) {
+    if (!(Number.isInteger(value) && value <= Number.MAX_SAFE_INTEGER && value >= Number.MIN_SAFE_INTEGER)) {
+      throw new RangeError(`Value ${value} cannot be a uint`)
+    }
+    this.value = value
+    Object.freeze(this)
+  }
+}
+
+class Uint {
+  constructor(value) {
+    if (!(Number.isInteger(value) && value <= Number.MAX_SAFE_INTEGER && value >= 0)) {
+      throw new RangeError(`Value ${value} cannot be a uint`)
+    }
+    this.value = value
+    Object.freeze(this)
+  }
+}
+
+class Float64 {
+  constructor(value) {
+    if (typeof value !== 'number') {
+      throw new RangeError(`Value ${value} cannot be a float64`)
+    }
+    this.value = value || 0.0
+    Object.freeze(this)
+  }
+}
+
+module.exports = { Int, Uint, Float64 }

automerge-js/src/proxies.js

@@ -0,0 +1,617 @@
+
+const AutomergeWASM = require("automerge-wasm")
+const { Int, Uint, Float64 } = require("./numbers");
+const { Counter, getWriteableCounter } = require("./counter");
+const { Text } = require("./text");
+const { STATE, HEADS, FROZEN, OBJECT_ID, READ_ONLY } = require("./constants")
+
+function parseListIndex(key) {
+  if (typeof key === 'string' && /^[0-9]+$/.test(key)) key = parseInt(key, 10)
+  if (typeof key !== 'number') {
+    // throw new TypeError('A list index must be a number, but you passed ' + JSON.stringify(key))
+    return key
+  }
+  if (key < 0 || isNaN(key) || key === Infinity || key === -Infinity) {
+    throw new RangeError('A list index must be positive, but you passed ' + key)
+  }
+  return key
+}
+
+function valueAt(target, prop) {
+      const { context, objectId, path, readonly, heads} = target
+      let value = context.get(objectId, prop, heads)
+      if (value === undefined) {
+        return
+      }
+      const datatype = value[0]
+      const val = value[1]
+      switch (datatype) {
+        case undefined: return;
+        case "map": return mapProxy(context, val, [ ... path, prop ], readonly, heads);
+        case "list": return listProxy(context, val, [ ... path, prop ], readonly, heads);
+        case "text": return textProxy(context, val, [ ... path, prop ], readonly, heads);
+        //case "table":
+        //case "cursor":
+        case "str": return val;
+        case "uint": return val;
+        case "int": return val;
+        case "f64": return val;
+        case "boolean": return val;
+        case "null": return null;
+        case "bytes": return val;
+        case "timestamp": return val;
+        case "counter": {
+          if (readonly) {
+            return new Counter(val);
+          } else {
+            return getWriteableCounter(val, context, path, objectId, prop)
+          }
+        }
+        default:
+          throw RangeError(`datatype ${datatype} unimplemented`)
+      }
+}
+
+function import_value(value) {
+    switch (typeof value) {
+      case 'object':
+        if (value == null) {
+          return [ null, "null"]
+        } else if (value instanceof Uint) {
+          return [ value.value, "uint" ]
+        } else if (value instanceof Int) {
+          return [ value.value, "int" ]
+        } else if (value instanceof Float64) {
+          return [ value.value, "f64" ]
+        } else if (value instanceof Counter) {
+          return [ value.value, "counter" ]
+        } else if (value instanceof Date) {
+          return [ value.getTime(), "timestamp" ]
+        } else if (value instanceof Uint8Array) {
+          return [ value, "bytes" ]
+        } else if (value instanceof Array) {
+          return [ value, "list" ]
+        } else if (value instanceof Text) {
+          return [ value, "text" ]
+        } else if (value[OBJECT_ID]) {
+          throw new RangeError('Cannot create a reference to an existing document object')
+        } else {
+          return [ value, "map" ]
+        }
+        break;
+      case 'boolean':
+        return [ value, "boolean" ]
+      case 'number':
+        if (Number.isInteger(value)) {
+          return [ value, "int" ]
+        } else {
+          return [ value, "f64" ]
+        }
+        break;
+      case 'string':
+        return [ value ]
+        break;
+      default:
+        throw new RangeError(`Unsupported type of value: ${typeof value}`)
+    }
+}
+
+const MapHandler = {
+  get (target, key) {
+    const { context, objectId, path, readonly, frozen, heads, cache } = target
+    if (key === Symbol.toStringTag) { return target[Symbol.toStringTag] }
+    if (key === OBJECT_ID) return objectId
+    if (key === READ_ONLY) return readonly
+    if (key === FROZEN) return frozen
+    if (key === HEADS) return heads
+    if (key === STATE) return context;
+    if (!cache[key]) {
+      cache[key] = valueAt(target, key)
+    }
+    return cache[key]
+  },
+
+  set (target, key, val) {
+    let { context, objectId, path, readonly, frozen} = target
+    target.cache = {} // reset cache on set
+    if (val && val[OBJECT_ID]) {
+          throw new RangeError('Cannot create a reference to an existing document object')
+    }
+    if (key === FROZEN) {
+      target.frozen = val
+      return
+    }
+    if (key === HEADS) {
+      target.heads = val
+      return
+    }
+    let [ value, datatype ] = import_value(val)
+    if (frozen) {
+      throw new RangeError("Attempting to use an outdated Automerge document")
+    }
+    if (readonly) {
+      throw new RangeError(`Object property "${key}" cannot be modified`)
+    }
+    switch (datatype) {
+      case "list":
+        const list = context.putObject(objectId, key, [])
+        const proxyList = listProxy(context, list, [ ... path, key ], readonly );
+        for (let i = 0; i < value.length; i++) {
+          proxyList[i] = value[i]
+        }
+        break;
+      case "text":
+        const text = context.putObject(objectId, key, "", "text")
+        const proxyText = textProxy(context, text, [ ... path, key ], readonly );
+        for (let i = 0; i < value.length; i++) {
+          proxyText[i] = value.get(i)
+        }
+        break;
+      case "map":
+        const map = context.putObject(objectId, key, {})
+        const proxyMap = mapProxy(context, map, [ ... path, key ], readonly );
+        for (const key in value) {
+          proxyMap[key] = value[key]
+        }
+        break;
+      default:
+        context.put(objectId, key, value, datatype)
+    }
+    return true
+  },
+
+  deleteProperty (target, key) {
+    const { context, objectId, path, readonly, frozen } = target
+    target.cache = {} // reset cache on delete
+    if (readonly) {
+      throw new RangeError(`Object property "${key}" cannot be modified`)
+    }
+    context.delete(objectId, key)
+    return true
+  },
+
+  has (target, key) {
+    const value = this.get(target, key)
+    return value !== undefined
+  },
+
+  getOwnPropertyDescriptor (target, key) {
+    const { context, objectId } = target
+    const value = this.get(target, key)
+    if (typeof value !== 'undefined') {
+      return {
+        configurable: true, enumerable: true, value
+      }
+    }
+  },
+
+  ownKeys (target) {
+    const { context, objectId, heads} = target
+    return context.keys(objectId, heads)
+  },
+}
+
+
+const ListHandler = {
+  get (target, index) {
+    const {context, objectId, path, readonly, frozen, heads } = target
+    index = parseListIndex(index)
+    if (index === Symbol.hasInstance) { return (instance) => { return [].has(instance) } }
+    if (index === Symbol.toStringTag) { return target[Symbol.toStringTag] }
+    if (index === OBJECT_ID) return objectId
+    if (index === READ_ONLY) return readonly
+    if (index === FROZEN) return frozen
+    if (index === HEADS) return heads
+    if (index === STATE) return context;
+    if (index === 'length') return context.length(objectId, heads);
+    if (index === Symbol.iterator) {
+      let i = 0;
+      return function *() {
+        // FIXME - ugly
+        let value = valueAt(target, i)
+        while (value !== undefined) {
+            yield value
+            i += 1
+            value = valueAt(target, i)
+        }
+      }
+    }
+    if (typeof index === 'number') {
+      return valueAt(target, index)
+    } else {
+      return listMethods(target)[index]
+    }
+  },
+
+  set (target, index, val) {
+    let {context, objectId, path, readonly, frozen } = target
+    index = parseListIndex(index)
+    if (val && val[OBJECT_ID]) {
+      throw new RangeError('Cannot create a reference to an existing document object')
+    }
+    if (index === FROZEN) {
+      target.frozen = val
+      return
+    }
+    if (index === HEADS) {
+      target.heads = val
+      return
+    }
+    if (typeof index == "string") {
+      throw new RangeError('list index must be a number')
+    }
+    const [ value, datatype] = import_value(val)
+    if (frozen) {
+      throw new RangeError("Attempting to use an outdated Automerge document")
+    }
+    if (readonly) {
+      throw new RangeError(`Object property "${index}" cannot be modified`)
+    }
+    switch (datatype) {
+      case "list":
+        let list
+        if (index >= context.length(objectId)) {
+          list = context.insertObject(objectId, index, [])
+        } else {
+          list = context.putObject(objectId, index, [])
+        }
+        const proxyList = listProxy(context, list, [ ... path, index ], readonly);
+        proxyList.splice(0,0,...value)
+        break;
+      case "text":
+        let text
+        if (index >= context.length(objectId)) {
+          text = context.insertObject(objectId, index, "", "text")
+        } else {
+          text = context.putObject(objectId, index, "", "text")
+        }
+        const proxyText = textProxy(context, text, [ ... path, index ], readonly);
+        proxyText.splice(0,0,...value)
+        break;
+      case "map":
+        let map
+        if (index >= context.length(objectId)) {
+          map = context.insertObject(objectId, index, {})
+        } else {
+          map = context.putObject(objectId, index, {})
+        }
+        const proxyMap = mapProxy(context, map, [ ... path, index ], readonly);
+        for (const key in value) {
+          proxyMap[key] = value[key]
+        }
+        break;
+      default:
+        if (index >= context.length(objectId)) {
+          context.insert(objectId, index, value, datatype)
+        } else {
+          context.put(objectId, index, value, datatype)
+        }
+    }
+    return true
+  },
+
+  deleteProperty (target, index) {
+    const {context, objectId} = target
+    index = parseListIndex(index)
+    if (context.get(objectId, index)[0] == "counter") {
+      throw new TypeError('Unsupported operation: deleting a counter from a list')
+    }
+    context.delete(objectId, index)
+    return true
+  },
+
+  has (target, index) {
+    const {context, objectId, heads} = target
+    index = parseListIndex(index)
+    if (typeof index === 'number') {
+      return index < context.length(objectId, heads)
+    }
+    return index === 'length'
+  },
+
+  getOwnPropertyDescriptor (target, index) {
+    const {context, objectId, path, readonly, frozen, heads} = target
+
+    if (index === 'length') return {writable: true, value: context.length(objectId, heads) }
+    if (index === OBJECT_ID) return {configurable: false, enumerable: false, value: objectId}
+
+    index = parseListIndex(index)
+
+    let value = valueAt(target, index)
+    return { configurable: true, enumerable: true, value }
+  },
+
+  getPrototypeOf(target) { return Object.getPrototypeOf([]) },
+  ownKeys (target) {
+    const {context, objectId, heads } = target
+    let keys = []
+    // uncommenting this causes assert.deepEqual() to fail when comparing to a pojo array
+    // but not uncommenting it causes for (i in list) {} to not enumerate values properly
+    //for (let i = 0; i < target.context.length(objectId, heads); i++) { keys.push(i.toString()) }
+    keys.push("length");
+    return keys
+  }
+}
+
+const TextHandler = Object.assign({}, ListHandler, {
+  get (target, index) {
+    // FIXME this is a one line change from ListHandler.get()
+    const {context, objectId, path, readonly, frozen, heads } = target
+    index = parseListIndex(index)
+    if (index === Symbol.toStringTag) { return target[Symbol.toStringTag] }
+    if (index === Symbol.hasInstance) { return (instance) => { return [].has(instance) } }
+    if (index === OBJECT_ID) return objectId
+    if (index === READ_ONLY) return readonly
+    if (index === FROZEN) return frozen
+    if (index === HEADS) return heads
+    if (index === STATE) return context;
+    if (index === 'length') return context.length(objectId, heads);
+    if (index === Symbol.iterator) {
+      let i = 0;
+      return function *() {
+        let value = valueAt(target, i)
+        while (value !== undefined) {
+            yield value
+            i += 1
+            value = valueAt(target, i)
+        }
+      }
+    }
+    if (typeof index === 'number') {
+      return valueAt(target, index)
+    } else {
+      return textMethods(target)[index] || listMethods(target)[index]
+    }
+  },
+  getPrototypeOf(target) {
+    return Object.getPrototypeOf(new Text())
+  },
+})
+
+function mapProxy(context, objectId, path, readonly, heads) {
+  return new Proxy({context, objectId, path, readonly: !!readonly, frozen: false, heads, cache: {}}, MapHandler)
+}
+
+function listProxy(context, objectId, path, readonly, heads) {
+  let target = []
+  Object.assign(target, {context, objectId, path, readonly: !!readonly, frozen: false, heads, cache: {}})
+  return new Proxy(target, ListHandler)
+}
+
+function textProxy(context, objectId, path, readonly, heads) {
+  let target = []
+  Object.assign(target, {context, objectId, path, readonly: !!readonly, frozen: false, heads, cache: {}})
+  return new Proxy(target, TextHandler)
+}
+
+function rootProxy(context, readonly) {
+  return mapProxy(context, "_root", [], readonly)
+}
+
+function listMethods(target) {
+  const {context, objectId, path, readonly, frozen, heads} = target
+  const methods = {
+    deleteAt(index, numDelete) {
+      if (typeof numDelete === 'number') {
+        context.splice(objectId, index, numDelete)
+      } else {
+        context.delete(objectId, index)
+      }
+      return this
+    },
+
+    fill(val, start, end) {
+      // FIXME
+      let list = context.getObject(objectId)
+      let [value, datatype] = valueAt(target, index)
+      for (let index = parseListIndex(start || 0); index < parseListIndex(end || list.length); index++) {
+        context.put(objectId, index, value, datatype)
+      }
+      return this
+    },
+
+    indexOf(o, start = 0) {
+      // FIXME
+      const id = o[OBJECT_ID]
+      if (id) {
+        const list = context.getObject(objectId)
+        for (let index = start; index < list.length; index++) {
+          if (list[index][OBJECT_ID] === id) {
+            return index
+          }
+        }
+        return -1
+      } else {
+        return context.indexOf(objectId, o, start)
+      }
+    },
+
+    insertAt(index, ...values) {
+      this.splice(index, 0, ...values)
+      return this
+    },
+
+    pop() {
+      let length = context.length(objectId)
+      if (length == 0) {
+        return undefined
+      }
+      let last = valueAt(target, length - 1)
+      context.delete(objectId, length - 1)
+      return last
+    },
+
+    push(...values) {
+      let len = context.length(objectId)
+      this.splice(len, 0, ...values)
+      return context.length(objectId)
+    },
+
+    shift() {
+      if (context.length(objectId) == 0) return
+      const first = valueAt(target, 0)
+      context.delete(objectId, 0)
+      return first
+    },
+
+    splice(index, del, ...vals) {
+      index = parseListIndex(index)
+      del = parseListIndex(del)
+      for (let val of vals) {
+        if (val && val[OBJECT_ID]) {
+              throw new RangeError('Cannot create a reference to an existing document object')
+        }
+      }
+      if (frozen) {
+        throw new RangeError("Attempting to use an outdated Automerge document")
+      }
+      if (readonly) {
+        throw new RangeError("Sequence object cannot be modified outside of a change block")
+      }
+      let result = []
+      for (let i = 0; i < del; i++) {
+        let value = valueAt(target, index)
+        result.push(value)
+        context.delete(objectId, index)
+      }
+      const values = vals.map((val) => import_value(val))
+      for (let [value,datatype] of values) {
+        switch (datatype) {
+          case "list":
+            const list = context.insertObject(objectId, index, [])
+            const proxyList = listProxy(context, list, [ ... path, index ], readonly);
+            proxyList.splice(0,0,...value)
+            break;
+          case "text":
+            const text = context.insertObject(objectId, index, "", "text")
+            const proxyText = textProxy(context, text, [ ... path, index ], readonly);
+            proxyText.splice(0,0,...value)
+            break;
+          case "map":
+            const map = context.insertObject(objectId, index, {})
+            const proxyMap = mapProxy(context, map, [ ... path, index ], readonly);
+            for (const key in value) {
+              proxyMap[key] = value[key]
+            }
+            break;
+          default:
+            context.insert(objectId, index, value, datatype)
+        }
+        index += 1
+      }
+      return result
+    },
+
+    unshift(...values) {
+      this.splice(0, 0, ...values)
+      return context.length(objectId)
+    },
+
+    entries() {
+      let i = 0;
+      const iterator = {
+        next: () => {
+          let value = valueAt(target, i)
+          if (value === undefined) {
+            return { value: undefined, done: true }
+          } else {
+            return { value: [ i, value ], done: false }
+          }
+        }
+      }
+      return iterator
+    },
+
+    keys() {
+      let i = 0;
+      let len = context.length(objectId, heads)
+      const iterator = {
+        next: () => {
+          let value = undefined
+          if (i < len) { value = i; i++ }
+          return { value, done: true }
+        }
+      }
+      return iterator
+    },
+
+    values() {
+      let i = 0;
+      const iterator = {
+        next: () => {
+          let value = valueAt(target, i)
+          if (value === undefined) {
+            return { value: undefined, done: true }
+          } else {
+            return { value, done: false }
+          }
+        }
+      }
+      return iterator
+    }
+  }
+
+  // Read-only methods that can delegate to the JavaScript built-in implementations
+  // FIXME - super slow
+  for (let method of ['concat', 'every', 'filter', 'find', 'findIndex', 'forEach', 'includes',
+                      'join', 'lastIndexOf', 'map', 'reduce', 'reduceRight',
+                      'slice', 'some', 'toLocaleString', 'toString']) {
+    methods[method] = (...args) => {
+      const list = []
+      while (true) {
+        let value =  valueAt(target, list.length)
+        if (value == undefined) {
+          break
+        }
+        list.push(value)
+      }
+
+      return list[method](...args)
+    }
+  }
+
+  return methods
+}
+
+function textMethods(target) {
+  const {context, objectId, path, readonly, frozen, heads } = target
+  const methods = {
+    set (index, value) {
+      return this[index] = value
+    },
+    get (index) {
+      return this[index]
+    },
+    toString () {
+      return context.text(objectId, heads).replace(//g,'')
+    },
+    toSpans () {
+      let spans = []
+      let chars = ''
+      let length = this.length
+      for (let i = 0; i < length; i++) {
+        const value = this[i]
+        if (typeof value === 'string') {
+          chars += value
+        } else {
+          if (chars.length > 0) {
+            spans.push(chars)
+            chars = ''
+          }
+          spans.push(value)
+        }
+      }
+      if (chars.length > 0) {
+        spans.push(chars)
+      }
+      return spans
+    },
+    toJSON () {
+      return this.toString()
+    }
+  }
+  return methods
+}
+
+
+module.exports = { rootProxy, textProxy, listProxy, mapProxy, MapHandler, ListHandler, TextHandler }

automerge-js/src/sync.js

@@ -16,15 +16,11 @@
  * last sync to disk), and we fall back to sending the entire document in this case.
  */
 
-const Backend = null //require('./backend')
+//const Backend = require('./backend')
-const {
+const Backend = {} //require('./backend')
-  hexStringToBytes,
+const { hexStringToBytes, bytesToHexString, Encoder, Decoder } = require('./encoding')
-  bytesToHexString,
+const { decodeChangeMeta } = require('./columnar')
-  Encoder,
+const { copyObject } = require('../src/common')
-  Decoder,
-} = require("./encoding")
-const { decodeChangeMeta } = require("./columnar")
-const { copyObject } = require("./common")
 
 const HASH_SIZE = 32 // 256 bits = 32 bytes
 const MESSAGE_TYPE_SYNC = 0x42 // first byte of a sync message, for identification
@@ -33,8 +29,7 @@ const PEER_STATE_TYPE = 0x43 // first byte of an encoded peer state, for identif
 // These constants correspond to a 1% false positive rate. The values can be changed without
 // breaking compatibility of the network protocol, since the parameters used for a particular
 // Bloom filter are encoded in the wire format.
-const BITS_PER_ENTRY = 10,
+const BITS_PER_ENTRY = 10, NUM_PROBES = 7
-  NUM_PROBES = 7
 
 /**
  * A Bloom filter implementation that can be serialised to a byte array for transmission
@@ -48,9 +43,7 @@ class BloomFilter {
       this.numEntries = arg.length
       this.numBitsPerEntry = BITS_PER_ENTRY
       this.numProbes = NUM_PROBES
-      this.bits = new Uint8Array(
+      this.bits = new Uint8Array(Math.ceil(this.numEntries * this.numBitsPerEntry / 8))
-        Math.ceil((this.numEntries * this.numBitsPerEntry) / 8)
-      )
       for (let hash of arg) this.addHash(hash)
     } else if (arg instanceof Uint8Array) {
       if (arg.byteLength === 0) {
@@ -63,12 +56,10 @@ class BloomFilter {
         this.numEntries = decoder.readUint32()
         this.numBitsPerEntry = decoder.readUint32()
         this.numProbes = decoder.readUint32()
-        this.bits = decoder.readRawBytes(
+        this.bits = decoder.readRawBytes(Math.ceil(this.numEntries * this.numBitsPerEntry / 8))
-          Math.ceil((this.numEntries * this.numBitsPerEntry) / 8)
-        )
       }
     } else {
-      throw new TypeError("invalid argument")
+      throw new TypeError('invalid argument')
     }
   }
 
@@ -96,32 +87,12 @@ class BloomFilter {
    * http://www.ccis.northeastern.edu/home/pete/pub/bloom-filters-verification.pdf
    */
   getProbes(hash) {
-    const hashBytes = hexStringToBytes(hash),
+    const hashBytes = hexStringToBytes(hash), modulo = 8 * this.bits.byteLength
-      modulo = 8 * this.bits.byteLength
+    if (hashBytes.byteLength !== 32) throw new RangeError(`Not a 256-bit hash: ${hash}`)
-    if (hashBytes.byteLength !== 32)
-      throw new RangeError(`Not a 256-bit hash: ${hash}`)
     // on the next three lines, the right shift means interpret value as unsigned
-    let x =
+    let x = ((hashBytes[0] | hashBytes[1] << 8 | hashBytes[2]  << 16 | hashBytes[3]  << 24) >>> 0) % modulo
-      ((hashBytes[0] |
+    let y = ((hashBytes[4] | hashBytes[5] << 8 | hashBytes[6]  << 16 | hashBytes[7]  << 24) >>> 0) % modulo
-        (hashBytes[1] << 8) |
+    let z = ((hashBytes[8] | hashBytes[9] << 8 | hashBytes[10] << 16 | hashBytes[11] << 24) >>> 0) % modulo
-        (hashBytes[2] << 16) |
-        (hashBytes[3] << 24)) >>>
-        0) %
-      modulo
-    let y =
-      ((hashBytes[4] |
-        (hashBytes[5] << 8) |
-        (hashBytes[6] << 16) |
-        (hashBytes[7] << 24)) >>>
-        0) %
-      modulo
-    let z =
-      ((hashBytes[8] |
-        (hashBytes[9] << 8) |
-        (hashBytes[10] << 16) |
-        (hashBytes[11] << 24)) >>>
-        0) %
-      modulo
     const probes = [x]
     for (let i = 1; i < this.numProbes; i++) {
       x = (x + y) % modulo
@@ -158,14 +129,12 @@ class BloomFilter {
  * Encodes a sorted array of SHA-256 hashes (as hexadecimal strings) into a byte array.
  */
 function encodeHashes(encoder, hashes) {
-  if (!Array.isArray(hashes)) throw new TypeError("hashes must be an array")
+  if (!Array.isArray(hashes)) throw new TypeError('hashes must be an array')
   encoder.appendUint32(hashes.length)
   for (let i = 0; i < hashes.length; i++) {
-    if (i > 0 && hashes[i - 1] >= hashes[i])
+    if (i > 0 && hashes[i - 1] >= hashes[i]) throw new RangeError('hashes must be sorted')
-      throw new RangeError("hashes must be sorted")
     const bytes = hexStringToBytes(hashes[i])
-    if (bytes.byteLength !== HASH_SIZE)
+    if (bytes.byteLength !== HASH_SIZE) throw new TypeError('heads hashes must be 256 bits')
-      throw new TypeError("heads hashes must be 256 bits")
     encoder.appendRawBytes(bytes)
   }
 }
@@ -175,8 +144,7 @@ function encodeHashes(encoder, hashes) {
  * array of hex strings.
  */
 function decodeHashes(decoder) {
-  let length = decoder.readUint32(),
+  let length = decoder.readUint32(), hashes = []
-    hashes = []
   for (let i = 0; i < length; i++) {
     hashes.push(bytesToHexString(decoder.readRawBytes(HASH_SIZE)))
   }
@@ -278,26 +246,20 @@ function makeBloomFilter(backend, lastSync) {
  */
 function getChangesToSend(backend, have, need) {
   if (have.length === 0) {
-    return need
+    return need.map(hash => Backend.getChangeByHash(backend, hash)).filter(change => change !== undefined)
-      .map(hash => Backend.getChangeByHash(backend, hash))
-      .filter(change => change !== undefined)
   }
 
-  let lastSyncHashes = {},
+  let lastSyncHashes = {}, bloomFilters = []
-    bloomFilters = []
   for (let h of have) {
     for (let hash of h.lastSync) lastSyncHashes[hash] = true
     bloomFilters.push(new BloomFilter(h.bloom))
   }
 
   // Get all changes that were added since the last sync
-  const changes = Backend.getChanges(backend, Object.keys(lastSyncHashes)).map(
+  const changes = Backend.getChanges(backend, Object.keys(lastSyncHashes))
-    change => decodeChangeMeta(change, true)
+    .map(change => decodeChangeMeta(change, true))
-  )
 
-  let changeHashes = {},
+  let changeHashes = {}, dependents = {}, hashesToSend = {}
-    dependents = {},
-    hashesToSend = {}
   for (let change of changes) {
     changeHashes[change.hash] = true
 
@@ -331,8 +293,7 @@ function getChangesToSend(backend, have, need) {
   let changesToSend = []
   for (let hash of need) {
     hashesToSend[hash] = true
-    if (!changeHashes[hash]) {
+    if (!changeHashes[hash]) { // Change is not among those returned by getMissingChanges()?
-      // Change is not among those returned by getMissingChanges()?
       const change = Backend.getChangeByHash(backend, hash)
       if (change) changesToSend.push(change)
     }
@@ -357,7 +318,7 @@ function initSyncState() {
 }
 
 function compareArrays(a, b) {
-  return a.length === b.length && a.every((v, i) => v === b[i])
+    return (a.length === b.length) && a.every((v, i) => v === b[i])
 }
 
 /**
@@ -369,19 +330,10 @@ function generateSyncMessage(backend, syncState) {
     throw new Error("generateSyncMessage called with no Automerge document")
   }
   if (!syncState) {
-    throw new Error(
+    throw new Error("generateSyncMessage requires a syncState, which can be created with initSyncState()")
-      "generateSyncMessage requires a syncState, which can be created with initSyncState()"
-    )
   }
 
-  let {
+  let { sharedHeads, lastSentHeads, theirHeads, theirNeed, theirHave, sentHashes } = syncState
-    sharedHeads,
-    lastSentHeads,
-    theirHeads,
-    theirNeed,
-    theirHave,
-    sentHashes,
-  } = syncState
   const ourHeads = Backend.getHeads(backend)
 
   // Hashes to explicitly request from the remote peer: any missing dependencies of unapplied
@@ -405,28 +357,18 @@ function generateSyncMessage(backend, syncState) {
     const lastSync = theirHave[0].lastSync
     if (!lastSync.every(hash => Backend.getChangeByHash(backend, hash))) {
       // we need to queue them to send us a fresh sync message, the one they sent is uninteligible so we don't know what they need
-      const resetMsg = {
+      const resetMsg = {heads: ourHeads, need: [], have: [{ lastSync: [], bloom: new Uint8Array(0) }], changes: []}
-        heads: ourHeads,
-        need: [],
-        have: [{ lastSync: [], bloom: new Uint8Array(0) }],
-        changes: [],
-      }
       return [syncState, encodeSyncMessage(resetMsg)]
     }
   }
 
   // XXX: we should limit ourselves to only sending a subset of all the messages, probably limited by a total message size
   //      these changes should ideally be RLE encoded but we haven't implemented that yet.
-  let changesToSend =
+  let changesToSend = Array.isArray(theirHave) && Array.isArray(theirNeed) ? getChangesToSend(backend, theirHave, theirNeed) : []
-    Array.isArray(theirHave) && Array.isArray(theirNeed)
-      ? getChangesToSend(backend, theirHave, theirNeed)
-      : []
 
   // If the heads are equal, we're in sync and don't need to do anything further
-  const headsUnchanged =
+  const headsUnchanged = Array.isArray(lastSentHeads) && compareArrays(ourHeads, lastSentHeads)
-    Array.isArray(lastSentHeads) && compareArrays(ourHeads, lastSentHeads)
+  const headsEqual = Array.isArray(theirHeads) && compareArrays(ourHeads, theirHeads)
-  const headsEqual =
-    Array.isArray(theirHeads) && compareArrays(ourHeads, theirHeads)
   if (headsUnchanged && headsEqual && changesToSend.length === 0) {
     // no need to send a sync message if we know we're synced!
     return [syncState, null]
@@ -434,19 +376,12 @@ function generateSyncMessage(backend, syncState) {
 
   // TODO: this recomputes the SHA-256 hash of each change; we should restructure this to avoid the
   // unnecessary recomputation
-  changesToSend = changesToSend.filter(
+  changesToSend = changesToSend.filter(change => !sentHashes[decodeChangeMeta(change, true).hash])
-    change => !sentHashes[decodeChangeMeta(change, true).hash]
-  )
 
   // Regular response to a sync message: send any changes that the other node
   // doesn't have. We leave the "have" field empty because the previous message
   // generated by `syncStart` already indicated what changes we have.
-  const syncMessage = {
+  const syncMessage = {heads: ourHeads, have: ourHave, need: ourNeed, changes: changesToSend}
-    heads: ourHeads,
-    have: ourHave,
-    need: ourNeed,
-    changes: changesToSend,
-  }
   if (changesToSend.length > 0) {
     sentHashes = copyObject(sentHashes)
     for (const change of changesToSend) {
@@ -454,10 +389,7 @@ function generateSyncMessage(backend, syncState) {
     }
   }
 
-  syncState = Object.assign({}, syncState, {
+  syncState = Object.assign({}, syncState, {lastSentHeads: ourHeads, sentHashes})
-    lastSentHeads: ourHeads,
-    sentHashes,
-  })
   return [syncState, encodeSyncMessage(syncMessage)]
 }
 
@@ -475,14 +407,13 @@ function generateSyncMessage(backend, syncState) {
  * another peer, that means that peer had those changes, and therefore we now both know about them.
  */
 function advanceHeads(myOldHeads, myNewHeads, ourOldSharedHeads) {
-  const newHeads = myNewHeads.filter(head => !myOldHeads.includes(head))
+  const newHeads = myNewHeads.filter((head) => !myOldHeads.includes(head))
-  const commonHeads = ourOldSharedHeads.filter(head =>
+  const commonHeads = ourOldSharedHeads.filter((head) => myNewHeads.includes(head))
-    myNewHeads.includes(head)
-  )
   const advancedHeads = [...new Set([...newHeads, ...commonHeads])].sort()
   return advancedHeads
 }
 
+
 /**
  * Given a backend, a message message and the state of our peer, apply any changes, update what
  * we believe about the peer, and (if there were applied changes) produce a patch for the frontend
@@ -492,13 +423,10 @@ function receiveSyncMessage(backend, oldSyncState, binaryMessage) {
     throw new Error("generateSyncMessage called with no Automerge document")
   }
   if (!oldSyncState) {
-    throw new Error(
+    throw new Error("generateSyncMessage requires a syncState, which can be created with initSyncState()")
-      "generateSyncMessage requires a syncState, which can be created with initSyncState()"
-    )
   }
 
-  let { sharedHeads, lastSentHeads, sentHashes } = oldSyncState,
+  let { sharedHeads, lastSentHeads, sentHashes } = oldSyncState, patch = null
-    patch = null
   const message = decodeSyncMessage(binaryMessage)
   const beforeHeads = Backend.getHeads(backend)
 
@@ -507,27 +435,18 @@ function receiveSyncMessage(backend, oldSyncState, binaryMessage) {
   // changes without applying them. The set of changes may also be incomplete if the sender decided
   // to break a large set of changes into chunks.
   if (message.changes.length > 0) {
-    ;[backend, patch] = Backend.applyChanges(backend, message.changes)
+    [backend, patch] = Backend.applyChanges(backend, message.changes)
-    sharedHeads = advanceHeads(
+    sharedHeads = advanceHeads(beforeHeads, Backend.getHeads(backend), sharedHeads)
-      beforeHeads,
-      Backend.getHeads(backend),
-      sharedHeads
-    )
   }
 
   // If heads are equal, indicate we don't need to send a response message
-  if (
+  if (message.changes.length === 0 && compareArrays(message.heads, beforeHeads)) {
-    message.changes.length === 0 &&
-    compareArrays(message.heads, beforeHeads)
-  ) {
     lastSentHeads = message.heads
   }
 
   // If all of the remote heads are known to us, that means either our heads are equal, or we are
   // ahead of the remote peer. In this case, take the remote heads to be our shared heads.
-  const knownHeads = message.heads.filter(head =>
+  const knownHeads = message.heads.filter(head => Backend.getChangeByHash(backend, head))
-    Backend.getChangeByHash(backend, head)
-  )
   if (knownHeads.length === message.heads.length) {
     sharedHeads = message.heads
     // If the remote peer has lost all its data, reset our state to perform a full resync
@@ -549,18 +468,14 @@ function receiveSyncMessage(backend, oldSyncState, binaryMessage) {
     theirHave: message.have, // the information we need to calculate the changes they need
     theirHeads: message.heads,
     theirNeed: message.need,
-    sentHashes,
+    sentHashes
   }
   return [backend, syncState, patch]
 }
 
 module.exports = {
-  receiveSyncMessage,
+  receiveSyncMessage, generateSyncMessage,
-  generateSyncMessage,
+  encodeSyncMessage, decodeSyncMessage,
-  encodeSyncMessage,
+  initSyncState, encodeSyncState, decodeSyncState,
-  decodeSyncMessage,
+  BloomFilter // BloomFilter is a private API, exported only for testing purposes
-  initSyncState,
-  encodeSyncState,
-  decodeSyncState,
-  BloomFilter, // BloomFilter is a private API, exported only for testing purposes
 }

automerge-js/src/text.js

@@ -0,0 +1,132 @@
+const { OBJECT_ID } = require('./constants')
+const { isObject } = require('../src/common')
+
+class Text {
+  constructor (text) {
+    const instance = Object.create(Text.prototype)
+    if (typeof text === 'string') {
+      instance.elems = [...text]
+    } else if (Array.isArray(text)) {
+      instance.elems = text
+    } else if (text === undefined) {
+      instance.elems = []
+    } else {
+      throw new TypeError(`Unsupported initial value for Text: ${text}`)
+    }
+    return instance
+  }
+
+  get length () {
+    return this.elems.length
+  }
+
+  get (index) {
+    return this.elems[index]
+  }
+
+  getElemId (index) {
+    return undefined
+  }
+
+  /**
+   * Iterates over the text elements character by character, including any
+   * inline objects.
+   */
+  [Symbol.iterator] () {
+    let elems = this.elems, index = -1
+    return {
+      next () {
+        index += 1
+        if (index < elems.length) {
+          return {done: false, value: elems[index]}
+        } else {
+          return {done: true}
+        }
+      }
+    }
+  }
+
+  /**
+   * Returns the content of the Text object as a simple string, ignoring any
+   * non-character elements.
+   */
+  toString() {
+    // Concatting to a string is faster than creating an array and then
+    // .join()ing for small (<100KB) arrays.
+    // https://jsperf.com/join-vs-loop-w-type-test
+    let str = ''
+    for (const elem of this.elems) {
+      if (typeof elem === 'string') str += elem
+    }
+    return str
+  }
+
+  /**
+   * Returns the content of the Text object as a sequence of strings,
+   * interleaved with non-character elements.
+   *
+   * For example, the value ['a', 'b', {x: 3}, 'c', 'd'] has spans:
+   * => ['ab', {x: 3}, 'cd']
+   */
+  toSpans() {
+    let spans = []
+    let chars = ''
+    for (const elem of this.elems) {
+      if (typeof elem === 'string') {
+        chars += elem
+      } else {
+        if (chars.length > 0) {
+          spans.push(chars)
+          chars = ''
+        }
+        spans.push(elem)
+      }
+    }
+    if (chars.length > 0) {
+      spans.push(chars)
+    }
+    return spans
+  }
+
+  /**
+   * Returns the content of the Text object as a simple string, so that the
+   * JSON serialization of an Automerge document represents text nicely.
+   */
+  toJSON() {
+    return this.toString()
+  }
+
+  /**
+   * Updates the list item at position `index` to a new value `value`.
+   */
+  set (index, value) {
+    this.elems[index] = value
+  }
+
+  /**
+   * Inserts new list items `values` starting at position `index`.
+   */
+  insertAt(index, ...values) {
+    this.elems.splice(index, 0, ... values)
+  }
+
+  /**
+   * Deletes `numDelete` list items starting at position `index`.
+   * if `numDelete` is not given, one item is deleted.
+   */
+  deleteAt(index, numDelete = 1) {
+    this.elems.splice(index, numDelete)
+  }
+}
+
+// Read-only methods that can delegate to the JavaScript built-in array
+for (let method of ['concat', 'every', 'filter', 'find', 'findIndex', 'forEach', 'includes',
+                    'indexOf', 'join', 'lastIndexOf', 'map', 'reduce', 'reduceRight',
+                    'slice', 'some', 'toLocaleString']) {
+  Text.prototype[method] = function (...args) {
+    const array = [...this]
+    return array[method](...args)
+  }
+}
+
+module.exports = { Text }

automerge-js/src/uuid.js

@@ -0,0 +1,16 @@
+const { v4: uuid } = require('uuid')
+
+function defaultFactory() {
+  return uuid().replace(/-/g, '')
+}
+
+let factory = defaultFactory
+
+function makeUuid() {
+  return factory()
+}
+
+makeUuid.setFactory = newFactory => { factory = newFactory }
+makeUuid.reset = () => { factory = defaultFactory }
+
+module.exports = makeUuid

automerge-js/test/basic_test.js

@@ -0,0 +1,164 @@
+
+const assert = require('assert')
+const util = require('util')
+const Automerge = require('..')
+
+describe('Automerge', () => {
+    describe('basics', () => {
+        it('should init clone and free', () => {
+            let doc1 = Automerge.init()
+            let doc2 = Automerge.clone(doc1);
+        })
+
+        it('handle basic set and read on root object', () => {
+            let doc1 = Automerge.init()
+            let doc2 = Automerge.change(doc1, (d) => {
+              d.hello = "world"
+              d.big = "little"
+              d.zip = "zop"
+              d.app = "dap"
+            assert.deepEqual(d, {  hello: "world", big: "little", zip: "zop", app: "dap" })
+            })
+            assert.deepEqual(doc2, {  hello: "world", big: "little", zip: "zop", app: "dap" })
+        })
+
+        it('handle basic sets over many changes', () => {
+            let doc1 = Automerge.init()
+            let timestamp = new Date();
+            let counter = new Automerge.Counter(100);
+            let bytes = new Uint8Array([10,11,12]);
+            let doc2 = Automerge.change(doc1, (d) => {
+              d.hello = "world"
+            })
+            let doc3 = Automerge.change(doc2, (d) => {
+              d.counter1 = counter
+            })
+            let doc4 = Automerge.change(doc3, (d) => {
+              d.timestamp1 = timestamp
+            })
+            let doc5 = Automerge.change(doc4, (d) => {
+              d.app = null
+            })
+            let doc6 = Automerge.change(doc5, (d) => {
+              d.bytes1 = bytes
+            })
+            let doc7 = Automerge.change(doc6, (d) => {
+              d.uint = new Automerge.Uint(1)
+              d.int = new Automerge.Int(-1)
+              d.float64 = new Automerge.Float64(5.5)
+              d.number1 = 100
+              d.number2 = -45.67
+              d.true = true
+              d.false = false
+            })
+
+            assert.deepEqual(doc7, {  hello: "world", true: true, false: false, int: -1, uint: 1, float64: 5.5, number1: 100, number2: -45.67, counter1: counter, timestamp1: timestamp, bytes1: bytes, app: null })
+
+            let changes = Automerge.getAllChanges(doc7)
+            let t1 = Automerge.init()
+            ;let [t2] = Automerge.applyChanges(t1, changes)
+            assert.deepEqual(doc7,t2)
+        })
+
+        it('handle overwrites to values', () => {
+            let doc1 = Automerge.init()
+            let doc2 = Automerge.change(doc1, (d) => {
+              d.hello = "world1"
+            })
+            let doc3 = Automerge.change(doc2, (d) => {
+              d.hello = "world2"
+            })
+            let doc4 = Automerge.change(doc3, (d) => {
+              d.hello = "world3"
+            })
+            let doc5 = Automerge.change(doc4, (d) => {
+              d.hello = "world4"
+            })
+            assert.deepEqual(doc5, {  hello: "world4" } )
+        })
+
+        it('handle set with object value', () => {
+            let doc1 = Automerge.init()
+            let doc2 = Automerge.change(doc1, (d) => {
+              d.subobj = { hello: "world", subsubobj: { zip: "zop" } }
+            })
+            assert.deepEqual(doc2, { subobj:  { hello: "world", subsubobj: { zip: "zop" } } })
+        })
+
+        it('handle simple list creation', () => {
+            let doc1 = Automerge.init()
+            let doc2 = Automerge.change(doc1, (d) => d.list = [])
+            assert.deepEqual(doc2, { list: []})
+        })
+
+        it('handle simple lists', () => {
+            let doc1 = Automerge.init()
+            let doc2 = Automerge.change(doc1, (d) => {
+              d.list = [ 1, 2, 3 ]
+            })
+            assert.deepEqual(doc2.list.length, 3)
+            assert.deepEqual(doc2.list[0], 1)
+            assert.deepEqual(doc2.list[1], 2)
+            assert.deepEqual(doc2.list[2], 3)
+            assert.deepEqual(doc2, { list: [1,2,3] })
+           // assert.deepStrictEqual(Automerge.toJS(doc2), { list: [1,2,3] })
+
+            let doc3 = Automerge.change(doc2, (d) => {
+              d.list[1] = "a"
+            })
+
+            assert.deepEqual(doc3.list.length, 3)
+            assert.deepEqual(doc3.list[0], 1)
+            assert.deepEqual(doc3.list[1], "a")
+            assert.deepEqual(doc3.list[2], 3)
+            assert.deepEqual(doc3, { list: [1,"a",3] })
+        })
+        it('handle simple lists', () => {
+            let doc1 = Automerge.init()
+            let doc2 = Automerge.change(doc1, (d) => {
+              d.list = [ 1, 2, 3 ]
+            })
+            let changes = Automerge.getChanges(doc1, doc2)
+            let docB1 = Automerge.init()
+            ;let [docB2] = Automerge.applyChanges(docB1, changes)
+            assert.deepEqual(docB2, doc2);
+        })
+        it('handle text', () => {
+            let doc1 = Automerge.init()
+            let tmp = new Automerge.Text("hello")
+            let doc2 = Automerge.change(doc1, (d) => {
+              d.list = new Automerge.Text("hello")
+              d.list.insertAt(2,"Z")
+            })
+            let changes = Automerge.getChanges(doc1, doc2)
+            let docB1 = Automerge.init()
+            ;let [docB2] = Automerge.applyChanges(docB1, changes)
+            assert.deepEqual(docB2, doc2);
+        })
+
+        it('have many list methods', () => {
+            let doc1 = Automerge.from({ list: [1,2,3] })
+            assert.deepEqual(doc1, { list: [1,2,3] });
+            let doc2 = Automerge.change(doc1, (d) => {
+              d.list.splice(1,1,9,10)
+            })
+            assert.deepEqual(doc2, { list: [1,9,10,3] });
+            let doc3 = Automerge.change(doc2, (d) => {
+              d.list.push(11,12)
+            })
+            assert.deepEqual(doc3, { list: [1,9,10,3,11,12] });
+            let doc4 = Automerge.change(doc3, (d) => {
+              d.list.unshift(2,2)
+            })
+            assert.deepEqual(doc4, { list: [2,2,1,9,10,3,11,12] });
+            let doc5 = Automerge.change(doc4, (d) => {
+              d.list.shift()
+            })
+            assert.deepEqual(doc5, { list: [2,1,9,10,3,11,12] });
+            let doc6 = Automerge.change(doc5, (d) => {
+              d.list.insertAt(3,100,101)
+            })
+            assert.deepEqual(doc6, { list: [2,1,9,100,101,10,3,11,12] });
+        })
+    })
+})

automerge-js/test/columnar_test.js

@@ -0,0 +1,97 @@
+const assert = require('assert')
+const { checkEncoded } = require('./helpers')
+const Automerge = require('..')
+const { encodeChange, decodeChange } =  Automerge
+
+describe('change encoding', () => {
+  it('should encode text edits', () => {
+    /*
+    const change1 = {actor: 'aaaa', seq: 1, startOp: 1, time: 9, message: '', deps: [], ops: [
+      {action: 'makeText', obj: '_root', key: 'text', insert: false, pred: []},
+      {action: 'set', obj: '1@aaaa', elemId: '_head', insert: true, value: 'h', pred: []},
+      {action: 'del', obj: '1@aaaa', elemId: '2@aaaa', insert: false, pred: ['2@aaaa']},
+      {action: 'set', obj: '1@aaaa', elemId: '_head', insert: true, value: 'H', pred: []},
+      {action: 'set', obj: '1@aaaa', elemId: '4@aaaa', insert: true, value: 'i', pred: []}
+    ]}
+    */
+    const change1 = {actor: 'aaaa', seq: 1, startOp: 1, time: 9, message: null, deps: [], ops: [
+      {action: 'makeText', obj: '_root', key: 'text', pred: []},
+      {action: 'set', obj: '1@aaaa', elemId: '_head', insert: true, value: 'h', pred: []},
+      {action: 'del', obj: '1@aaaa', elemId: '2@aaaa', pred: ['2@aaaa']},
+      {action: 'set', obj: '1@aaaa', elemId: '_head', insert: true, value: 'H', pred: []},
+      {action: 'set', obj: '1@aaaa', elemId: '4@aaaa', insert: true, value: 'i', pred: []}
+    ]}
+    checkEncoded(encodeChange(change1), [
+      0x85, 0x6f, 0x4a, 0x83, // magic bytes
+      0xe2, 0xbd, 0xfb, 0xf5, // checksum
+      1, 94, 0, 2, 0xaa, 0xaa, // chunkType: change, length, deps, actor 'aaaa'
+      1, 1, 9, 0, 0, // seq, startOp, time, message, actor list
+      12, 0x01, 4, 0x02, 4, // column count, objActor, objCtr
+      0x11, 8, 0x13, 7, 0x15, 8, // keyActor, keyCtr, keyStr
+      0x34, 4, 0x42, 6, // insert, action
+      0x56, 6, 0x57, 3, // valLen, valRaw
+      0x70, 6, 0x71, 2, 0x73, 2, // predNum, predActor, predCtr
+      0, 1, 4, 0, // objActor column: null, 0, 0, 0, 0
+      0, 1, 4, 1, // objCtr column: null, 1, 1, 1, 1
+      0, 2, 0x7f, 0, 0, 1, 0x7f, 0, // keyActor column: null, null, 0, null, 0
+      0, 1, 0x7c, 0, 2, 0x7e, 4, // keyCtr column: null, 0, 2, 0, 4
+      0x7f, 4, 0x74, 0x65, 0x78, 0x74, 0, 4, // keyStr column: 'text', null, null, null, null
+      1, 1, 1, 2, // insert column: false, true, false, true, true
+      0x7d, 4, 1, 3, 2, 1, // action column: makeText, set, del, set, set
+      0x7d, 0, 0x16, 0, 2, 0x16, // valLen column: 0, 0x16, 0, 0x16, 0x16
+      0x68, 0x48, 0x69, // valRaw column: 'h', 'H', 'i'
+      2, 0, 0x7f, 1, 2, 0, // predNum column: 0, 0, 1, 0, 0
+      0x7f, 0, // predActor column: 0
+      0x7f, 2 // predCtr column: 2
+    ])
+    const decoded = decodeChange(encodeChange(change1))
+    assert.deepStrictEqual(decoded, Object.assign({hash: decoded.hash}, change1))
+  })
+
+  // FIXME - skipping this b/c it was never implemented in the rust impl and isnt trivial
+/*
+  it.skip('should require strict ordering of preds', () => {
+    const change = new Uint8Array([
+      133, 111, 74, 131, 31, 229, 112, 44, 1, 105, 1, 58, 30, 190, 100, 253, 180, 180, 66, 49, 126,
+      81, 142, 10, 3, 35, 140, 189, 231, 34, 145, 57, 66, 23, 224, 149, 64, 97, 88, 140, 168, 194,
+      229, 4, 244, 209, 58, 138, 67, 140, 1, 152, 236, 250, 2, 0, 1, 4, 55, 234, 66, 242, 8, 21, 11,
+      52, 1, 66, 2, 86, 3, 87, 10, 112, 2, 113, 3, 115, 4, 127, 9, 99, 111, 109, 109, 111, 110, 86,
+      97, 114, 1, 127, 1, 127, 166, 1, 52, 48, 57, 49, 52, 57, 52, 53, 56, 50, 127, 2, 126, 0, 1,
+      126, 139, 1, 0
+    ])
+    assert.throws(() => { decodeChange(change) }, /operation IDs are not in ascending order/)
+  })
+*/
+
+  describe('with trailing bytes', () => {
+    let change = new Uint8Array([
+      0x85, 0x6f, 0x4a, 0x83, // magic bytes
+      0xb2, 0x98, 0x9e, 0xa9, // checksum
+      1, 61, 0, 2, 0x12, 0x34, // chunkType: change, length, deps, actor '1234'
+      1, 1, 252, 250, 220, 255, 5, // seq, startOp, time
+      14, 73, 110, 105, 116, 105, 97, 108, 105, 122, 97, 116, 105, 111, 110, // message: 'Initialization'
+      0, 6, // actor list, column count
+      0x15, 3, 0x34, 1, 0x42, 2, // keyStr, insert, action
+      0x56, 2, 0x57, 1, 0x70, 2, // valLen, valRaw, predNum
+      0x7f, 1, 0x78, // keyStr: 'x'
+      1, // insert: false
+      0x7f, 1, // action: set
+      0x7f, 19, // valLen: 1 byte of type uint
+      1, // valRaw: 1
+      0x7f, 0, // predNum: 0
+      0, 1, 2, 3, 4, 5, 6, 7, 8, 9 // 10 trailing bytes
+    ])
+
+    it('should allow decoding and re-encoding', () => {
+      // NOTE: This calls the JavaScript encoding and decoding functions, even when the WebAssembly
+      // backend is loaded. Should the wasm backend export its own functions for testing?
+      checkEncoded(change, encodeChange(decodeChange(change)))
+    })
+
+    it('should be preserved in document encoding', () => {
+      const [doc] = Automerge.applyChanges(Automerge.init(), [change])
+      const [reconstructed] = Automerge.getAllChanges(Automerge.load(Automerge.save(doc)))
+      checkEncoded(change, reconstructed)
+    })
+  })
+})

automerge-js/test/helpers.js

@@ -1,21 +1,16 @@
-import * as assert from "assert"
+const assert = require('assert')
-import { Encoder } from "./legacy/encoding"
+const { Encoder } = require('../src/encoding')
 
 // Assertion that succeeds if the first argument deepStrictEquals at least one of the
 // subsequent arguments (but we don't care which one)
-export function assertEqualsOneOf(actual, ...expected) {
+function assertEqualsOneOf(actual, ...expected) {
   assert(expected.length > 0)
   for (let i = 0; i < expected.length; i++) {
     try {
       assert.deepStrictEqual(actual, expected[i])
       return // if we get here without an exception, that means success
     } catch (e) {
-      if (e instanceof assert.AssertionError) {
+      if (!e.name.match(/^AssertionError/) || i === expected.length - 1) throw e
-        if (!e.name.match(/^AssertionError/) || i === expected.length - 1)
-          throw e
-      } else {
-        throw e
-      }
     }
   }
 }
@@ -24,13 +19,14 @@ export function assertEqualsOneOf(actual, ...expected) {
  * Asserts that the byte array maintained by `encoder` contains the same byte
  * sequence as the array `bytes`.
  */
-export function checkEncoded(encoder, bytes, detail?) {
+function checkEncoded(encoder, bytes, detail) {
-  const encoded = encoder instanceof Encoder ? encoder.buffer : encoder
+  const encoded = (encoder instanceof Encoder) ? encoder.buffer : encoder
   const expected = new Uint8Array(bytes)
-  const message =
+  const message = (detail ? `${detail}: ` : '') + `${encoded} expected to equal ${expected}`
-    (detail ? `${detail}: ` : "") + `${encoded} expected to equal ${expected}`
   assert(encoded.byteLength === expected.byteLength, message)
   for (let i = 0; i < encoded.byteLength; i++) {
     assert(encoded[i] === expected[i], message)
   }
 }
+
+module.exports = { assertEqualsOneOf, checkEncoded }

automerge-js/test/text_test.js

@@ -0,0 +1,697 @@
+const assert = require('assert')
+const Automerge = require('..')
+const { assertEqualsOneOf } = require('./helpers')
+
+function attributeStateToAttributes(accumulatedAttributes) {
+  const attributes = {}
+  Object.entries(accumulatedAttributes).forEach(([key, values]) => {
+    if (values.length && values[0] !== null) {
+      attributes[key] = values[0]
+    }
+  })
+  return attributes
+}
+
+function isEquivalent(a, b) {
+  const aProps = Object.getOwnPropertyNames(a)
+  const bProps = Object.getOwnPropertyNames(b)
+
+  if (aProps.length != bProps.length) {
+      return false
+  }
+
+  for (let i = 0; i < aProps.length; i++) {
+    const propName = aProps[i]
+      if (a[propName] !== b[propName]) {
+          return false
+      }
+  }
+
+  return true
+}
+
+function isControlMarker(pseudoCharacter) {
+  return typeof pseudoCharacter === 'object' && pseudoCharacter.attributes
+}
+
+function opFrom(text, attributes) {
+  let op = { insert: text }
+  if (Object.keys(attributes).length > 0) {
+      op.attributes = attributes
+  }
+  return op
+}
+
+function accumulateAttributes(span, accumulatedAttributes) {
+  Object.entries(span).forEach(([key, value]) => {
+    if (!accumulatedAttributes[key]) {
+      accumulatedAttributes[key] = []
+    }
+    if (value === null) {
+      if (accumulatedAttributes[key].length === 0 || accumulatedAttributes[key] === null) {
+        accumulatedAttributes[key].unshift(null)
+      } else {
+        accumulatedAttributes[key].shift()
+      }
+    } else {
+      if (accumulatedAttributes[key][0] === null) {
+        accumulatedAttributes[key].shift()
+      } else {
+        accumulatedAttributes[key].unshift(value)
+      }
+    }
+  })
+  return accumulatedAttributes
+}
+
+function automergeTextToDeltaDoc(text) {
+  let ops = []
+  let controlState = {}
+  let currentString = ""
+  let attributes = {}
+  text.toSpans().forEach((span) => {
+    if (isControlMarker(span)) {
+      controlState = accumulateAttributes(span.attributes, controlState)
+    } else {
+      let next = attributeStateToAttributes(controlState)
+
+      // if the next span has the same calculated attributes as the current span
+      // don't bother outputting it as a separate span, just let it ride
+      if (typeof span === 'string' && isEquivalent(next, attributes)) {
+          currentString = currentString + span
+          return
+      }
+
+      if (currentString) {
+        ops.push(opFrom(currentString, attributes))
+      }
+
+      // If we've got a string, we might be able to concatenate it to another
+      // same-attributed-string, so remember it and go to the next iteration.
+      if (typeof span === 'string') {
+        currentString = span
+        attributes = next
+      } else {
+        // otherwise we have an embed "character" and should output it immediately.
+        // embeds are always one-"character" in length.
+        ops.push(opFrom(span, next))
+        currentString = ''
+        attributes = {}
+      }
+    }
+  })
+
+  // at the end, flush any accumulated string out
+  if (currentString) {
+    ops.push(opFrom(currentString, attributes))
+  }
+
+  return ops
+}
+
+function inverseAttributes(attributes) {
+  let invertedAttributes = {}
+  Object.keys(attributes).forEach((key) => {
+    invertedAttributes[key] = null
+  })
+  return invertedAttributes
+}
+
+function applyDeleteOp(text, offset, op) {
+  let length = op.delete
+  while (length > 0) {
+    if (isControlMarker(text.get(offset))) {
+      offset += 1
+    } else {
+      // we need to not delete control characters, but we do delete embed characters
+      text.deleteAt(offset, 1)
+      length -= 1
+    }
+  }
+  return [text, offset]
+}
+
+function applyRetainOp(text, offset, op) {
+  let length = op.retain
+
+  if (op.attributes) {
+    text.insertAt(offset, { attributes: op.attributes })
+    offset += 1
+  }
+
+  while (length > 0) {
+    const char = text.get(offset)
+    offset += 1
+    if (!isControlMarker(char)) {
+      length -= 1
+    }
+  }
+
+  if (op.attributes) {
+    text.insertAt(offset, { attributes: inverseAttributes(op.attributes) })
+    offset += 1
+  }
+
+  return [text, offset]
+}
+
+
+function applyInsertOp(text, offset, op) {
+  let originalOffset = offset
+
+  if (typeof op.insert === 'string') {
+    text.insertAt(offset, ...op.insert.split(''))
+    offset += op.insert.length
+  } else {
+    // we have an embed or something similar
+    text.insertAt(offset, op.insert)
+    offset += 1
+  }
+
+  if (op.attributes) {
+    text.insertAt(originalOffset, { attributes: op.attributes })
+    offset += 1
+  }
+  if (op.attributes) {
+    text.insertAt(offset, { attributes: inverseAttributes(op.attributes) })
+    offset += 1
+  }
+  return [text, offset]
+}
+
+// XXX: uhhhhh, why can't I pass in text?
+function applyDeltaDocToAutomergeText(delta, doc) {
+  let offset = 0
+
+  delta.forEach(op => {
+    if (op.retain) {
+      [, offset] = applyRetainOp(doc.text, offset, op)
+    } else if (op.delete) {
+      [, offset] = applyDeleteOp(doc.text, offset, op)
+    } else if (op.insert) {
+      [, offset] = applyInsertOp(doc.text, offset, op)
+    }
+  })
+}
+
+describe('Automerge.Text', () => {
+  let s1, s2
+  beforeEach(() => {
+    s1 = Automerge.change(Automerge.init(), doc => doc.text = new Automerge.Text())
+    s2 = Automerge.merge(Automerge.init(), s1)
+  })
+
+  it('should support insertion', () => {
+    s1 = Automerge.change(s1, doc => doc.text.insertAt(0, 'a'))
+    assert.strictEqual(s1.text.length, 1)
+    assert.strictEqual(s1.text.get(0), 'a')
+    assert.strictEqual(s1.text.toString(), 'a')
+    //assert.strictEqual(s1.text.getElemId(0), `2@${Automerge.getActorId(s1)}`)
+  })
+
+  it('should support deletion', () => {
+    s1 = Automerge.change(s1, doc => doc.text.insertAt(0, 'a', 'b', 'c'))
+    s1 = Automerge.change(s1, doc => doc.text.deleteAt(1, 1))
+    assert.strictEqual(s1.text.length, 2)
+    assert.strictEqual(s1.text.get(0), 'a')
+    assert.strictEqual(s1.text.get(1), 'c')
+    assert.strictEqual(s1.text.toString(), 'ac')
+  })
+
+  it("should support implicit and explicit deletion", () => {
+    s1 = Automerge.change(s1, doc => doc.text.insertAt(0, "a", "b", "c"))
+    s1 = Automerge.change(s1, doc => doc.text.deleteAt(1))
+    s1 = Automerge.change(s1, doc => doc.text.deleteAt(1, 0))
+    assert.strictEqual(s1.text.length, 2)
+    assert.strictEqual(s1.text.get(0), "a")
+    assert.strictEqual(s1.text.get(1), "c")
+    assert.strictEqual(s1.text.toString(), "ac")
+  })
+
+  it('should handle concurrent insertion', () => {
+    s1 = Automerge.change(s1, doc => doc.text.insertAt(0, 'a', 'b', 'c'))
+    s2 = Automerge.change(s2, doc => doc.text.insertAt(0, 'x', 'y', 'z'))
+    s1 = Automerge.merge(s1, s2)
+    assert.strictEqual(s1.text.length, 6)
+    assertEqualsOneOf(s1.text.toString(), 'abcxyz', 'xyzabc')
+    assertEqualsOneOf(s1.text.join(''), 'abcxyz', 'xyzabc')
+  })
+
+  it('should handle text and other ops in the same change', () => {
+    s1 = Automerge.change(s1, doc => {
+      doc.foo = 'bar'
+      doc.text.insertAt(0, 'a')
+    })
+    assert.strictEqual(s1.foo, 'bar')
+    assert.strictEqual(s1.text.toString(), 'a')
+    assert.strictEqual(s1.text.join(''), 'a')
+  })
+
+  it('should serialize to JSON as a simple string', () => {
+    s1 = Automerge.change(s1, doc => doc.text.insertAt(0, 'a', '"', 'b'))
+    assert.strictEqual(JSON.stringify(s1), '{"text":"a\\"b"}')
+  })
+
+  it('should allow modification before an object is assigned to a document', () => {
+    s1 = Automerge.change(Automerge.init(), doc => {
+      const text = new Automerge.Text()
+      text.insertAt(0, 'a', 'b', 'c', 'd')
+      text.deleteAt(2)
+      doc.text = text
+      assert.strictEqual(doc.text.toString(), 'abd')
+      assert.strictEqual(doc.text.join(''), 'abd')
+    })
+    assert.strictEqual(s1.text.toString(), 'abd')
+    assert.strictEqual(s1.text.join(''), 'abd')
+  })
+
+  it('should allow modification after an object is assigned to a document', () => {
+    s1 = Automerge.change(Automerge.init(), doc => {
+      const text = new Automerge.Text()
+      doc.text = text
+      doc.text.insertAt(0, 'a', 'b', 'c', 'd')
+      doc.text.deleteAt(2)
+      assert.strictEqual(doc.text.toString(), 'abd')
+      assert.strictEqual(doc.text.join(''), 'abd')
+    })
+    assert.strictEqual(s1.text.join(''), 'abd')
+  })
+
+  it('should not allow modification outside of a change callback', () => {
+    assert.throws(() => s1.text.insertAt(0, 'a'), /object cannot be modified outside of a change block/)
+  })
+
+  describe('with initial value', () => {
+    it('should accept a string as initial value', () => {
+      let s1 = Automerge.change(Automerge.init(), doc => doc.text = new Automerge.Text('init'))
+      assert.strictEqual(s1.text.length, 4)
+      assert.strictEqual(s1.text.get(0), 'i')
+      assert.strictEqual(s1.text.get(1), 'n')
+      assert.strictEqual(s1.text.get(2), 'i')
+      assert.strictEqual(s1.text.get(3), 't')
+      assert.strictEqual(s1.text.toString(), 'init')
+    })
+
+    it('should accept an array as initial value', () => {
+      let s1 = Automerge.change(Automerge.init(), doc => doc.text = new Automerge.Text(['i', 'n', 'i', 't']))
+      assert.strictEqual(s1.text.length, 4)
+      assert.strictEqual(s1.text.get(0), 'i')
+      assert.strictEqual(s1.text.get(1), 'n')
+      assert.strictEqual(s1.text.get(2), 'i')
+      assert.strictEqual(s1.text.get(3), 't')
+      assert.strictEqual(s1.text.toString(), 'init')
+    })
+
+    it('should initialize text in Automerge.from()', () => {
+      let s1 = Automerge.from({text: new Automerge.Text('init')})
+      assert.strictEqual(s1.text.length, 4)
+      assert.strictEqual(s1.text.get(0), 'i')
+      assert.strictEqual(s1.text.get(1), 'n')
+      assert.strictEqual(s1.text.get(2), 'i')
+      assert.strictEqual(s1.text.get(3), 't')
+      assert.strictEqual(s1.text.toString(), 'init')
+    })
+
+    it('should encode the initial value as a change', () => {
+      const s1 = Automerge.from({text: new Automerge.Text('init')})
+      const changes = Automerge.getAllChanges(s1)
+      assert.strictEqual(changes.length, 1)
+      const [s2] = Automerge.applyChanges(Automerge.init(), changes)
+      assert.strictEqual(s2.text instanceof Automerge.Text, true)
+      assert.strictEqual(s2.text.toString(), 'init')
+      assert.strictEqual(s2.text.join(''), 'init')
+    })
+
+    it('should allow immediate access to the value', () => {
+      Automerge.change(Automerge.init(), doc => {
+        const text = new Automerge.Text('init')
+        assert.strictEqual(text.length, 4)
+        assert.strictEqual(text.get(0), 'i')
+        assert.strictEqual(text.toString(), 'init')
+        doc.text = text
+        assert.strictEqual(doc.text.length, 4)
+        assert.strictEqual(doc.text.get(0), 'i')
+        assert.strictEqual(doc.text.toString(), 'init')
+      })
+    })
+
+    it('should allow pre-assignment modification of the initial value', () => {
+      let s1 = Automerge.change(Automerge.init(), doc => {
+        const text = new Automerge.Text('init')
+        text.deleteAt(3)
+        assert.strictEqual(text.join(''), 'ini')
+        doc.text = text
+        assert.strictEqual(doc.text.join(''), 'ini')
+        assert.strictEqual(doc.text.toString(), 'ini')
+      })
+      assert.strictEqual(s1.text.toString(), 'ini')
+      assert.strictEqual(s1.text.join(''), 'ini')
+    })
+
+    it('should allow post-assignment modification of the initial value', () => {
+      let s1 = Automerge.change(Automerge.init(), doc => {
+        const text = new Automerge.Text('init')
+        doc.text = text
+        doc.text.deleteAt(0)
+        doc.text.insertAt(0, 'I')
+        assert.strictEqual(doc.text.join(''), 'Init')
+        assert.strictEqual(doc.text.toString(), 'Init')
+      })
+      assert.strictEqual(s1.text.join(''), 'Init')
+      assert.strictEqual(s1.text.toString(), 'Init')
+    })
+  })
+
+  describe('non-textual control characters', () => {
+    let s1
+    beforeEach(() => {
+      s1 = Automerge.change(Automerge.init(), doc => {
+        doc.text = new Automerge.Text()
+        doc.text.insertAt(0, 'a')
+        doc.text.insertAt(1, { attribute: 'bold' })
+      })
+    })
+
+    it('should allow fetching non-textual characters', () => {
+      assert.deepEqual(s1.text.get(1), { attribute: 'bold' })
+      //assert.strictEqual(s1.text.getElemId(1), `3@${Automerge.getActorId(s1)}`)
+    })
+
+    it('should include control characters in string length', () => {
+      assert.strictEqual(s1.text.length, 2)
+      assert.strictEqual(s1.text.get(0), 'a')
+    })
+
+    it('should exclude control characters from toString()', () => {
+      assert.strictEqual(s1.text.toString(), 'a')
+    })
+
+    it('should allow control characters to be updated', () => {
+      const s2 = Automerge.change(s1, doc => doc.text.get(1).attribute = 'italic')
+      const s3 = Automerge.load(Automerge.save(s2))
+      assert.strictEqual(s1.text.get(1).attribute, 'bold')
+      assert.strictEqual(s2.text.get(1).attribute, 'italic')
+      assert.strictEqual(s3.text.get(1).attribute, 'italic')
+    })
+
+    describe('spans interface to Text', () => {
+      it('should return a simple string as a single span', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('hello world')
+        })
+        assert.deepEqual(s1.text.toSpans(), ['hello world'])
+      })
+      it('should return an empty string as an empty array', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text()
+        })
+        assert.deepEqual(s1.text.toSpans(), [])
+      })
+      it('should split a span at a control character', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('hello world')
+          doc.text.insertAt(5, { attributes: { bold: true } })
+        })
+        assert.deepEqual(s1.text.toSpans(),
+          ['hello', { attributes: { bold: true } }, ' world'])
+      })
+      it('should allow consecutive control characters', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('hello world')
+          doc.text.insertAt(5, { attributes: { bold: true } })
+          doc.text.insertAt(6, { attributes: { italic: true } })
+        })
+        assert.deepEqual(s1.text.toSpans(),
+          ['hello',
+           { attributes: { bold: true } },
+           { attributes: { italic: true } },
+           ' world'
+          ])
+      })
+      it('should allow non-consecutive control characters', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('hello world')
+          doc.text.insertAt(5, { attributes: { bold: true } })
+          doc.text.insertAt(12, { attributes: { italic: true } })
+        })
+        assert.deepEqual(s1.text.toSpans(),
+          ['hello',
+           { attributes: { bold: true } },
+           ' world',
+           { attributes: { italic: true } }
+          ])
+      })
+
+      it('should be convertable into a Quill delta', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('Gandalf the Grey')
+          doc.text.insertAt(0,  { attributes: { bold: true } })
+          doc.text.insertAt(7 + 1, { attributes: { bold: null } })
+          doc.text.insertAt(12 + 2, { attributes: { color: '#cccccc' } })
+        })
+
+        let deltaDoc = automergeTextToDeltaDoc(s1.text)
+
+        // From https://quilljs.com/docs/delta/
+        let expectedDoc = [
+          { insert: 'Gandalf', attributes: { bold: true } },
+          { insert: ' the ' },
+          { insert: 'Grey', attributes: { color: '#cccccc' } }
+        ]
+
+        assert.deepEqual(deltaDoc, expectedDoc)
+      })
+
+      it('should support embeds', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('')
+          doc.text.insertAt(0, { attributes: { link: 'https://quilljs.com' } })
+          doc.text.insertAt(1, {
+            image: 'https://quilljs.com/assets/images/icon.png'
+          })
+          doc.text.insertAt(2, { attributes: { link: null } })
+        })
+
+        let deltaDoc = automergeTextToDeltaDoc(s1.text)
+
+        // From https://quilljs.com/docs/delta/
+        let expectedDoc = [{
+          // An image link
+          insert: {
+            image: 'https://quilljs.com/assets/images/icon.png'
+          },
+          attributes: {
+            link: 'https://quilljs.com'
+          }
+        }]
+
+        assert.deepEqual(deltaDoc, expectedDoc)
+      })
+
+      it('should handle concurrent overlapping spans', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('Gandalf the Grey')
+        })
+
+        let s2 = Automerge.merge(Automerge.init(), s1)
+
+        let s3 = Automerge.change(s1, doc => {
+          doc.text.insertAt(8,  { attributes: { bold: true } })
+          doc.text.insertAt(16 + 1, { attributes: { bold: null } })
+        })
+
+        let s4 = Automerge.change(s2, doc => {
+          doc.text.insertAt(0,  { attributes: { bold: true } })
+          doc.text.insertAt(11 + 1, { attributes: { bold: null } })
+        })
+
+        let merged = Automerge.merge(s3, s4)
+
+        let deltaDoc = automergeTextToDeltaDoc(merged.text)
+
+        // From https://quilljs.com/docs/delta/
+        let expectedDoc = [
+          { insert: 'Gandalf the Grey', attributes: { bold: true } },
+        ]
+
+        assert.deepEqual(deltaDoc, expectedDoc)
+      })
+
+      it('should handle debolding spans', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('Gandalf the Grey')
+        })
+
+        let s2 = Automerge.merge(Automerge.init(), s1)
+
+        let s3 = Automerge.change(s1, doc => {
+          doc.text.insertAt(0,  { attributes: { bold: true } })
+          doc.text.insertAt(16 + 1, { attributes: { bold: null } })
+        })
+
+        let s4 = Automerge.change(s2, doc => {
+          doc.text.insertAt(8,  { attributes: { bold: null } })
+          doc.text.insertAt(11 + 1, { attributes: { bold: true } })
+        })
+
+
+        let merged = Automerge.merge(s3, s4)
+
+        let deltaDoc = automergeTextToDeltaDoc(merged.text)
+
+        // From https://quilljs.com/docs/delta/
+        let expectedDoc = [
+          { insert: 'Gandalf ', attributes: { bold: true } },
+          { insert: 'the' },
+          { insert: ' Grey', attributes: { bold: true } },
+        ]
+
+        assert.deepEqual(deltaDoc, expectedDoc)
+      })
+
+      // xxx: how would this work for colors?
+      it('should handle destyling across destyled spans', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('Gandalf the Grey')
+        })
+
+        let s2 = Automerge.merge(Automerge.init(), s1)
+
+        let s3 = Automerge.change(s1, doc => {
+          doc.text.insertAt(0,  { attributes: { bold: true } })
+          doc.text.insertAt(16 + 1, { attributes: { bold: null } })
+        })
+
+        let s4 = Automerge.change(s2, doc => {
+          doc.text.insertAt(8,  { attributes: { bold: null } })
+          doc.text.insertAt(11 + 1, { attributes: { bold: true } })
+        })
+
+        let merged = Automerge.merge(s3, s4)
+
+        let final = Automerge.change(merged, doc => {
+          doc.text.insertAt(3 + 1, { attributes: { bold: null } })
+          doc.text.insertAt(doc.text.length, { attributes: { bold: true } })
+        })
+
+        let deltaDoc = automergeTextToDeltaDoc(final.text)
+
+        // From https://quilljs.com/docs/delta/
+        let expectedDoc = [
+          { insert: 'Gan', attributes: { bold: true } },
+          { insert: 'dalf the Grey' },
+        ]
+
+        assert.deepEqual(deltaDoc, expectedDoc)
+      })
+
+      it('should apply an insert', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('Hello world')
+        })
+
+        const delta = [
+          { retain: 6 },
+          { insert: 'reader' },
+          { delete: 5 }
+        ]
+
+        let s2 = Automerge.change(s1, doc => {
+          applyDeltaDocToAutomergeText(delta, doc)
+        })
+
+        assert.strictEqual(s2.text.join(''), 'Hello reader')
+      })
+
+      it('should apply an insert with control characters', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('Hello world')
+        })
+
+        const delta = [
+          { retain: 6 },
+          { insert: 'reader', attributes: { bold: true } },
+          { delete: 5 },
+          { insert: '!' }
+        ]
+
+        let s2 = Automerge.change(s1, doc => {
+          applyDeltaDocToAutomergeText(delta, doc)
+        })
+
+        assert.strictEqual(s2.text.toString(), 'Hello reader!')
+        assert.deepEqual(s2.text.toSpans(), [
+          "Hello ",
+          { attributes: { bold: true } },
+          "reader",
+          { attributes: { bold: null } },
+          "!"
+        ])
+      })
+
+      it('should account for control characters in retain/delete lengths', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('Hello world')
+          doc.text.insertAt(4, { attributes: { color: '#ccc' } })
+          doc.text.insertAt(10, { attributes: { color: '#f00' } })
+        })
+
+        const delta = [
+          { retain: 6 },
+          { insert: 'reader', attributes: { bold: true } },
+          { delete: 5 },
+          { insert: '!' }
+        ]
+
+        let s2 = Automerge.change(s1, doc => {
+          applyDeltaDocToAutomergeText(delta, doc)
+        })
+
+        assert.strictEqual(s2.text.toString(), 'Hello reader!')
+        assert.deepEqual(s2.text.toSpans(), [
+          "Hell",
+          { attributes: { color: '#ccc'} },
+          "o ",
+          { attributes: { bold: true } },
+          "reader",
+          { attributes: { bold: null } },
+          { attributes: { color: '#f00'} },
+          "!"
+        ])
+      })
+
+      it('should support embeds', () => {
+        let s1 = Automerge.change(Automerge.init(), doc => {
+          doc.text = new Automerge.Text('')
+        })
+
+        let deltaDoc = [{
+          // An image link
+          insert: {
+            image: 'https://quilljs.com/assets/images/icon.png'
+          },
+          attributes: {
+            link: 'https://quilljs.com'
+          }
+        }]
+
+        let s2 = Automerge.change(s1, doc => {
+          applyDeltaDocToAutomergeText(deltaDoc, doc)
+        })
+
+        assert.deepEqual(s2.text.toSpans(), [
+          { attributes: { link: 'https://quilljs.com' } },
+          { image: 'https://quilljs.com/assets/images/icon.png'},
+          { attributes: { link: null } },
+        ])
+      })
+    })
+  })
+
+  it('should support unicode when creating text', () => {
+    s1 = Automerge.from({
+      text: new Automerge.Text('🐦')
+    })
+    assert.strictEqual(s1.text.get(0), '🐦')
+  })
+})

automerge-js/test/uuid_test.js

@@ -0,0 +1,32 @@
+const assert = require('assert')
+const Automerge = require('..')
+
+const uuid = Automerge.uuid
+
+describe('uuid', () => {
+  afterEach(() => {
+    uuid.reset()
+  })
+
+  describe('default implementation', () => {
+    it('generates unique values', () => {
+      assert.notEqual(uuid(), uuid())
+    })
+  })
+
+  describe('custom implementation', () => {
+    let counter
+
+    function customUuid() {
+      return `custom-uuid-${counter++}`
+    }
+
+    before(() => uuid.setFactory(customUuid))
+    beforeEach(() => counter = 0)
+
+    it('invokes the custom factory', () => {
+      assert.equal(uuid(), 'custom-uuid-0')
+      assert.equal(uuid(), 'custom-uuid-1')
+    })
+  })
+})

automerge-wasm/.gitignore

@@ -1,6 +1,5 @@
 /node_modules
-/bundler
+/dev
-/nodejs
+/target
-/deno
 Cargo.lock
 yarn.lock

automerge-wasm/Cargo.toml

@@ -9,7 +9,6 @@ categories = ["wasm"]
 readme = "README.md"
 edition = "2021"
 license = "MIT"
-rust-version = "1.57.0"
 
 [lib]
 crate-type = ["cdylib","rlib"]
@@ -28,16 +27,14 @@ serde = "^1.0"
 serde_json = "^1.0"
 rand = { version = "^0.8.4" }
 getrandom = { version = "^0.2.2", features=["js"] }
-uuid = { version = "^1.2.1", features=["v4", "js", "serde"] }
+uuid = { version = "^0.8.2", features=["v4", "wasm-bindgen", "serde"] }
-serde-wasm-bindgen = "0.4.3"
+serde-wasm-bindgen = "0.1.3"
 serde_bytes = "0.11.5"
 hex = "^0.4.3"
 regex = "^1.5"
-itertools = "^0.10.3"
-thiserror = "^1.0.16"
 
 [dependencies.wasm-bindgen]
-version = "^0.2.83"
+version = "^0.2"
 #features = ["std"]
 features = ["serde-serialize", "std"]
 
@@ -57,6 +54,5 @@ features = ["console"]
 
 [dev-dependencies]
 futures = "^0.1"
-proptest = { version = "^1.0.0", default-features = false, features = ["std"] }
 wasm-bindgen-futures = "^0.4"
 wasm-bindgen-test = "^0.3"

automerge-wasm/README.md

@@ -18,6 +18,34 @@ An Object id uniquely identifies a Map, List or Text object within a document.
 
 Heads refers to a set of hashes that uniquely identifies a point in time in a document's history.  Heads are useful for comparing documents state or retrieving past states from the document.
 
+### Using the Library and Creating a Document
+
+This is a rust/wasm package and will work in a node or web environment.  Node is able to load wasm synchronously but a web environment is not.  The default import of the package is a function that returns a promise that resolves once the wasm is loaded.
+
+This creates a document in node.  The memory allocated is handled by wasm and isn't managed by the javascript garbage collector and thus needs to be manually freed.
+
+```javascript
+  import { create } from "automerge-wasm"
+
+  let doc = create()
+
+  doc.free()
+```
+
+While this will work in both node and in a web context
+
+```javascript
+  import init, { create } from "automerge-wasm"
+
+  init().then(_ => {
+    let doc = create()
+    doc.free()
+  })
+
+```
+
+The examples below will assume a node context for brevity.
+
 ### Automerge Scalar Types
 
 Automerge has many scalar types.  Methods like `put()` and `insert()` take an optional data type parameter.  Normally the type can be inferred but in some cases, such as telling the difference between int, uint and a counter, it cannot.
@@ -25,7 +53,7 @@ Automerge has many scalar types.  Methods like `put()` and `insert()` take an op
 These are puts without a data type
 
 ```javascript
-  import { create } from "@automerge/automerge-wasm"
+  import { create } from "automerge-wasm"
 
   let doc = create()
   doc.put("/", "prop1", 100)  // int
@@ -35,6 +63,7 @@ These are puts without a data type
   doc.put("/", "prop5", new Uint8Array([1,2,3]))
   doc.put("/", "prop6", true)
   doc.put("/", "prop7", null)
+  doc.free()
 ```
 
 Put's with a data type and examples of all the supported data types.
@@ -42,7 +71,7 @@ Put's with a data type and examples of all the supported data types.
 While int vs uint vs f64 matters little in javascript, Automerge is a cross platform library where these distinctions matter.
 
 ```javascript
-  import { create } from "@automerge/automerge-wasm"
+  import { create } from "automerge-wasm"
 
   let doc = create()
   doc.put("/", "prop1", 100, "int")
@@ -55,6 +84,7 @@ While int vs uint vs f64 matters little in javascript, Automerge is a cross plat
   doc.put("/", "prop8", new Uint8Array([1,2,3]), "bytes")
   doc.put("/", "prop9", true, "boolean")
   doc.put("/", "prop10", null, "null")
+  doc.free()
 ```
 
 ### Automerge Object Types
@@ -62,7 +92,7 @@ While int vs uint vs f64 matters little in javascript, Automerge is a cross plat
 Automerge WASM supports 3 object types.  Maps, lists, and text.  Maps are key value stores where the values can be any scalar type or any object type.  Lists are numerically indexed sets of data that can hold any scalar or any object type.
 
 ```javascript
-  import { create } from "@automerge/automerge-wasm"
+  import { create } from "automerge-wasm"
 
   let doc = create()
 
@@ -81,12 +111,14 @@ Automerge WASM supports 3 object types.  Maps, lists, and text.  Maps are key va
   // text is initialized with a string
 
   let notes = doc.putObject("/", "notes", "Hello world!")
+
+  doc.free()
 ```
 
 You can access objects by passing the object id as the first parameter for a call.
 
 ```javascript
-  import { create } from "@automerge/automerge-wasm"
+  import { create } from "automerge-wasm"
 
   let doc = create()
 
@@ -99,10 +131,7 @@ You can access objects by passing the object id as the first parameter for a cal
 
   // get the id then use it
 
-  // get returns a single simple javascript value or undefined
+  let id = doc.get("/", "config")
-  // getWithType returns an Array of the datatype plus basic type or null
-
-  let id = doc.getWithType("/", "config")
   if (id && id[0] === 'map') {
     doc.put(id[1], "align", "right")
   }
@@ -110,6 +139,8 @@ You can access objects by passing the object id as the first parameter for a cal
   // use a path instead
 
   doc.put("/config", "align", "right")
+
+  doc.free()
 ```
 
 Using the id directly is always faster (as it prevents the path to id conversion internally) so it is preferred for performance critical code.
@@ -131,6 +162,7 @@ Maps are key/value stores.  The root object is always a map.  The keys are alway
 
     doc.keys(mymap)           // returns ["bytes","foo","sub"]
     doc.materialize("_root")  // returns { mymap: { bytes: new Uint8Array([1,2,3]), foo: "bar", sub: {}}}
+    doc.free()
 ```
 
 ### Lists
@@ -150,11 +182,12 @@ Lists are index addressable sets of values.  These values can be any scalar or o
 
     doc.materialize(items)                        // returns [ "bat", [1,2], { hello : "world" }, true, "bag", "brick"]
     doc.length(items)                             // returns 6
+    doc.free()
 ```
 
 ### Text
 
-Text is a specialized list type intended for modifying a text document.  The primary way to interact with a text document is via the `splice()` method. Spliced strings will be indexable by character (important to note for platforms that index by graphmeme cluster).
+Text is a specialized list type intended for modifying a text document.  The primary way to interact with a text document is via the `splice()` method. Spliced strings will be indexable by character (important to note for platforms that index by graphmeme cluster).  Non text can be inserted into a text document and will be represented with the unicode object replacement character.
 
 ```javascript
     let doc = create("aaaaaa")
@@ -162,6 +195,13 @@ Text is a specialized list type intended for modifying a text document.  The pri
     doc.splice(notes, 6, 5, "everyone")
 
     doc.text(notes)      // returns "Hello everyone"
+
+    let obj = doc.insertObject(notes, 6, { hi: "there" })
+
+    doc.text(notes)       // returns "Hello \ufffceveryone"
+    doc.get(notes, 6)   // returns ["map", obj]
+    doc.get(obj, "hi") // returns ["str", "there"]
+    doc.free()
 ```
 
 ### Tables
@@ -177,8 +217,8 @@ When querying maps use the `get()` method with the object in question and the pr
     doc1.put("_root", "key1", "val1")
     let key2 = doc1.putObject("_root", "key2", [])
 
-    doc1.get("_root", "key1") // returns "val1"
+    doc1.get("_root", "key1") // returns ["str", "val1"]
-    doc1.getWithType("_root", "key2") // returns ["list", "2@aabbcc"]
+    doc1.get("_root", "key2") // returns ["list", "2@aabbcc"]
     doc1.keys("_root")          // returns ["key1", "key2"]
 
     let doc2 = doc1.fork("ffaaff")
@@ -189,8 +229,9 @@ When querying maps use the `get()` method with the object in question and the pr
 
     doc1.merge(doc2)
 
-    doc1.get("_root","key3")   // returns "doc2val"
+    doc1.get("_root","key3")   // returns ["str", "doc2val"]
     doc1.getAll("_root","key3")  // returns [[ "str", "doc1val"], ["str", "doc2val"]]
+    doc1.free(); doc2.free()
 ```
 
 ### Counters
@@ -212,6 +253,8 @@ Counters are 64 bit ints that support the increment operation.  Frequently diffe
     doc1.merge(doc2)
 
     doc1.materialize("_root")  // returns { number: 10, total: 33 }
+
+    doc1.free(); doc2.free()
 ```
 
 ### Transactions
@@ -223,7 +266,7 @@ Generally speaking you don't need to think about transactions when using Automer
 
     doc.put("_root", "key", "val1")
 
-    doc.get("_root", "key")        // returns "val1"
+    doc.get("_root", "key")        // returns ["str","val1"]
     doc.pendingOps()                 // returns 1
 
     doc.rollback()
@@ -237,8 +280,10 @@ Generally speaking you don't need to think about transactions when using Automer
 
     doc.commit("test commit 1")
 
-    doc.get("_root", "key")        // returns "val2"
+    doc.get("_root", "key")        // returns ["str","val2"]
     doc.pendingOps()                 // returns 0
+
+    doc.free()
 ```
 
 ### Viewing Old Versions of the Document
@@ -256,10 +301,12 @@ All query functions can take an optional argument of `heads` which allow you to
 
     doc.put("_root", "key", "val3")
 
-    doc.get("_root","key")          // returns "val3"
+    doc.get("_root","key")          // returns ["str","val3"]
-    doc.get("_root","key",heads2)   // returns "val2"
+    doc.get("_root","key",heads2)   // returns ["str","val2"]
-    doc.get("_root","key",heads1)   // returns "val1"
+    doc.get("_root","key",heads1)   // returns ["str","val1"]
-    doc.get("_root","key",[])       // returns undefined
+    doc.get("_root","key",[])       // returns null
+
+    doc.free()
 ```
 
 This works for `get()`, `getAll()`, `keys()`, `length()`, `text()`, and `materialize()`
@@ -285,6 +332,8 @@ The `merge()` command applies all changes in the argument doc into the calling d
 
     doc1.materialize("_root")       // returns { key1: "val1", key2: "val2", key3: "val3" }
     doc2.materialize("_root")       // returns { key1: "val1", key3: "val3" }
+
+    doc1.free(); doc2.free()
 ```
 
 Note that calling `a.merge(a)` will produce an unrecoverable error from the wasm-bindgen layer which (as of this writing) there is no workaround for.
@@ -298,7 +347,7 @@ If you wish to incrementally update a saved Automerge doc you can call `saveIncr
 The `load()` function takes a `Uint8Array()` of bytes produced in this way and constitutes a new document.  The `loadIncremental()` method is available if you wish to consume the result of a `saveIncremental()` with an already instanciated document.
 
 ```javascript
-  import { create, load } from "@automerge/automerge-wasm"
+  import { create, load } from "automerge-wasm"
 
   let doc1 = create()
 
@@ -330,12 +379,14 @@ The `load()` function takes a `Uint8Array()` of bytes produced in this way and c
   doc2.materialize("_root")  // returns { key1: "value1", key2: "value2" }
   doc3.materialize("_root")  // returns { key1: "value1", key2: "value2" }
   doc4.materialize("_root")  // returns { key1: "value1", key2: "value2" }
+
+  doc1.free(); doc2.free(); doc3.free(); doc4.free()
 ```
 
 One interesting feature of automerge binary saves is that they can be concatenated together in any order and can still be loaded into a coherent merged document.
 
 ```javascript
-import { load } from "@automerge/automerge-wasm"
+import { load } from "automerge-wasm"
 import * as fs from "fs"
 
 let file1 = fs.readFileSync("automerge_save_1");
@@ -355,7 +406,7 @@ When syncing a document the `generateSyncMessage()` and `receiveSyncMessage()` m
 A very simple sync implementation might look like this.
 
 ```javascript
-  import { encodeSyncState, decodeSyncState, initSyncState } from "@automerge/automerge-wasm"
+  import { encodeSyncState, decodeSyncState, initSyncState } from "automerge-wasm"
 
   let states = {}
 
@@ -403,7 +454,7 @@ Actors are ids that need to be unique to each process writing to a document.  Th
 Methods that create new documents will generate random actors automatically - if you wish to supply your own it is always taken as an optional argument.  This is true for the following functions.
 
 ```javascript
-  import { create, load } from "@automerge/automerge-wasm"
+  import { create, load } from "automerge-wasm"
 
   let doc1 = create()  // random actorid
   let doc2 = create("aabbccdd")
@@ -413,6 +464,8 @@ Methods that create new documents will generate random actors automatically - if
   let doc6 = load(doc4.save(), "00aabb11")
 
   let actor = doc1.getActor()
+
+  doc1.free(); doc2.free(); doc3.free(); doc4.free(); doc5.free(); doc6.free()
 ```
 
 ### Glossary: Object Id's
@@ -435,35 +488,7 @@ Object Ids uniquely identify an object within a document.  They are represented
   doc.put(o1v2, "x", "y")  // modifying the new "o1" object
 
   assert.deepEqual(doc.materialize("_root"), { "o1": { x: "y" }, "o2": {} })
-```
-
-### Appendix: Building
-
-  The following steps should allow you to build the package
-
-  ```
-   $ rustup target add wasm32-unknown-unknown
-   $ cargo install wasm-bindgen-cli
-   $ cargo install wasm-opt
-   $ yarn
-   $ yarn release
-   $ yarn pack
-  ```
-
-### Appendix: WASM and Memory Allocation
-
-Allocated memory in rust will be freed automatically on platforms that support `FinalizationRegistry`.
-
-This is currently supported in [all major browsers and nodejs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry).
-
-On unsupported platforms you can free memory explicitly.
-
-```javascript
-  import { create, initSyncState } from "@automerge/automerge-wasm"
-
-  let doc = create()
-  let sync = initSyncState()
 
   doc.free()
-  sync.free()
 ```
+

automerge-wasm/index.d.ts

@@ -0,0 +1,164 @@
+
+export type Actor = string;
+export type ObjID = string;
+export type Change = Uint8Array;
+export type SyncMessage = Uint8Array;
+export type Prop = string | number;
+export type Hash = string;
+export type Heads = Hash[];
+export type Value = string | number | boolean | null | Date | Uint8Array
+export type ObjType = string | Array | Object
+export type FullValue =
+  ["str", string] |
+  ["int", number] |
+  ["uint", number] |
+  ["f64", number] |
+  ["boolean", boolean] |
+  ["timestamp", Date] |
+  ["counter", number] |
+  ["bytes", Uint8Array] |
+  ["null", Uint8Array] |
+  ["map", ObjID] |
+  ["list", ObjID] |
+  ["text", ObjID] |
+  ["table", ObjID]
+
+export enum ObjTypeName {
+  list = "list",
+  map = "map",
+  table = "table",
+  text = "text",
+}
+
+export type Datatype =
+  "boolean" |
+  "str" |
+  "int" |
+  "uint" |
+  "f64" |
+  "null" |
+  "timestamp" |
+  "counter" |
+  "bytes" |
+  "map" |
+  "text" |
+  "list";
+
+export type DecodedSyncMessage = {
+  heads: Heads,
+  need: Heads,
+  have: any[]
+  changes: Change[]
+}
+
+export type DecodedChange = {
+  actor: Actor,
+  seq: number
+  startOp: number,
+  time: number,
+  message: string | null,
+  deps: Heads,
+  hash: Hash,
+  ops: Op[]
+}
+
+export type Op = {
+  action: string,
+  obj: ObjID,
+  key: string,
+  value?: string | number | boolean,
+  datatype?: string,
+  pred: string[],
+}
+
+export type Patch = {
+  obj: ObjID
+  action: 'assign' | 'insert' | 'delete'
+  key: Prop
+  value: Value
+  datatype: Datatype
+  conflict: boolean
+}
+
+export function create(actor?: Actor): Automerge;
+export function load(data: Uint8Array, actor?: Actor): Automerge;
+export function encodeChange(change: DecodedChange): Change;
+export function decodeChange(change: Change): DecodedChange;
+export function initSyncState(): SyncState;
+export function encodeSyncMessage(message: DecodedSyncMessage): SyncMessage;
+export function decodeSyncMessage(msg: SyncMessage): DecodedSyncMessage;
+export function encodeSyncState(state: SyncState): Uint8Array;
+export function decodeSyncState(data: Uint8Array): SyncState;
+
+export class Automerge {
+  // change state
+  put(obj: ObjID, prop: Prop, value: Value, datatype?: Datatype): undefined;
+  putObject(obj: ObjID, prop: Prop, value: ObjType): ObjID;
+  insert(obj: ObjID, index: number, value: Value, datatype?: Datatype): undefined;
+  insertObject(obj: ObjID, index: number, value: ObjType): ObjID;
+  push(obj: ObjID, value: Value, datatype?: Datatype): undefined;
+  pushObject(obj: ObjID, value: ObjType): ObjID;
+  splice(obj: ObjID, start: number, delete_count: number, text?: string | Array<Value>): ObjID[] | undefined;
+  increment(obj: ObjID, prop: Prop, value: number): void;
+  delete(obj: ObjID, prop: Prop): void;
+
+  // returns a single value - if there is a conflict return the winner
+  get(obj: ObjID, prop: any, heads?: Heads): FullValue | null;
+  // return all values in case of a conflict
+  getAll(obj: ObjID, arg: any, heads?: Heads): FullValue[];
+  keys(obj: ObjID, heads?: Heads): string[];
+  text(obj: ObjID, heads?: Heads): string;
+  length(obj: ObjID, heads?: Heads): number;
+  materialize(obj?: ObjID, heads?: Heads): any;
+
+  // transactions
+  commit(message?: string, time?: number): Hash;
+  merge(other: Automerge): Heads;
+  getActorId(): Actor;
+  pendingOps(): number;
+  rollback(): number;
+
+  // patches
+  enablePatches(enable: boolean): void;
+  popPatches(): Patch[];
+
+  // save and load to local store
+  save(): Uint8Array;
+  saveIncremental(): Uint8Array;
+  loadIncremental(data: Uint8Array): number;
+
+  // sync over network
+  receiveSyncMessage(state: SyncState, message: SyncMessage): void;
+  generateSyncMessage(state: SyncState): SyncMessage | null;
+
+  // low level change functions
+  applyChanges(changes: Change[]): void;
+  getChanges(have_deps: Heads): Change[];
+  getChangeByHash(hash: Hash): Change | null;
+  getChangesAdded(other: Automerge): Change[];
+  getHeads(): Heads;
+  getLastLocalChange(): Change;
+  getMissingDeps(heads?: Heads): Heads;
+
+  // memory management
+  free(): void;
+  clone(actor?: string): Automerge;
+  fork(actor?: string): Automerge;
+  forkAt(heads: Heads, actor?: string): Automerge;
+
+  // dump internal state to console.log
+  dump(): void;
+
+  // dump internal state to a JS object
+  toJS(): any;
+}
+
+export class SyncState {
+  free(): void;
+  clone(): SyncState;
+  lastSentHeads: any;
+  sentHashes: any;
+  readonly sharedHeads: any;
+}
+
+export default function init (): Promise<any>;

automerge-wasm/nodejs-index.js

@@ -0,0 +1,6 @@
+let wasm = require("./bindgen")
+module.exports = wasm
+module.exports.load = module.exports.loadDoc
+delete module.exports.loadDoc
+Object.defineProperty(module.exports, "__esModule", { value: true });
+module.exports.default = () => (new Promise((resolve,reject) => { resolve() }))

automerge-wasm/package.json

@@ -0,0 +1,49 @@
+{
+  "collaborators": [
+    "Orion Henry <orion@inkandswitch.com>",
+    "Alex Good <alex@memoryandthought.me>",
+    "Martin Kleppmann"
+  ],
+  "name": "automerge-wasm",
+  "description": "wasm-bindgen bindings to the automerge rust implementation",
+  "homepage": "https://github.com/automerge/automerge-rs/tree/main/automerge-wasm",
+  "repository": "github:automerge/automerge-rs",
+  "version": "0.1.2",
+  "license": "MIT",
+  "files": [
+    "README.md",
+    "LICENSE",
+    "package.json",
+    "index.d.ts",
+    "nodejs/index.js",
+    "nodejs/bindgen.js",
+    "nodejs/bindgen_bg.wasm",
+    "web/index.js",
+    "web/bindgen.js",
+    "web/bindgen_bg.wasm"
+  ],
+  "types": "index.d.ts",
+  "module": "./web/index.js",
+  "main": "./nodejs/index.js",
+  "scripts": {
+    "build": "cross-env PROFILE=dev TARGET=nodejs yarn target",
+    "release": "cross-env PROFILE=release yarn buildall",
+    "buildall": "cross-env TARGET=nodejs yarn target && cross-env TARGET=web yarn target",
+    "target": "rimraf ./$TARGET && wasm-pack build --target $TARGET --$PROFILE --out-name bindgen -d $TARGET && cp $TARGET-index.js $TARGET/index.js",
+    "test": "ts-mocha -p tsconfig.json --type-check --bail --full-trace test/*.ts"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/expect": "^24.3.0",
+    "@types/jest": "^27.4.0",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "^17.0.13",
+    "cross-env": "^7.0.3",
+    "fast-sha256": "^1.3.0",
+    "mocha": "^9.1.3",
+    "pako": "^2.0.4",
+    "rimraf": "^3.0.2",
+    "ts-mocha": "^9.0.2",
+    "typescript": "^4.5.5"
+  }
+}

automerge-wasm/src/interop.rs

@@ -0,0 +1,433 @@
+use automerge as am;
+use automerge::transaction::Transactable;
+use automerge::{Change, ChangeHash, Prop};
+use js_sys::{Array, Object, Reflect, Uint8Array};
+use std::collections::HashSet;
+use std::fmt::Display;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+
+use crate::{ObjId, ScalarValue, Value};
+
+pub(crate) struct JS(pub(crate) JsValue);
+pub(crate) struct AR(pub(crate) Array);
+
+impl From<AR> for JsValue {
+    fn from(ar: AR) -> Self {
+        ar.0.into()
+    }
+}
+
+impl From<JS> for JsValue {
+    fn from(js: JS) -> Self {
+        js.0
+    }
+}
+
+impl From<am::sync::State> for JS {
+    fn from(state: am::sync::State) -> Self {
+        let shared_heads: JS = state.shared_heads.into();
+        let last_sent_heads: JS = state.last_sent_heads.into();
+        let their_heads: JS = state.their_heads.into();
+        let their_need: JS = state.their_need.into();
+        let sent_hashes: JS = state.sent_hashes.into();
+        let their_have = if let Some(have) = &state.their_have {
+            JsValue::from(AR::from(have.as_slice()).0)
+        } else {
+            JsValue::null()
+        };
+        let result: JsValue = Object::new().into();
+        // we can unwrap here b/c we made the object and know its not frozen
+        Reflect::set(&result, &"sharedHeads".into(), &shared_heads.0).unwrap();
+        Reflect::set(&result, &"lastSentHeads".into(), &last_sent_heads.0).unwrap();
+        Reflect::set(&result, &"theirHeads".into(), &their_heads.0).unwrap();
+        Reflect::set(&result, &"theirNeed".into(), &their_need.0).unwrap();
+        Reflect::set(&result, &"theirHave".into(), &their_have).unwrap();
+        Reflect::set(&result, &"sentHashes".into(), &sent_hashes.0).unwrap();
+        JS(result)
+    }
+}
+
+impl From<Vec<ChangeHash>> for JS {
+    fn from(heads: Vec<ChangeHash>) -> Self {
+        let heads: Array = heads
+            .iter()
+            .map(|h| JsValue::from_str(&h.to_string()))
+            .collect();
+        JS(heads.into())
+    }
+}
+
+impl From<HashSet<ChangeHash>> for JS {
+    fn from(heads: HashSet<ChangeHash>) -> Self {
+        let result: JsValue = Object::new().into();
+        for key in &heads {
+            Reflect::set(&result, &key.to_string().into(), &true.into()).unwrap();
+        }
+        JS(result)
+    }
+}
+
+impl From<Option<Vec<ChangeHash>>> for JS {
+    fn from(heads: Option<Vec<ChangeHash>>) -> Self {
+        if let Some(v) = heads {
+            let v: Array = v
+                .iter()
+                .map(|h| JsValue::from_str(&h.to_string()))
+                .collect();
+            JS(v.into())
+        } else {
+            JS(JsValue::null())
+        }
+    }
+}
+
+impl TryFrom<JS> for HashSet<ChangeHash> {
+    type Error = JsValue;
+
+    fn try_from(value: JS) -> Result<Self, Self::Error> {
+        let mut result = HashSet::new();
+        for key in Reflect::own_keys(&value.0)?.iter() {
+            if let Some(true) = Reflect::get(&value.0, &key)?.as_bool() {
+                result.insert(key.into_serde().map_err(to_js_err)?);
+            }
+        }
+        Ok(result)
+    }
+}
+
+impl TryFrom<JS> for Vec<ChangeHash> {
+    type Error = JsValue;
+
+    fn try_from(value: JS) -> Result<Self, Self::Error> {
+        let value = value.0.dyn_into::<Array>()?;
+        let value: Result<Vec<ChangeHash>, _> = value.iter().map(|j| j.into_serde()).collect();
+        let value = value.map_err(to_js_err)?;
+        Ok(value)
+    }
+}
+
+impl From<JS> for Option<Vec<ChangeHash>> {
+    fn from(value: JS) -> Self {
+        let value = value.0.dyn_into::<Array>().ok()?;
+        let value: Result<Vec<ChangeHash>, _> = value.iter().map(|j| j.into_serde()).collect();
+        let value = value.ok()?;
+        Some(value)
+    }
+}
+
+impl TryFrom<JS> for Vec<Change> {
+    type Error = JsValue;
+
+    fn try_from(value: JS) -> Result<Self, Self::Error> {
+        let value = value.0.dyn_into::<Array>()?;
+        let changes: Result<Vec<Uint8Array>, _> = value.iter().map(|j| j.dyn_into()).collect();
+        let changes = changes?;
+        let changes: Result<Vec<Change>, _> = changes
+            .iter()
+            .map(|a| Change::try_from(a.to_vec()))
+            .collect();
+        let changes = changes.map_err(to_js_err)?;
+        Ok(changes)
+    }
+}
+
+impl TryFrom<JS> for am::sync::State {
+    type Error = JsValue;
+
+    fn try_from(value: JS) -> Result<Self, Self::Error> {
+        let value = value.0;
+        let shared_heads = js_get(&value, "sharedHeads")?.try_into()?;
+        let last_sent_heads = js_get(&value, "lastSentHeads")?.try_into()?;
+        let their_heads = js_get(&value, "theirHeads")?.into();
+        let their_need = js_get(&value, "theirNeed")?.into();
+        let their_have = js_get(&value, "theirHave")?.try_into()?;
+        let sent_hashes = js_get(&value, "sentHashes")?.try_into()?;
+        Ok(am::sync::State {
+            shared_heads,
+            last_sent_heads,
+            their_heads,
+            their_need,
+            their_have,
+            sent_hashes,
+        })
+    }
+}
+
+impl TryFrom<JS> for Option<Vec<am::sync::Have>> {
+    type Error = JsValue;
+
+    fn try_from(value: JS) -> Result<Self, Self::Error> {
+        if value.0.is_null() {
+            Ok(None)
+        } else {
+            Ok(Some(value.try_into()?))
+        }
+    }
+}
+
+impl TryFrom<JS> for Vec<am::sync::Have> {
+    type Error = JsValue;
+
+    fn try_from(value: JS) -> Result<Self, Self::Error> {
+        let value = value.0.dyn_into::<Array>()?;
+        let have: Result<Vec<am::sync::Have>, JsValue> = value
+            .iter()
+            .map(|s| {
+                let last_sync = js_get(&s, "lastSync")?.try_into()?;
+                let bloom = js_get(&s, "bloom")?.try_into()?;
+                Ok(am::sync::Have { last_sync, bloom })
+            })
+            .collect();
+        let have = have?;
+        Ok(have)
+    }
+}
+
+impl TryFrom<JS> for am::sync::BloomFilter {
+    type Error = JsValue;
+
+    fn try_from(value: JS) -> Result<Self, Self::Error> {
+        let value: Uint8Array = value.0.dyn_into()?;
+        let value = value.to_vec();
+        let value = value.as_slice().try_into().map_err(to_js_err)?;
+        Ok(value)
+    }
+}
+
+impl From<&[ChangeHash]> for AR {
+    fn from(value: &[ChangeHash]) -> Self {
+        AR(value
+            .iter()
+            .map(|h| JsValue::from_str(&hex::encode(&h.0)))
+            .collect())
+    }
+}
+
+impl From<&[Change]> for AR {
+    fn from(value: &[Change]) -> Self {
+        let changes: Array = value
+            .iter()
+            .map(|c| Uint8Array::from(c.raw_bytes()))
+            .collect();
+        AR(changes)
+    }
+}
+
+impl From<&[am::sync::Have]> for AR {
+    fn from(value: &[am::sync::Have]) -> Self {
+        AR(value
+            .iter()
+            .map(|have| {
+                let last_sync: Array = have
+                    .last_sync
+                    .iter()
+                    .map(|h| JsValue::from_str(&hex::encode(&h.0)))
+                    .collect();
+                // FIXME - the clone and the unwrap here shouldnt be needed - look at into_bytes()
+                let bloom = Uint8Array::from(have.bloom.to_bytes().as_slice());
+                let obj: JsValue = Object::new().into();
+                // we can unwrap here b/c we created the object and know its not frozen
+                Reflect::set(&obj, &"lastSync".into(), &last_sync.into()).unwrap();
+                Reflect::set(&obj, &"bloom".into(), &bloom.into()).unwrap();
+                obj
+            })
+            .collect())
+    }
+}
+
+pub(crate) fn to_js_err<T: Display>(err: T) -> JsValue {
+    js_sys::Error::new(&std::format!("{}", err)).into()
+}
+
+pub(crate) fn js_get<J: Into<JsValue>>(obj: J, prop: &str) -> Result<JS, JsValue> {
+    Ok(JS(Reflect::get(&obj.into(), &prop.into())?))
+}
+
+pub(crate) fn js_set<V: Into<JsValue>>(obj: &JsValue, prop: &str, val: V) -> Result<bool, JsValue> {
+    Reflect::set(obj, &prop.into(), &val.into())
+}
+
+pub(crate) fn to_prop(p: JsValue) -> Result<Prop, JsValue> {
+    if let Some(s) = p.as_string() {
+        Ok(Prop::Map(s))
+    } else if let Some(n) = p.as_f64() {
+        Ok(Prop::Seq(n as usize))
+    } else {
+        Err(to_js_err("prop must me a string or number"))
+    }
+}
+
+pub(crate) fn to_objtype(
+    value: &JsValue,
+    datatype: &Option<String>,
+) -> Option<(am::ObjType, Vec<(Prop, JsValue)>)> {
+    match datatype.as_deref() {
+        Some("map") => {
+            let map = value.clone().dyn_into::<js_sys::Object>().ok()?;
+            // FIXME unwrap
+            let map = js_sys::Object::keys(&map)
+                .iter()
+                .zip(js_sys::Object::values(&map).iter())
+                .map(|(key, val)| (key.as_string().unwrap().into(), val))
+                .collect();
+            Some((am::ObjType::Map, map))
+        }
+        Some("list") => {
+            let list = value.clone().dyn_into::<js_sys::Array>().ok()?;
+            let list = list
+                .iter()
+                .enumerate()
+                .map(|(i, e)| (i.into(), e))
+                .collect();
+            Some((am::ObjType::List, list))
+        }
+        Some("text") => {
+            let text = value.as_string()?;
+            let text = text
+                .chars()
+                .enumerate()
+                .map(|(i, ch)| (i.into(), ch.to_string().into()))
+                .collect();
+            Some((am::ObjType::Text, text))
+        }
+        Some(_) => None,
+        None => {
+            if let Ok(list) = value.clone().dyn_into::<js_sys::Array>() {
+                let list = list
+                    .iter()
+                    .enumerate()
+                    .map(|(i, e)| (i.into(), e))
+                    .collect();
+                Some((am::ObjType::List, list))
+            } else if let Ok(map) = value.clone().dyn_into::<js_sys::Object>() {
+                // FIXME unwrap
+                let map = js_sys::Object::keys(&map)
+                    .iter()
+                    .zip(js_sys::Object::values(&map).iter())
+                    .map(|(key, val)| (key.as_string().unwrap().into(), val))
+                    .collect();
+                Some((am::ObjType::Map, map))
+            } else if let Some(text) = value.as_string() {
+                let text = text
+                    .chars()
+                    .enumerate()
+                    .map(|(i, ch)| (i.into(), ch.to_string().into()))
+                    .collect();
+                Some((am::ObjType::Text, text))
+            } else {
+                None
+            }
+        }
+    }
+}
+
+pub(crate) fn get_heads(heads: Option<Array>) -> Option<Vec<ChangeHash>> {
+    let heads = heads?;
+    let heads: Result<Vec<ChangeHash>, _> = heads.iter().map(|j| j.into_serde()).collect();
+    heads.ok()
+}
+
+pub(crate) fn map_to_js(doc: &am::AutoCommit, obj: &ObjId) -> JsValue {
+    let keys = doc.keys(obj);
+    let map = Object::new();
+    for k in keys {
+        let val = doc.get(obj, &k);
+        match val {
+            Ok(Some((Value::Object(o), exid)))
+                if o == am::ObjType::Map || o == am::ObjType::Table =>
+            {
+                Reflect::set(&map, &k.into(), &map_to_js(doc, &exid)).unwrap();
+            }
+            Ok(Some((Value::Object(o), exid))) if o == am::ObjType::List => {
+                Reflect::set(&map, &k.into(), &list_to_js(doc, &exid)).unwrap();
+            }
+            Ok(Some((Value::Object(o), exid))) if o == am::ObjType::Text => {
+                Reflect::set(&map, &k.into(), &doc.text(&exid).unwrap().into()).unwrap();
+            }
+            Ok(Some((Value::Scalar(v), _))) => {
+                Reflect::set(&map, &k.into(), &ScalarValue(v).into()).unwrap();
+            }
+            _ => (),
+        };
+    }
+    map.into()
+}
+
+pub(crate) fn map_to_js_at(doc: &am::AutoCommit, obj: &ObjId, heads: &[ChangeHash]) -> JsValue {
+    let keys = doc.keys(obj);
+    let map = Object::new();
+    for k in keys {
+        let val = doc.get_at(obj, &k, heads);
+        match val {
+            Ok(Some((Value::Object(o), exid)))
+                if o == am::ObjType::Map || o == am::ObjType::Table =>
+            {
+                Reflect::set(&map, &k.into(), &map_to_js_at(doc, &exid, heads)).unwrap();
+            }
+            Ok(Some((Value::Object(o), exid))) if o == am::ObjType::List => {
+                Reflect::set(&map, &k.into(), &list_to_js_at(doc, &exid, heads)).unwrap();
+            }
+            Ok(Some((Value::Object(o), exid))) if o == am::ObjType::Text => {
+                Reflect::set(&map, &k.into(), &doc.text_at(&exid, heads).unwrap().into()).unwrap();
+            }
+            Ok(Some((Value::Scalar(v), _))) => {
+                Reflect::set(&map, &k.into(), &ScalarValue(v).into()).unwrap();
+            }
+            _ => (),
+        };
+    }
+    map.into()
+}
+
+pub(crate) fn list_to_js(doc: &am::AutoCommit, obj: &ObjId) -> JsValue {
+    let len = doc.length(obj);
+    let array = Array::new();
+    for i in 0..len {
+        let val = doc.get(obj, i as usize);
+        match val {
+            Ok(Some((Value::Object(o), exid)))
+                if o == am::ObjType::Map || o == am::ObjType::Table =>
+            {
+                array.push(&map_to_js(doc, &exid));
+            }
+            Ok(Some((Value::Object(o), exid))) if o == am::ObjType::List => {
+                array.push(&list_to_js(doc, &exid));
+            }
+            Ok(Some((Value::Object(o), exid))) if o == am::ObjType::Text => {
+                array.push(&doc.text(&exid).unwrap().into());
+            }
+            Ok(Some((Value::Scalar(v), _))) => {
+                array.push(&ScalarValue(v).into());
+            }
+            _ => (),
+        };
+    }
+    array.into()
+}
+
+pub(crate) fn list_to_js_at(doc: &am::AutoCommit, obj: &ObjId, heads: &[ChangeHash]) -> JsValue {
+    let len = doc.length(obj);
+    let array = Array::new();
+    for i in 0..len {
+        let val = doc.get_at(obj, i as usize, heads);
+        match val {
+            Ok(Some((Value::Object(o), exid)))
+                if o == am::ObjType::Map || o == am::ObjType::Table =>
+            {
+                array.push(&map_to_js_at(doc, &exid, heads));
+            }
+            Ok(Some((Value::Object(o), exid))) if o == am::ObjType::List => {
+                array.push(&list_to_js_at(doc, &exid, heads));
+            }
+            Ok(Some((Value::Object(o), exid))) if o == am::ObjType::Text => {
+                array.push(&doc.text_at(exid, heads).unwrap().into());
+            }
+            Ok(Some((Value::Scalar(v), _))) => {
+                array.push(&ScalarValue(v).into());
+            }
+            _ => (),
+        };
+    }
+    array.into()
+}

automerge-wasm/src/lib.rs

@@ -0,0 +1,919 @@
+#![doc(
+    html_logo_url = "https://raw.githubusercontent.com/automerge/automerge-rs/main/img/brandmark.svg",
+    html_favicon_url = "https:///raw.githubusercontent.com/automerge/automerge-rs/main/img/favicon.ico"
+)]
+#![warn(
+    missing_debug_implementations,
+    // missing_docs, // TODO: add documentation!
+    rust_2021_compatibility,
+    rust_2018_idioms,
+    unreachable_pub,
+    bad_style,
+    const_err,
+    dead_code,
+    improper_ctypes,
+    non_shorthand_field_patterns,
+    no_mangle_generic_items,
+    overflowing_literals,
+    path_statements,
+    patterns_in_fns_without_body,
+    private_in_public,
+    unconditional_recursion,
+    unused,
+    unused_allocation,
+    unused_comparisons,
+    unused_parens,
+    while_true
+)]
+#![allow(clippy::unused_unit)]
+use am::transaction::CommitOptions;
+use am::transaction::Transactable;
+use am::ApplyOptions;
+use automerge as am;
+use automerge::Patch;
+use automerge::VecOpObserver;
+use automerge::{Change, ObjId, Prop, Value, ROOT};
+use js_sys::{Array, Object, Uint8Array};
+use std::convert::TryInto;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+
+mod interop;
+mod sync;
+mod value;
+
+use interop::{
+    get_heads, js_get, js_set, list_to_js, list_to_js_at, map_to_js, map_to_js_at, to_js_err,
+    to_objtype, to_prop, AR, JS,
+};
+use sync::SyncState;
+use value::{datatype, ScalarValue};
+
+#[allow(unused_macros)]
+macro_rules! log {
+    ( $( $t:tt )* ) => {
+          web_sys::console::log_1(&format!( $( $t )* ).into());
+    };
+}
+
+#[cfg(feature = "wee_alloc")]
+#[global_allocator]
+static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+
+#[wasm_bindgen]
+#[derive(Debug)]
+pub struct Automerge {
+    doc: automerge::AutoCommit,
+    observer: Option<VecOpObserver>,
+}
+
+#[wasm_bindgen]
+impl Automerge {
+    pub fn new(actor: Option<String>) -> Result<Automerge, JsValue> {
+        let mut automerge = automerge::AutoCommit::new();
+        if let Some(a) = actor {
+            let a = automerge::ActorId::from(hex::decode(a).map_err(to_js_err)?.to_vec());
+            automerge.set_actor(a);
+        }
+        Ok(Automerge {
+            doc: automerge,
+            observer: None,
+        })
+    }
+
+    fn ensure_transaction_closed(&mut self) {
+        if self.doc.pending_ops() > 0 {
+            let mut opts = CommitOptions::default();
+            if let Some(observer) = self.observer.as_mut() {
+                opts.set_op_observer(observer);
+            }
+            self.doc.commit_with(opts);
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    pub fn clone(&mut self, actor: Option<String>) -> Result<Automerge, JsValue> {
+        self.ensure_transaction_closed();
+        let mut automerge = Automerge {
+            doc: self.doc.clone(),
+            observer: None,
+        };
+        if let Some(s) = actor {
+            let actor = automerge::ActorId::from(hex::decode(s).map_err(to_js_err)?.to_vec());
+            automerge.doc.set_actor(actor);
+        }
+        Ok(automerge)
+    }
+
+    pub fn fork(&mut self, actor: Option<String>) -> Result<Automerge, JsValue> {
+        self.ensure_transaction_closed();
+        let mut automerge = Automerge {
+            doc: self.doc.fork(),
+            observer: None,
+        };
+        if let Some(s) = actor {
+            let actor = automerge::ActorId::from(hex::decode(s).map_err(to_js_err)?.to_vec());
+            automerge.doc.set_actor(actor);
+        }
+        Ok(automerge)
+    }
+
+    #[wasm_bindgen(js_name = forkAt)]
+    pub fn fork_at(&mut self, heads: JsValue, actor: Option<String>) -> Result<Automerge, JsValue> {
+        let deps: Vec<_> = JS(heads).try_into()?;
+        let mut automerge = Automerge {
+            doc: self.doc.fork_at(&deps)?,
+            observer: None,
+        };
+        if let Some(s) = actor {
+            let actor = automerge::ActorId::from(hex::decode(s).map_err(to_js_err)?.to_vec());
+            automerge.doc.set_actor(actor);
+        }
+        Ok(automerge)
+    }
+
+    pub fn free(self) {}
+
+    #[wasm_bindgen(js_name = pendingOps)]
+    pub fn pending_ops(&self) -> JsValue {
+        (self.doc.pending_ops() as u32).into()
+    }
+
+    pub fn commit(&mut self, message: Option<String>, time: Option<f64>) -> JsValue {
+        let mut commit_opts = CommitOptions::default();
+        if let Some(message) = message {
+            commit_opts.set_message(message);
+        }
+        if let Some(time) = time {
+            commit_opts.set_time(time as i64);
+        }
+        if let Some(observer) = self.observer.as_mut() {
+            commit_opts.set_op_observer(observer);
+        }
+        let hash = self.doc.commit_with(commit_opts);
+        JsValue::from_str(&hex::encode(&hash.0))
+    }
+
+    pub fn merge(&mut self, other: &mut Automerge) -> Result<Array, JsValue> {
+        self.ensure_transaction_closed();
+        let options = if let Some(observer) = self.observer.as_mut() {
+            ApplyOptions::default().with_op_observer(observer)
+        } else {
+            ApplyOptions::default()
+        };
+        let heads = self.doc.merge_with(&mut other.doc, options)?;
+        let heads: Array = heads
+            .iter()
+            .map(|h| JsValue::from_str(&hex::encode(&h.0)))
+            .collect();
+        Ok(heads)
+    }
+
+    pub fn rollback(&mut self) -> f64 {
+        self.doc.rollback() as f64
+    }
+
+    pub fn keys(&self, obj: JsValue, heads: Option<Array>) -> Result<Array, JsValue> {
+        let obj = self.import(obj)?;
+        let result = if let Some(heads) = get_heads(heads) {
+            self.doc
+                .keys_at(&obj, &heads)
+                .map(|s| JsValue::from_str(&s))
+                .collect()
+        } else {
+            self.doc.keys(&obj).map(|s| JsValue::from_str(&s)).collect()
+        };
+        Ok(result)
+    }
+
+    pub fn text(&self, obj: JsValue, heads: Option<Array>) -> Result<String, JsValue> {
+        let obj = self.import(obj)?;
+        if let Some(heads) = get_heads(heads) {
+            Ok(self.doc.text_at(&obj, &heads)?)
+        } else {
+            Ok(self.doc.text(&obj)?)
+        }
+    }
+
+    pub fn splice(
+        &mut self,
+        obj: JsValue,
+        start: f64,
+        delete_count: f64,
+        text: JsValue,
+    ) -> Result<(), JsValue> {
+        let obj = self.import(obj)?;
+        let start = start as usize;
+        let delete_count = delete_count as usize;
+        let mut vals = vec![];
+        if let Some(t) = text.as_string() {
+            self.doc.splice_text(&obj, start, delete_count, &t)?;
+        } else {
+            if let Ok(array) = text.dyn_into::<Array>() {
+                for i in array.iter() {
+                    let value = self
+                        .import_scalar(&i, &None)
+                        .ok_or_else(|| to_js_err("expected scalar"))?;
+                    vals.push(value);
+                }
+            }
+            self.doc
+                .splice(&obj, start, delete_count, vals.into_iter())?;
+        }
+        Ok(())
+    }
+
+    pub fn push(&mut self, obj: JsValue, value: JsValue, datatype: JsValue) -> Result<(), JsValue> {
+        let obj = self.import(obj)?;
+        let value = self
+            .import_scalar(&value, &datatype.as_string())
+            .ok_or_else(|| to_js_err("invalid scalar value"))?;
+        let index = self.doc.length(&obj);
+        self.doc.insert(&obj, index, value)?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = pushObject)]
+    pub fn push_object(&mut self, obj: JsValue, value: JsValue) -> Result<Option<String>, JsValue> {
+        let obj = self.import(obj)?;
+        let (value, subvals) =
+            to_objtype(&value, &None).ok_or_else(|| to_js_err("expected object"))?;
+        let index = self.doc.length(&obj);
+        let opid = self.doc.insert_object(&obj, index, value)?;
+        self.subset(&opid, subvals)?;
+        Ok(opid.to_string().into())
+    }
+
+    pub fn insert(
+        &mut self,
+        obj: JsValue,
+        index: f64,
+        value: JsValue,
+        datatype: JsValue,
+    ) -> Result<(), JsValue> {
+        let obj = self.import(obj)?;
+        let index = index as f64;
+        let value = self
+            .import_scalar(&value, &datatype.as_string())
+            .ok_or_else(|| to_js_err("expected scalar value"))?;
+        self.doc.insert(&obj, index as usize, value)?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = insertObject)]
+    pub fn insert_object(
+        &mut self,
+        obj: JsValue,
+        index: f64,
+        value: JsValue,
+    ) -> Result<Option<String>, JsValue> {
+        let obj = self.import(obj)?;
+        let index = index as f64;
+        let (value, subvals) =
+            to_objtype(&value, &None).ok_or_else(|| to_js_err("expected object"))?;
+        let opid = self.doc.insert_object(&obj, index as usize, value)?;
+        self.subset(&opid, subvals)?;
+        Ok(opid.to_string().into())
+    }
+
+    pub fn put(
+        &mut self,
+        obj: JsValue,
+        prop: JsValue,
+        value: JsValue,
+        datatype: JsValue,
+    ) -> Result<(), JsValue> {
+        let obj = self.import(obj)?;
+        let prop = self.import_prop(prop)?;
+        let value = self
+            .import_scalar(&value, &datatype.as_string())
+            .ok_or_else(|| to_js_err("expected scalar value"))?;
+        self.doc.put(&obj, prop, value)?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = putObject)]
+    pub fn put_object(
+        &mut self,
+        obj: JsValue,
+        prop: JsValue,
+        value: JsValue,
+    ) -> Result<JsValue, JsValue> {
+        let obj = self.import(obj)?;
+        let prop = self.import_prop(prop)?;
+        let (value, subvals) =
+            to_objtype(&value, &None).ok_or_else(|| to_js_err("expected object"))?;
+        let opid = self.doc.put_object(&obj, prop, value)?;
+        self.subset(&opid, subvals)?;
+        Ok(opid.to_string().into())
+    }
+
+    fn subset(&mut self, obj: &am::ObjId, vals: Vec<(am::Prop, JsValue)>) -> Result<(), JsValue> {
+        for (p, v) in vals {
+            let (value, subvals) = self.import_value(&v, None)?;
+            //let opid = self.0.set(id, p, value)?;
+            let opid = match (p, value) {
+                (Prop::Map(s), Value::Object(objtype)) => {
+                    Some(self.doc.put_object(obj, s, objtype)?)
+                }
+                (Prop::Map(s), Value::Scalar(scalar)) => {
+                    self.doc.put(obj, s, scalar.into_owned())?;
+                    None
+                }
+                (Prop::Seq(i), Value::Object(objtype)) => {
+                    Some(self.doc.insert_object(obj, i, objtype)?)
+                }
+                (Prop::Seq(i), Value::Scalar(scalar)) => {
+                    self.doc.insert(obj, i, scalar.into_owned())?;
+                    None
+                }
+            };
+            if let Some(opid) = opid {
+                self.subset(&opid, subvals)?;
+            }
+        }
+        Ok(())
+    }
+
+    pub fn increment(
+        &mut self,
+        obj: JsValue,
+        prop: JsValue,
+        value: JsValue,
+    ) -> Result<(), JsValue> {
+        let obj = self.import(obj)?;
+        let prop = self.import_prop(prop)?;
+        let value: f64 = value
+            .as_f64()
+            .ok_or_else(|| to_js_err("increment needs a numeric value"))?;
+        self.doc.increment(&obj, prop, value as i64)?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = get)]
+    pub fn get(
+        &self,
+        obj: JsValue,
+        prop: JsValue,
+        heads: Option<Array>,
+    ) -> Result<Option<Array>, JsValue> {
+        let obj = self.import(obj)?;
+        let result = Array::new();
+        let prop = to_prop(prop);
+        let heads = get_heads(heads);
+        if let Ok(prop) = prop {
+            let value = if let Some(h) = heads {
+                self.doc.get_at(&obj, prop, &h)?
+            } else {
+                self.doc.get(&obj, prop)?
+            };
+            match value {
+                Some((Value::Object(obj_type), obj_id)) => {
+                    result.push(&obj_type.to_string().into());
+                    result.push(&obj_id.to_string().into());
+                    Ok(Some(result))
+                }
+                Some((Value::Scalar(value), _)) => {
+                    result.push(&datatype(&value).into());
+                    result.push(&ScalarValue(value).into());
+                    Ok(Some(result))
+                }
+                None => Ok(None),
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    #[wasm_bindgen(js_name = getAll)]
+    pub fn get_all(
+        &self,
+        obj: JsValue,
+        arg: JsValue,
+        heads: Option<Array>,
+    ) -> Result<Array, JsValue> {
+        let obj = self.import(obj)?;
+        let result = Array::new();
+        let prop = to_prop(arg);
+        if let Ok(prop) = prop {
+            let values = if let Some(heads) = get_heads(heads) {
+                self.doc.get_all_at(&obj, prop, &heads)
+            } else {
+                self.doc.get_all(&obj, prop)
+            }
+            .map_err(to_js_err)?;
+            for value in values {
+                match value {
+                    (Value::Object(obj_type), obj_id) => {
+                        let sub = Array::new();
+                        sub.push(&obj_type.to_string().into());
+                        sub.push(&obj_id.to_string().into());
+                        result.push(&sub.into());
+                    }
+                    (Value::Scalar(value), id) => {
+                        let sub = Array::new();
+                        sub.push(&datatype(&value).into());
+                        sub.push(&ScalarValue(value).into());
+                        sub.push(&id.to_string().into());
+                        result.push(&sub.into());
+                    }
+                }
+            }
+        }
+        Ok(result)
+    }
+
+    #[wasm_bindgen(js_name = enablePatches)]
+    pub fn enable_patches(&mut self, enable: JsValue) -> Result<(), JsValue> {
+        let enable = enable
+            .as_bool()
+            .ok_or_else(|| to_js_err("expected boolean"))?;
+        if enable {
+            if self.observer.is_none() {
+                self.observer = Some(VecOpObserver::default());
+            }
+        } else {
+            self.observer = None;
+        }
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = popPatches)]
+    pub fn pop_patches(&mut self) -> Result<Array, JsValue> {
+        // transactions send out observer updates as they occur, not waiting for them to be
+        // committed.
+        // If we pop the patches then we won't be able to revert them.
+        self.ensure_transaction_closed();
+
+        let patches = self
+            .observer
+            .as_mut()
+            .map_or_else(Vec::new, |o| o.take_patches());
+        let result = Array::new();
+        for p in patches {
+            let patch = Object::new();
+            match p {
+                Patch::Put {
+                    obj,
+                    key,
+                    value,
+                    conflict,
+                } => {
+                    js_set(&patch, "action", "put")?;
+                    js_set(&patch, "obj", obj.to_string())?;
+                    js_set(&patch, "key", key)?;
+                    match value {
+                        (Value::Object(obj_type), obj_id) => {
+                            js_set(&patch, "datatype", obj_type.to_string())?;
+                            js_set(&patch, "value", obj_id.to_string())?;
+                        }
+                        (Value::Scalar(value), _) => {
+                            js_set(&patch, "datatype", datatype(&value))?;
+                            js_set(&patch, "value", ScalarValue(value))?;
+                        }
+                    };
+                    js_set(&patch, "conflict", conflict)?;
+                }
+
+                Patch::Insert { obj, index, value } => {
+                    js_set(&patch, "action", "insert")?;
+                    js_set(&patch, "obj", obj.to_string())?;
+                    js_set(&patch, "key", index as f64)?;
+                    match value {
+                        (Value::Object(obj_type), obj_id) => {
+                            js_set(&patch, "datatype", obj_type.to_string())?;
+                            js_set(&patch, "value", obj_id.to_string())?;
+                        }
+                        (Value::Scalar(value), _) => {
+                            js_set(&patch, "datatype", datatype(&value))?;
+                            js_set(&patch, "value", ScalarValue(value))?;
+                        }
+                    };
+                }
+
+                Patch::Increment { obj, key, value } => {
+                    js_set(&patch, "action", "increment")?;
+                    js_set(&patch, "obj", obj.to_string())?;
+                    js_set(&patch, "key", key)?;
+                    js_set(&patch, "value", value.0)?;
+                }
+
+                Patch::Delete { obj, key } => {
+                    js_set(&patch, "action", "delete")?;
+                    js_set(&patch, "obj", obj.to_string())?;
+                    js_set(&patch, "key", key)?;
+                }
+            }
+            result.push(&patch);
+        }
+        Ok(result)
+    }
+
+    pub fn length(&self, obj: JsValue, heads: Option<Array>) -> Result<f64, JsValue> {
+        let obj = self.import(obj)?;
+        if let Some(heads) = get_heads(heads) {
+            Ok(self.doc.length_at(&obj, &heads) as f64)
+        } else {
+            Ok(self.doc.length(&obj) as f64)
+        }
+    }
+
+    pub fn delete(&mut self, obj: JsValue, prop: JsValue) -> Result<(), JsValue> {
+        let obj = self.import(obj)?;
+        let prop = to_prop(prop)?;
+        self.doc.delete(&obj, prop).map_err(to_js_err)?;
+        Ok(())
+    }
+
+    pub fn save(&mut self) -> Uint8Array {
+        self.ensure_transaction_closed();
+        Uint8Array::from(self.doc.save().as_slice())
+    }
+
+    #[wasm_bindgen(js_name = saveIncremental)]
+    pub fn save_incremental(&mut self) -> Uint8Array {
+        self.ensure_transaction_closed();
+        let bytes = self.doc.save_incremental();
+        Uint8Array::from(bytes.as_slice())
+    }
+
+    #[wasm_bindgen(js_name = loadIncremental)]
+    pub fn load_incremental(&mut self, data: Uint8Array) -> Result<f64, JsValue> {
+        self.ensure_transaction_closed();
+        let data = data.to_vec();
+        let options = if let Some(observer) = self.observer.as_mut() {
+            ApplyOptions::default().with_op_observer(observer)
+        } else {
+            ApplyOptions::default()
+        };
+        let len = self
+            .doc
+            .load_incremental_with(&data, options)
+            .map_err(to_js_err)?;
+        Ok(len as f64)
+    }
+
+    #[wasm_bindgen(js_name = applyChanges)]
+    pub fn apply_changes(&mut self, changes: JsValue) -> Result<(), JsValue> {
+        self.ensure_transaction_closed();
+        let changes: Vec<_> = JS(changes).try_into()?;
+        let options = if let Some(observer) = self.observer.as_mut() {
+            ApplyOptions::default().with_op_observer(observer)
+        } else {
+            ApplyOptions::default()
+        };
+        self.doc
+            .apply_changes_with(changes, options)
+            .map_err(to_js_err)?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = getChanges)]
+    pub fn get_changes(&mut self, have_deps: JsValue) -> Result<Array, JsValue> {
+        self.ensure_transaction_closed();
+        let deps: Vec<_> = JS(have_deps).try_into()?;
+        let changes = self.doc.get_changes(&deps);
+        let changes: Array = changes
+            .iter()
+            .map(|c| Uint8Array::from(c.raw_bytes()))
+            .collect();
+        Ok(changes)
+    }
+
+    #[wasm_bindgen(js_name = getChangeByHash)]
+    pub fn get_change_by_hash(&mut self, hash: JsValue) -> Result<JsValue, JsValue> {
+        self.ensure_transaction_closed();
+        let hash = hash.into_serde().map_err(to_js_err)?;
+        let change = self.doc.get_change_by_hash(&hash);
+        if let Some(c) = change {
+            Ok(Uint8Array::from(c.raw_bytes()).into())
+        } else {
+            Ok(JsValue::null())
+        }
+    }
+
+    #[wasm_bindgen(js_name = getChangesAdded)]
+    pub fn get_changes_added(&mut self, other: &mut Automerge) -> Result<Array, JsValue> {
+        self.ensure_transaction_closed();
+        let changes = self.doc.get_changes_added(&mut other.doc);
+        let changes: Array = changes
+            .iter()
+            .map(|c| Uint8Array::from(c.raw_bytes()))
+            .collect();
+        Ok(changes)
+    }
+
+    #[wasm_bindgen(js_name = getHeads)]
+    pub fn get_heads(&mut self) -> Array {
+        self.ensure_transaction_closed();
+        let heads = self.doc.get_heads();
+        let heads: Array = heads
+            .iter()
+            .map(|h| JsValue::from_str(&hex::encode(&h.0)))
+            .collect();
+        heads
+    }
+
+    #[wasm_bindgen(js_name = getActorId)]
+    pub fn get_actor_id(&self) -> String {
+        let actor = self.doc.get_actor();
+        actor.to_string()
+    }
+
+    #[wasm_bindgen(js_name = getLastLocalChange)]
+    pub fn get_last_local_change(&mut self) -> Result<Uint8Array, JsValue> {
+        self.ensure_transaction_closed();
+        if let Some(change) = self.doc.get_last_local_change() {
+            Ok(Uint8Array::from(change.raw_bytes()))
+        } else {
+            Err(to_js_err("no local changes"))
+        }
+    }
+
+    pub fn dump(&mut self) {
+        self.ensure_transaction_closed();
+        self.doc.dump()
+    }
+
+    #[wasm_bindgen(js_name = getMissingDeps)]
+    pub fn get_missing_deps(&mut self, heads: Option<Array>) -> Result<Array, JsValue> {
+        self.ensure_transaction_closed();
+        let heads = get_heads(heads).unwrap_or_default();
+        let deps = self.doc.get_missing_deps(&heads);
+        let deps: Array = deps
+            .iter()
+            .map(|h| JsValue::from_str(&hex::encode(&h.0)))
+            .collect();
+        Ok(deps)
+    }
+
+    #[wasm_bindgen(js_name = receiveSyncMessage)]
+    pub fn receive_sync_message(
+        &mut self,
+        state: &mut SyncState,
+        message: Uint8Array,
+    ) -> Result<(), JsValue> {
+        self.ensure_transaction_closed();
+        let message = message.to_vec();
+        let message = am::sync::Message::decode(message.as_slice()).map_err(to_js_err)?;
+        let options = if let Some(observer) = self.observer.as_mut() {
+            ApplyOptions::default().with_op_observer(observer)
+        } else {
+            ApplyOptions::default()
+        };
+        self.doc
+            .receive_sync_message_with(&mut state.0, message, options)
+            .map_err(to_js_err)?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = generateSyncMessage)]
+    pub fn generate_sync_message(&mut self, state: &mut SyncState) -> Result<JsValue, JsValue> {
+        self.ensure_transaction_closed();
+        if let Some(message) = self.doc.generate_sync_message(&mut state.0) {
+            Ok(Uint8Array::from(message.encode().as_slice()).into())
+        } else {
+            Ok(JsValue::null())
+        }
+    }
+
+    #[wasm_bindgen(js_name = toJS)]
+    pub fn to_js(&self) -> JsValue {
+        map_to_js(&self.doc, &ROOT)
+    }
+
+    pub fn materialize(&self, obj: JsValue, heads: Option<Array>) -> Result<JsValue, JsValue> {
+        let obj = self.import(obj).unwrap_or(ROOT);
+        let heads = get_heads(heads);
+        if let Some(heads) = heads {
+            match self.doc.object_type(&obj) {
+                Some(am::ObjType::Map) => Ok(map_to_js_at(&self.doc, &obj, heads.as_slice())),
+                Some(am::ObjType::List) => Ok(list_to_js_at(&self.doc, &obj, heads.as_slice())),
+                Some(am::ObjType::Text) => Ok(self.doc.text_at(&obj, heads.as_slice())?.into()),
+                Some(am::ObjType::Table) => Ok(map_to_js_at(&self.doc, &obj, heads.as_slice())),
+                None => Err(to_js_err(format!("invalid obj {}", obj))),
+            }
+        } else {
+            match self.doc.object_type(&obj) {
+                Some(am::ObjType::Map) => Ok(map_to_js(&self.doc, &obj)),
+                Some(am::ObjType::List) => Ok(list_to_js(&self.doc, &obj)),
+                Some(am::ObjType::Text) => Ok(self.doc.text(&obj)?.into()),
+                Some(am::ObjType::Table) => Ok(map_to_js(&self.doc, &obj)),
+                None => Err(to_js_err(format!("invalid obj {}", obj))),
+            }
+        }
+    }
+
+    fn import(&self, id: JsValue) -> Result<ObjId, JsValue> {
+        if let Some(s) = id.as_string() {
+            if let Some(post) = s.strip_prefix('/') {
+                let mut obj = ROOT;
+                let mut is_map = true;
+                let parts = post.split('/');
+                for prop in parts {
+                    if prop.is_empty() {
+                        break;
+                    }
+                    let val = if is_map {
+                        self.doc.get(obj, prop)?
+                    } else {
+                        self.doc.get(obj, am::Prop::Seq(prop.parse().unwrap()))?
+                    };
+                    match val {
+                        Some((am::Value::Object(am::ObjType::Map), id)) => {
+                            is_map = true;
+                            obj = id;
+                        }
+                        Some((am::Value::Object(am::ObjType::Table), id)) => {
+                            is_map = true;
+                            obj = id;
+                        }
+                        Some((am::Value::Object(_), id)) => {
+                            is_map = false;
+                            obj = id;
+                        }
+                        None => return Err(to_js_err(format!("invalid path '{}'", s))),
+                        _ => return Err(to_js_err(format!("path '{}' is not an object", s))),
+                    };
+                }
+                Ok(obj)
+            } else {
+                Ok(self.doc.import(&s)?)
+            }
+        } else {
+            Err(to_js_err("invalid objid"))
+        }
+    }
+
+    fn import_prop(&self, prop: JsValue) -> Result<Prop, JsValue> {
+        if let Some(s) = prop.as_string() {
+            Ok(s.into())
+        } else if let Some(n) = prop.as_f64() {
+            Ok((n as usize).into())
+        } else {
+            Err(to_js_err(format!("invalid prop {:?}", prop)))
+        }
+    }
+
+    fn import_scalar(&self, value: &JsValue, datatype: &Option<String>) -> Option<am::ScalarValue> {
+        match datatype.as_deref() {
+            Some("boolean") => value.as_bool().map(am::ScalarValue::Boolean),
+            Some("int") => value.as_f64().map(|v| am::ScalarValue::Int(v as i64)),
+            Some("uint") => value.as_f64().map(|v| am::ScalarValue::Uint(v as u64)),
+            Some("str") => value.as_string().map(|v| am::ScalarValue::Str(v.into())),
+            Some("f64") => value.as_f64().map(am::ScalarValue::F64),
+            Some("bytes") => Some(am::ScalarValue::Bytes(
+                value.clone().dyn_into::<Uint8Array>().unwrap().to_vec(),
+            )),
+            Some("counter") => value.as_f64().map(|v| am::ScalarValue::counter(v as i64)),
+            Some("timestamp") => {
+                if let Some(v) = value.as_f64() {
+                    Some(am::ScalarValue::Timestamp(v as i64))
+                } else if let Ok(d) = value.clone().dyn_into::<js_sys::Date>() {
+                    Some(am::ScalarValue::Timestamp(d.get_time() as i64))
+                } else {
+                    None
+                }
+            }
+            Some("null") => Some(am::ScalarValue::Null),
+            Some(_) => None,
+            None => {
+                if value.is_null() {
+                    Some(am::ScalarValue::Null)
+                } else if let Some(b) = value.as_bool() {
+                    Some(am::ScalarValue::Boolean(b))
+                } else if let Some(s) = value.as_string() {
+                    Some(am::ScalarValue::Str(s.into()))
+                } else if let Some(n) = value.as_f64() {
+                    if (n.round() - n).abs() < f64::EPSILON {
+                        Some(am::ScalarValue::Int(n as i64))
+                    } else {
+                        Some(am::ScalarValue::F64(n))
+                    }
+                } else if let Ok(d) = value.clone().dyn_into::<js_sys::Date>() {
+                    Some(am::ScalarValue::Timestamp(d.get_time() as i64))
+                } else if let Ok(o) = &value.clone().dyn_into::<Uint8Array>() {
+                    Some(am::ScalarValue::Bytes(o.to_vec()))
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    fn import_value(
+        &self,
+        value: &JsValue,
+        datatype: Option<String>,
+    ) -> Result<(Value<'static>, Vec<(Prop, JsValue)>), JsValue> {
+        match self.import_scalar(value, &datatype) {
+            Some(val) => Ok((val.into(), vec![])),
+            None => {
+                if let Some((o, subvals)) = to_objtype(value, &datatype) {
+                    Ok((o.into(), subvals))
+                } else {
+                    web_sys::console::log_2(&"Invalid value".into(), value);
+                    Err(to_js_err("invalid value"))
+                }
+            }
+        }
+    }
+}
+
+#[wasm_bindgen(js_name = create)]
+pub fn init(actor: Option<String>) -> Result<Automerge, JsValue> {
+    console_error_panic_hook::set_once();
+    Automerge::new(actor)
+}
+
+#[wasm_bindgen(js_name = loadDoc)]
+pub fn load(data: Uint8Array, actor: Option<String>) -> Result<Automerge, JsValue> {
+    let data = data.to_vec();
+    let observer = None;
+    let options = ApplyOptions::<()>::default();
+    let mut automerge = am::AutoCommit::load_with(&data, options).map_err(to_js_err)?;
+    if let Some(s) = actor {
+        let actor = automerge::ActorId::from(hex::decode(s).map_err(to_js_err)?.to_vec());
+        automerge.set_actor(actor);
+    }
+    Ok(Automerge {
+        doc: automerge,
+        observer,
+    })
+}
+
+#[wasm_bindgen(js_name = encodeChange)]
+pub fn encode_change(change: JsValue) -> Result<Uint8Array, JsValue> {
+    let change: am::ExpandedChange = change.into_serde().map_err(to_js_err)?;
+    let change: Change = change.into();
+    Ok(Uint8Array::from(change.raw_bytes()))
+}
+
+#[wasm_bindgen(js_name = decodeChange)]
+pub fn decode_change(change: Uint8Array) -> Result<JsValue, JsValue> {
+    let change = Change::from_bytes(change.to_vec()).map_err(to_js_err)?;
+    let change: am::ExpandedChange = change.decode();
+    JsValue::from_serde(&change).map_err(to_js_err)
+}
+
+#[wasm_bindgen(js_name = initSyncState)]
+pub fn init_sync_state() -> SyncState {
+    SyncState(am::sync::State::new())
+}
+
+// this is needed to be compatible with the automerge-js api
+#[wasm_bindgen(js_name = importSyncState)]
+pub fn import_sync_state(state: JsValue) -> Result<SyncState, JsValue> {
+    Ok(SyncState(JS(state).try_into()?))
+}
+
+// this is needed to be compatible with the automerge-js api
+#[wasm_bindgen(js_name = exportSyncState)]
+pub fn export_sync_state(state: SyncState) -> JsValue {
+    JS::from(state.0).into()
+}
+
+#[wasm_bindgen(js_name = encodeSyncMessage)]
+pub fn encode_sync_message(message: JsValue) -> Result<Uint8Array, JsValue> {
+    let heads = js_get(&message, "heads")?.try_into()?;
+    let need = js_get(&message, "need")?.try_into()?;
+    let changes = js_get(&message, "changes")?.try_into()?;
+    let have = js_get(&message, "have")?.try_into()?;
+    Ok(Uint8Array::from(
+        am::sync::Message {
+            heads,
+            need,
+            have,
+            changes,
+        }
+        .encode()
+        .as_slice(),
+    ))
+}
+
+#[wasm_bindgen(js_name = decodeSyncMessage)]
+pub fn decode_sync_message(msg: Uint8Array) -> Result<JsValue, JsValue> {
+    let data = msg.to_vec();
+    let msg = am::sync::Message::decode(&data).map_err(to_js_err)?;
+    let heads = AR::from(msg.heads.as_slice());
+    let need = AR::from(msg.need.as_slice());
+    let changes = AR::from(msg.changes.as_slice());
+    let have = AR::from(msg.have.as_slice());
+    let obj = Object::new().into();
+    js_set(&obj, "heads", heads)?;
+    js_set(&obj, "need", need)?;
+    js_set(&obj, "have", have)?;
+    js_set(&obj, "changes", changes)?;
+    Ok(obj)
+}
+
+#[wasm_bindgen(js_name = encodeSyncState)]
+pub fn encode_sync_state(state: SyncState) -> Result<Uint8Array, JsValue> {
+    let state = state.0;
+    Ok(Uint8Array::from(state.encode().as_slice()))
+}
+
+#[wasm_bindgen(js_name = decodeSyncState)]
+pub fn decode_sync_state(data: Uint8Array) -> Result<SyncState, JsValue> {
+    SyncState::decode(data)
+}

automerge-wasm/src/sync.rs

@@ -1,11 +1,11 @@
 use automerge as am;
 use automerge::ChangeHash;
 use js_sys::Uint8Array;
-use std::collections::{BTreeSet, HashMap};
+use std::collections::{HashMap, HashSet};
 use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
 
-use crate::interop::{self, to_js_err, AR, JS};
+use crate::interop::{to_js_err, AR, JS};
 
 #[wasm_bindgen]
 #[derive(Debug)]
@@ -24,10 +24,7 @@ impl SyncState {
     }
 
     #[wasm_bindgen(setter, js_name = lastSentHeads)]
-    pub fn set_last_sent_heads(
+    pub fn set_last_sent_heads(&mut self, heads: JsValue) -> Result<(), JsValue> {
-        &mut self,
-        heads: JsValue,
-    ) -> Result<(), interop::error::BadChangeHashes> {
         let heads: Vec<ChangeHash> = JS(heads).try_into()?;
         self.0.last_sent_heads = heads;
         Ok(())
@@ -35,9 +32,8 @@ impl SyncState {
 
     #[wasm_bindgen(setter, js_name = sentHashes)]
     pub fn set_sent_hashes(&mut self, hashes: JsValue) -> Result<(), JsValue> {
-        let hashes_map: HashMap<ChangeHash, bool> =
+        let hashes_map: HashMap<ChangeHash, bool> = hashes.into_serde().map_err(to_js_err)?;
-            serde_wasm_bindgen::from_value(hashes).map_err(to_js_err)?;
+        let hashes_set: HashSet<ChangeHash> = hashes_map.keys().cloned().collect();
-        let hashes_set: BTreeSet<ChangeHash> = hashes_map.keys().cloned().collect();
         self.0.sent_hashes = hashes_set;
         Ok(())
     }
@@ -47,19 +43,10 @@ impl SyncState {
         SyncState(self.0.clone())
     }
 
-    pub(crate) fn decode(data: Uint8Array) -> Result<SyncState, DecodeSyncStateErr> {
+    pub(crate) fn decode(data: Uint8Array) -> Result<SyncState, JsValue> {
         let data = data.to_vec();
-        let s = am::sync::State::decode(&data)?;
+        let s = am::sync::State::decode(&data);
+        let s = s.map_err(to_js_err)?;
         Ok(SyncState(s))
     }
 }
-
-#[derive(Debug, thiserror::Error)]
-#[error(transparent)]
-pub struct DecodeSyncStateErr(#[from] automerge::sync::DecodeStateError);
-
-impl From<DecodeSyncStateErr> for JsValue {
-    fn from(e: DecodeSyncStateErr) -> Self {
-        JsValue::from(e.to_string())
-    }
-}

automerge-wasm/src/value.rs

@@ -0,0 +1,38 @@
+use std::borrow::Cow;
+
+use automerge as am;
+use js_sys::Uint8Array;
+use wasm_bindgen::prelude::*;
+
+#[derive(Debug)]
+pub struct ScalarValue<'a>(pub(crate) Cow<'a, am::ScalarValue>);
+
+impl<'a> From<ScalarValue<'a>> for JsValue {
+    fn from(val: ScalarValue<'a>) -> Self {
+        match &*val.0 {
+            am::ScalarValue::Bytes(v) => Uint8Array::from(v.as_slice()).into(),
+            am::ScalarValue::Str(v) => v.to_string().into(),
+            am::ScalarValue::Int(v) => (*v as f64).into(),
+            am::ScalarValue::Uint(v) => (*v as f64).into(),
+            am::ScalarValue::F64(v) => (*v).into(),
+            am::ScalarValue::Counter(v) => (f64::from(v)).into(),
+            am::ScalarValue::Timestamp(v) => js_sys::Date::new(&(*v as f64).into()).into(),
+            am::ScalarValue::Boolean(v) => (*v).into(),
+            am::ScalarValue::Null => JsValue::null(),
+        }
+    }
+}
+
+pub(crate) fn datatype(s: &am::ScalarValue) -> String {
+    match s {
+        am::ScalarValue::Bytes(_) => "bytes".into(),
+        am::ScalarValue::Str(_) => "str".into(),
+        am::ScalarValue::Int(_) => "int".into(),
+        am::ScalarValue::Uint(_) => "uint".into(),
+        am::ScalarValue::F64(_) => "f64".into(),
+        am::ScalarValue::Counter(_) => "counter".into(),
+        am::ScalarValue::Timestamp(_) => "timestamp".into(),
+        am::ScalarValue::Boolean(_) => "boolean".into(),
+        am::ScalarValue::Null => "null".into(),
+    }
+}

automerge-wasm/test/helpers/common.js

@@ -1,5 +1,5 @@
 function isObject(obj) {
-  return typeof obj === "object" && obj !== null
+  return typeof obj === 'object' && obj !== null
 }
 
 /**
@@ -20,7 +20,7 @@ function copyObject(obj) {
  * with an actor ID, separated by an `@` sign) and returns an object `{counter, actorId}`.
  */
 function parseOpId(opId) {
-  const match = /^(\d+)@(.*)$/.exec(opId || "")
+  const match = /^(\d+)@(.*)$/.exec(opId || '')
   if (!match) {
     throw new RangeError(`Not a valid opId: ${opId}`)
   }
@@ -32,7 +32,7 @@ function parseOpId(opId) {
  */
 function equalBytes(array1, array2) {
   if (!(array1 instanceof Uint8Array) || !(array2 instanceof Uint8Array)) {
-    throw new TypeError("equalBytes can only compare Uint8Arrays")
+    throw new TypeError('equalBytes can only compare Uint8Arrays')
   }
   if (array1.byteLength !== array2.byteLength) return false
   for (let i = 0; i < array1.byteLength; i++) {
@@ -41,19 +41,6 @@ function equalBytes(array1, array2) {
   return true
 }
 
-/**
- * Creates an array containing the value `null` repeated `length` times.
- */
-function createArrayOfNulls(length) {
-  const array = new Array(length)
-  for (let i = 0; i < length; i++) array[i] = null
-  return array
-}
-
 module.exports = {
-  isObject,
+  isObject, copyObject, parseOpId, equalBytes
-  copyObject,
-  parseOpId,
-  equalBytes,
-  createArrayOfNulls,
 }

automerge-wasm/test/helpers/encoding.js

@@ -6,7 +6,7 @@
  * https://github.com/anonyco/FastestSmallestTextEncoderDecoder
  */
 const utf8encoder = new TextEncoder()
-const utf8decoder = new TextDecoder("utf-8")
+const utf8decoder = new TextDecoder('utf-8')
 
 function stringToUtf8(string) {
   return utf8encoder.encode(string)
@@ -20,48 +20,30 @@ function utf8ToString(buffer) {
  * Converts a string consisting of hexadecimal digits into an Uint8Array.
  */
 function hexStringToBytes(value) {
-  if (typeof value !== "string") {
+  if (typeof value !== 'string') {
-    throw new TypeError("value is not a string")
+    throw new TypeError('value is not a string')
   }
   if (!/^([0-9a-f][0-9a-f])*$/.test(value)) {
-    throw new RangeError("value is not hexadecimal")
+    throw new RangeError('value is not hexadecimal')
   }
-  if (value === "") {
+  if (value === '') {
     return new Uint8Array(0)
   } else {
     return new Uint8Array(value.match(/../g).map(b => parseInt(b, 16)))
   }
 }
 
-const NIBBLE_TO_HEX = [
+const NIBBLE_TO_HEX = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
-  "0",
-  "1",
-  "2",
-  "3",
-  "4",
-  "5",
-  "6",
-  "7",
-  "8",
-  "9",
-  "a",
-  "b",
-  "c",
-  "d",
-  "e",
-  "f",
-]
 const BYTE_TO_HEX = new Array(256)
 for (let i = 0; i < 256; i++) {
-  BYTE_TO_HEX[i] = `${NIBBLE_TO_HEX[(i >>> 4) & 0xf]}${NIBBLE_TO_HEX[i & 0xf]}`
+  BYTE_TO_HEX[i] = `${NIBBLE_TO_HEX[(i >>> 4) & 0xf]}${NIBBLE_TO_HEX[i & 0xf]}`;
 }
 
 /**
  * Converts a Uint8Array into the equivalent hexadecimal string.
  */
 function bytesToHexString(bytes) {
-  let hex = "",
+  let hex = '', len = bytes.byteLength
-    len = bytes.byteLength
   for (let i = 0; i < len; i++) {
     hex += BYTE_TO_HEX[bytes[i]]
   }
@@ -113,17 +95,14 @@ class Encoder {
    * appends it to the buffer. Returns the number of bytes written.
    */
   appendUint32(value) {
-    if (!Number.isInteger(value))
+    if (!Number.isInteger(value)) throw new RangeError('value is not an integer')
-      throw new RangeError("value is not an integer")
+    if (value < 0 || value > 0xffffffff) throw new RangeError('number out of range')
-    if (value < 0 || value > 0xffffffff)
-      throw new RangeError("number out of range")
 
     const numBytes = Math.max(1, Math.ceil((32 - Math.clz32(value)) / 7))
     if (this.offset + numBytes > this.buf.byteLength) this.grow()
 
     for (let i = 0; i < numBytes; i++) {
-      this.buf[this.offset + i] =
+      this.buf[this.offset + i] = (value & 0x7f) | (i === numBytes - 1 ? 0x00 : 0x80)
-        (value & 0x7f) | (i === numBytes - 1 ? 0x00 : 0x80)
       value >>>= 7 // zero-filling right shift
     }
     this.offset += numBytes
@@ -136,19 +115,14 @@ class Encoder {
    * it to the buffer. Returns the number of bytes written.
    */
   appendInt32(value) {
-    if (!Number.isInteger(value))
+    if (!Number.isInteger(value)) throw new RangeError('value is not an integer')
-      throw new RangeError("value is not an integer")
+    if (value < -0x80000000 || value > 0x7fffffff) throw new RangeError('number out of range')
-    if (value < -0x80000000 || value > 0x7fffffff)
-      throw new RangeError("number out of range")
 
-    const numBytes = Math.ceil(
+    const numBytes = Math.ceil((33 - Math.clz32(value >= 0 ? value : -value - 1)) / 7)
-      (33 - Math.clz32(value >= 0 ? value : -value - 1)) / 7
-    )
     if (this.offset + numBytes > this.buf.byteLength) this.grow()
 
     for (let i = 0; i < numBytes; i++) {
-      this.buf[this.offset + i] =
+      this.buf[this.offset + i] = (value & 0x7f) | (i === numBytes - 1 ? 0x00 : 0x80)
-        (value & 0x7f) | (i === numBytes - 1 ? 0x00 : 0x80)
       value >>= 7 // sign-propagating right shift
     }
     this.offset += numBytes
@@ -161,10 +135,9 @@ class Encoder {
    * (53 bits).
    */
   appendUint53(value) {
-    if (!Number.isInteger(value))
+    if (!Number.isInteger(value)) throw new RangeError('value is not an integer')
-      throw new RangeError("value is not an integer")
     if (value < 0 || value > Number.MAX_SAFE_INTEGER) {
-      throw new RangeError("number out of range")
+      throw new RangeError('number out of range')
     }
     const high32 = Math.floor(value / 0x100000000)
     const low32 = (value & 0xffffffff) >>> 0 // right shift to interpret as unsigned
@@ -177,10 +150,9 @@ class Encoder {
    * (53 bits).
    */
   appendInt53(value) {
-    if (!Number.isInteger(value))
+    if (!Number.isInteger(value)) throw new RangeError('value is not an integer')
-      throw new RangeError("value is not an integer")
     if (value < Number.MIN_SAFE_INTEGER || value > Number.MAX_SAFE_INTEGER) {
-      throw new RangeError("number out of range")
+      throw new RangeError('number out of range')
     }
     const high32 = Math.floor(value / 0x100000000)
     const low32 = (value & 0xffffffff) >>> 0 // right shift to interpret as unsigned
@@ -195,10 +167,10 @@ class Encoder {
    */
   appendUint64(high32, low32) {
     if (!Number.isInteger(high32) || !Number.isInteger(low32)) {
-      throw new RangeError("value is not an integer")
+      throw new RangeError('value is not an integer')
     }
     if (high32 < 0 || high32 > 0xffffffff || low32 < 0 || low32 > 0xffffffff) {
-      throw new RangeError("number out of range")
+      throw new RangeError('number out of range')
     }
     if (high32 === 0) return this.appendUint32(low32)
 
@@ -208,12 +180,10 @@ class Encoder {
       this.buf[this.offset + i] = (low32 & 0x7f) | 0x80
       low32 >>>= 7 // zero-filling right shift
     }
-    this.buf[this.offset + 4] =
+    this.buf[this.offset + 4] = (low32 & 0x0f) | ((high32 & 0x07) << 4) | (numBytes === 5 ? 0x00 : 0x80)
-      (low32 & 0x0f) | ((high32 & 0x07) << 4) | (numBytes === 5 ? 0x00 : 0x80)
     high32 >>>= 3
     for (let i = 5; i < numBytes; i++) {
-      this.buf[this.offset + i] =
+      this.buf[this.offset + i] = (high32 & 0x7f) | (i === numBytes - 1 ? 0x00 : 0x80)
-        (high32 & 0x7f) | (i === numBytes - 1 ? 0x00 : 0x80)
       high32 >>>= 7
     }
     this.offset += numBytes
@@ -230,35 +200,25 @@ class Encoder {
    */
   appendInt64(high32, low32) {
     if (!Number.isInteger(high32) || !Number.isInteger(low32)) {
-      throw new RangeError("value is not an integer")
+      throw new RangeError('value is not an integer')
     }
-    if (
+    if (high32 < -0x80000000 || high32 > 0x7fffffff || low32 < -0x80000000 || low32 > 0xffffffff) {
-      high32 < -0x80000000 ||
+      throw new RangeError('number out of range')
-      high32 > 0x7fffffff ||
-      low32 < -0x80000000 ||
-      low32 > 0xffffffff
-    ) {
-      throw new RangeError("number out of range")
     }
     low32 >>>= 0 // interpret as unsigned
     if (high32 === 0 && low32 <= 0x7fffffff) return this.appendInt32(low32)
-    if (high32 === -1 && low32 >= 0x80000000)
+    if (high32 === -1 && low32 >= 0x80000000) return this.appendInt32(low32 - 0x100000000)
-      return this.appendInt32(low32 - 0x100000000)
 
-    const numBytes = Math.ceil(
+    const numBytes = Math.ceil((65 - Math.clz32(high32 >= 0 ? high32 : -high32 - 1)) / 7)
-      (65 - Math.clz32(high32 >= 0 ? high32 : -high32 - 1)) / 7
-    )
     if (this.offset + numBytes > this.buf.byteLength) this.grow()
     for (let i = 0; i < 4; i++) {
       this.buf[this.offset + i] = (low32 & 0x7f) | 0x80
       low32 >>>= 7 // zero-filling right shift
     }
-    this.buf[this.offset + 4] =
+    this.buf[this.offset + 4] = (low32 & 0x0f) | ((high32 & 0x07) << 4) | (numBytes === 5 ? 0x00 : 0x80)
-      (low32 & 0x0f) | ((high32 & 0x07) << 4) | (numBytes === 5 ? 0x00 : 0x80)
     high32 >>= 3 // sign-propagating right shift
     for (let i = 5; i < numBytes; i++) {
-      this.buf[this.offset + i] =
+      this.buf[this.offset + i] = (high32 & 0x7f) | (i === numBytes - 1 ? 0x00 : 0x80)
-        (high32 & 0x7f) | (i === numBytes - 1 ? 0x00 : 0x80)
       high32 >>= 7
     }
     this.offset += numBytes
@@ -283,7 +243,7 @@ class Encoder {
    * number of bytes appended.
    */
   appendRawString(value) {
-    if (typeof value !== "string") throw new TypeError("value is not a string")
+    if (typeof value !== 'string') throw new TypeError('value is not a string')
     return this.appendRawBytes(stringToUtf8(value))
   }
 
@@ -302,7 +262,7 @@ class Encoder {
    * (where the length is encoded as an unsigned LEB128 integer).
    */
   appendPrefixedString(value) {
-    if (typeof value !== "string") throw new TypeError("value is not a string")
+    if (typeof value !== 'string') throw new TypeError('value is not a string')
     this.appendPrefixedBytes(stringToUtf8(value))
     return this
   }
@@ -321,7 +281,8 @@ class Encoder {
    * Flushes any unwritten data to the buffer. Call this before reading from
    * the buffer constructed by this Encoder.
    */
-  finish() {}
+  finish() {
+  }
 }
 
 /**
@@ -360,7 +321,7 @@ class Decoder {
    */
   skip(bytes) {
     if (this.offset + bytes > this.buf.byteLength) {
-      throw new RangeError("cannot skip beyond end of buffer")
+      throw new RangeError('cannot skip beyond end of buffer')
     }
     this.offset += bytes
   }
@@ -378,20 +339,18 @@ class Decoder {
    * Throws an exception if the value doesn't fit in a 32-bit unsigned int.
    */
   readUint32() {
-    let result = 0,
+    let result = 0, shift = 0
-      shift = 0
     while (this.offset < this.buf.byteLength) {
       const nextByte = this.buf[this.offset]
-      if (shift === 28 && (nextByte & 0xf0) !== 0) {
+      if (shift === 28 && (nextByte & 0xf0) !== 0) { // more than 5 bytes, or value > 0xffffffff
-        // more than 5 bytes, or value > 0xffffffff
+        throw new RangeError('number out of range')
-        throw new RangeError("number out of range")
       }
-      result = (result | ((nextByte & 0x7f) << shift)) >>> 0 // right shift to interpret value as unsigned
+      result = (result | (nextByte & 0x7f) << shift) >>> 0 // right shift to interpret value as unsigned
       shift += 7
       this.offset++
       if ((nextByte & 0x80) === 0) return result
     }
-    throw new RangeError("buffer ended with incomplete number")
+    throw new RangeError('buffer ended with incomplete number')
   }
 
   /**
@@ -399,17 +358,13 @@ class Decoder {
    * Throws an exception if the value doesn't fit in a 32-bit signed int.
    */
   readInt32() {
-    let result = 0,
+    let result = 0, shift = 0
-      shift = 0
     while (this.offset < this.buf.byteLength) {
       const nextByte = this.buf[this.offset]
-      if (
+      if ((shift === 28 && (nextByte & 0x80) !== 0) || // more than 5 bytes
-        (shift === 28 && (nextByte & 0x80) !== 0) || // more than 5 bytes
           (shift === 28 && (nextByte & 0x40) === 0 && (nextByte & 0x38) !== 0) || // positive int > 0x7fffffff
-        (shift === 28 && (nextByte & 0x40) !== 0 && (nextByte & 0x38) !== 0x38)
+          (shift === 28 && (nextByte & 0x40) !== 0 && (nextByte & 0x38) !== 0x38)) { // negative int < -0x80000000
-      ) {
+        throw new RangeError('number out of range')
-        // negative int < -0x80000000
-        throw new RangeError("number out of range")
       }
       result |= (nextByte & 0x7f) << shift
       shift += 7
@@ -423,7 +378,7 @@ class Decoder {
         }
       }
     }
-    throw new RangeError("buffer ended with incomplete number")
+    throw new RangeError('buffer ended with incomplete number')
   }
 
   /**
@@ -434,7 +389,7 @@ class Decoder {
   readUint53() {
     const { low32, high32 } = this.readUint64()
     if (high32 < 0 || high32 > 0x1fffff) {
-      throw new RangeError("number out of range")
+      throw new RangeError('number out of range')
     }
     return high32 * 0x100000000 + low32
   }
@@ -446,12 +401,8 @@ class Decoder {
    */
   readInt53() {
     const { low32, high32 } = this.readInt64()
-    if (
+    if (high32 < -0x200000 || (high32 === -0x200000 && low32 === 0) || high32 > 0x1fffff) {
-      high32 < -0x200000 ||
+      throw new RangeError('number out of range')
-      (high32 === -0x200000 && low32 === 0) ||
-      high32 > 0x1fffff
-    ) {
-      throw new RangeError("number out of range")
     }
     return high32 * 0x100000000 + low32
   }
@@ -463,12 +414,10 @@ class Decoder {
    * `{high32, low32}`.
    */
   readUint64() {
-    let low32 = 0,
+    let low32 = 0, high32 = 0, shift = 0
-      high32 = 0,
-      shift = 0
     while (this.offset < this.buf.byteLength && shift <= 28) {
       const nextByte = this.buf[this.offset]
-      low32 = (low32 | ((nextByte & 0x7f) << shift)) >>> 0 // right shift to interpret value as unsigned
+      low32 = (low32 | (nextByte & 0x7f) << shift) >>> 0 // right shift to interpret value as unsigned
       if (shift === 28) {
         high32 = (nextByte & 0x70) >>> 4
       }
@@ -480,16 +429,15 @@ class Decoder {
     shift = 3
     while (this.offset < this.buf.byteLength) {
       const nextByte = this.buf[this.offset]
-      if (shift === 31 && (nextByte & 0xfe) !== 0) {
+      if (shift === 31 && (nextByte & 0xfe) !== 0) { // more than 10 bytes, or value > 2^64 - 1
-        // more than 10 bytes, or value > 2^64 - 1
+        throw new RangeError('number out of range')
-        throw new RangeError("number out of range")
       }
-      high32 = (high32 | ((nextByte & 0x7f) << shift)) >>> 0
+      high32 = (high32 | (nextByte & 0x7f) << shift) >>> 0
       shift += 7
       this.offset++
       if ((nextByte & 0x80) === 0) return { high32, low32 }
     }
-    throw new RangeError("buffer ended with incomplete number")
+    throw new RangeError('buffer ended with incomplete number')
   }
 
   /**
@@ -500,20 +448,17 @@ class Decoder {
    * sign of the `high32` half indicates the sign of the 64-bit number.
    */
   readInt64() {
-    let low32 = 0,
+    let low32 = 0, high32 = 0, shift = 0
-      high32 = 0,
-      shift = 0
     while (this.offset < this.buf.byteLength && shift <= 28) {
       const nextByte = this.buf[this.offset]
-      low32 = (low32 | ((nextByte & 0x7f) << shift)) >>> 0 // right shift to interpret value as unsigned
+      low32 = (low32 | (nextByte & 0x7f) << shift) >>> 0 // right shift to interpret value as unsigned
       if (shift === 28) {
         high32 = (nextByte & 0x70) >>> 4
       }
       shift += 7
       this.offset++
       if ((nextByte & 0x80) === 0) {
-        if ((nextByte & 0x40) !== 0) {
+        if ((nextByte & 0x40) !== 0) { // sign-extend negative integer
-          // sign-extend negative integer
           if (shift < 32) low32 = (low32 | (-1 << shift)) >>> 0
           high32 |= -1 << Math.max(shift - 32, 0)
         }
@@ -527,20 +472,19 @@ class Decoder {
       // On the 10th byte there are only two valid values: all 7 value bits zero
       // (if the value is positive) or all 7 bits one (if the value is negative)
       if (shift === 31 && nextByte !== 0 && nextByte !== 0x7f) {
-        throw new RangeError("number out of range")
+        throw new RangeError('number out of range')
       }
       high32 |= (nextByte & 0x7f) << shift
       shift += 7
       this.offset++
       if ((nextByte & 0x80) === 0) {
-        if ((nextByte & 0x40) !== 0 && shift < 32) {
+        if ((nextByte & 0x40) !== 0 && shift < 32) { // sign-extend negative integer
-          // sign-extend negative integer
           high32 |= -1 << shift
         }
         return { high32, low32 }
       }
     }
-    throw new RangeError("buffer ended with incomplete number")
+    throw new RangeError('buffer ended with incomplete number')
   }
 
   /**
@@ -550,7 +494,7 @@ class Decoder {
   readRawBytes(length) {
     const start = this.offset
     if (start + length > this.buf.byteLength) {
-      throw new RangeError("subarray exceeds buffer size")
+      throw new RangeError('subarray exceeds buffer size')
     }
     this.offset += length
     return this.buf.subarray(start, this.offset)
@@ -615,7 +559,7 @@ class RLEEncoder extends Encoder {
   constructor(type) {
     super()
     this.type = type
-    this.state = "empty"
+    this.state = 'empty'
     this.lastValue = undefined
     this.count = 0
     this.literal = []
@@ -634,81 +578,76 @@ class RLEEncoder extends Encoder {
    */
   _appendValue(value, repetitions = 1) {
     if (repetitions <= 0) return
-    if (this.state === "empty") {
+    if (this.state === 'empty') {
-      this.state =
+      this.state = (value === null ? 'nulls' : (repetitions === 1 ? 'loneValue' : 'repetition'))
-        value === null
-          ? "nulls"
-          : repetitions === 1
-          ? "loneValue"
-          : "repetition"
       this.lastValue = value
       this.count = repetitions
-    } else if (this.state === "loneValue") {
+    } else if (this.state === 'loneValue') {
       if (value === null) {
         this.flush()
-        this.state = "nulls"
+        this.state = 'nulls'
         this.count = repetitions
       } else if (value === this.lastValue) {
-        this.state = "repetition"
+        this.state = 'repetition'
         this.count = 1 + repetitions
       } else if (repetitions > 1) {
         this.flush()
-        this.state = "repetition"
+        this.state = 'repetition'
         this.count = repetitions
         this.lastValue = value
       } else {
-        this.state = "literal"
+        this.state = 'literal'
         this.literal = [this.lastValue]
         this.lastValue = value
       }
-    } else if (this.state === "repetition") {
+    } else if (this.state === 'repetition') {
       if (value === null) {
         this.flush()
-        this.state = "nulls"
+        this.state = 'nulls'
         this.count = repetitions
       } else if (value === this.lastValue) {
         this.count += repetitions
       } else if (repetitions > 1) {
         this.flush()
-        this.state = "repetition"
+        this.state = 'repetition'
         this.count = repetitions
         this.lastValue = value
       } else {
         this.flush()
-        this.state = "loneValue"
+        this.state = 'loneValue'
         this.lastValue = value
       }
-    } else if (this.state === "literal") {
+    } else if (this.state === 'literal') {
       if (value === null) {
         this.literal.push(this.lastValue)
         this.flush()
-        this.state = "nulls"
+        this.state = 'nulls'
         this.count = repetitions
       } else if (value === this.lastValue) {
         this.flush()
-        this.state = "repetition"
+        this.state = 'repetition'
         this.count = 1 + repetitions
       } else if (repetitions > 1) {
         this.literal.push(this.lastValue)
         this.flush()
-        this.state = "repetition"
+        this.state = 'repetition'
         this.count = repetitions
         this.lastValue = value
       } else {
         this.literal.push(this.lastValue)
         this.lastValue = value
       }
-    } else if (this.state === "nulls") {
+    } else if (this.state === 'nulls') {
       if (value === null) {
         this.count += repetitions
       } else if (repetitions > 1) {
         this.flush()
-        this.state = "repetition"
+        this.state = 'repetition'
         this.count = repetitions
         this.lastValue = value
       } else {
         this.flush()
-        this.state = "loneValue"
+        this.state = 'loneValue'
         this.lastValue = value
       }
     }
@@ -727,16 +666,13 @@ class RLEEncoder extends Encoder {
    */
   copyFrom(decoder, options = {}) {
     const { count, sumValues, sumShift } = options
-    if (!(decoder instanceof RLEDecoder) || decoder.type !== this.type) {
+    if (!(decoder instanceof RLEDecoder) || (decoder.type !== this.type)) {
-      throw new TypeError("incompatible type of decoder")
+      throw new TypeError('incompatible type of decoder')
     }
-    let remaining = typeof count === "number" ? count : Number.MAX_SAFE_INTEGER
+    let remaining = (typeof count === 'number' ? count : Number.MAX_SAFE_INTEGER)
-    let nonNullValues = 0,
+    let nonNullValues = 0, sum = 0
-      sum = 0
+    if (count && remaining > 0 && decoder.done) throw new RangeError(`cannot copy ${count} values`)
-    if (count && remaining > 0 && decoder.done)
+    if (remaining === 0 || decoder.done) return sumValues ? {nonNullValues, sum} : {nonNullValues}
-      throw new RangeError(`cannot copy ${count} values`)
-    if (remaining === 0 || decoder.done)
-      return sumValues ? { nonNullValues, sum } : { nonNullValues }
 
     // Copy a value so that we have a well-defined starting state. NB: when super.copyFrom() is
     // called by the DeltaEncoder subclass, the following calls to readValue() and appendValue()
@@ -748,69 +684,55 @@ class RLEEncoder extends Encoder {
       remaining -= numNulls
       decoder.count -= numNulls - 1
       this.appendValue(null, numNulls)
-      if (count && remaining > 0 && decoder.done)
+      if (count && remaining > 0 && decoder.done) throw new RangeError(`cannot copy ${count} values`)
-        throw new RangeError(`cannot copy ${count} values`)
+      if (remaining === 0 || decoder.done) return sumValues ? {nonNullValues, sum} : {nonNullValues}
-      if (remaining === 0 || decoder.done)
-        return sumValues ? { nonNullValues, sum } : { nonNullValues }
       firstValue = decoder.readValue()
-      if (firstValue === null)
+      if (firstValue === null) throw new RangeError('null run must be followed by non-null value')
-        throw new RangeError("null run must be followed by non-null value")
     }
     this.appendValue(firstValue)
     remaining--
     nonNullValues++
-    if (sumValues) sum += sumShift ? firstValue >>> sumShift : firstValue
+    if (sumValues) sum += (sumShift ? (firstValue >>> sumShift) : firstValue)
-    if (count && remaining > 0 && decoder.done)
+    if (count && remaining > 0 && decoder.done) throw new RangeError(`cannot copy ${count} values`)
-      throw new RangeError(`cannot copy ${count} values`)
+    if (remaining === 0 || decoder.done) return sumValues ? {nonNullValues, sum} : {nonNullValues}
-    if (remaining === 0 || decoder.done)
-      return sumValues ? { nonNullValues, sum } : { nonNullValues }
 
     // Copy data at the record level without expanding repetitions
-    let firstRun = decoder.count > 0
+    let firstRun = (decoder.count > 0)
     while (remaining > 0 && !decoder.done) {
       if (!firstRun) decoder.readRecord()
       const numValues = Math.min(decoder.count, remaining)
       decoder.count -= numValues
 
-      if (decoder.state === "literal") {
+      if (decoder.state === 'literal') {
         nonNullValues += numValues
         for (let i = 0; i < numValues; i++) {
-          if (decoder.done) throw new RangeError("incomplete literal")
+          if (decoder.done) throw new RangeError('incomplete literal')
           const value = decoder.readRawValue()
-          if (value === decoder.lastValue)
+          if (value === decoder.lastValue) throw new RangeError('Repetition of values is not allowed in literal')
-            throw new RangeError(
-              "Repetition of values is not allowed in literal"
-            )
           decoder.lastValue = value
           this._appendValue(value)
-          if (sumValues) sum += sumShift ? value >>> sumShift : value
+          if (sumValues) sum += (sumShift ? (value >>> sumShift) : value)
         }
-      } else if (decoder.state === "repetition") {
+      } else if (decoder.state === 'repetition') {
         nonNullValues += numValues
-        if (sumValues)
+        if (sumValues) sum += numValues * (sumShift ? (decoder.lastValue >>> sumShift) : decoder.lastValue)
-          sum +=
-            numValues *
-            (sumShift ? decoder.lastValue >>> sumShift : decoder.lastValue)
         const value = decoder.lastValue
         this._appendValue(value)
         if (numValues > 1) {
           this._appendValue(value)
-          if (this.state !== "repetition")
+          if (this.state !== 'repetition') throw new RangeError(`Unexpected state ${this.state}`)
-            throw new RangeError(`Unexpected state ${this.state}`)
           this.count += numValues - 2
         }
-      } else if (decoder.state === "nulls") {
+      } else if (decoder.state === 'nulls') {
         this._appendValue(null)
-        if (this.state !== "nulls")
+        if (this.state !== 'nulls') throw new RangeError(`Unexpected state ${this.state}`)
-          throw new RangeError(`Unexpected state ${this.state}`)
         this.count += numValues - 1
       }
 
       firstRun = false
       remaining -= numValues
     }
-    if (count && remaining > 0 && decoder.done)
+    if (count && remaining > 0 && decoder.done) throw new RangeError(`cannot copy ${count} values`)
-      throw new RangeError(`cannot copy ${count} values`)
     return sumValues ? {nonNullValues, sum} : {nonNullValues}
   }
 
@@ -818,31 +740,31 @@ class RLEEncoder extends Encoder {
    * Private method, do not call from outside the class.
    */
   flush() {
-    if (this.state === "loneValue") {
+    if (this.state === 'loneValue') {
       this.appendInt32(-1)
       this.appendRawValue(this.lastValue)
-    } else if (this.state === "repetition") {
+    } else if (this.state === 'repetition') {
       this.appendInt53(this.count)
       this.appendRawValue(this.lastValue)
-    } else if (this.state === "literal") {
+    } else if (this.state === 'literal') {
       this.appendInt53(-this.literal.length)
       for (let v of this.literal) this.appendRawValue(v)
-    } else if (this.state === "nulls") {
+    } else if (this.state === 'nulls') {
       this.appendInt32(0)
       this.appendUint53(this.count)
     }
-    this.state = "empty"
+    this.state = 'empty'
   }
 
   /**
    * Private method, do not call from outside the class.
    */
   appendRawValue(value) {
-    if (this.type === "int") {
+    if (this.type === 'int') {
       this.appendInt53(value)
-    } else if (this.type === "uint") {
+    } else if (this.type === 'uint') {
       this.appendUint53(value)
-    } else if (this.type === "utf8") {
+    } else if (this.type === 'utf8') {
       this.appendPrefixedString(value)
     } else {
       throw new RangeError(`Unknown RLEEncoder datatype: ${this.type}`)
@@ -854,9 +776,9 @@ class RLEEncoder extends Encoder {
    * the buffer constructed by this Encoder.
    */
   finish() {
-    if (this.state === "literal") this.literal.push(this.lastValue)
+    if (this.state === 'literal') this.literal.push(this.lastValue)
     // Don't write anything if the only values we have seen are nulls
-    if (this.state !== "nulls" || this.offset > 0) this.flush()
+    if (this.state !== 'nulls' || this.offset > 0) this.flush()
   }
 }
 
@@ -878,7 +800,7 @@ class RLEDecoder extends Decoder {
    * position, and true if we are at the end of the buffer.
    */
   get done() {
-    return this.count === 0 && this.offset === this.buf.byteLength
+    return (this.count === 0) && (this.offset === this.buf.byteLength)
   }
 
   /**
@@ -899,10 +821,9 @@ class RLEDecoder extends Decoder {
     if (this.done) return null
     if (this.count === 0) this.readRecord()
     this.count -= 1
-    if (this.state === "literal") {
+    if (this.state === 'literal') {
       const value = this.readRawValue()
-      if (value === this.lastValue)
+      if (value === this.lastValue) throw new RangeError('Repetition of values is not allowed in literal')
-        throw new RangeError("Repetition of values is not allowed in literal")
       this.lastValue = value
       return value
     } else {
@@ -918,22 +839,20 @@ class RLEDecoder extends Decoder {
       if (this.count === 0) {
         this.count = this.readInt53()
         if (this.count > 0) {
-          this.lastValue =
+          this.lastValue = (this.count <= numSkip) ? this.skipRawValues(1) : this.readRawValue()
-            this.count <= numSkip ? this.skipRawValues(1) : this.readRawValue()
+          this.state = 'repetition'
-          this.state = "repetition"
         } else if (this.count < 0) {
           this.count = -this.count
-          this.state = "literal"
+          this.state = 'literal'
-        } else {
+        } else { // this.count == 0
-          // this.count == 0
           this.count = this.readUint53()
           this.lastValue = null
-          this.state = "nulls"
+          this.state = 'nulls'
         }
       }
 
       const consume = Math.min(numSkip, this.count)
-      if (this.state === "literal") this.skipRawValues(consume)
+      if (this.state === 'literal') this.skipRawValues(consume)
       numSkip -= consume
       this.count -= consume
     }
@@ -947,34 +866,23 @@ class RLEDecoder extends Decoder {
     this.count = this.readInt53()
     if (this.count > 1) {
       const value = this.readRawValue()
-      if (
+      if ((this.state === 'repetition' || this.state === 'literal') && this.lastValue === value) {
-        (this.state === "repetition" || this.state === "literal") &&
+        throw new RangeError('Successive repetitions with the same value are not allowed')
-        this.lastValue === value
-      ) {
-        throw new RangeError(
-          "Successive repetitions with the same value are not allowed"
-        )
       }
-      this.state = "repetition"
+      this.state = 'repetition'
       this.lastValue = value
     } else if (this.count === 1) {
-      throw new RangeError(
+      throw new RangeError('Repetition count of 1 is not allowed, use a literal instead')
-        "Repetition count of 1 is not allowed, use a literal instead"
-      )
     } else if (this.count < 0) {
       this.count = -this.count
-      if (this.state === "literal")
+      if (this.state === 'literal') throw new RangeError('Successive literals are not allowed')
-        throw new RangeError("Successive literals are not allowed")
+      this.state = 'literal'
-      this.state = "literal"
+    } else { // this.count == 0
-    } else {
+      if (this.state === 'nulls') throw new RangeError('Successive null runs are not allowed')
-      // this.count == 0
-      if (this.state === "nulls")
-        throw new RangeError("Successive null runs are not allowed")
       this.count = this.readUint53()
-      if (this.count === 0)
+      if (this.count === 0) throw new RangeError('Zero-length null runs are not allowed')
-        throw new RangeError("Zero-length null runs are not allowed")
       this.lastValue = null
-      this.state = "nulls"
+      this.state = 'nulls'
     }
   }
 
@@ -983,11 +891,11 @@ class RLEDecoder extends Decoder {
    * Reads one value of the datatype configured on construction.
    */
   readRawValue() {
-    if (this.type === "int") {
+    if (this.type === 'int') {
       return this.readInt53()
-    } else if (this.type === "uint") {
+    } else if (this.type === 'uint') {
       return this.readUint53()
-    } else if (this.type === "utf8") {
+    } else if (this.type === 'utf8') {
       return this.readPrefixedString()
     } else {
       throw new RangeError(`Unknown RLEDecoder datatype: ${this.type}`)
@@ -999,14 +907,14 @@ class RLEDecoder extends Decoder {
    * Skips over `num` values of the datatype configured on construction.
    */
   skipRawValues(num) {
-    if (this.type === "utf8") {
+    if (this.type === 'utf8') {
       for (let i = 0; i < num; i++) this.skip(this.readUint53())
     } else {
       while (num > 0 && this.offset < this.buf.byteLength) {
         if ((this.buf[this.offset] & 0x80) === 0) num--
         this.offset++
       }
-      if (num > 0) throw new RangeError("cannot skip beyond end of buffer")
+      if (num > 0) throw new RangeError('cannot skip beyond end of buffer')
     }
   }
 }
@@ -1023,7 +931,7 @@ class RLEDecoder extends Decoder {
  */
 class DeltaEncoder extends RLEEncoder {
   constructor() {
-    super("int")
+    super('int')
     this.absoluteValue = 0
   }
 
@@ -1033,7 +941,7 @@ class DeltaEncoder extends RLEEncoder {
    */
   appendValue(value, repetitions = 1) {
     if (repetitions <= 0) return
-    if (typeof value === "number") {
+    if (typeof value === 'number') {
       super.appendValue(value - this.absoluteValue, 1)
       this.absoluteValue = value
       if (repetitions > 1) super.appendValue(0, repetitions - 1)
@@ -1049,29 +957,26 @@ class DeltaEncoder extends RLEEncoder {
    */
   copyFrom(decoder, options = {}) {
     if (options.sumValues) {
-      throw new RangeError("unsupported options for DeltaEncoder.copyFrom()")
+      throw new RangeError('unsupported options for DeltaEncoder.copyFrom()')
     }
     if (!(decoder instanceof DeltaDecoder)) {
-      throw new TypeError("incompatible type of decoder")
+      throw new TypeError('incompatible type of decoder')
     }
 
     let remaining = options.count
-    if (remaining > 0 && decoder.done)
+    if (remaining > 0 && decoder.done) throw new RangeError(`cannot copy ${remaining} values`)
-      throw new RangeError(`cannot copy ${remaining} values`)
     if (remaining === 0 || decoder.done) return
 
     // Copy any null values, and the first non-null value, so that appendValue() computes the
     // difference between the encoder's last value and the decoder's first (absolute) value.
-    let value = decoder.readValue(),
+    let value = decoder.readValue(), nulls = 0
-      nulls = 0
     this.appendValue(value)
     if (value === null) {
       nulls = decoder.count + 1
       if (remaining !== undefined && remaining < nulls) nulls = remaining
       decoder.count -= nulls - 1
       this.count += nulls - 1
-      if (remaining > nulls && decoder.done)
+      if (remaining > nulls && decoder.done) throw new RangeError(`cannot copy ${remaining} values`)
-        throw new RangeError(`cannot copy ${remaining} values`)
       if (remaining === nulls || decoder.done) return
 
       // The next value read is certain to be non-null because we're not at the end of the decoder,
@@ -1084,10 +989,7 @@ class DeltaEncoder extends RLEEncoder {
     // value, while subsequent values are relative. Thus, the sum of all of the (non-null) copied
     // values must equal the absolute value of the final element copied.
     if (remaining !== undefined) remaining -= nulls + 1
-    const { nonNullValues, sum } = super.copyFrom(decoder, {
+    const { nonNullValues, sum } = super.copyFrom(decoder, {count: remaining, sumValues: true})
-      count: remaining,
-      sumValues: true,
-    })
     if (nonNullValues > 0) {
       this.absoluteValue = sum
       decoder.absoluteValue = sum
@@ -1101,7 +1003,7 @@ class DeltaEncoder extends RLEEncoder {
  */
 class DeltaDecoder extends RLEDecoder {
   constructor(buffer) {
-    super("int", buffer)
+    super('int', buffer)
     this.absoluteValue = 0
   }
 
@@ -1134,12 +1036,12 @@ class DeltaDecoder extends RLEDecoder {
     while (numSkip > 0 && !this.done) {
       if (this.count === 0) this.readRecord()
       const consume = Math.min(numSkip, this.count)
-      if (this.state === "literal") {
+      if (this.state === 'literal') {
         for (let i = 0; i < consume; i++) {
           this.lastValue = this.readRawValue()
           this.absoluteValue += this.lastValue
         }
-      } else if (this.state === "repetition") {
+      } else if (this.state === 'repetition') {
         this.absoluteValue += consume * this.lastValue
       }
       numSkip -= consume
@@ -1188,13 +1090,12 @@ class BooleanEncoder extends Encoder {
    */
   copyFrom(decoder, options = {}) {
     if (!(decoder instanceof BooleanDecoder)) {
-      throw new TypeError("incompatible type of decoder")
+      throw new TypeError('incompatible type of decoder')
     }
 
     const { count } = options
-    let remaining = typeof count === "number" ? count : Number.MAX_SAFE_INTEGER
+    let remaining = (typeof count === 'number' ? count : Number.MAX_SAFE_INTEGER)
-    if (count && remaining > 0 && decoder.done)
+    if (count && remaining > 0 && decoder.done) throw new RangeError(`cannot copy ${count} values`)
-      throw new RangeError(`cannot copy ${count} values`)
     if (remaining === 0 || decoder.done) return
 
     // Copy one value to bring decoder and encoder state into sync, then finish that value's repetitions
@@ -1207,8 +1108,7 @@ class BooleanEncoder extends Encoder {
 
     while (remaining > 0 && !decoder.done) {
       decoder.count = decoder.readUint53()
-      if (decoder.count === 0)
+      if (decoder.count === 0) throw new RangeError('Zero-length runs are not allowed')
-        throw new RangeError("Zero-length runs are not allowed")
       decoder.lastValue = !decoder.lastValue
       this.appendUint53(this.count)
 
@@ -1219,8 +1119,7 @@ class BooleanEncoder extends Encoder {
       remaining -= numCopied
     }
 
-    if (count && remaining > 0 && decoder.done)
+    if (count && remaining > 0 && decoder.done) throw new RangeError(`cannot copy ${count} values`)
-      throw new RangeError(`cannot copy ${count} values`)
   }
 
   /**
@@ -1252,7 +1151,7 @@ class BooleanDecoder extends Decoder {
    * position, and true if we are at the end of the buffer.
    */
   get done() {
-    return this.count === 0 && this.offset === this.buf.byteLength
+    return (this.count === 0) && (this.offset === this.buf.byteLength)
   }
 
   /**
@@ -1275,7 +1174,7 @@ class BooleanDecoder extends Decoder {
       this.count = this.readUint53()
       this.lastValue = !this.lastValue
       if (this.count === 0 && !this.firstRun) {
-        throw new RangeError("Zero-length runs are not allowed")
+        throw new RangeError('Zero-length runs are not allowed')
       }
       this.firstRun = false
     }
@@ -1291,8 +1190,7 @@ class BooleanDecoder extends Decoder {
       if (this.count === 0) {
         this.count = this.readUint53()
         this.lastValue = !this.lastValue
-        if (this.count === 0)
+        if (this.count === 0) throw new RangeError('Zero-length runs are not allowed')
-          throw new RangeError("Zero-length runs are not allowed")
       }
       if (this.count < numSkip) {
         numSkip -= this.count
@@ -1306,16 +1204,6 @@ class BooleanDecoder extends Decoder {
 }
 
 module.exports = {
-  stringToUtf8,
+  stringToUtf8, utf8ToString, hexStringToBytes, bytesToHexString,
-  utf8ToString,
+  Encoder, Decoder, RLEEncoder, RLEDecoder, DeltaEncoder, DeltaDecoder, BooleanEncoder, BooleanDecoder
-  hexStringToBytes,
-  bytesToHexString,
-  Encoder,
-  Decoder,
-  RLEEncoder,
-  RLEDecoder,
-  DeltaEncoder,
-  DeltaDecoder,
-  BooleanEncoder,
-  BooleanDecoder,
 }

automerge-wasm/test/readme.ts

@@ -1,18 +1,24 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import { describe, it } from 'mocha';
-import * as assert from 'assert'
+//@ts-ignore
-import { create, load, initSyncState } from '..'
+import assert from 'assert'
+//@ts-ignore
+import init, { create, load } from '..'
 
 describe('Automerge', () => {
   describe('Readme Examples', () => {
-    it('Using the Library and Creating a Document', () => {
+    it('Using the Library and Creating a Document (1)', () => {
-      const doc = create(true)
+      let doc = create()
-      const sync = initSyncState()
       doc.free()
-      sync.free()
+    })
+    it('Using the Library and Creating a Document (2)', (done) => {
+      init().then((_:any) => {
+        let doc = create()
+        doc.free()
+        done()
+      })
     })
     it('Automerge Scalar Types (1)', () => {
-      const doc = create(true)
+      let doc = create()
       doc.put("/", "prop1", 100)  // int
       doc.put("/", "prop2", 3.14) // f64
       doc.put("/", "prop3", "hello world")
@@ -30,9 +36,11 @@ describe('Automerge', () => {
         prop6: true,
         prop7: null
       })
+
+      doc.free()
     })
     it('Automerge Scalar Types (2)', () => {
-      const doc = create(true)
+      let doc = create()
       doc.put("/", "prop1", 100, "int")
       doc.put("/", "prop2", 100, "uint")
       doc.put("/", "prop3", 100.5, "f64")
@@ -43,37 +51,40 @@ describe('Automerge', () => {
       doc.put("/", "prop8", new Uint8Array([1,2,3]), "bytes")
       doc.put("/", "prop9", true, "boolean")
       doc.put("/", "prop10", null, "null")
+      doc.free()
     })
     it('Automerge Object Types (1)', () => {
-      const doc = create(true)
+      let doc = create()
 
       // you can create an object by passing in the inital state - if blank pass in `{}`
       // the return value is the Object Id
       // these functions all return an object id
 
-      const config = doc.putObject("/", "config", { align: "left", archived: false, cycles: [10, 19, 21] })
+      let config = doc.putObject("/", "config", { align: "left", archived: false, cycles: [10, 19, 21] })
-      const token = doc.putObject("/", "tokens", {})
+      let token = doc.putObject("/", "tokens", {})
 
       // lists can be made with javascript arrays
 
-      const birds = doc.putObject("/", "birds", ["bluejay", "penguin", "puffin"])
+      let birds = doc.putObject("/", "birds", ["bluejay", "penguin", "puffin"])
-      const bots = doc.putObject("/", "bots", [])
+      let bots = doc.putObject("/", "bots", [])
 
       // text is initialized with a string
 
-      const notes = doc.putObject("/", "notes", "Hello world!")
+      let notes = doc.putObject("/", "notes", "Hello world!")
+
+      doc.free()
     })
     it('Automerge Object Types (2)', () => {
-      const doc = create(true)
+      let doc = create()
 
-      const config = doc.putObject("/", "config", { align: "left", archived: false, cycles: [10, 19, 21] })
+      let config = doc.putObject("/", "config", { align: "left", archived: false, cycles: [10, 19, 21] })
 
       doc.put(config, "align", "right")
 
       // Anywhere Object Ids are being used a path can also be used.
       // The following two statements are equivalent:
 
-      const id = doc.getWithType("/", "config")
+      let id = doc.get("/", "config")
       if (id && id[0] === 'map') {
         doc.put(id[1], "align", "right")
       }
@@ -83,24 +94,28 @@ describe('Automerge', () => {
       assert.deepEqual(doc.materialize("/"), {
          config: { align: "right", archived: false, cycles: [ 10, 19, 21 ] }
       })
+
+      doc.free()
     })
     it('Maps (1)', () => {
-      const doc = create(true)
+      let doc = create()
-      const mymap = doc.putObject("_root", "mymap", { foo: "bar"})
+      let mymap = doc.putObject("_root", "mymap", { foo: "bar"})
                                 // make a new map with the foo key
 
       doc.put(mymap, "bytes", new Uint8Array([1,2,3]))
                                 // assign a byte array to key `bytes` of the mymap object
 
-      const submap = doc.putObject(mymap, "sub", {})
+      let submap = doc.putObject(mymap, "sub", {})
                                 // make a new empty object and assign it to the key `sub` of mymap
 
       assert.deepEqual(doc.keys(mymap),["bytes","foo","sub"])
       assert.deepEqual(doc.materialize("_root"), { mymap: { bytes: new Uint8Array([1,2,3]), foo: "bar", sub: {} }})
+
+      doc.free()
     })
     it('Lists (1)', () => {
-      const doc = create(true)
+      let doc = create()
-      const items = doc.putObject("_root", "items", [10,"box"])
+      let items = doc.putObject("_root", "items", [10,"box"])
                                                     // init a new list with two elements
       doc.push(items, true)                         // push `true` to the end of the list
       doc.putObject(items, 0, { hello: "world" })   // overwrite the value 10 with an object with a key and value
@@ -111,24 +126,34 @@ describe('Automerge', () => {
 
       assert.deepEqual(doc.materialize(items),[ "bat", [ 1 ,2 ], { hello : "world" }, true, "bag", "brick" ])
       assert.deepEqual(doc.length(items),6)
+
+      doc.free()
     })
     it('Text (1)', () => {
-      const doc = create(true, "aaaaaa")
+      let doc = create("aaaaaa")
-      const notes = doc.putObject("_root", "notes", "Hello world")
+      let notes = doc.putObject("_root", "notes", "Hello world")
       doc.splice(notes, 6, 5, "everyone")
 
       assert.deepEqual(doc.text(notes), "Hello everyone")
+
+      let obj = doc.insertObject(notes, 6, { hi: "there" })
+
+      assert.deepEqual(doc.text(notes), "Hello \ufffceveryone")
+      assert.deepEqual(doc.get(notes, 6), ["map", obj])
+      assert.deepEqual(doc.get(obj, "hi"), ["str", "there"])
+
+      doc.free()
     })
     it('Querying Data (1)', () => {
-      const doc1 = create(true, "aabbcc")
+      let doc1 = create("aabbcc")
       doc1.put("_root", "key1", "val1")
-      const key2 = doc1.putObject("_root", "key2", [])
+      let key2 = doc1.putObject("_root", "key2", [])
 
-      assert.deepEqual(doc1.get("_root", "key1"), "val1")
+      assert.deepEqual(doc1.get("_root", "key1"), ["str", "val1"])
-      assert.deepEqual(doc1.getWithType("_root", "key2"), ["list", "2@aabbcc"])
+      assert.deepEqual(doc1.get("_root", "key2"), ["list", "2@aabbcc"])
       assert.deepEqual(doc1.keys("_root"), ["key1", "key2"])
 
-      const doc2 = doc1.fork("ffaaff")
+      let doc2 = doc1.fork("ffaaff")
 
       // set a value concurrently
       doc1.put("_root","key3","doc1val")
@@ -136,15 +161,17 @@ describe('Automerge', () => {
 
       doc1.merge(doc2)
 
-      assert.deepEqual(doc1.get("_root","key3"), "doc2val")
+      assert.deepEqual(doc1.get("_root","key3"), ["str", "doc2val"])
       assert.deepEqual(doc1.getAll("_root","key3"),[[ "str", "doc1val", "3@aabbcc"], ["str", "doc2val", "3@ffaaff"]])
+
+      doc1.free(); doc2.free()
     })
     it('Counters (1)', () => {
-      const doc1 = create(true, "aaaaaa")
+      let doc1 = create("aaaaaa")
       doc1.put("_root", "number", 0)
       doc1.put("_root", "total", 0, "counter")
 
-      const doc2 = doc1.fork("bbbbbb")
+      let doc2 = doc1.fork("bbbbbb")
       doc2.put("_root", "number", 10)
       doc2.increment("_root", "total", 11)
 
@@ -154,18 +181,20 @@ describe('Automerge', () => {
       doc1.merge(doc2)
 
       assert.deepEqual(doc1.materialize("_root"), { number: 10, total: 33 })
+
+      doc1.free(); doc2.free()
     })
     it('Transactions (1)', () => {
-      const doc = create(true)
+      let doc = create()
 
       doc.put("_root", "key", "val1")
 
-      assert.deepEqual(doc.get("_root", "key"),"val1")
+      assert.deepEqual(doc.get("_root", "key"),["str","val1"])
       assert.deepEqual(doc.pendingOps(),1)
 
       doc.rollback()
 
-      assert.deepEqual(doc.get("_root", "key"),undefined)
+      assert.deepEqual(doc.get("_root", "key"),null)
       assert.deepEqual(doc.pendingOps(),0)
 
       doc.put("_root", "key", "val2")
@@ -174,30 +203,34 @@ describe('Automerge', () => {
 
       doc.commit("test commit 1")
 
-      assert.deepEqual(doc.get("_root", "key"),"val2")
+      assert.deepEqual(doc.get("_root", "key"),["str","val2"])
       assert.deepEqual(doc.pendingOps(),0)
+
+      doc.free()
     })
     it('Viewing Old Versions of the Document (1)', () => {
-      const doc = create(true)
+      let doc = create()
 
       doc.put("_root", "key", "val1")
-      const heads1 = doc.getHeads()
+      let heads1 = doc.getHeads()
 
       doc.put("_root", "key", "val2")
-      const heads2 = doc.getHeads()
+      let heads2 = doc.getHeads()
 
       doc.put("_root", "key", "val3")
 
-      assert.deepEqual(doc.get("_root","key"), "val3")
+      assert.deepEqual(doc.get("_root","key"), ["str","val3"])
-      assert.deepEqual(doc.get("_root","key",heads2), "val2")
+      assert.deepEqual(doc.get("_root","key",heads2), ["str","val2"])
-      assert.deepEqual(doc.get("_root","key",heads1), "val1")
+      assert.deepEqual(doc.get("_root","key",heads1), ["str","val1"])
-      assert.deepEqual(doc.get("_root","key",[]), undefined)
+      assert.deepEqual(doc.get("_root","key",[]), null)
+
+      doc.free()
     })
     it('Forking And Merging (1)', () => {
-      const doc1 = create(true)
+      let doc1 = create()
       doc1.put("_root", "key1", "val1")
 
-      const doc2 = doc1.fork()
+      let doc2 = doc1.fork()
 
       doc1.put("_root", "key2", "val2")
       doc2.put("_root", "key3", "val3")
@@ -206,39 +239,43 @@ describe('Automerge', () => {
 
       assert.deepEqual(doc1.materialize("_root"), { key1: "val1", key2: "val2", key3: "val3" })
       assert.deepEqual(doc2.materialize("_root"), { key1: "val1", key3: "val3" })
+
+      doc1.free(); doc2.free()
     })
     it('Saving And Loading (1)', () => {
-      const doc1 = create(true)
+      let doc1 = create()
 
       doc1.put("_root", "key1", "value1")
 
-      const save1 = doc1.save()
+      let save1 = doc1.save()
 
-      const doc2 = load(save1, true)
+      let doc2 = load(save1)
 
       doc2.materialize("_root")  // returns { key1: "value1" }
 
       doc1.put("_root", "key2", "value2")
 
-      const saveIncremental = doc1.saveIncremental()
+      let saveIncremental = doc1.saveIncremental()
 
-      const save2 = doc1.save()
+      let save2 = doc1.save()
 
-      const save3 = new Uint8Array([... save1, ... saveIncremental])
+      let save3 = new Uint8Array([... save1, ... saveIncremental])
 
       // save2 has fewer bytes than save3 but contains the same ops
 
       doc2.loadIncremental(saveIncremental)
 
-      const doc3 = load(save2, true)
+      let doc3 = load(save2)
 
-      const doc4 = load(save3, true)
+      let doc4 = load(save3)
 
       assert.deepEqual(doc1.materialize("_root"), { key1: "value1", key2: "value2" })
       assert.deepEqual(doc2.materialize("_root"), { key1: "value1", key2: "value2" })
       assert.deepEqual(doc3.materialize("_root"), { key1: "value1", key2: "value2" })
       assert.deepEqual(doc4.materialize("_root"), { key1: "value1", key2: "value2" })
+
+      doc1.free(); doc2.free(); doc3.free(); doc4.free()
     })
-    //it.skip('Syncing (1)', () => { })
+    it.skip('Syncing (1)', () => { })
   })
 })

automerge-wasm/tsconfig.json

@@ -11,9 +11,7 @@
     "paths": { "dev": ["*"]},
     "rootDir": "",
     "target": "es2016",
-    "types": ["mocha", "node"],
     "typeRoots": ["./index.d.ts"]
   },
-  "include": ["test/**/*.ts"],
+  "exclude": ["dist/**/*"]
-  "exclude": ["dist/**/*", "examples/**/*"]
 }

automerge-wasm/web-index.js

@@ -0,0 +1,13 @@
+export {
+  loadDoc as load,
+  create,
+  encodeChange,
+  decodeChange,
+  initSyncState,
+  encodeSyncMessage,
+  decodeSyncMessage,
+  encodeSyncState,
+  decodeSyncState,
+} from "./bindgen.js"
+import init from "./bindgen.js"
+export default init;

automerge/Cargo.toml

@@ -1,37 +1,36 @@
 [package]
 name = "automerge"
-version = "0.3.0"
+version = "0.1.0"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/automerge/automerge-rs"
 documentation = "https://automerge.org/automerge-rs/automerge/"
-rust-version = "1.57.0"
+
-description = "A JSON-like data structure (a CRDT) that can be modified concurrently by different users, and merged again automatically"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-readme = "./README.md"
 
 [features]
-optree-visualisation = ["dot", "rand"]
+optree-visualisation = ["dot"]
-wasm = ["js-sys", "wasm-bindgen", "web-sys", "uuid/js"]
+wasm = ["js-sys", "wasm-bindgen", "web-sys"]
 
 [dependencies]
 hex = "^0.4.3"
 leb128 = "^0.2.5"
 sha2 = "^0.10.0"
+rand = { version = "^0.8.4" }
 thiserror = "^1.0.16"
 itertools = "^0.10.3"
 flate2 = "^1.0.22"
-uuid = { version = "^1.2.1", features=["v4", "serde"] }
+nonzero_ext = "^0.2.0"
+uuid = { version = "^0.8.2", features=["v4", "wasm-bindgen", "serde"] }
 smol_str = { version = "^0.1.21", features=["serde"] }
-tracing = { version = "^0.1.29" }
+tracing = { version = "^0.1.29", features = ["log"] }
 fxhash = "^0.2.1"
 tinyvec = { version = "^1.5.1", features = ["alloc"] }
 serde = { version = "^1.0", features=["derive"] }
-
 # optional deps
 dot = { version = "0.1.4", optional = true }
 js-sys = { version = "^0.3", optional = true }
 wasm-bindgen = { version = "^0.2", optional = true }
-rand = { version = "^0.8.4", optional = true }
 
 [dependencies.web-sys]
 version = "^0.3.55"
@@ -43,20 +42,9 @@ pretty_assertions = "1.0.0"
 proptest = { version = "^1.0.0", default-features = false, features = ["std"] }
 serde_json = { version = "^1.0.73", features=["float_roundtrip"], default-features=true }
 maplit = { version = "^1.0" }
-criterion = "0.4.0"
+decorum = "0.3.1"
-test-log = { version = "0.2.10", features=["trace"], default-features = false}
+criterion = "0.3.5"
-tracing-subscriber = {version = "0.3.9", features = ["fmt", "env-filter"] }
-automerge-test = { path = "../automerge-test" }
-prettytable = "0.10.0"
-
-[[bench]]
-name = "range"
-harness = false
 
 [[bench]]
 name = "map"
 harness = false
-
-[[bench]]
-name = "sync"
-harness = false

automerge/benches/map.rs

@@ -0,0 +1,48 @@
+use automerge::{transaction::Transactable, Automerge, ROOT};
+use criterion::{criterion_group, criterion_main, Criterion};
+
+fn query_single(doc: &Automerge, rounds: u32) {
+    for _ in 0..rounds {
+        // repeatedly get the last key
+        doc.get(ROOT, (rounds - 1).to_string()).unwrap();
+    }
+}
+
+fn query_range(doc: &Automerge, rounds: u32) {
+    for i in 0..rounds {
+        doc.get(ROOT, i.to_string()).unwrap();
+    }
+}
+
+fn put_doc(doc: &mut Automerge, rounds: u32) {
+    for i in 0..rounds {
+        let mut tx = doc.transaction();
+        tx.put(ROOT, i.to_string(), "value").unwrap();
+        tx.commit();
+    }
+}
+
+fn bench(c: &mut Criterion) {
+    let mut group = c.benchmark_group("map");
+
+    let rounds = 10_000;
+    let mut doc = Automerge::new();
+    put_doc(&mut doc, rounds);
+
+    group.bench_function("query single", |b| b.iter(|| query_single(&doc, rounds)));
+
+    group.bench_function("query range", |b| b.iter(|| query_range(&doc, rounds)));
+
+    group.bench_function("put", |b| {
+        b.iter_batched(
+            Automerge::new,
+            |mut doc| put_doc(&mut doc, rounds),
+            criterion::BatchSize::LargeInput,
+        )
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, bench);
+criterion_main!(benches);

automerge/examples/quickstart.rs

@@ -2,13 +2,13 @@ use automerge::transaction::CommitOptions;
 use automerge::transaction::Transactable;
 use automerge::AutomergeError;
 use automerge::ObjType;
-use automerge::{Automerge, ReadDoc, ROOT};
+use automerge::{Automerge, ROOT};
 
 // Based on https://automerge.github.io/docs/quickstart
 fn main() {
     let mut doc1 = Automerge::new();
     let (cards, card1) = doc1
-        .transact_with::<_, _, AutomergeError, _>(
+        .transact_with::<_, _, AutomergeError, _, ()>(
             |_| CommitOptions::default().with_message("Add card".to_owned()),
             |tx| {
                 let cards = tx.put_object(ROOT, "cards", ObjType::List).unwrap();
@@ -30,7 +30,7 @@ fn main() {
     let binary = doc1.save();
     let mut doc2 = Automerge::load(&binary).unwrap();
 
-    doc1.transact_with::<_, _, AutomergeError, _>(
+    doc1.transact_with::<_, _, AutomergeError, _, ()>(
         |_| CommitOptions::default().with_message("Mark card as done".to_owned()),
         |tx| {
             tx.put(&card1, "done", true)?;
@@ -39,7 +39,7 @@ fn main() {
     )
     .unwrap();
 
-    doc2.transact_with::<_, _, AutomergeError, _>(
+    doc2.transact_with::<_, _, AutomergeError, _, ()>(
         |_| CommitOptions::default().with_message("Delete card".to_owned()),
         |tx| {
             tx.delete(&cards, 0)?;
@@ -50,8 +50,8 @@ fn main() {
 
     doc1.merge(&mut doc2).unwrap();
 
-    for change in doc1.get_changes(&[]).unwrap() {
+    for change in doc1.get_changes(&[]) {
-        let length = doc1.length_at(&cards, &[change.hash()]);
+        let length = doc1.length_at(&cards, &[change.hash]);
         println!("{} {}", change.message().unwrap(), length);
     }
 }

automerge/examples/watch.rs

@@ -3,26 +3,25 @@ use automerge::transaction::Transactable;
 use automerge::Automerge;
 use automerge::AutomergeError;
 use automerge::Patch;
-use automerge::ReadDoc;
 use automerge::VecOpObserver;
 use automerge::ROOT;
 
 fn main() {
     let mut doc = Automerge::new();
 
+    let mut observer = VecOpObserver::default();
     // a simple scalar change in the root object
-    let mut result = doc
+    doc.transact_with::<_, _, AutomergeError, _, _>(
-        .transact_observed_with::<_, _, AutomergeError, _, VecOpObserver>(
+        |_result| CommitOptions::default().with_op_observer(&mut observer),
-            |_result| CommitOptions::default(),
         |tx| {
             tx.put(ROOT, "hello", "world").unwrap();
             Ok(())
         },
     )
     .unwrap();
-    get_changes(&doc, result.op_observer.take_patches());
+    get_changes(&doc, observer.take_patches());
 
-    let mut tx = doc.transaction_with_observer(VecOpObserver::default());
+    let mut tx = doc.transaction();
     let map = tx
         .put_object(ROOT, "my new map", automerge::ObjType::Map)
         .unwrap();
@@ -37,28 +36,28 @@ fn main() {
     tx.insert(&list, 1, "woo").unwrap();
     let m = tx.insert_object(&list, 2, automerge::ObjType::Map).unwrap();
     tx.put(&m, "hi", 2).unwrap();
-    let patches = tx.observer().take_patches();
+    let _heads3 = tx.commit_with(CommitOptions::default().with_op_observer(&mut observer));
-    let _heads3 = tx.commit_with(CommitOptions::default());
+    get_changes(&doc, observer.take_patches());
-    get_changes(&doc, patches);
 }
 
 fn get_changes(doc: &Automerge, patches: Vec<Patch>) {
     for patch in patches {
         match patch {
             Patch::Put {
-                obj, prop, value, ..
+                obj,
+                key,
+                value,
+                conflict: _,
             } => {
                 println!(
                     "put {:?} at {:?} in obj {:?}, object path {:?}",
                     value,
-                    prop,
+                    key,
                     obj,
                     doc.path_to_object(&obj)
                 )
             }
-            Patch::Insert {
+            Patch::Insert { obj, index, value } => {
-                obj, index, value, ..
-            } => {
                 println!(
                     "insert {:?} at {:?} in obj {:?}, object path {:?}",
                     value,
@@ -67,37 +66,18 @@ fn get_changes(doc: &Automerge, patches: Vec<Patch>) {
                     doc.path_to_object(&obj)
                 )
             }
-            Patch::Splice {
+            Patch::Increment { obj, key, value } => {
-                obj, index, value, ..
-            } => {
-                println!(
-                    "splice '{:?}' at {:?} in obj {:?}, object path {:?}",
-                    value,
-                    index,
-                    obj,
-                    doc.path_to_object(&obj)
-                )
-            }
-            Patch::Increment {
-                obj, prop, value, ..
-            } => {
                 println!(
                     "increment {:?} in obj {:?} by {:?}, object path {:?}",
-                    prop,
+                    key,
                     obj,
                     value,
                     doc.path_to_object(&obj)
                 )
             }
-            Patch::Delete { obj, prop, .. } => println!(
+            Patch::Delete { obj, key } => println!(
                 "delete {:?} in obj {:?}, object path {:?}",
-                prop,
+                key,
-                obj,
-                doc.path_to_object(&obj)
-            ),
-            Patch::Expose { obj, prop, .. } => println!(
-                "expose {:?} in obj {:?}, object path {:?}",
-                prop,
                 obj,
                 doc.path_to_object(&obj)
             ),

automerge/src/autocommit.rs

@@ -0,0 +1,482 @@
+use std::ops::RangeBounds;
+
+use crate::exid::ExId;
+use crate::op_observer::OpObserver;
+use crate::transaction::{CommitOptions, Transactable};
+use crate::{
+    sync, ApplyOptions, Keys, KeysAt, ObjType, Parents, Range, RangeAt, ScalarValue, Values,
+    ValuesAt,
+};
+use crate::{
+    transaction::TransactionInner, ActorId, Automerge, AutomergeError, Change, ChangeHash, Prop,
+    Value,
+};
+
+/// An automerge document that automatically manages transactions.
+#[derive(Debug, Clone)]
+pub struct AutoCommit {
+    doc: Automerge,
+    transaction: Option<TransactionInner>,
+}
+
+impl Default for AutoCommit {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AutoCommit {
+    pub fn new() -> Self {
+        Self {
+            doc: Automerge::new(),
+            transaction: None,
+        }
+    }
+
+    /// Get the inner document.
+    #[doc(hidden)]
+    pub fn document(&mut self) -> &Automerge {
+        self.ensure_transaction_closed();
+        &self.doc
+    }
+
+    pub fn with_actor(mut self, actor: ActorId) -> Self {
+        self.ensure_transaction_closed();
+        self.doc.set_actor(actor);
+        self
+    }
+
+    pub fn set_actor(&mut self, actor: ActorId) -> &mut Self {
+        self.ensure_transaction_closed();
+        self.doc.set_actor(actor);
+        self
+    }
+
+    pub fn get_actor(&self) -> &ActorId {
+        self.doc.get_actor()
+    }
+
+    fn ensure_transaction_open(&mut self) {
+        if self.transaction.is_none() {
+            self.transaction = Some(self.doc.transaction_inner());
+        }
+    }
+
+    pub fn fork(&mut self) -> Self {
+        self.ensure_transaction_closed();
+        Self {
+            doc: self.doc.fork(),
+            transaction: self.transaction.clone(),
+        }
+    }
+
+    pub fn fork_at(&mut self, heads: &[ChangeHash]) -> Result<Self, AutomergeError> {
+        self.ensure_transaction_closed();
+        Ok(Self {
+            doc: self.doc.fork_at(heads)?,
+            transaction: self.transaction.clone(),
+        })
+    }
+
+    fn ensure_transaction_closed(&mut self) {
+        if let Some(tx) = self.transaction.take() {
+            tx.commit::<()>(&mut self.doc, None, None, None);
+        }
+    }
+
+    pub fn load(data: &[u8]) -> Result<Self, AutomergeError> {
+        let doc = Automerge::load(data)?;
+        Ok(Self {
+            doc,
+            transaction: None,
+        })
+    }
+
+    pub fn load_with<Obs: OpObserver>(
+        data: &[u8],
+        options: ApplyOptions<'_, Obs>,
+    ) -> Result<Self, AutomergeError> {
+        let doc = Automerge::load_with(data, options)?;
+        Ok(Self {
+            doc,
+            transaction: None,
+        })
+    }
+
+    pub fn load_incremental(&mut self, data: &[u8]) -> Result<usize, AutomergeError> {
+        self.ensure_transaction_closed();
+        self.doc.load_incremental(data)
+    }
+
+    pub fn load_incremental_with<'a, Obs: OpObserver>(
+        &mut self,
+        data: &[u8],
+        options: ApplyOptions<'a, Obs>,
+    ) -> Result<usize, AutomergeError> {
+        self.ensure_transaction_closed();
+        self.doc.load_incremental_with(data, options)
+    }
+
+    pub fn apply_changes(&mut self, changes: Vec<Change>) -> Result<(), AutomergeError> {
+        self.ensure_transaction_closed();
+        self.doc.apply_changes(changes)
+    }
+
+    pub fn apply_changes_with<Obs: OpObserver>(
+        &mut self,
+        changes: Vec<Change>,
+        options: ApplyOptions<'_, Obs>,
+    ) -> Result<(), AutomergeError> {
+        self.ensure_transaction_closed();
+        self.doc.apply_changes_with(changes, options)
+    }
+
+    /// Takes all the changes in `other` which are not in `self` and applies them
+    pub fn merge(&mut self, other: &mut Self) -> Result<Vec<ChangeHash>, AutomergeError> {
+        self.ensure_transaction_closed();
+        other.ensure_transaction_closed();
+        self.doc.merge(&mut other.doc)
+    }
+
+    /// Takes all the changes in `other` which are not in `self` and applies them
+    pub fn merge_with<'a, Obs: OpObserver>(
+        &mut self,
+        other: &mut Self,
+        options: ApplyOptions<'a, Obs>,
+    ) -> Result<Vec<ChangeHash>, AutomergeError> {
+        self.ensure_transaction_closed();
+        other.ensure_transaction_closed();
+        self.doc.merge_with(&mut other.doc, options)
+    }
+
+    pub fn save(&mut self) -> Vec<u8> {
+        self.ensure_transaction_closed();
+        self.doc.save()
+    }
+
+    // should this return an empty vec instead of None?
+    pub fn save_incremental(&mut self) -> Vec<u8> {
+        self.ensure_transaction_closed();
+        self.doc.save_incremental()
+    }
+
+    pub fn get_missing_deps(&mut self, heads: &[ChangeHash]) -> Vec<ChangeHash> {
+        self.ensure_transaction_closed();
+        self.doc.get_missing_deps(heads)
+    }
+
+    pub fn get_last_local_change(&mut self) -> Option<&Change> {
+        self.ensure_transaction_closed();
+        self.doc.get_last_local_change()
+    }
+
+    pub fn get_changes(&mut self, have_deps: &[ChangeHash]) -> Vec<&Change> {
+        self.ensure_transaction_closed();
+        self.doc.get_changes(have_deps)
+    }
+
+    pub fn get_change_by_hash(&mut self, hash: &ChangeHash) -> Option<&Change> {
+        self.ensure_transaction_closed();
+        self.doc.get_change_by_hash(hash)
+    }
+
+    pub fn get_changes_added<'a>(&mut self, other: &'a mut Self) -> Vec<&'a Change> {
+        self.ensure_transaction_closed();
+        other.ensure_transaction_closed();
+        self.doc.get_changes_added(&other.doc)
+    }
+
+    pub fn import(&self, s: &str) -> Result<ExId, AutomergeError> {
+        self.doc.import(s)
+    }
+
+    pub fn dump(&mut self) {
+        self.ensure_transaction_closed();
+        self.doc.dump()
+    }
+
+    pub fn generate_sync_message(&mut self, sync_state: &mut sync::State) -> Option<sync::Message> {
+        self.ensure_transaction_closed();
+        self.doc.generate_sync_message(sync_state)
+    }
+
+    pub fn receive_sync_message(
+        &mut self,
+        sync_state: &mut sync::State,
+        message: sync::Message,
+    ) -> Result<(), AutomergeError> {
+        self.ensure_transaction_closed();
+        self.doc.receive_sync_message(sync_state, message)
+    }
+
+    pub fn receive_sync_message_with<'a, Obs: OpObserver>(
+        &mut self,
+        sync_state: &mut sync::State,
+        message: sync::Message,
+        options: ApplyOptions<'a, Obs>,
+    ) -> Result<(), AutomergeError> {
+        self.ensure_transaction_closed();
+        self.doc
+            .receive_sync_message_with(sync_state, message, options)
+    }
+
+    #[cfg(feature = "optree-visualisation")]
+    pub fn visualise_optree(&self) -> String {
+        self.doc.visualise_optree()
+    }
+
+    /// Get the current heads of the document.
+    ///
+    /// This closes the transaction first, if one is in progress.
+    pub fn get_heads(&mut self) -> Vec<ChangeHash> {
+        self.ensure_transaction_closed();
+        self.doc.get_heads()
+    }
+
+    pub fn commit(&mut self) -> ChangeHash {
+        self.commit_with::<()>(CommitOptions::default())
+    }
+
+    /// Commit the current operations with some options.
+    ///
+    /// ```
+    /// # use automerge::transaction::CommitOptions;
+    /// # use automerge::transaction::Transactable;
+    /// # use automerge::ROOT;
+    /// # use automerge::AutoCommit;
+    /// # use automerge::ObjType;
+    /// # use std::time::SystemTime;
+    /// let mut doc = AutoCommit::new();
+    /// doc.put_object(&ROOT, "todos", ObjType::List).unwrap();
+    /// let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs() as
+    /// i64;
+    /// doc.commit_with::<()>(CommitOptions::default().with_message("Create todos list").with_time(now));
+    /// ```
+    pub fn commit_with<Obs: OpObserver>(&mut self, options: CommitOptions<'_, Obs>) -> ChangeHash {
+        // ensure that even no changes triggers a change
+        self.ensure_transaction_open();
+        let tx = self.transaction.take().unwrap();
+        tx.commit(
+            &mut self.doc,
+            options.message,
+            options.time,
+            options.op_observer,
+        )
+    }
+
+    pub fn rollback(&mut self) -> usize {
+        self.transaction
+            .take()
+            .map(|tx| tx.rollback(&mut self.doc))
+            .unwrap_or(0)
+    }
+}
+
+impl Transactable for AutoCommit {
+    fn pending_ops(&self) -> usize {
+        self.transaction
+            .as_ref()
+            .map(|t| t.pending_ops())
+            .unwrap_or(0)
+    }
+
+    // KeysAt::()
+    // LenAt::()
+    // PropAt::()
+    // NthAt::()
+
+    fn keys<O: AsRef<ExId>>(&self, obj: O) -> Keys<'_, '_> {
+        self.doc.keys(obj)
+    }
+
+    fn keys_at<O: AsRef<ExId>>(&self, obj: O, heads: &[ChangeHash]) -> KeysAt<'_, '_> {
+        self.doc.keys_at(obj, heads)
+    }
+
+    fn range<O: AsRef<ExId>, R: RangeBounds<String>>(&self, obj: O, range: R) -> Range<'_, R> {
+        self.doc.range(obj, range)
+    }
+
+    fn range_at<O: AsRef<ExId>, R: RangeBounds<String>>(
+        &self,
+        obj: O,
+        range: R,
+        heads: &[ChangeHash],
+    ) -> RangeAt<'_, R> {
+        self.doc.range_at(obj, range, heads)
+    }
+
+    fn values<O: AsRef<ExId>>(&self, obj: O) -> Values<'_> {
+        self.doc.values(obj)
+    }
+
+    fn values_at<O: AsRef<ExId>>(&self, obj: O, heads: &[ChangeHash]) -> ValuesAt<'_> {
+        self.doc.values_at(obj, heads)
+    }
+
+    fn length<O: AsRef<ExId>>(&self, obj: O) -> usize {
+        self.doc.length(obj)
+    }
+
+    fn length_at<O: AsRef<ExId>>(&self, obj: O, heads: &[ChangeHash]) -> usize {
+        self.doc.length_at(obj, heads)
+    }
+
+    fn object_type<O: AsRef<ExId>>(&self, obj: O) -> Option<ObjType> {
+        self.doc.object_type(obj)
+    }
+
+    // set(obj, prop, value) - value can be scalar or objtype
+    // del(obj, prop)
+    // inc(obj, prop, value)
+    // insert(obj, index, value)
+
+    /// Set the value of property `P` to value `V` in object `obj`.
+    ///
+    /// # Returns
+    ///
+    /// The opid of the operation which was created, or None if this operation doesn't change the
+    /// document or create a new object.
+    ///
+    /// # Errors
+    ///
+    /// This will return an error if
+    /// - The object does not exist
+    /// - The key is the wrong type for the object
+    /// - The key does not exist in the object
+    fn put<O: AsRef<ExId>, P: Into<Prop>, V: Into<ScalarValue>>(
+        &mut self,
+        obj: O,
+        prop: P,
+        value: V,
+    ) -> Result<(), AutomergeError> {
+        self.ensure_transaction_open();
+        let tx = self.transaction.as_mut().unwrap();
+        tx.put(&mut self.doc, obj.as_ref(), prop, value)
+    }
+
+    fn put_object<O: AsRef<ExId>, P: Into<Prop>>(
+        &mut self,
+        obj: O,
+        prop: P,
+        value: ObjType,
+    ) -> Result<ExId, AutomergeError> {
+        self.ensure_transaction_open();
+        let tx = self.transaction.as_mut().unwrap();
+        tx.put_object(&mut self.doc, obj.as_ref(), prop, value)
+    }
+
+    fn insert<O: AsRef<ExId>, V: Into<ScalarValue>>(
+        &mut self,
+        obj: O,
+        index: usize,
+        value: V,
+    ) -> Result<(), AutomergeError> {
+        self.ensure_transaction_open();
+        let tx = self.transaction.as_mut().unwrap();
+        tx.insert(&mut self.doc, obj.as_ref(), index, value)
+    }
+
+    fn insert_object<O: AsRef<ExId>>(
+        &mut self,
+        obj: O,
+        index: usize,
+        value: ObjType,
+    ) -> Result<ExId, AutomergeError> {
+        self.ensure_transaction_open();
+        let tx = self.transaction.as_mut().unwrap();
+        tx.insert_object(&mut self.doc, obj.as_ref(), index, value)
+    }
+
+    fn increment<O: AsRef<ExId>, P: Into<Prop>>(
+        &mut self,
+        obj: O,
+        prop: P,
+        value: i64,
+    ) -> Result<(), AutomergeError> {
+        self.ensure_transaction_open();
+        let tx = self.transaction.as_mut().unwrap();
+        tx.increment(&mut self.doc, obj.as_ref(), prop, value)
+    }
+
+    fn delete<O: AsRef<ExId>, P: Into<Prop>>(
+        &mut self,
+        obj: O,
+        prop: P,
+    ) -> Result<(), AutomergeError> {
+        self.ensure_transaction_open();
+        let tx = self.transaction.as_mut().unwrap();
+        tx.delete(&mut self.doc, obj.as_ref(), prop)
+    }
+
+    /// Splice new elements into the given sequence. Returns a vector of the OpIds used to insert
+    /// the new elements
+    fn splice<O: AsRef<ExId>, V: IntoIterator<Item = ScalarValue>>(
+        &mut self,
+        obj: O,
+        pos: usize,
+        del: usize,
+        vals: V,
+    ) -> Result<(), AutomergeError> {
+        self.ensure_transaction_open();
+        let tx = self.transaction.as_mut().unwrap();
+        tx.splice(&mut self.doc, obj.as_ref(), pos, del, vals)
+    }
+
+    fn text<O: AsRef<ExId>>(&self, obj: O) -> Result<String, AutomergeError> {
+        self.doc.text(obj)
+    }
+
+    fn text_at<O: AsRef<ExId>>(
+        &self,
+        obj: O,
+        heads: &[ChangeHash],
+    ) -> Result<String, AutomergeError> {
+        self.doc.text_at(obj, heads)
+    }
+
+    // TODO - I need to return these OpId's here **only** to get
+    // the legacy conflicts format of { [opid]: value }
+    // Something better?
+    fn get<O: AsRef<ExId>, P: Into<Prop>>(
+        &self,
+        obj: O,
+        prop: P,
+    ) -> Result<Option<(Value<'_>, ExId)>, AutomergeError> {
+        self.doc.get(obj, prop)
+    }
+
+    fn get_at<O: AsRef<ExId>, P: Into<Prop>>(
+        &self,
+        obj: O,
+        prop: P,
+        heads: &[ChangeHash],
+    ) -> Result<Option<(Value<'_>, ExId)>, AutomergeError> {
+        self.doc.get_at(obj, prop, heads)
+    }
+
+    fn get_all<O: AsRef<ExId>, P: Into<Prop>>(
+        &self,
+        obj: O,
+        prop: P,
+    ) -> Result<Vec<(Value<'_>, ExId)>, AutomergeError> {
+        self.doc.get_all(obj, prop)
+    }
+
+    fn get_all_at<O: AsRef<ExId>, P: Into<Prop>>(
+        &self,
+        obj: O,
+        prop: P,
+        heads: &[ChangeHash],
+    ) -> Result<Vec<(Value<'_>, ExId)>, AutomergeError> {
+        self.doc.get_all_at(obj, prop, heads)
+    }
+
+    fn parent_object<O: AsRef<ExId>>(&self, obj: O) -> Option<(ExId, Prop)> {
+        self.doc.parent_object(obj)
+    }
+
+    fn parents(&self, obj: ExId) -> Parents<'_> {
+        self.doc.parents(obj)
+    }
+}

automerge/src/change.rs

@@ -0,0 +1,997 @@
+use crate::columnar::{
+    ChangeEncoder, ChangeIterator, ColumnEncoder, DepsIterator, DocChange, DocOp, DocOpEncoder,
+    DocOpIterator, OperationIterator, COLUMN_TYPE_DEFLATE,
+};
+use crate::decoding;
+use crate::decoding::{Decodable, InvalidChangeError};
+use crate::encoding::{Encodable, DEFLATE_MIN_SIZE};
+use crate::error::AutomergeError;
+use crate::indexed_cache::IndexedCache;
+use crate::legacy as amp;
+use crate::transaction::TransactionInner;
+use crate::types;
+use crate::types::{ActorId, ElemId, Key, ObjId, Op, OpId, OpType};
+use core::ops::Range;
+use flate2::{
+    bufread::{DeflateDecoder, DeflateEncoder},
+    Compression,
+};
+use itertools::Itertools;
+use sha2::Digest;
+use sha2::Sha256;
+use std::collections::{HashMap, HashSet};
+use std::convert::TryInto;
+use std::fmt::Debug;
+use std::io::{Read, Write};
+use std::num::NonZeroU64;
+use tracing::instrument;
+
+const MAGIC_BYTES: [u8; 4] = [0x85, 0x6f, 0x4a, 0x83];
+const PREAMBLE_BYTES: usize = 8;
+const HEADER_BYTES: usize = PREAMBLE_BYTES + 1;
+
+const HASH_BYTES: usize = 32;
+const BLOCK_TYPE_DOC: u8 = 0;
+const BLOCK_TYPE_CHANGE: u8 = 1;
+const BLOCK_TYPE_DEFLATE: u8 = 2;
+const CHUNK_START: usize = 8;
+const HASH_RANGE: Range<usize> = 4..8;
+
+pub(crate) fn encode_document<'a, 'b>(
+    heads: Vec<amp::ChangeHash>,
+    changes: impl Iterator<Item = &'a Change>,
+    doc_ops: impl Iterator<Item = (&'b ObjId, &'b Op)>,
+    actors_index: &IndexedCache<ActorId>,
+    props: &'a [String],
+) -> Vec<u8> {
+    let mut bytes: Vec<u8> = Vec::new();
+
+    let actors_map = actors_index.encode_index();
+    let actors = actors_index.sorted();
+
+    /*
+    // this assumes that all actor_ids referenced are seen in changes.actor_id which is true
+    // so long as we have a full history
+    let mut actors: Vec<_> = changes
+        .iter()
+        .map(|c| &c.actor)
+        .unique()
+        .sorted()
+        .cloned()
+        .collect();
+    */
+
+    let (change_bytes, change_info) = ChangeEncoder::encode_changes(changes, &actors);
+
+    //let doc_ops = group_doc_ops(changes, &actors);
+
+    let (ops_bytes, ops_info) = DocOpEncoder::encode_doc_ops(doc_ops, &actors_map, props);
+
+    bytes.extend(MAGIC_BYTES);
+    bytes.extend([0, 0, 0, 0]); // we dont know the hash yet so fill in a fake
+    bytes.push(BLOCK_TYPE_DOC);
+
+    let mut chunk = Vec::new();
+
+    actors.len().encode_vec(&mut chunk);
+
+    for a in actors.into_iter() {
+        a.to_bytes().encode_vec(&mut chunk);
+    }
+
+    heads.len().encode_vec(&mut chunk);
+    for head in heads.iter() {
+        chunk.write_all(&head.0).unwrap();
+    }
+
+    chunk.extend(change_info);
+    chunk.extend(ops_info);
+
+    chunk.extend(change_bytes);
+    chunk.extend(ops_bytes);
+
+    leb128::write::unsigned(&mut bytes, chunk.len() as u64).unwrap();
+
+    bytes.extend(&chunk);
+
+    let hash_result = Sha256::digest(&bytes[CHUNK_START..bytes.len()]);
+
+    bytes.splice(HASH_RANGE, hash_result[0..4].iter().copied());
+
+    bytes
+}
+
+/// When encoding a change we take all the actor IDs referenced by a change and place them in an
+/// array. The array has the actor who authored the change as the first element and all remaining
+/// actors (i.e. those referenced in object IDs in the target of an operation or in the `pred` of
+/// an operation) lexicographically ordered following the change author.
+fn actor_ids_in_change(change: &amp::Change) -> Vec<amp::ActorId> {
+    let mut other_ids: Vec<&amp::ActorId> = change
+        .operations
+        .iter()
+        .flat_map(opids_in_operation)
+        .filter(|a| *a != &change.actor_id)
+        .unique()
+        .collect();
+    other_ids.sort();
+    // Now prepend the change actor
+    std::iter::once(&change.actor_id)
+        .chain(other_ids.into_iter())
+        .cloned()
+        .collect()
+}
+
+fn opids_in_operation(op: &amp::Op) -> impl Iterator<Item = &amp::ActorId> {
+    let obj_actor_id = match &op.obj {
+        amp::ObjectId::Root => None,
+        amp::ObjectId::Id(opid) => Some(opid.actor()),
+    };
+    let pred_ids = op.pred.iter().map(amp::OpId::actor);
+    let key_actor = match &op.key {
+        amp::Key::Seq(amp::ElementId::Id(i)) => Some(i.actor()),
+        _ => None,
+    };
+    obj_actor_id
+        .into_iter()
+        .chain(key_actor.into_iter())
+        .chain(pred_ids)
+}
+
+impl From<amp::Change> for Change {
+    fn from(value: amp::Change) -> Self {
+        encode(&value)
+    }
+}
+
+impl From<&amp::Change> for Change {
+    fn from(value: &amp::Change) -> Self {
+        encode(value)
+    }
+}
+
+fn encode(change: &amp::Change) -> Change {
+    let mut deps = change.deps.clone();
+    deps.sort_unstable();
+
+    let mut chunk = encode_chunk(change, &deps);
+
+    let mut bytes = Vec::with_capacity(MAGIC_BYTES.len() + 4 + chunk.bytes.len());
+
+    bytes.extend(&MAGIC_BYTES);
+
+    bytes.extend(vec![0, 0, 0, 0]); // we dont know the hash yet so fill in a fake
+
+    bytes.push(BLOCK_TYPE_CHANGE);
+
+    leb128::write::unsigned(&mut bytes, chunk.bytes.len() as u64).unwrap();
+
+    let body_start = bytes.len();
+
+    increment_range(&mut chunk.body, bytes.len());
+    increment_range(&mut chunk.message, bytes.len());
+    increment_range(&mut chunk.extra_bytes, bytes.len());
+    increment_range_map(&mut chunk.ops, bytes.len());
+
+    bytes.extend(&chunk.bytes);
+
+    let hash_result = Sha256::digest(&bytes[CHUNK_START..bytes.len()]);
+    let hash: amp::ChangeHash = hash_result[..].try_into().unwrap();
+
+    bytes.splice(HASH_RANGE, hash_result[0..4].iter().copied());
+
+    // any time I make changes to the encoder decoder its a good idea
+    // to run it through a round trip to detect errors the tests might not
+    // catch
+    // let c0 = Change::from_bytes(bytes.clone()).unwrap();
+    // std::assert_eq!(c1, c0);
+    // perhaps we should add something like this to the test suite
+
+    let bytes = ChangeBytes::Uncompressed(bytes);
+
+    Change {
+        bytes,
+        body_start,
+        hash,
+        seq: change.seq,
+        start_op: change.start_op,
+        time: change.time,
+        actors: chunk.actors,
+        message: chunk.message,
+        deps,
+        ops: chunk.ops,
+        extra_bytes: chunk.extra_bytes,
+    }
+}
+
+struct ChunkIntermediate {
+    bytes: Vec<u8>,
+    body: Range<usize>,
+    actors: Vec<ActorId>,
+    message: Range<usize>,
+    ops: HashMap<u32, Range<usize>>,
+    extra_bytes: Range<usize>,
+}
+
+fn encode_chunk(change: &amp::Change, deps: &[amp::ChangeHash]) -> ChunkIntermediate {
+    let mut bytes = Vec::new();
+
+    // All these unwraps are okay because we're writing to an in memory buffer so io erros should
+    // not happen
+
+    // encode deps
+    deps.len().encode(&mut bytes).unwrap();
+    for hash in deps.iter() {
+        bytes.write_all(&hash.0).unwrap();
+    }
+
+    let actors = actor_ids_in_change(change);
+    change.actor_id.to_bytes().encode(&mut bytes).unwrap();
+
+    // encode seq, start_op, time, message
+    change.seq.encode(&mut bytes).unwrap();
+    change.start_op.encode(&mut bytes).unwrap();
+    change.time.encode(&mut bytes).unwrap();
+    let message = bytes.len() + 1;
+    change.message.encode(&mut bytes).unwrap();
+    let message = message..bytes.len();
+
+    // encode ops into a side buffer - collect all other actors
+    let (ops_buf, mut ops) = ColumnEncoder::encode_ops(&change.operations, &actors);
+
+    // encode all other actors
+    actors[1..].encode(&mut bytes).unwrap();
+
+    // now we know how many bytes ops are offset by so we can adjust the ranges
+    increment_range_map(&mut ops, bytes.len());
+
+    // write out the ops
+
+    bytes.write_all(&ops_buf).unwrap();
+
+    // write out the extra bytes
+    let extra_bytes = bytes.len()..(bytes.len() + change.extra_bytes.len());
+    bytes.write_all(&change.extra_bytes).unwrap();
+    let body = 0..bytes.len();
+
+    ChunkIntermediate {
+        bytes,
+        body,
+        actors,
+        message,
+        ops,
+        extra_bytes,
+    }
+}
+
+#[derive(PartialEq, Debug, Clone)]
+enum ChangeBytes {
+    Compressed {
+        compressed: Vec<u8>,
+        uncompressed: Vec<u8>,
+    },
+    Uncompressed(Vec<u8>),
+}
+
+impl ChangeBytes {
+    fn uncompressed(&self) -> &[u8] {
+        match self {
+            ChangeBytes::Compressed { uncompressed, .. } => &uncompressed[..],
+            ChangeBytes::Uncompressed(b) => &b[..],
+        }
+    }
+
+    fn compress(&mut self, body_start: usize) {
+        match self {
+            ChangeBytes::Compressed { .. } => {}
+            ChangeBytes::Uncompressed(uncompressed) => {
+                if uncompressed.len() > DEFLATE_MIN_SIZE {
+                    let mut result = Vec::with_capacity(uncompressed.len());
+                    result.extend(&uncompressed[0..8]);
+                    result.push(BLOCK_TYPE_DEFLATE);
+                    let mut deflater =
+                        DeflateEncoder::new(&uncompressed[body_start..], Compression::default());
+                    let mut deflated = Vec::new();
+                    let deflated_len = deflater.read_to_end(&mut deflated).unwrap();
+                    leb128::write::unsigned(&mut result, deflated_len as u64).unwrap();
+                    result.extend(&deflated[..]);
+                    *self = ChangeBytes::Compressed {
+                        compressed: result,
+                        uncompressed: std::mem::take(uncompressed),
+                    }
+                }
+            }
+        }
+    }
+
+    fn raw(&self) -> &[u8] {
+        match self {
+            ChangeBytes::Compressed { compressed, .. } => &compressed[..],
+            ChangeBytes::Uncompressed(b) => &b[..],
+        }
+    }
+}
+
+/// A change represents a group of operations performed by an actor.
+#[derive(PartialEq, Debug, Clone)]
+pub struct Change {
+    bytes: ChangeBytes,
+    body_start: usize,
+    /// Hash of this change.
+    pub hash: amp::ChangeHash,
+    /// The index of this change in the changes from this actor.
+    pub seq: u64,
+    /// The start operation index. Starts at 1.
+    pub start_op: NonZeroU64,
+    /// The time that this change was committed.
+    pub time: i64,
+    /// The message of this change.
+    message: Range<usize>,
+    /// The actors referenced in this change.
+    actors: Vec<ActorId>,
+    /// The dependencies of this change.
+    pub deps: Vec<amp::ChangeHash>,
+    ops: HashMap<u32, Range<usize>>,
+    extra_bytes: Range<usize>,
+}
+
+impl Change {
+    pub fn actor_id(&self) -> &ActorId {
+        &self.actors[0]
+    }
+
+    #[instrument(level = "debug", skip(bytes))]
+    pub fn load_document(bytes: &[u8]) -> Result<Vec<Change>, AutomergeError> {
+        load_blocks(bytes)
+    }
+
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<Change, decoding::Error> {
+        Change::try_from(bytes)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn len(&self) -> usize {
+        // TODO - this could be a lot more efficient
+        self.iter_ops().count()
+    }
+
+    pub fn max_op(&self) -> u64 {
+        self.start_op.get() + (self.len() as u64) - 1
+    }
+
+    pub fn message(&self) -> Option<String> {
+        let m = &self.bytes.uncompressed()[self.message.clone()];
+        if m.is_empty() {
+            None
+        } else {
+            std::str::from_utf8(m).map(ToString::to_string).ok()
+        }
+    }
+
+    pub fn decode(&self) -> amp::Change {
+        amp::Change {
+            start_op: self.start_op,
+            seq: self.seq,
+            time: self.time,
+            hash: Some(self.hash),
+            message: self.message(),
+            actor_id: self.actors[0].clone(),
+            deps: self.deps.clone(),
+            operations: self
+                .iter_ops()
+                .map(|op| amp::Op {
+                    action: op.action.clone(),
+                    obj: op.obj.clone(),
+                    key: op.key.clone(),
+                    pred: op.pred.clone(),
+                    insert: op.insert,
+                })
+                .collect(),
+            extra_bytes: self.extra_bytes().into(),
+        }
+    }
+
+    pub(crate) fn iter_ops(&self) -> OperationIterator<'_> {
+        OperationIterator::new(self.bytes.uncompressed(), self.actors.as_slice(), &self.ops)
+    }
+
+    pub fn extra_bytes(&self) -> &[u8] {
+        &self.bytes.uncompressed()[self.extra_bytes.clone()]
+    }
+
+    pub fn compress(&mut self) {
+        self.bytes.compress(self.body_start);
+    }
+
+    pub fn raw_bytes(&self) -> &[u8] {
+        self.bytes.raw()
+    }
+}
+
+fn read_leb128(bytes: &mut &[u8]) -> Result<(usize, usize), decoding::Error> {
+    let mut buf = &bytes[..];
+    let val = leb128::read::unsigned(&mut buf)? as usize;
+    let leb128_bytes = bytes.len() - buf.len();
+    Ok((val, leb128_bytes))
+}
+
+fn read_slice<T: Decodable + Debug>(
+    bytes: &[u8],
+    cursor: &mut Range<usize>,
+) -> Result<T, decoding::Error> {
+    let mut view = &bytes[cursor.clone()];
+    let init_len = view.len();
+    let val = T::decode::<&[u8]>(&mut view).ok_or(decoding::Error::NoDecodedValue);
+    let bytes_read = init_len - view.len();
+    *cursor = (cursor.start + bytes_read)..cursor.end;
+    val
+}
+
+fn slice_bytes(bytes: &[u8], cursor: &mut Range<usize>) -> Result<Range<usize>, decoding::Error> {
+    let (val, len) = read_leb128(&mut &bytes[cursor.clone()])?;
+    let start = cursor.start + len;
+    let end = start + val;
+    *cursor = end..cursor.end;
+    Ok(start..end)
+}
+
+fn increment_range(range: &mut Range<usize>, len: usize) {
+    range.end += len;
+    range.start += len;
+}
+
+fn increment_range_map(ranges: &mut HashMap<u32, Range<usize>>, len: usize) {
+    for range in ranges.values_mut() {
+        increment_range(range, len);
+    }
+}
+
+fn export_objid(id: &ObjId, actors: &IndexedCache<ActorId>) -> amp::ObjectId {
+    if id == &ObjId::root() {
+        amp::ObjectId::Root
+    } else {
+        export_opid(&id.0, actors).into()
+    }
+}
+
+fn export_elemid(id: &ElemId, actors: &IndexedCache<ActorId>) -> amp::ElementId {
+    if id == &types::HEAD {
+        amp::ElementId::Head
+    } else {
+        export_opid(&id.0, actors).into()
+    }
+}
+
+fn export_opid(id: &OpId, actors: &IndexedCache<ActorId>) -> amp::OpId {
+    amp::OpId(id.0, actors.get(id.1).clone())
+}
+
+fn export_op(
+    op: &Op,
+    obj: &ObjId,
+    actors: &IndexedCache<ActorId>,
+    props: &IndexedCache<String>,
+) -> amp::Op {
+    let action = op.action.clone();
+    let key = match &op.key {
+        Key::Map(n) => amp::Key::Map(props.get(*n).clone().into()),
+        Key::Seq(id) => amp::Key::Seq(export_elemid(id, actors)),
+    };
+    let obj = export_objid(obj, actors);
+    let pred = op.pred.iter().map(|id| export_opid(id, actors)).collect();
+    amp::Op {
+        action,
+        obj,
+        insert: op.insert,
+        pred,
+        key,
+    }
+}
+
+pub(crate) fn export_change(
+    change: TransactionInner,
+    actors: &IndexedCache<ActorId>,
+    props: &IndexedCache<String>,
+) -> Change {
+    amp::Change {
+        actor_id: actors.get(change.actor).clone(),
+        seq: change.seq,
+        start_op: change.start_op,
+        time: change.time,
+        deps: change.deps,
+        message: change.message,
+        hash: change.hash,
+        operations: change
+            .operations
+            .iter()
+            .map(|(obj, _, op)| export_op(op, obj, actors, props))
+            .collect(),
+        extra_bytes: change.extra_bytes,
+    }
+    .into()
+}
+
+impl TryFrom<Vec<u8>> for Change {
+    type Error = decoding::Error;
+
+    fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
+        let (chunktype, body) = decode_header_without_hash(&bytes)?;
+        let bytes = if chunktype == BLOCK_TYPE_DEFLATE {
+            decompress_chunk(0..PREAMBLE_BYTES, body, bytes)?
+        } else {
+            ChangeBytes::Uncompressed(bytes)
+        };
+
+        let (chunktype, hash, body) = decode_header(bytes.uncompressed())?;
+
+        if chunktype != BLOCK_TYPE_CHANGE {
+            return Err(decoding::Error::WrongType {
+                expected_one_of: vec![BLOCK_TYPE_CHANGE],
+                found: chunktype,
+            });
+        }
+
+        let body_start = body.start;
+        let mut cursor = body;
+
+        let deps = decode_hashes(bytes.uncompressed(), &mut cursor)?;
+
+        let actor =
+            ActorId::from(&bytes.uncompressed()[slice_bytes(bytes.uncompressed(), &mut cursor)?]);
+        let seq = read_slice(bytes.uncompressed(), &mut cursor)?;
+        let start_op = read_slice(bytes.uncompressed(), &mut cursor)?;
+        let time = read_slice(bytes.uncompressed(), &mut cursor)?;
+        let message = slice_bytes(bytes.uncompressed(), &mut cursor)?;
+
+        let actors = decode_actors(bytes.uncompressed(), &mut cursor, Some(actor))?;
+
+        let ops_info = decode_column_info(bytes.uncompressed(), &mut cursor, false)?;
+        let ops = decode_columns(&mut cursor, &ops_info);
+
+        Ok(Change {
+            bytes,
+            body_start,
+            hash,
+            seq,
+            start_op,
+            time,
+            actors,
+            message,
+            deps,
+            ops,
+            extra_bytes: cursor,
+        })
+    }
+}
+
+fn decompress_chunk(
+    preamble: Range<usize>,
+    body: Range<usize>,
+    compressed: Vec<u8>,
+) -> Result<ChangeBytes, decoding::Error> {
+    let mut decoder = DeflateDecoder::new(&compressed[body]);
+    let mut decompressed = Vec::new();
+    decoder.read_to_end(&mut decompressed)?;
+    let mut result = Vec::with_capacity(decompressed.len() + preamble.len());
+    result.extend(&compressed[preamble]);
+    result.push(BLOCK_TYPE_CHANGE);
+    leb128::write::unsigned::<Vec<u8>>(&mut result, decompressed.len() as u64).unwrap();
+    result.extend(decompressed);
+    Ok(ChangeBytes::Compressed {
+        uncompressed: result,
+        compressed,
+    })
+}
+
+fn decode_hashes(
+    bytes: &[u8],
+    cursor: &mut Range<usize>,
+) -> Result<Vec<amp::ChangeHash>, decoding::Error> {
+    let num_hashes = read_slice(bytes, cursor)?;
+    let mut hashes = Vec::with_capacity(num_hashes);
+    for _ in 0..num_hashes {
+        let hash = cursor.start..(cursor.start + HASH_BYTES);
+        *cursor = hash.end..cursor.end;
+        hashes.push(
+            bytes
+                .get(hash)
+                .ok_or(decoding::Error::NotEnoughBytes)?
+                .try_into()
+                .map_err(InvalidChangeError::from)?,
+        );
+    }
+    Ok(hashes)
+}
+
+fn decode_actors(
+    bytes: &[u8],
+    cursor: &mut Range<usize>,
+    first: Option<ActorId>,
+) -> Result<Vec<ActorId>, decoding::Error> {
+    let num_actors: usize = read_slice(bytes, cursor)?;
+    let mut actors = Vec::with_capacity(num_actors + 1);
+    if let Some(actor) = first {
+        actors.push(actor);
+    }
+    for _ in 0..num_actors {
+        actors.push(ActorId::from(
+            bytes
+                .get(slice_bytes(bytes, cursor)?)
+                .ok_or(decoding::Error::NotEnoughBytes)?,
+        ));
+    }
+    Ok(actors)
+}
+
+fn decode_column_info(
+    bytes: &[u8],
+    cursor: &mut Range<usize>,
+    allow_compressed_column: bool,
+) -> Result<Vec<(u32, usize)>, decoding::Error> {
+    let num_columns = read_slice(bytes, cursor)?;
+    let mut columns = Vec::with_capacity(num_columns);
+    let mut last_id = 0;
+    for _ in 0..num_columns {
+        let id: u32 = read_slice(bytes, cursor)?;
+        if (id & !COLUMN_TYPE_DEFLATE) <= (last_id & !COLUMN_TYPE_DEFLATE) {
+            return Err(decoding::Error::ColumnsNotInAscendingOrder {
+                last: last_id,
+                found: id,
+            });
+        }
+        if id & COLUMN_TYPE_DEFLATE != 0 && !allow_compressed_column {
+            return Err(decoding::Error::ChangeContainedCompressedColumns);
+        }
+        last_id = id;
+        let length = read_slice(bytes, cursor)?;
+        columns.push((id, length));
+    }
+    Ok(columns)
+}
+
+fn decode_columns(
+    cursor: &mut Range<usize>,
+    columns: &[(u32, usize)],
+) -> HashMap<u32, Range<usize>> {
+    let mut ops = HashMap::new();
+    for (id, length) in columns {
+        let start = cursor.start;
+        let end = start + length;
+        *cursor = end..cursor.end;
+        ops.insert(*id, start..end);
+    }
+    ops
+}
+
+fn decode_header(bytes: &[u8]) -> Result<(u8, amp::ChangeHash, Range<usize>), decoding::Error> {
+    let (chunktype, body) = decode_header_without_hash(bytes)?;
+
+    let calculated_hash = Sha256::digest(&bytes[PREAMBLE_BYTES..]);
+
+    let checksum = &bytes[4..8];
+    if checksum != &calculated_hash[0..4] {
+        return Err(decoding::Error::InvalidChecksum {
+            found: checksum.try_into().unwrap(),
+            calculated: calculated_hash[0..4].try_into().unwrap(),
+        });
+    }
+
+    let hash = calculated_hash[..]
+        .try_into()
+        .map_err(InvalidChangeError::from)?;
+
+    Ok((chunktype, hash, body))
+}
+
+fn decode_header_without_hash(bytes: &[u8]) -> Result<(u8, Range<usize>), decoding::Error> {
+    if bytes.len() <= HEADER_BYTES {
+        return Err(decoding::Error::NotEnoughBytes);
+    }
+
+    if bytes[0..4] != MAGIC_BYTES {
+        return Err(decoding::Error::WrongMagicBytes);
+    }
+
+    let (val, len) = read_leb128(&mut &bytes[HEADER_BYTES..])?;
+    let body = (HEADER_BYTES + len)..(HEADER_BYTES + len + val);
+    if bytes.len() != body.end {
+        return Err(decoding::Error::WrongByteLength {
+            expected: body.end,
+            found: bytes.len(),
+        });
+    }
+
+    let chunktype = bytes[PREAMBLE_BYTES];
+
+    Ok((chunktype, body))
+}
+
+fn load_blocks(bytes: &[u8]) -> Result<Vec<Change>, AutomergeError> {
+    let mut changes = Vec::new();
+    for slice in split_blocks(bytes)? {
+        decode_block(slice, &mut changes)?;
+    }
+    Ok(changes)
+}
+
+fn split_blocks(bytes: &[u8]) -> Result<Vec<&[u8]>, decoding::Error> {
+    // split off all valid blocks - ignore the rest if its corrupted or truncated
+    let mut blocks = Vec::new();
+    let mut cursor = bytes;
+    while let Some(block) = pop_block(cursor)? {
+        blocks.push(&cursor[block.clone()]);
+        if cursor.len() <= block.end {
+            break;
+        }
+        cursor = &cursor[block.end..];
+    }
+    Ok(blocks)
+}
+
+fn pop_block(bytes: &[u8]) -> Result<Option<Range<usize>>, decoding::Error> {
+    if bytes.len() < 4 || bytes[0..4] != MAGIC_BYTES {
+        // not reporting error here - file got corrupted?
+        return Ok(None);
+    }
+    let (val, len) = read_leb128(
+        &mut bytes
+            .get(HEADER_BYTES..)
+            .ok_or(decoding::Error::NotEnoughBytes)?,
+    )?;
+    // val is arbitrary so it could overflow
+    let end = (HEADER_BYTES + len)
+        .checked_add(val)
+        .ok_or(decoding::Error::Overflow)?;
+    if end > bytes.len() {
+        // not reporting error here - file got truncated?
+        return Ok(None);
+    }
+    Ok(Some(0..end))
+}
+
+fn decode_block(bytes: &[u8], changes: &mut Vec<Change>) -> Result<(), decoding::Error> {
+    match bytes[PREAMBLE_BYTES] {
+        BLOCK_TYPE_DOC => {
+            changes.extend(decode_document(bytes)?);
+            Ok(())
+        }
+        BLOCK_TYPE_CHANGE | BLOCK_TYPE_DEFLATE => {
+            changes.push(Change::try_from(bytes.to_vec())?);
+            Ok(())
+        }
+        found => Err(decoding::Error::WrongType {
+            expected_one_of: vec![BLOCK_TYPE_DOC, BLOCK_TYPE_CHANGE, BLOCK_TYPE_DEFLATE],
+            found,
+        }),
+    }
+}
+
+fn decode_document(bytes: &[u8]) -> Result<Vec<Change>, decoding::Error> {
+    let (chunktype, _hash, mut cursor) = decode_header(bytes)?;
+
+    // chunktype == 0 is a document, chunktype = 1 is a change
+    if chunktype > 0 {
+        return Err(decoding::Error::WrongType {
+            expected_one_of: vec![0],
+            found: chunktype,
+        });
+    }
+
+    let actors = decode_actors(bytes, &mut cursor, None)?;
+
+    let heads = decode_hashes(bytes, &mut cursor)?;
+
+    let changes_info = decode_column_info(bytes, &mut cursor, true)?;
+    let ops_info = decode_column_info(bytes, &mut cursor, true)?;
+
+    let changes_data = decode_columns(&mut cursor, &changes_info);
+    let mut doc_changes = ChangeIterator::new(bytes, &changes_data).collect::<Vec<_>>();
+    let doc_changes_deps = DepsIterator::new(bytes, &changes_data);
+
+    let doc_changes_len = doc_changes.len();
+
+    let ops_data = decode_columns(&mut cursor, &ops_info);
+    let doc_ops: Vec<_> = DocOpIterator::new(bytes, &actors, &ops_data).collect();
+
+    group_doc_change_and_doc_ops(&mut doc_changes, doc_ops, &actors)?;
+
+    let uncompressed_changes =
+        doc_changes_to_uncompressed_changes(doc_changes.into_iter(), &actors);
+
+    let changes = compress_doc_changes(uncompressed_changes, doc_changes_deps, doc_changes_len)
+        .ok_or(decoding::Error::NoDocChanges)?;
+
+    let mut calculated_heads = HashSet::new();
+    for change in &changes {
+        for dep in &change.deps {
+            calculated_heads.remove(dep);
+        }
+        calculated_heads.insert(change.hash);
+    }
+
+    if calculated_heads != heads.into_iter().collect::<HashSet<_>>() {
+        return Err(decoding::Error::MismatchedHeads);
+    }
+
+    Ok(changes)
+}
+
+fn compress_doc_changes(
+    uncompressed_changes: impl Iterator<Item = amp::Change>,
+    doc_changes_deps: impl Iterator<Item = Vec<usize>>,
+    num_changes: usize,
+) -> Option<Vec<Change>> {
+    let mut changes: Vec<Change> = Vec::with_capacity(num_changes);
+
+    // fill out the hashes as we go
+    for (deps, mut uncompressed_change) in doc_changes_deps.zip_eq(uncompressed_changes) {
+        for idx in deps {
+            uncompressed_change.deps.push(changes.get(idx)?.hash);
+        }
+        changes.push(uncompressed_change.into());
+    }
+
+    Some(changes)
+}
+
+fn group_doc_change_and_doc_ops(
+    changes: &mut [DocChange],
+    mut ops: Vec<DocOp>,
+    actors: &[ActorId],
+) -> Result<(), decoding::Error> {
+    let mut changes_by_actor: HashMap<usize, Vec<usize>> = HashMap::new();
+
+    for (i, change) in changes.iter().enumerate() {
+        let actor_change_index = changes_by_actor.entry(change.actor).or_default();
+        if change.seq != (actor_change_index.len() + 1) as u64 {
+            return Err(decoding::Error::ChangeDecompressFailed(
+                "Doc Seq Invalid".into(),
+            ));
+        }
+        if change.actor >= actors.len() {
+            return Err(decoding::Error::ChangeDecompressFailed(
+                "Doc Actor Invalid".into(),
+            ));
+        }
+        actor_change_index.push(i);
+    }
+
+    let mut op_by_id = HashMap::new();
+    ops.iter().enumerate().for_each(|(i, op)| {
+        op_by_id.insert((op.ctr, op.actor), i);
+    });
+
+    for i in 0..ops.len() {
+        let op = ops[i].clone(); // this is safe - avoid borrow checker issues
+                                 //let id = (op.ctr, op.actor);
+                                 //op_by_id.insert(id, i);
+        for succ in &op.succ {
+            if let Some(index) = op_by_id.get(succ) {
+                ops[*index].pred.push((op.ctr, op.actor));
+            } else {
+                let key = if op.insert {
+                    amp::OpId(op.ctr, actors[op.actor].clone()).into()
+                } else {
+                    op.key.clone()
+                };
+                let del = DocOp {
+                    actor: succ.1,
+                    ctr: succ.0,
+                    action: OpType::Delete,
+                    obj: op.obj.clone(),
+                    key,
+                    succ: Vec::new(),
+                    pred: vec![(op.ctr, op.actor)],
+                    insert: false,
+                };
+                op_by_id.insert(*succ, ops.len());
+                ops.push(del);
+            }
+        }
+    }
+
+    for op in ops {
+        // binary search for our change
+        let actor_change_index = changes_by_actor.entry(op.actor).or_default();
+        let mut left = 0;
+        let mut right = actor_change_index.len();
+        while left < right {
+            let seq = (left + right) / 2;
+            if changes[actor_change_index[seq]].max_op < op.ctr {
+                left = seq + 1;
+            } else {
+                right = seq;
+            }
+        }
+        if left >= actor_change_index.len() {
+            return Err(decoding::Error::ChangeDecompressFailed(
+                "Doc MaxOp Invalid".into(),
+            ));
+        }
+        changes[actor_change_index[left]].ops.push(op);
+    }
+
+    changes
+        .iter_mut()
+        .for_each(|change| change.ops.sort_unstable());
+
+    Ok(())
+}
+
+fn doc_changes_to_uncompressed_changes<'a>(
+    changes: impl Iterator<Item = DocChange> + 'a,
+    actors: &'a [ActorId],
+) -> impl Iterator<Item = amp::Change> + 'a {
+    changes.map(move |change| amp::Change {
+        // we've already confirmed that all change.actor's are valid
+        actor_id: actors[change.actor].clone(),
+        seq: change.seq,
+        time: change.time,
+        // SAFETY: this unwrap is safe as we always add 1
+        start_op: NonZeroU64::new(change.max_op - change.ops.len() as u64 + 1).unwrap(),
+        hash: None,
+        message: change.message,
+        operations: change
+            .ops
+            .into_iter()
+            .map(|op| amp::Op {
+                action: op.action.clone(),
+                insert: op.insert,
+                key: op.key,
+                obj: op.obj,
+                // we've already confirmed that all op.actor's are valid
+                pred: pred_into(op.pred.into_iter(), actors),
+            })
+            .collect(),
+        deps: Vec::new(),
+        extra_bytes: change.extra_bytes,
+    })
+}
+
+fn pred_into(
+    pred: impl Iterator<Item = (u64, usize)>,
+    actors: &[ActorId],
+) -> amp::SortedVec<amp::OpId> {
+    pred.map(|(ctr, actor)| amp::OpId(ctr, actors[actor].clone()))
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::legacy as amp;
+    #[test]
+    fn mismatched_head_repro_one() {
+        let op_json = serde_json::json!({
+            "ops": [
+                {
+                    "action": "del",
+                    "obj": "1@1485eebc689d47efbf8b892e81653eb3",
+                    "elemId": "3164@0dcdf83d9594477199f80ccd25e87053",
+                    "pred": [
+                        "3164@0dcdf83d9594477199f80ccd25e87053"
+                    ],
+                    "insert": false
+                },
+            ],
+            "actor": "e63cf5ed1f0a4fb28b2c5bc6793b9272",
+            "hash": "e7fd5c02c8fdd2cdc3071ce898a5839bf36229678af3b940f347da541d147ae2",
+            "seq": 1,
+            "startOp": 3179,
+            "time": 1634146652,
+            "message": null,
+            "deps": [
+                "2603cded00f91e525507fc9e030e77f9253b239d90264ee343753efa99e3fec1"
+            ]
+        });
+
+        let change: amp::Change = serde_json::from_value(op_json).unwrap();
+        let expected_hash: super::amp::ChangeHash =
+            "4dff4665d658a28bb6dcace8764eb35fa8e48e0a255e70b6b8cbf8e8456e5c50"
+                .parse()
+                .unwrap();
+        let encoded: super::Change = change.into();
+        assert_eq!(encoded.hash, expected_hash);
+    }
+}

automerge/src/clock.rs

@@ -0,0 +1,52 @@
+use crate::types::OpId;
+use fxhash::FxBuildHasher;
+use std::cmp;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct Clock(HashMap<usize, u64, FxBuildHasher>);
+
+impl Clock {
+    pub(crate) fn new() -> Self {
+        Clock(Default::default())
+    }
+
+    pub(crate) fn include(&mut self, key: usize, n: u64) {
+        self.0
+            .entry(key)
+            .and_modify(|m| *m = cmp::max(n, *m))
+            .or_insert(n);
+    }
+
+    pub(crate) fn covers(&self, id: &OpId) -> bool {
+        if let Some(val) = self.0.get(&id.1) {
+            val >= &id.0
+        } else {
+            false
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn covers() {
+        let mut clock = Clock::new();
+
+        clock.include(1, 20);
+        clock.include(2, 10);
+
+        assert!(clock.covers(&OpId(10, 1)));
+        assert!(clock.covers(&OpId(20, 1)));
+        assert!(!clock.covers(&OpId(30, 1)));
+
+        assert!(clock.covers(&OpId(5, 2)));
+        assert!(clock.covers(&OpId(10, 2)));
+        assert!(!clock.covers(&OpId(15, 2)));
+
+        assert!(!clock.covers(&OpId(1, 3)));
+        assert!(!clock.covers(&OpId(100, 3)));
+    }
+}

automerge/src/encoding.rs

@@ -0,0 +1,391 @@
+use core::fmt::Debug;
+use std::{
+    io,
+    io::{Read, Write},
+    mem,
+    num::NonZeroU64,
+};
+
+use flate2::{bufread::DeflateEncoder, Compression};
+use smol_str::SmolStr;
+
+use crate::columnar::COLUMN_TYPE_DEFLATE;
+use crate::ActorId;
+
+pub(crate) const DEFLATE_MIN_SIZE: usize = 256;
+
+/// The error type for encoding operations.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error(transparent)]
+    Io(#[from] io::Error),
+}
+
+impl PartialEq<Error> for Error {
+    fn eq(&self, other: &Error) -> bool {
+        match (self, other) {
+            (Self::Io(error1), Self::Io(error2)) => error1.kind() == error2.kind(),
+        }
+    }
+}
+
+/// Encodes booleans by storing the count of the same value.
+///
+/// The sequence of numbers describes the count of false values on even indices (0-indexed) and the
+/// count of true values on odd indices (0-indexed).
+///
+/// Counts are encoded as usize.
+pub(crate) struct BooleanEncoder {
+    buf: Vec<u8>,
+    last: bool,
+    count: usize,
+}
+
+impl BooleanEncoder {
+    pub(crate) fn new() -> BooleanEncoder {
+        BooleanEncoder {
+            buf: Vec::new(),
+            last: false,
+            count: 0,
+        }
+    }
+
+    pub(crate) fn append(&mut self, value: bool) {
+        if value == self.last {
+            self.count += 1;
+        } else {
+            self.count.encode(&mut self.buf).ok();
+            self.last = value;
+            self.count = 1;
+        }
+    }
+
+    pub(crate) fn finish(mut self, col: u32) -> ColData {
+        if self.count > 0 {
+            self.count.encode(&mut self.buf).ok();
+        }
+        ColData::new(col, self.buf)
+    }
+}
+
+/// Encodes integers as the change since the previous value.
+///
+/// The initial value is 0 encoded as u64. Deltas are encoded as i64.
+///
+/// Run length encoding is then applied to the resulting sequence.
+pub(crate) struct DeltaEncoder {
+    rle: RleEncoder<i64>,
+    absolute_value: u64,
+}
+
+impl DeltaEncoder {
+    pub(crate) fn new() -> DeltaEncoder {
+        DeltaEncoder {
+            rle: RleEncoder::new(),
+            absolute_value: 0,
+        }
+    }
+
+    pub(crate) fn append_value(&mut self, value: u64) {
+        self.rle
+            .append_value(value as i64 - self.absolute_value as i64);
+        self.absolute_value = value;
+    }
+
+    pub(crate) fn append_null(&mut self) {
+        self.rle.append_null();
+    }
+
+    pub(crate) fn finish(self, col: u32) -> ColData {
+        self.rle.finish(col)
+    }
+}
+
+enum RleState<T> {
+    Empty,
+    NullRun(usize),
+    LiteralRun(T, Vec<T>),
+    LoneVal(T),
+    Run(T, usize),
+}
+
+/// Encodes data in run lengh encoding format. This is very efficient for long repeats of data
+///
+/// There are 3 types of 'run' in this encoder:
+/// - a normal run (compresses repeated values)
+/// - a null run (compresses repeated nulls)
+/// - a literal run (no compression)
+///
+/// A normal run consists of the length of the run (encoded as an i64) followed by the encoded value that this run contains.
+///
+/// A null run consists of a zero value (encoded as an i64) followed by the length of the null run (encoded as a usize).
+///
+/// A literal run consists of the **negative** length of the run (encoded as an i64) followed by the values in the run.
+///
+/// Therefore all the types start with an encoded i64, the value of which determines the type of the following data.
+pub(crate) struct RleEncoder<T>
+where
+    T: Encodable + PartialEq + Clone,
+{
+    buf: Vec<u8>,
+    state: RleState<T>,
+}
+
+impl<T> RleEncoder<T>
+where
+    T: Encodable + PartialEq + Clone,
+{
+    pub(crate) fn new() -> RleEncoder<T> {
+        RleEncoder {
+            buf: Vec::new(),
+            state: RleState::Empty,
+        }
+    }
+
+    pub(crate) fn finish(mut self, col: u32) -> ColData {
+        match self.take_state() {
+            // this covers `only_nulls`
+            RleState::NullRun(size) => {
+                if !self.buf.is_empty() {
+                    self.flush_null_run(size);
+                }
+            }
+            RleState::LoneVal(value) => self.flush_lit_run(vec![value]),
+            RleState::Run(value, len) => self.flush_run(&value, len),
+            RleState::LiteralRun(last, mut run) => {
+                run.push(last);
+                self.flush_lit_run(run);
+            }
+            RleState::Empty => {}
+        }
+        ColData::new(col, self.buf)
+    }
+
+    fn flush_run(&mut self, val: &T, len: usize) {
+        self.encode(&(len as i64));
+        self.encode(val);
+    }
+
+    fn flush_null_run(&mut self, len: usize) {
+        self.encode::<i64>(&0);
+        self.encode(&len);
+    }
+
+    fn flush_lit_run(&mut self, run: Vec<T>) {
+        self.encode(&-(run.len() as i64));
+        for val in run {
+            self.encode(&val);
+        }
+    }
+
+    fn take_state(&mut self) -> RleState<T> {
+        let mut state = RleState::Empty;
+        mem::swap(&mut self.state, &mut state);
+        state
+    }
+
+    pub(crate) fn append_null(&mut self) {
+        self.state = match self.take_state() {
+            RleState::Empty => RleState::NullRun(1),
+            RleState::NullRun(size) => RleState::NullRun(size + 1),
+            RleState::LoneVal(other) => {
+                self.flush_lit_run(vec![other]);
+                RleState::NullRun(1)
+            }
+            RleState::Run(other, len) => {
+                self.flush_run(&other, len);
+                RleState::NullRun(1)
+            }
+            RleState::LiteralRun(last, mut run) => {
+                run.push(last);
+                self.flush_lit_run(run);
+                RleState::NullRun(1)
+            }
+        }
+    }
+
+    pub(crate) fn append_value(&mut self, value: T) {
+        self.state = match self.take_state() {
+            RleState::Empty => RleState::LoneVal(value),
+            RleState::LoneVal(other) => {
+                if other == value {
+                    RleState::Run(value, 2)
+                } else {
+                    let mut v = Vec::with_capacity(2);
+                    v.push(other);
+                    RleState::LiteralRun(value, v)
+                }
+            }
+            RleState::Run(other, len) => {
+                if other == value {
+                    RleState::Run(other, len + 1)
+                } else {
+                    self.flush_run(&other, len);
+                    RleState::LoneVal(value)
+                }
+            }
+            RleState::LiteralRun(last, mut run) => {
+                if last == value {
+                    self.flush_lit_run(run);
+                    RleState::Run(value, 2)
+                } else {
+                    run.push(last);
+                    RleState::LiteralRun(value, run)
+                }
+            }
+            RleState::NullRun(size) => {
+                self.flush_null_run(size);
+                RleState::LoneVal(value)
+            }
+        }
+    }
+
+    fn encode<V>(&mut self, val: &V)
+    where
+        V: Encodable,
+    {
+        val.encode(&mut self.buf).ok();
+    }
+}
+
+pub(crate) trait Encodable {
+    fn encode_with_actors_to_vec(&self, actors: &mut [ActorId]) -> io::Result<Vec<u8>> {
+        let mut buf = Vec::new();
+        self.encode_with_actors(&mut buf, actors)?;
+        Ok(buf)
+    }
+
+    fn encode_with_actors<R: Write>(&self, buf: &mut R, _actors: &[ActorId]) -> io::Result<usize> {
+        self.encode(buf)
+    }
+
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize>;
+
+    fn encode_vec(&self, buf: &mut Vec<u8>) -> usize {
+        self.encode(buf).unwrap()
+    }
+}
+
+impl Encodable for SmolStr {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        let bytes = self.as_bytes();
+        let head = bytes.len().encode(buf)?;
+        buf.write_all(bytes)?;
+        Ok(head + bytes.len())
+    }
+}
+
+impl Encodable for String {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        let bytes = self.as_bytes();
+        let head = bytes.len().encode(buf)?;
+        buf.write_all(bytes)?;
+        Ok(head + bytes.len())
+    }
+}
+
+impl Encodable for Option<String> {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        if let Some(s) = self {
+            s.encode(buf)
+        } else {
+            0.encode(buf)
+        }
+    }
+}
+
+impl Encodable for u64 {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        leb128::write::unsigned(buf, *self)
+    }
+}
+
+impl Encodable for NonZeroU64 {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        leb128::write::unsigned(buf, self.get())
+    }
+}
+
+impl Encodable for f64 {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        let bytes = self.to_le_bytes();
+        buf.write_all(&bytes)?;
+        Ok(bytes.len())
+    }
+}
+
+impl Encodable for f32 {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        let bytes = self.to_le_bytes();
+        buf.write_all(&bytes)?;
+        Ok(bytes.len())
+    }
+}
+
+impl Encodable for i64 {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        leb128::write::signed(buf, *self)
+    }
+}
+
+impl Encodable for usize {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        (*self as u64).encode(buf)
+    }
+}
+
+impl Encodable for u32 {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        u64::from(*self).encode(buf)
+    }
+}
+
+impl Encodable for i32 {
+    fn encode<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        i64::from(*self).encode(buf)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ColData {
+    pub(crate) col: u32,
+    pub(crate) data: Vec<u8>,
+    #[cfg(debug_assertions)]
+    has_been_deflated: bool,
+}
+
+impl ColData {
+    pub(crate) fn new(col_id: u32, data: Vec<u8>) -> ColData {
+        ColData {
+            col: col_id,
+            data,
+            #[cfg(debug_assertions)]
+            has_been_deflated: false,
+        }
+    }
+
+    pub(crate) fn encode_col_len<R: Write>(&self, buf: &mut R) -> io::Result<usize> {
+        let mut len = 0;
+        if !self.data.is_empty() {
+            len += self.col.encode(buf)?;
+            len += self.data.len().encode(buf)?;
+        }
+        Ok(len)
+    }
+
+    pub(crate) fn deflate(&mut self) {
+        #[cfg(debug_assertions)]
+        {
+            debug_assert!(!self.has_been_deflated);
+            self.has_been_deflated = true;
+        }
+        if self.data.len() > DEFLATE_MIN_SIZE {
+            let mut deflated = Vec::new();
+            let mut deflater = DeflateEncoder::new(&self.data[..], Compression::default());
+            //This unwrap should be okay as we're reading and writing to in memory buffers
+            deflater.read_to_end(&mut deflated).unwrap();
+            self.col |= COLUMN_TYPE_DEFLATE;
+            self.data = deflated;
+        }
+    }
+}

automerge/src/error.rs

@@ -0,0 +1,68 @@
+use crate::types::{ActorId, ScalarValue};
+use crate::value::DataType;
+use crate::{decoding, encoding, ChangeHash};
+use thiserror::Error;
+
+#[derive(Error, Debug, PartialEq)]
+pub enum AutomergeError {
+    #[error("invalid obj id format `{0}`")]
+    InvalidObjIdFormat(String),
+    #[error("invalid obj id `{0}`")]
+    InvalidObjId(String),
+    #[error("there was an encoding problem: {0}")]
+    Encoding(#[from] encoding::Error),
+    #[error("there was a decoding problem: {0}")]
+    Decoding(#[from] decoding::Error),
+    #[error("key must not be an empty string")]
+    EmptyStringKey,
+    #[error("invalid seq {0}")]
+    InvalidSeq(u64),
+    #[error("index {0} is out of bounds")]
+    InvalidIndex(usize),
+    #[error("duplicate seq {0} found for actor {1}")]
+    DuplicateSeqNumber(u64, ActorId),
+    #[error("invalid hash {0}")]
+    InvalidHash(ChangeHash),
+    #[error("increment operations must be against a counter value")]
+    MissingCounter,
+    #[error("general failure")]
+    Fail,
+    #[error(transparent)]
+    HexDecode(#[from] hex::FromHexError),
+}
+
+#[cfg(feature = "wasm")]
+impl From<AutomergeError> for wasm_bindgen::JsValue {
+    fn from(err: AutomergeError) -> Self {
+        js_sys::Error::new(&std::format!("{}", err)).into()
+    }
+}
+
+#[derive(Error, Debug)]
+#[error("Invalid actor ID: {0}")]
+pub struct InvalidActorId(pub String);
+
+#[derive(Error, Debug, PartialEq)]
+#[error("Invalid scalar value, expected {expected} but received {unexpected}")]
+pub(crate) struct InvalidScalarValue {
+    pub(crate) raw_value: ScalarValue,
+    pub(crate) datatype: DataType,
+    pub(crate) unexpected: String,
+    pub(crate) expected: String,
+}
+
+#[derive(Error, Debug, PartialEq)]
+#[error("Invalid change hash slice: {0:?}")]
+pub struct InvalidChangeHashSlice(pub Vec<u8>);
+
+#[derive(Error, Debug, PartialEq)]
+#[error("Invalid object ID: {0}")]
+pub struct InvalidObjectId(pub String);
+
+#[derive(Error, Debug)]
+#[error("Invalid element ID: {0}")]
+pub struct InvalidElementId(pub String);
+
+#[derive(Error, Debug)]
+#[error("Invalid OpID: {0}")]
+pub struct InvalidOpId(pub String);

automerge/src/exid.rs

@@ -0,0 +1,82 @@
+use crate::ActorId;
+use serde::Serialize;
+use serde::Serializer;
+use std::cmp::{Ord, Ordering};
+use std::fmt;
+use std::hash::{Hash, Hasher};
+
+#[derive(Debug, Clone)]
+pub enum ExId {
+    Root,
+    Id(u64, ActorId, usize),
+}
+
+impl PartialEq for ExId {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (ExId::Root, ExId::Root) => true,
+            (ExId::Id(ctr1, actor1, _), ExId::Id(ctr2, actor2, _))
+                if ctr1 == ctr2 && actor1 == actor2 =>
+            {
+                true
+            }
+            _ => false,
+        }
+    }
+}
+
+impl Eq for ExId {}
+
+impl fmt::Display for ExId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ExId::Root => write!(f, "_root"),
+            ExId::Id(ctr, actor, _) => write!(f, "{}@{}", ctr, actor),
+        }
+    }
+}
+
+impl Hash for ExId {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        match self {
+            ExId::Root => 0.hash(state),
+            ExId::Id(ctr, actor, _) => {
+                ctr.hash(state);
+                actor.hash(state);
+            }
+        }
+    }
+}
+
+impl Ord for ExId {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self, other) {
+            (ExId::Root, ExId::Root) => Ordering::Equal,
+            (ExId::Root, _) => Ordering::Less,
+            (_, ExId::Root) => Ordering::Greater,
+            (ExId::Id(c1, a1, _), ExId::Id(c2, a2, _)) if c1 == c2 => a2.cmp(a1),
+            (ExId::Id(c1, _, _), ExId::Id(c2, _, _)) => c1.cmp(c2),
+        }
+    }
+}
+
+impl PartialOrd for ExId {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Serialize for ExId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.to_string().as_str())
+    }
+}
+
+impl AsRef<ExId> for ExId {
+    fn as_ref(&self) -> &ExId {
+        self
+    }
+}