v13.0.0-3 -- distribution files

13.0.0-3
change to correct main file
2017-07-06 03:29:38 +02:00 · 2017-07-06 03:29:09 +02:00 · 2017-07-06 03:28:06 +02:00 · 2017-07-05 18:41:26 +02:00 · 2017-07-05 18:40:41 +02:00 · 2017-07-05 18:33:16 +02:00
66 changed files with 9839 additions and 4991 deletions
--- a/.babelrc
+++ b/.babelrc
@@ -0,0 +1,12 @@
+{
+  "presets": [
+    ["latest", {
+      "es2015": {
+        "modules": false
+      }
+    }]
+  ],
+  "plugins": [
+    "external-helpers"
+  ]
+}
--- a/.bowerrc
+++ b/.bowerrc
@@ -1,3 +0,0 @@
-{
- "directory": "../"
-}
--- a/.flowconfig
+++ b/.flowconfig
@@ -0,0 +1,12 @@
+[ignore]
+.*/node_modules/.*
+.*/dist/.*
+.*/build/.*
+
+[include]
+./src/
+
+[libs]
+./declarations/
+
+[options]
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,6 @@ build_test
 .validate.json
 /y.js
 /y.js.map
+/y-*
+.vscode
+jsconfig.json
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +0,0 @@
-[submodule "dist"]
-	path = dist
-	url = https://github.com/y-js/yjs.git
-	branch = dist
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,8 +0,0 @@
-language: node_js
-before_install:
-  - "npm install -g bower"
-node_js:
-  - "0.12"
-branches:
-  only:
-    - master
--- a/Examples/OfflineEditing/index.html
+++ b/Examples/OfflineEditing/index.html
@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html>
-<body>
-  <button id="button">Disconnect</button>
-  <h1 id="contenteditable" contentEditable></h1>
-  <textarea style="width:80%;" rows=40 id="textfield"></textarea>
-
-  <script src="../../node_modules/simplewebrtc/simplewebrtc.bundle.js"></script>
-  <script src="../../y.js"></script>
-  <script src="./index.js"></script>
-</body>
-</html>
--- a/Examples/OfflineEditing/index.js
+++ b/Examples/OfflineEditing/index.js
@@ -1,50 +0,0 @@
-/* global Y */
-
-// create a shared object. This function call will return a promise!
-Y({
-  db: {
-    name: 'IndexedDB',
-    namespace: 'offlineEditingDemo'
-  },
-  connector: {
-    name: 'WebRTC',
-    room: 'offlineEditingDemo',
-    debug: true
-  }
-}).then(function (yconfig) {
-  // yconfig holds all the information about the shared object
-  window.yconfig = yconfig
-  // yconfig.root holds the shared element
-  window.y = yconfig.root
-
-  // now we bind the textarea and the contenteditable h1 element
-  // to a shared element
-  var textarea = document.getElementById('textfield')
-  var contenteditable = document.getElementById('contenteditable')
-  yconfig.root.observePath(['text'], function (text) {
-    // every time the 'text' property of the yconfig.root changes,
-    // this function is called. Then we bind it to the html elements
-    if (text != null) {
-      // when the text property is deleted, text may be undefined!
-      // This is why we have to check if text exists..
-      text.bind(textarea)
-      text.bind(contenteditable)
-    }
-  })
-  // create a shared TextBind
-  var textpromise = yconfig.root.get('text')
-  if (textpromise == null) {
-    yconfig.root.set('text', Y.TextBind)
-  }
-  // We also provide a button for disconnecting/reconnecting the shared element
-  var button = document.querySelector('#button')
-  button.onclick = function () {
-    if (button.innerText === 'Disconnect') {
-      yconfig.disconnect()
-      button.innerText = 'Reconnect'
-    } else {
-      yconfig.reconnect()
-      button.innerText = 'Disconnect'
-    }
-  }
-})
--- a/Examples/TextBind/index.html
+++ b/Examples/TextBind/index.html
@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html>
-<body>
-  <button id="button">Disconnect</button>
-  <h1 id="contenteditable" contentEditable></h1>
-  <textarea style="width:80%;" rows=40 id="textfield"></textarea>
-
-  <script src="../../node_modules/simplewebrtc/simplewebrtc.bundle.js"></script>
-  <script src="../../y.js"></script>
-  <script src="./index.js"></script>
-</body>
-</html>
--- a/Examples/TextBind/index.js
+++ b/Examples/TextBind/index.js
@@ -1,47 +0,0 @@
-/* global Y */
-
-// create a shared object. This function call will return a promise!
-Y({
-  db: {
-    name: 'Memory'
-  },
-  connector: {
-    name: 'WebRTC',
-    room: 'TextBindDemo',
-    debug: true
-  }
-}).then(function (yconfig) {
-  // yconfig holds all the information about the shared object
-  window.yconfig = yconfig
-  // yconfig.root holds the shared element
-  window.y = yconfig.root
-
-  // now we bind the textarea and the contenteditable h1 element
-  // to a shared element
-  var textarea = document.getElementById('textfield')
-  var contenteditable = document.getElementById('contenteditable')
-  yconfig.root.observePath(['text'], function (text) {
-    // every time the 'text' property of the yconfig.root changes,
-    // this function is called. Then we bind it to the html elements
-    if (text != null) {
-      // when the text property is deleted, text may be undefined!
-      // This is why we have to check if text exists..
-      text.bind(textarea)
-      text.bind(contenteditable)
-    }
-  })
-  // create a shared TextBind
-  yconfig.root.set('text', Y.TextBind)
-
-  // We also provide a button for disconnecting/reconnecting the shared element
-  var button = document.querySelector('#button')
-  button.onclick = function () {
-    if (button.innerText === 'Disconnect') {
-      yconfig.disconnect()
-      button.innerText = 'Reconnect'
-    } else {
-      yconfig.reconnect()
-      button.innerText = 'Disconnect'
-    }
-  }
-})
--- a/README.md
+++ b/README.md
@@ -1,145 +1,294 @@

-# ![Yjs](http://y-js.org/files/layout/yjs.svg)
+# ![Yjs](http://y-js.org/images/yjs.png)

-[![Build Status](https://travis-ci.org/y-js/yjs.svg)](https://travis-ci.org/y-js/yjs)
+Yjs is a framework for offline-first p2p shared editing on structured data like
+text, richtext, json, or XML. It is fairly easy to get started, as Yjs hides
+most of the complexity of concurrent editing. For additional information, demos,
+and tutorials visit [y-js.org](http://y-js.org/).

-Yjs is a framework for optimistic concurrency control and automatic conflict resolution on shared data types. The framework implements a new OT-like concurrency algorithm and provides similar functionality as [ShareJs] and [OpenCoweb]. Yjs was designed to handle concurrent actions on arbitrary complex data types like Text, Json, and XML. We provide a tutorial and some applications for this framework on our [homepage](http://y-js.org/).
+### Extensions
+Yjs only knows how to resolve conflicts on shared data. You have to choose a ..
+* *Connector* - a communication protocol that propagates changes to the clients
+* *Database* - a database to store your changes
+* one or more *Types* - that represent the shared data

-You can create you own shared types easily. Therefore, you can take matters into your own hand by defining the meaning of the shared types and ensure that it is valid, while Yjs ensures data consistency (everyone will eventually end up with the same data). We already provide data types for
+Connectors, Databases, and Types are available as modules that extend Yjs. Here
+is a list of the modules we know of:

-| Name                                                 | Description
-| ---------------------------------------------------- | ---------------------------------------------
-y-object | Add, update, and remove properties of an object. Circular references are supported. Included in Yjs
-[y-list](https://github.com/y-js/y-list) | A shared linked list implementation. Circular references are supported
-[y-selections](https://github.com/y-js/y-selections) | Manages selections on types that use linear structures (e.g. the y-list type). You can select a range of elements and assign meaning to them.
-[y-xml](https://github.com/y-js/y-xml) | An implementation of the DOM. You can create a two way binding to Browser DOM objects
-[y-text](https://github.com/y-js/y-text) | Collaborate on text. You can create a two way binding to textareas, input elements, or HTML elements (e.g. *h1*, or *p*)
-[y-richtext](https://github.com/y-js/y-richtext) | Collaborate on rich text. You can create a two way binding to several editors
+##### Connectors

-Unlike other frameworks, Yjs supports P2P message propagation and is not bound to a specific communication protocol. Therefore, Yjs is extremely scalable and can be used in a wide range of application scenarios.
+|Name            | Description               |
+|----------------|-----------------------------------|
+|[webrtc](https://github.com/y-js/y-webrtc) | Propagate updates Browser2Browser via WebRTC|
+|[websockets](https://github.com/y-js/y-websockets-client) | Set up [a central server](https://github.com/y-js/y-websockets-client), and connect to it via websockets |
+|[xmpp](https://github.com/y-js/y-xmpp) | Propagate updates in a XMPP multi-user-chat room ([XEP-0045](http://xmpp.org/extensions/xep-0045.html))|
+|[test](https://github.com/y-js/y-test) | A Connector for testing purposes. It is designed to simulate delays that happen in worst case scenarios|

-We support several communication protocols as so called *Connectors*. You can create your own connector too - read [this wiki page](https://github.com/y-js/yjs/wiki/Custom-Connectors). Currently, we support the following communication protocols:
+##### Database adapters

-Name                                     | Description
---------------------------------------- | -------------------------------------------------------
-[y-xmpp](https://github.com/y-js/y-xmpp) | Propagate updates in a XMPP multi-user-chat room ([XEP-0045](http://xmpp.org/extensions/xep-0045.html))
-[y-webrtc](https://github.com/y-js/y-webrtc) | Propagate updates Browser2Browser via WebRTC
-[y-test](https://github.com/y-js/y-test) | A Connector for testing purposes. It is designed to simulate delays that happen in worst case scenarios
+|Name            | Description               |
+|----------------|-----------------------------------|
+|[memory](https://github.com/y-js/y-memory) | In-memory storage. |
+|[indexeddb](https://github.com/y-js/y-indexeddb) | Offline storage for the browser |
+|[leveldb](https://github.com/y-js/y-leveldb) | Persistent storage for node apps |


-You can use Yjs client-, and server- side. You can get it as via npm, and bower. We even provide polymer elements for Yjs!
+##### Types

-The advantages over similar frameworks are support for
-* .. P2P message propagation and arbitrary communication protocols
-* .. arbitrary complex data types
-* .. offline editing: Changes are stored persistently and only relevant changes are propagated on rejoin
-* .. AnyUndo: Undo *any* action that was executed in constant time (coming..)
-* .. Intention Preservation: When working on Text, the intention of your changes are preserved. This is particularily important when working offline. Every type has a notion on how we define Intention Preservation on it.
+| Name     | Description       |
+|----------|-------------------|
+|[map](https://github.com/y-js/y-map) | A shared Map implementation. Maps from text to any stringify-able object |
+|[array](https://github.com/y-js/y-array) | A shared Array implementation |
+|[xml](https://github.com/y-js/y-xml) | An implementation of the DOM. You can create a two way binding to Browser DOM objects |
+|[text](https://github.com/y-js/y-text) | Collaborate on text. Supports two way binding to the [Ace Editor](https://ace.c9.io), [CodeMirror](https://codemirror.net/), [Monaco](https://github.com/Microsoft/monaco-editor), textareas, input elements, and HTML elements (e.g. <*h1*>, or <*p*>) |
+|[richtext](https://github.com/y-js/y-richtext) | Collaborate on rich text. Supports two way binding to the [Quill Rich Text Editor](http://quilljs.com/)|

+##### Other
+
+| Name      | Description       |
+|-----------|-------------------|
+|[y-element](http://y-js.org/y-element/) | Yjs Polymer Element |

 ## Use it!
-You can find a tutorial, and examples on the [website](http://y-js.org). Furthermore, the [github wiki](https://github.com/y-js/yjs/wiki) offers more information about how you can use Yjs in your application.
-
-Either clone this git repository, install it with [bower](http://bower.io/), or install it with [npm](https://www.npmjs.org/package/yjs).
+Install Yjs, and its modules with [bower](http://bower.io/), or
+[npm](https://www.npmjs.org/package/yjs).

 ### Bower
 ```
-bower install y-js/yjs
+bower install --save yjs y-array % add all y-* modules you want to use
 ```
-Then you include the libraries directly from the installation folder.
+You only need to include the `y.js` file. Yjs is able to automatically require
+missing modules.  
 ```
 <script src="./bower_components/yjs/y.js"></script>
 ```

 ### Npm
 ```
-npm install yjs --save
+npm install --save yjs % add all y-* modules you want to use
 ```

-And use it like this with *npm*:
+If you don't include via script tag, you have to explicitly include all modules!
+(Same goes for other module systems)
 ```
-Y = require("yjs");
+var Y = require('yjs')
+require('y-array')(Y) // add the y-array type to Yjs
+require('y-websockets-client')(Y)
+require('y-memory')(Y)
+require('y-array')(Y)
+require('y-map')(Y)
+require('y-text')(Y)
+// ..
+// do the same for all modules you want to use
 ```

-# Y()
-In order to create an instance of Y, you need to have a connection object (instance of a Connector). Then, you can create a shared data type like this:
+### ES6 Syntax
 ```
-var y = new Y(connector);
+import Y from 'yjs'
+import yArray from 'y-array'
+import yWebsocketsClient from 'y-webrtc'
+import yMemory from 'y-memory'
+import yArray from 'y-array'
+import yMap from 'y-map'
+import yText from 'y-text'
+// ..
+Y.extend(yArray, yWebsocketsClient, yMemory, yArray, yMap, yText /*, .. */)
 ```

-
-# Y.Map
-Yjs includes only one type by default - the Y.Map type. It mimics the behaviour of a javascript Object. You can create, update, and remove properies on the Y.Map type. Furthermore, you can observe changes on this type as you can observe changes on Javascript Objects with [Object.observe](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe) - an ECMAScript 7 proposal which is likely to become accepted by the committee. Until then, we have our own implementation.
-
-
-##### Reference
-* Create
+# Text editing example
+Install dependencies
 ```
-var map = y.set("new_map", Y.Map).then(function(map){
-  map // is my map type
-});
+bower i yjs y-memory y-webrtc y-array y-text
 ```
-* Every instance of Y is an Y.Map
+
+Here is a simple example of a shared textarea
+```HTML
+  <!DOCTYPE html>
+  <html>
+    <body>
+      <script src="./bower_components/yjs/y.js"></script>
+      <!-- Yjs automatically includes all missing dependencies (browser only) -->
+      <script>
+        Y({
+          db: {
+            name: 'memory' // use memory database adapter.
+            // name: 'indexeddb' // use indexeddb database adapter instead for offline apps
+          },
+          connector: {
+            name: 'webrtc', // use webrtc connector
+            // name: 'websockets-client'
+            // name: 'xmpp'
+            room: 'my-room' // clients connecting to the same room share data
+          },
+          sourceDir: '/bower_components', // location of the y-* modules (browser only)
+          share: {
+            textarea: 'Text' // y.share.textarea is of type y-text
+          }
+        }).then(function (y) {
+          // The Yjs instance `y` is available
+          // y.share.* contains the shared types
+
+          // Bind `y.share.textarea` to `<textarea/>`
+          y.share.textarea.bind(document.querySelector('textarea'))
+        })
+      </script>
+      <textarea></textarea>
+    </body>
+  </html>
 ```
-var y = new Y(options);
+
+## Get Help & Give Help
+There are some friendly people on [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/y-js/yjs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) who are eager to help, and answer questions. Please join!
+
+Report _any_ issues to the
+[Github issue page](https://github.com/y-js/yjs/issues)! I try to fix them very
+soon, if possible.
+
+# API
+
+### Y(options)
+* Y.extend(module1, module2, ..)
+  * Add extensions to Y
+  * `Y.extend(require('y-webrtc'))` has the same semantics as
+    `require('y-webrtc')(Y)`
+* options.db
+  * Will be forwarded to the database adapter. Specify the database adaper on
+    `options.db.name`.
+  * Have a look at the used database adapter repository to see all available
+    options.
+* options.connector
+  * Will be forwarded to the connector adapter. Specify the connector adaper on
+    `options.connector.name`.
+  * All our connectors implement a `room` property. Clients that specify the
+    same room share the same data.
+  * All of our connectors specify an `url` property that defines the connection
+    endpoint of the used connector.
+    * All of our connectors also have a default connection endpoint that you can
+      use for development.
+  * Set `options.connector.generateUserId = true` in order to genenerate a
+    userid, instead of receiving one from the server. This way the `Y(..)` is
+    immediately going to be resolved, without waiting for any confirmation from
+    the server. Use with caution.
+  * Have a look at the used connector repository to see all available options.
+  * *Only if you know what you are doing:* Set
+    `options.connector.preferUntransformed = true` in order receive the shared
+    data untransformed. This is very efficient as the database content is simply
+    copied to this client. This does only work if this client receives content
+    from only one client.
+* options.sourceDir (browser only)
+  * Path where all y-* modules are stored
+  * Defaults to `/bower_components`
+  * Not required when running on `nodejs` / `iojs`
+  * When using nodejs you need to manually extend Yjs:
 ```
-* .get(name)
-  * Retrieve the value of a property. If the value is a type, `.get(name)` returns a promise
-* .set(name, value)
-  * Set/update a property. `value` may be a primitive type, or a custom type definition (e.g. `Y.Map`)
-* .delete(name)
-  * Delete a property
-* .observe(observer)
-  * The `observer` is called whenever something on this object changes. Throws *add*, *update*, and *delete* events
-* .observePath(path, observer)
-  * `path` is an array of property names. `observer` is called when the property under `path` is set, deleted, or updated
-* .unobserve(f)
-  * Delete an observer
+var Y = require('yjs')
+// you have to require a db, connector, and *all* types you use!
+require('y-memory')(Y)
+require('y-webrtc')(Y)
+require('y-map')(Y)
+// ..
+```
+* options.share
+  * Specify on `options.share[arbitraryName]` types that are shared among all
+    users.
+  * E.g. Specify `options.share[arbitraryName] = 'Array'` to require y-array and
+    create an y-array type on `y.share[arbitraryName]`.
+  * If userA doesn't specify `options.share[arbitraryName]`, it won't be
+    available for userA.
+  * If userB specifies `options.share[arbitraryName]`, it still won't be
+    available for userA. But all the updates are send from userB to userA.
+  * In contrast to y-map, types on `y.share.*` cannot be overwritten or deleted.
+    Instead, they are merged among all users. This feature is only available on
+    `y.share.*`
+  * Weird behavior: It is supported that two users specify different types with
+    the same property name.
+     E.g. userA specifies `options.share.x = 'Array'`, and userB specifies
+     `options.share.x = 'Text'`. But they only share data if they specified the
+     same type with the same property name
+* options.type (browser only)
+  * Array of modules that Yjs needs to require, before instantiating a shared
+    type.
+  * By default Yjs requires the specified database adapter, the specified
+    connector, and all modules that are used in `options.share.*`
+  * Put all types here that you intend to use, but are not used in y.share.*

-# A note on intention preservation
-When users create/update/delete the same property concurrently, only one change will prevail. Changes on different properties do not conflict with each other.
+### Instantiated Y object (y)
+`Y(options)` returns a promise that is fulfilled when..

-# A note on time complexities
-* .get(name)
-  * O(1)
-* .set(name, value)
-  * O(1)
-* .delete(name)
-  * O(1)
-* Apply a delete operation from another user
-  * O(1)
-* Apply an update operation from another user (set/update a property)
-  * Yjs does not transform against operations that do not conflict with each other.
-  * An operation conflicts with another operation if it changes the same property.
-  * Overall worst case complexety: O(|conflicts|!)
+* All modules are loaded
+  * The specified database adapter is loaded
+  * The specified connector is loaded
+  * All types are included
+* The connector is initialized, and a unique user id is set (received from the
+  server)
+  * Note: When using y-indexeddb, a retrieved user id is stored on `localStorage`

-# Status
-Yjs is a work in progress. Different versions of the *y-* repositories may not work together. Just drop me a line if you run into troubles.
+The promise returns an instance of Y. We denote it with a lower case `y`.

-## Get help
-There are some friendly people on [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/y-js/yjs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) who may help you with your problem, and answer your questions.
+* y.share.*
+  * Instances of the types you specified on options.share.*
+  * y.share.* can only be defined once when you instantiate Y!
+* y.connector is an instance of Y.AbstractConnector
+* y.connector.onUserEvent(function (event) {..})
+  * Observe user events (event.action is either 'userLeft' or 'userJoined')
+* y.connector.whenSynced(listener)
+  * `listener` is executed when y synced with at least one user.
+  * `listener` is not called when no other user is in the same room.
+  * y-websockets-client aways waits to sync with the server
+* y.connector.disconnect()
+  * Force to disconnect this instance from the other instances
+* y.connector.reconnect()
+  * Try to reconnect to the other instances (needs to be supported by the
+    connector)
+  * Not supported by y-xmpp
+* y.close()
+  * Destroy this object.
+  * Destroys all types (they will throw weird errors if you still use them)
+  * Disconnects from the other instances (via connector)
+  * Returns a promise
+* y.destroy()
+  * calls y.close()
+  * Removes all data from the database
+  * Returns a promise
+* y.db.stopGarbageCollector()
+  * Stop the garbage collector. Call y.db.garbageCollect() to continue garbage
+    collection
+* y.db.gc :: Boolean
+  * Whether gc is turned on
+* y.db.gcTimeout :: Number (defaults to 50000 ms)
+  * Time interval between two garbage collect cycles
+  * It is required that all instances exchanged all messages after two garbage
+    collect cycles (after 100000 ms per default)
+* y.db.userId :: String
+  * The used user id for this client. **Never overwrite this**

-Please report _any_ issues to the [Github issue page](https://github.com/y-js/yjs/issues)! I try to fix them very soon, if possible.
+### Logging
+Yjs uses [debug](https://github.com/visionmedia/debug) for logging. The flag
+`y*` enables logging for all y-* components. You can selectively remove
+components you are not interested in: E.g. The flag `y*,-y:connector-message`
+will not log the long `y:connector-message` messages.

-## Changelog
-##### 1.0
-This is a complete rewrite of the 0.5 version of Yjs. Since Yjs 1.0 it is possible to work asynchronously on a persistent database, which enables offline support.
-* Switched to semver versioning
-* Requires a promise implementation in environment (es6 promises suffice, included in all the major browsers). Otherwise you have to include a polyfill
-* Y.Object has been renamed to Y.Map
-* Y.Map exchanges `.val(name [, value])` in favor of `.set(name, value)` and `.get(name)`
-* Y.Map `.get(name)` returns a promise, if the value is a custom type
-* The Connector definition slightly changed (I'll update the wiki)
-* The Type definitions completely changed, so you have to rewrite them (I'll rewrite the article in the wiki)
-* Support for several packaging systems
+##### Enable logging in Node.js
+```sh
+DEBUG=y* node app.js
+```

+Remove the colors in order to log to a file:
+```sh
+DEBUG_COLORS=0 DEBUG=y* node app.js > log
+```
+
+##### Enable logging in the browser
+```js
+localStorage.debug = 'y*'
+```

 ## Contribution
-I created this framework during my bachelor thesis at the chair of computer science 5 [(i5)](http://dbis.rwth-aachen.de/cms), RWTH University. Since December 2014 I'm working on Yjs as a part of my student worker job at the i5.
+I created this framework during my bachelor thesis at the chair of computer
+science 5 [(i5)](http://dbis.rwth-aachen.de/cms), RWTH University. Since
+December 2014 I'm working on Yjs as a part of my student worker job at the i5.

 ## License
-Yjs is licensed under the [MIT License](./LICENSE.txt).
+Yjs is licensed under the [MIT License](./LICENSE).

 <yjs@dbis.rwth-aachen.de>
-
-[ShareJs]: https://github.com/sh
--- a/1
+++ b/1
--- a/examples/ace/index.html
+++ b/examples/ace/index.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style type="text/css" media="screen">
+    #aceContainer {
+        position: absolute;
+        top: 0;
+        right: 0;
+        bottom: 0;
+        left: 0;
+    }
+    .inserted {
+      position:absolute;
+      z-index:20;
+      background-color: #FFC107;
+    }
+    .deleted {
+      position:absolute;
+      z-index:20;
+      background-color: #FFC107;
+    }
+    </style>
+  </head>
+  <body>
+
+    <div id="aceContainer"></div>
+    <script src="../bower_components/yjs/y.js"></script>
+    <script src="../bower_components/ace-builds/src/ace.js"></script>
+
+    <script src="./index.js"></script>
+  </body>
+</html>
--- a/examples/ace/index.js
+++ b/examples/ace/index.js
@@ -0,0 +1,24 @@
+/* global Y, ace */
+
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'ace-example'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    ace: 'Text' // y.share.textarea is of type Y.Text
+  }
+}).then(function (y) {
+  window.yAce = y
+
+  // bind the textarea to a shared text element
+  var editor = ace.edit('aceContainer')
+  editor.setTheme('ace/theme/chrome')
+  editor.getSession().setMode('ace/mode/javascript')
+
+  y.share.ace.bindAce(editor)
+})
--- a/examples/bower.json
+++ b/examples/bower.json
@@ -0,0 +1,29 @@
+{
+  "name": "yjs-examples",
+  "version": "0.0.0",
+  "homepage": "y-js.org",
+  "authors": [
+    "Kevin Jahns <kevin.jahns@rwth-aachen.de>"
+  ],
+  "description": "Examples for Yjs",
+  "license": "MIT",
+  "ignore": [],
+  "dependencies": {
+    "yjs": "latest",
+    "y-array": "latest",
+    "y-map": "latest",
+    "y-memory": "latest",
+    "y-richtext": "latest",
+    "y-webrtc": "latest",
+    "y-websockets-client": "latest",
+    "y-text": "latest",
+    "y-indexeddb": "latest",
+    "y-xml": "latest",
+    "quill": "^1.0.0-rc.2",
+    "ace": "~1.2.3",
+    "ace-builds": "~1.2.3",
+    "jquery": "~2.2.2",
+    "d3": "^3.5.16",
+    "codemirror": "^5.25.0"
+  }
+}
--- a/examples/chat/index.html
+++ b/examples/chat/index.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <style>
+      #chat p span {
+        color: blue;
+      }
+    </style>
+    <div id="chat"></div>
+    <form id="chatform">
+      <input name="username" type="text" style="width:15%;">
+      <input name="message" type="text" style="width:60%;">
+      <input type="submit" value="Send">
+    </form>
+    <script src="../bower_components/yjs/y.js"></script>
+    <script src="./index.js"></script>
+  </body>
+</html>
--- a/examples/chat/index.js
+++ b/examples/chat/index.js
@@ -0,0 +1,73 @@
+/* global Y, chat */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'chat-example'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    chat: 'Array'
+  }
+}).then(function (y) {
+  window.yChat = y
+  // This functions inserts a message at the specified position in the DOM
+  function appendMessage (message, position) {
+    var p = document.createElement('p')
+    var uname = document.createElement('span')
+    uname.appendChild(document.createTextNode(message.username + ': '))
+    p.appendChild(uname)
+    p.appendChild(document.createTextNode(message.message))
+    document.querySelector('#chat').insertBefore(p, chat.children[position] || null)
+  }
+  // This function makes sure that only 7 messages exist in the chat history.
+  // The rest is deleted
+  function cleanupChat () {
+    if (y.share.chat.length > 7) {
+      y.share.chat.delete(0, y.chat.length - 7)
+    }
+  }
+  // Insert the initial content
+  y.share.chat.toArray().forEach(appendMessage)
+  cleanupChat()
+
+  // whenever content changes, make sure to reflect the changes in the DOM
+  y.share.chat.observe(function (event) {
+    if (event.type === 'insert') {
+      for (let i = 0; i < event.length; i++) {
+        appendMessage(event.values[i], event.index + i)
+      }
+    } else if (event.type === 'delete') {
+      for (let i = 0; i < event.length; i++) {
+        chat.children[event.index].remove()
+      }
+    }
+    // concurrent insertions may result in a history > 7, so cleanup here
+    cleanupChat()
+  })
+  document.querySelector('#chatform').onsubmit = function (event) {
+    // the form is submitted
+    var message = {
+      username: this.querySelector('[name=username]').value,
+      message: this.querySelector('[name=message]').value
+    }
+    if (message.username.length > 0 && message.message.length > 0) {
+      if (y.share.chat.length > 6) {
+        // If we are goint to insert the 8th element, make sure to delete first.
+        y.share.chat.delete(0)
+      }
+      // Here we insert a message in the shared chat type.
+      // This will call the observe function (see line 40)
+      // and reflect the change in the DOM
+      y.share.chat.push([message])
+      this.querySelector('[name=message]').value = ''
+    }
+    // Do not send this form!
+    event.preventDefault()
+    return false
+  }
+})
--- a/examples/codemirror/index.html
+++ b/examples/codemirror/index.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+  <head>
+  </head>
+  <body>
+    <div id="codeMirrorContainer"></div>
+
+    <script src="../bower_components/yjs/y.js"></script>
+    <script src="../bower_components/codemirror/lib/codemirror.js"></script>
+    <script src="../bower_components/codemirror/mode/javascript/javascript.js"></script>
+    <link rel="stylesheet" href="../bower_components/codemirror/lib/codemirror.css">
+    <style>
+      .CodeMirror {
+        position: fixed;
+        top: 0;
+        left: 0;
+        height: 100%;
+        width: 100%;
+      }
+    </style>
+    <script src="./index.js"></script>
+  </body>
+</html>
--- a/examples/codemirror/index.js
+++ b/examples/codemirror/index.js
@@ -0,0 +1,24 @@
+/* global Y, CodeMirror */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'codemirror-example'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    codemirror: 'Text' // y.share.codemirror is of type Y.Text
+  }
+}).then(function (y) {
+  window.yCodeMirror = y
+
+  var editor = CodeMirror(document.querySelector('#codeMirrorContainer'), {
+    mode: 'javascript',
+    lineNumbers: true
+  })
+  y.share.codemirror.bindCodeMirror(editor)
+})
--- a/examples/drawing/index.html
+++ b/examples/drawing/index.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<body>
+  <style>
+    path {
+      fill: none;
+      stroke: blue;
+      stroke-width: 1px;
+      stroke-linejoin: round;
+      stroke-linecap: round;
+    }
+  </style>
+  <button type="button" id="clearDrawingCanvas">Clear Drawing</button>
+  <svg id="drawingCanvas" viewbox="0 0 100 100" width="100%"></svg>
+  <script src="../bower_components/yjs/y.js"></script>
+  <script src="../bower_components/d3/d3.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/drawing/index.js
+++ b/examples/drawing/index.js
@@ -0,0 +1,84 @@
+/* globals Y, d3 */
+'strict mode'
+
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'drawing-example'
+    // url: 'localhost:1234'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    drawing: 'Array'
+  }
+}).then(function (y) {
+  window.yDrawing = y
+  var drawing = y.share.drawing
+  var renderPath = d3.svg.line()
+    .x(function (d) { return d[0] })
+    .y(function (d) { return d[1] })
+    .interpolate('basis')
+
+  var svg = d3.select('#drawingCanvas')
+    .call(d3.behavior.drag()
+      .on('dragstart', dragstart)
+      .on('drag', drag)
+      .on('dragend', dragend))
+
+  // create line from a shared array object and update the line when the array changes
+  function drawLine (yarray) {
+    var line = svg.append('path').datum(yarray.toArray())
+    line.attr('d', renderPath)
+    yarray.observe(function (event) {
+      // we only implement insert events that are appended to the end of the array
+      event.values.forEach(function (value) {
+        line.datum().push(value)
+      })
+      line.attr('d', renderPath)
+    })
+  }
+  // call drawLine every time an array is appended
+  y.share.drawing.observe(function (event) {
+    if (event.type === 'insert') {
+      event.values.forEach(drawLine)
+    } else {
+      // just remove all elements (thats what we do anyway)
+      svg.selectAll('path').remove()
+    }
+  })
+  // draw all existing content
+  for (var i = 0; i < drawing.length; i++) {
+    drawLine(drawing.get(i))
+  }
+
+  // clear canvas on request
+  document.querySelector('#clearDrawingCanvas').onclick = function () {
+    drawing.delete(0, drawing.length)
+  }
+
+  var sharedLine = null
+  function dragstart () {
+    drawing.insert(drawing.length, [Y.Array])
+    sharedLine = drawing.get(drawing.length - 1)
+  }
+
+  // After one dragged event is recognized, we ignore them for 33ms.
+  var ignoreDrag = null
+  function drag () {
+    if (sharedLine != null && ignoreDrag == null) {
+      ignoreDrag = window.setTimeout(function () {
+        ignoreDrag = null
+      }, 33)
+      sharedLine.push([d3.mouse(this)])
+    }
+  }
+
+  function dragend () {
+    sharedLine = null
+    window.clearTimeout(ignoreDrag)
+    ignoreDrag = null
+  }
+})
--- a/examples/jigsaw/index.html
+++ b/examples/jigsaw/index.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <style type="text/css">
+    .draggable {
+      cursor: move;
+    }
+  </style>
+</head>
+<body>
+  <svg id="puzzle-example" width="100%" viewBox="0 0 800 800">
+    <g>
+      <path d="M 311.76636,154.23389 C 312.14136,171.85693 318.14087,184.97998 336.13843,184.23047 C 354.13647,183.48047 351.88647,180.48096 354.88599,178.98096 C 357.8855,177.48096 368.38452,170.35693 380.00806,169.98193 C 424.61841,168.54297 419.78296,223.6001 382.25757,223.6001 C 377.75806,223.6001 363.51001,219.10107 356.38599,211.97656 C 349.26196,204.85254 310.64185,207.10254 314.76636,236.34863 C 316.34888,247.5708 324.08374,267.90723 324.84595,286.23486 C 325.29321,296.99414 323.17603,307.00635 321.58911,315.6377 C 360.11353,305.4585 367.73462,304.30518 404.00513,312.83936 C 410.37915,314.33887 436.62573,310.21436 421.25269,290.3418 C 405.87964,270.46924 406.25464,248.34717 417.12817,240.84814 C 428.00171,233.34912 446.74976,228.84961 457.99829,234.09912 C 469.24683,239.34814 484.61987,255.84619 475.24585,271.59424 C 465.87231,287.34229 452.74878,290.7168 456.49829,303.84033 C 460.2478,316.96387 479.74536,320.33838 500.74292,321.83789 C 509.70142,322.47803 527.97192,323.28467 542.10864,320.12939 C 549.91821,318.38672 556.92212,315.89502 562.46753,313.56396 C 561.40796,277.80664 560.84888,245.71729 560.3606,241.97314 C 558.85278,230.41455 542.49536,217.28564 525.86499,223.2251 C 520.61548,225.1001 519.86548,231.84912 505.24243,232.59912 C 444.92798,235.69238 462.06958,143.26709 525.86499,180.48096 C 539.52759,188.45068 575.19409,190.7583 570.10913,156.85889 C 567.85962,141.86035 553.98608,102.86523 553.98608,102.86523 C 553.98608,102.86523 477.23755,111.82227 451.99878,91.991699 C 441.50024,83.74292 444.87476,69.494629 449.37427,61.245605 C 453.87378,52.996582 465.12231,46.622559 464.74731,36.123779 C 463.02563,-12.086426 392.96704,-10.902832 396.5061,36.873535 C 397.25562,46.997314 406.62964,52.621582 410.75415,60.495605 C 420.00757,78.161377 405.50024,96.073486 384.50757,99.490723 C 377.36206,100.65381 349.17505,102.65332 320.39429,102.23486 C 319.677,102.22461 318.95923,102.21143 318.24194,102.19775 C 315.08423,120.9751 311.55688,144.39697 311.76636,154.23389 z " style="fill:#f2c569;stroke:#000000" id="path2502"/>
+      <path d="M 500.74292,321.83789 C 479.74536,320.33838 460.2478,316.96387 456.49829,303.84033 C 452.74878,290.7168 465.87231,287.34229 475.24585,271.59424 C 484.61987,255.84619 469.24683,239.34814 457.99829,234.09912 C 446.74976,228.84961 428.00171,233.34912 417.12817,240.84814 C 406.25464,248.34717 405.87964,270.46924 421.25269,290.3418 C 436.62573,310.21436 410.37915,314.33887 404.00513,312.83936 C 367.73462,304.30518 360.11353,305.4585 321.58911,315.6377 C 320.56372,321.21484 319.75854,326.2207 320.01538,330.46191 C 320.76538,342.83545 329.3894,385.95508 327.8894,392.7041 C 326.3894,399.45312 313.64136,418.20117 297.89331,407.32715 C 282.14526,396.45361 276.52075,393.4541 265.27222,394.5791 C 254.02368,395.70361 239.77563,402.07812 239.77563,419.32568 C 239.77563,436.57373 250.27417,449.69727 268.64673,447.82227 C 287.36353,445.9126 317.92163,423.11035 325.63989,452.69678 C 330.1394,469.94434 330.51392,487.19238 330.1394,498.44092 C 329.95825,503.87646 326.09985,518.06592 322.16089,531.28125 C 353.2854,532.73682 386.47095,531.26611 394.2561,529.93701 C 430.30933,523.78174 429.31909,496.09766 412.62866,477.44385 C 406.25464,470.31934 401.75513,455.32129 405.87964,444.82275 C 414.07056,423.97314 458.8064,422.17773 473.37134,438.82324 C 483.86987,450.82178 475.99585,477.44385 468.49683,482.69287 C 453.52222,493.17529 457.22485,516.83008 473.37134,528.06201 C 504.79126,549.91943 572.35913,535.56152 572.35913,535.56152 C 572.35913,535.56152 567.85962,498.06592 567.48462,471.81934 C 567.10962,445.57275 589.60669,450.07227 593.3562,450.07227 C 597.10571,450.07227 604.22974,455.32129 609.47925,459.4458 C 614.72876,463.57031 618.85327,469.94434 630.85181,470.69434 C 677.43726,473.60596 674.58813,420.7373 631.97632,413.32666 C 623.35229,411.82666 614.72876,416.32617 603.10522,424.57519 C 591.48169,432.82422 577.23315,425.32519 570.10913,417.45117 C 566.07788,412.99561 563.8479,360.16406 562.46753,313.56396 C 556.92212,315.89502 549.91821,318.38672 542.10864,320.12939 C 527.97192,323.28467 509.70142,322.47803 500.74292,321.83789 z " style="fill:#f3f3d6;stroke:#000000" id="path2504"/>
+      <path d="M 240.52563,141.86035 C 257.60327,159.6499 243.94507,188.68799 214.65356,190.22949 C 185.09448,191.78516 164.66675,157.17822 190.28589,136.61621 C 200.49585,128.42139 198.05786,114.12158 179.78296,106.98975 C 154.4187,97.091553 90.54419,107.73975 90.54419,107.73975 C 90.54419,107.73975 100.88794,135.11328 101.41772,168.48242 C 101.79272,192.104 68.796875,189.47949 63.172607,186.85498 C 57.54834,184.23047 45.924805,173.73145 37.675781,173.73145 C -14.411865,173.73145 -10.013184,245.84375 39.925537,232.22412 C 48.174316,229.97461 56.42334,220.97559 68.796875,222.47559 C 81.17041,223.9751 87.544434,232.59912 87.544434,246.09766 C 87.544434,252.51709 87.0354,281.24268 86.340576,312.87012 C 119.15894,313.67676 160.60962,314.46582 170.03442,313.58887 C 186.15698,312.08936 195.90601,301.59033 188.40698,293.3418 C 180.90796,285.09277 156.16089,256.59619 179.03296,239.34814 C 201.90503,222.10059 235.65112,231.84912 239.77563,247.22217 C 243.90015,262.59521 240.52563,273.46924 234.90112,279.09326 C 229.27661,284.71777 210.52905,298.96582 221.40259,308.71484 C 232.27661,318.46338 263.77222,330.83691 302.39282,320.71338 C 309.58862,318.82715 315.92114,317.13525 321.58911,315.6377 C 323.17603,307.00635 325.29321,296.99414 324.84595,286.23486 C 324.08374,267.90723 316.34888,247.5708 314.76636,236.34863 C 310.64185,207.10254 349.26196,204.85254 356.38599,211.97656 C 363.51001,219.10107 377.75806,223.6001 382.25757,223.6001 C 419.78296,223.6001 424.61841,168.54297 380.00806,169.98193 C 368.38452,170.35693 357.8855,177.48096 354.88599,178.98096 C 351.88647,180.48096 354.13647,183.48047 336.13843,184.23047 C 318.14087,184.97998 312.14136,171.85693 311.76636,154.23389 C 311.55688,144.39697 315.08423,120.9751 318.24194,102.19775 C 290.37524,101.67725 262.46069,98.968262 254.39868,97.991211 C 233.38013,95.443359 217.17456,117.53662 240.52563,141.86035 z " style="fill:#bebcdb;stroke:#000000" id="path2506"/>
+      <path d="M 325.63989,452.69678 C 317.92163,423.11035 287.36353,445.9126 268.64673,447.82227 C 250.27417,449.69727 239.77563,436.57373 239.77563,419.32568 C 239.77563,402.07812 254.02368,395.70361 265.27222,394.5791 C 276.52075,393.4541 282.14526,396.45361 297.89331,407.32715 C 313.64136,418.20117 326.3894,399.45313 327.8894,392.7041 C 329.3894,385.95508 320.76538,342.83545 320.01538,330.46191 C 319.75855,326.2207 320.56372,321.21484 321.58911,315.6377 C 315.92114,317.13525 309.58862,318.82715 302.39282,320.71338 C 263.77222,330.83691 232.27661,318.46338 221.40259,308.71484 C 210.52905,298.96582 229.27661,284.71777 234.90112,279.09326 C 240.52563,273.46924 243.90015,262.59521 239.77563,247.22217 C 235.65112,231.84912 201.90503,222.10059 179.03296,239.34814 C 156.16089,256.59619 180.90796,285.09277 188.40698,293.3418 C 195.90601,301.59033 186.15698,312.08936 170.03442,313.58887 C 160.60962,314.46582 119.15894,313.67676 86.340576,312.87012 C 85.573975,347.74561 84.581299,386.15088 83.794922,402.07812 C 82.295166,432.44922 109.29175,422.32568 115.66577,420.82568 C 122.04028,419.32568 126.16479,409.57715 143.03735,408.45215 C 185.9231,405.59326 186.09985,466.69629 144.16235,467.69482 C 128.41431,468.06982 113.79126,451.19678 108.16675,447.44727 C 102.54272,443.69775 87.919433,442.94775 83.794922,457.9458 C 82.01709,464.41113 78.118652,481.65137 78.098144,496.18994 C 78.071045,515.38037 82.295166,531.81201 82.295166,531.81201 C 82.295166,531.81201 105.54224,526.5625 149.41187,526.5625 C 193.28149,526.5625 199.65552,547.93506 194.78101,558.80859 C 189.90649,569.68213 181.28296,568.93213 179.40796,583.18066 C 172.7063,634.11133 253.34106,631.08203 249.14917,584.68018 C 247.96948,571.62354 237.16528,571.66699 232.27661,557.68359 C 222.17944,528.80273 244.64966,523.56299 257.39819,524.68799 C 263.59351,525.23437 290.95679,529.73389 320.75757,531.21582 C 321.22437,531.23877 321.69312,531.25928 322.16089,531.28125 C 326.09985,518.06592 329.95825,503.87646 330.1394,498.44092 C 330.51392,487.19238 330.1394,469.94434 325.63989,452.69678 z " style="fill:#d3ea9d;stroke:#000000" id="path2508"/>
+		</g>
+  </svg>
+  <script src="../bower_components/yjs/y.js"></script>
+  <script src="../bower_components/d3/d3.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/jigsaw/index.js
+++ b/examples/jigsaw/index.js
@@ -0,0 +1,74 @@
+/* @flow */
+/* global Y, d3 */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'Puzzle-example'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    piece1: 'Map',
+    piece2: 'Map',
+    piece3: 'Map',
+    piece4: 'Map'
+  }
+}).then(function (y) {
+  window.yJigsaw = y
+  var origin // mouse start position - translation of piece
+  var drag = d3.behavior.drag()
+    .on('dragstart', function (params) {
+      // get the translation of the element
+      var translation = d3
+        .select(this)
+        .attr('transform')
+        .slice(10, -1)
+        .split(',')
+        .map(Number)
+      // mouse coordinates
+      var mouse = d3.mouse(this.parentNode)
+      origin = {
+        x: mouse[0] - translation[0],
+        y: mouse[1] - translation[1]
+      }
+    })
+    .on('drag', function () {
+      var mouse = d3.mouse(this.parentNode)
+      var x = mouse[0] - origin.x // =^= mouse - mouse at dragstart + translation at dragstart
+      var y = mouse[1] - origin.y
+      d3.select(this).attr('transform', 'translate(' + x + ',' + y + ')')
+    })
+    .on('dragend', function (piece, i) {
+      // save the current translation of the puzzle piece
+      var mouse = d3.mouse(this.parentNode)
+      var x = mouse[0] - origin.x
+      var y = mouse[1] - origin.y
+      piece.set('translation', {x: x, y: y})
+    })
+
+  var data = [y.share.piece1, y.share.piece2, y.share.piece3, y.share.piece4]
+  var pieces = d3.select(document.querySelector('#puzzle-example')).selectAll('path').data(data)
+
+  pieces
+    .classed('draggable', true)
+    .attr('transform', function (piece) {
+      var translation = piece.get('translation') || {x: 0, y: 0}
+      return 'translate(' + translation.x + ',' + translation.y + ')'
+    }).call(drag)
+
+  data.forEach(function (piece) {
+    piece.observe(function () {
+      // whenever a property of a piece changes, update the translation of the pieces
+      pieces
+        .transition()
+        .attr('transform', function (piece) {
+          var translation = piece.get('translation') || {x: 0, y: 0}
+          return 'translate(' + translation.x + ',' + translation.y + ')'
+        })
+    })
+  })
+})
--- a/examples/monaco/index.html
+++ b/examples/monaco/index.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html>
+  <head>
+  </head>
+  <body>
+    <div id="monacoContainer"></div>
+    <style>
+      #monacoContainer {
+        position: fixed;
+        top: 0;
+        left: 0;
+        height: 100%;
+        width: 100%;
+      }
+    </style>
+    <script src="../bower_components/yjs/y.js"></script>
+    <script src="../bower_components/y-array/y-array.js"></script>
+    <script src="../bower_components/y-text/y-text.js"></script>
+    <script src="../bower_components/y-websockets-client/y-websockets-client.js"></script>
+    <script src="../bower_components/y-memory/y-memory.js"></script>
+    <script src="../node_modules/monaco-editor/min/vs/loader.js"></script>
+    <script src="./index.js"></script>
+  </body>
+</html>
--- a/examples/monaco/index.js
+++ b/examples/monaco/index.js
@@ -0,0 +1,30 @@
+/* global Y, monaco */
+
+require.config({ paths: { 'vs': '../node_modules/monaco-editor/min/vs' } })
+
+require(['vs/editor/editor.main'], function () {
+  // Initialize a shared object. This function call returns a promise!
+  Y({
+    db: {
+      name: 'memory'
+    },
+    connector: {
+      name: 'websockets-client',
+      room: 'monaco-example'
+    },
+    sourceDir: '/bower_components',
+    share: {
+      monaco: 'Text' // y.share.monaco is of type Y.Text
+    }
+  }).then(function (y) {
+    window.yMonaco = y
+
+    // Create Monaco editor
+    var editor = monaco.editor.create(document.getElementById('monacoContainer'), {
+      language: 'javascript'
+    })
+
+    // Bind to y.share.monaco
+    y.share.monaco.bindMonaco(editor)
+  })
+})
--- a/examples/package-lock.json
+++ b/examples/package-lock.json
--- a/examples/package.json
+++ b/examples/package.json
@@ -0,0 +1,16 @@
+{
+  "name": "examples",
+  "version": "0.0.0",
+  "description": "",
+  "author": "Kevin Jahns",
+  "license": "MIT",
+  "dependencies": {
+    "monaco-editor": "^0.8.3"
+  },
+  "devDependencies": {
+    "standard": "^10.0.2"
+  },
+  "standard": {
+    "ignore": ["bower_components"]
+  }
+}
--- a/examples/quill/index.html
+++ b/examples/quill/index.html
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <!-- quill does not include dist files! We are using the hosted version instead -->
+  <!--link rel="stylesheet" href="../bower_components/quill/dist/quill.snow.css" /-->
+  <link href="https://cdn.quilljs.com/1.0.4/quill.snow.css" rel="stylesheet">
+  <link href="//cdnjs.cloudflare.com/ajax/libs/KaTeX/0.5.1/katex.min.css" rel="stylesheet">
+  <link href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.2.0/styles/monokai-sublime.min.css" rel="stylesheet">
+  <style>
+    #quill-container {
+      border: 1px solid gray;
+      box-shadow: 0px 0px 10px gray;
+    }
+  </style>
+</head>
+<body>
+  <div id="quill-container">
+    <div id="quill">
+    </div>
+  </div>
+
+  <script src="//cdnjs.cloudflare.com/ajax/libs/KaTeX/0.5.1/katex.min.js" type="text/javascript"></script>
+  <script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.2.0/highlight.min.js" type="text/javascript"></script>
+  <script src="https://cdn.quilljs.com/1.0.4/quill.js"></script>
+  <!-- quill does not include dist files! We are using the hosted version instead (see above)
+  <script src="../bower_components/quill/dist/quill.js"></script>
+  -->
+  <script src="../bower_components/yjs/y.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/quill/index.js
+++ b/examples/quill/index.js
@@ -0,0 +1,39 @@
+/* global Y, Quill */
+
+// initialize a shared object. This function call returns a promise!
+
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'richtext-example-quill-1.0-test'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    richtext: 'Richtext' // y.share.richtext is of type Y.Richtext
+  }
+}).then(function (y) {
+  window.yQuill = y
+
+  // create quill element
+  window.quill = new Quill('#quill', {
+    modules: {
+      formula: true,
+      syntax: true,
+      toolbar: [
+        [{ size: ['small', false, 'large', 'huge'] }],
+        ['bold', 'italic', 'underline'],
+        [{ color: [] }, { background: [] }],    // Snow theme fills in values
+        [{ script: 'sub' }, { script: 'super' }],
+        ['link', 'image'],
+        ['link', 'code-block'],
+        [{ list: 'ordered' }]
+      ]
+    },
+    theme: 'snow'
+  })
+  // bind quill to richtext type
+  y.share.richtext.bind(window.quill)
+})
--- a/examples/serviceworker/index.html
+++ b/examples/serviceworker/index.html
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <!-- quill does not include dist files! We are using the hosted version instead -->
+  <!--link rel="stylesheet" href="../bower_components/quill/dist/quill.snow.css" /-->
+  <link href="https://cdn.quilljs.com/1.0.4/quill.snow.css" rel="stylesheet">
+  <link href="//cdnjs.cloudflare.com/ajax/libs/KaTeX/0.5.1/katex.min.css" rel="stylesheet">
+  <link href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.2.0/styles/monokai-sublime.min.css" rel="stylesheet">
+  <style>
+    #quill-container {
+      border: 1px solid gray;
+      box-shadow: 0px 0px 10px gray;
+    }
+  </style>
+</head>
+<body>
+  <div id="quill-container">
+    <div id="quill">
+    </div>
+  </div>
+
+  <script src="//cdnjs.cloudflare.com/ajax/libs/KaTeX/0.5.1/katex.min.js" type="text/javascript"></script>
+  <script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.2.0/highlight.min.js" type="text/javascript"></script>
+  <script src="https://cdn.quilljs.com/1.0.4/quill.js"></script>
+  <!-- quill does not include dist files! We are using the hosted version instead (see above)
+  <script src="../bower_components/quill/dist/quill.js"></script>
+  -->
+  <script src="../bower_components/yjs/y.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/serviceworker/index.js
+++ b/examples/serviceworker/index.js
@@ -0,0 +1,49 @@
+/* global Y, Quill */
+
+// register yjs service worker
+if ('serviceWorker' in navigator) {
+  // Register service worker
+  // it is important to copy yjs-sw-template to the root directory!
+  navigator.serviceWorker.register('./yjs-sw-template.js').then(function (reg) {
+    console.log('Yjs service worker registration succeeded. Scope is ' + reg.scope)
+  }).catch(function (err) {
+    console.error('Yjs service worker registration failed with error ' + err)
+  })
+}
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'serviceworker',
+    room: 'ServiceWorkerExample2'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    richtext: 'Richtext' // y.share.richtext is of type Y.Richtext
+  }
+}).then(function (y) {
+  window.yServiceWorker = y
+
+  // create quill element
+  window.quill = new Quill('#quill', {
+    modules: {
+      formula: true,
+      syntax: true,
+      toolbar: [
+        [{ size: ['small', false, 'large', 'huge'] }],
+        ['bold', 'italic', 'underline'],
+        [{ color: [] }, { background: [] }],    // Snow theme fills in values
+        [{ script: 'sub' }, { script: 'super' }],
+        ['link', 'image'],
+        ['link', 'code-block'],
+        [{ list: 'ordered' }]
+      ]
+    },
+    theme: 'snow'
+  })
+  // bind quill to richtext type
+  y.share.richtext.bind(window.quill)
+})
--- a/examples/serviceworker/yjs-sw-template.js
+++ b/examples/serviceworker/yjs-sw-template.js
@@ -0,0 +1,22 @@
+/* eslint-env worker */
+
+// copy and modify this file
+
+self.DBConfig = {
+  name: 'indexeddb'
+}
+self.ConnectorConfig = {
+  name: 'websockets-client',
+  // url: '..',
+  options: {
+    jsonp: false
+  }
+}
+
+importScripts(
+  '/bower_components/yjs/y.js',
+  '/bower_components/y-memory/y-memory.js',
+  '/bower_components/y-indexeddb/y-indexeddb.js',
+  '/bower_components/y-websockets-client/y-websockets-client.js',
+  '/bower_components/y-serviceworker/yjs-sw-include.js'
+)
--- a/examples/textarea/index.html
+++ b/examples/textarea/index.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<body>
+  <textarea style="width:80%;" rows=40 id="textfield" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"></textarea>
+  <script src="../../y.js"></script>
+  <script src="../../../y-array/y-array.js"></script>
+  <script src="../../../y-text/dist/y-text.js"></script>
+  <script src="../../../y-memory/y-memory.js"></script>
+  <script src="../../../y-websockets-client/dist/y-websockets-client.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/textarea/index.js
+++ b/examples/textarea/index.js
@@ -0,0 +1,23 @@
+/* global Y */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'Textarea-example'
+    // url: '127.0.0.1:1234'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    textarea: 'Text' // y.share.textarea is of type Y.Text
+  }
+}).then(function (y) {
+  window.yTextarea = y
+
+  // bind the textarea to a shared text element
+  y.share.textarea.bind(document.getElementById('textfield'))
+  // thats it..
+})
--- a/examples/xml/index.html
+++ b/examples/xml/index.html
@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html>
+</head>
+  <script src="../bower_components/yjs/y.js"></script>
+  <script src="../bower_components/jquery/dist/jquery.min.js"></script>
+  <script src="./index.js"></script>
+</head>
+<body>
+  <h1> Shared DOM Example </h1>
+  <p> Use native DOM function or jQuery to manipulate the shared DOM (window.sharedDom). </p>
+  <div class="command">
+    <button type="button">Execute</button>
+    <input type="text" value='$(sharedDom).append("<h3>Appended headline</h3>")' size="40"/>
+  </div>
+  <div class="command">
+    <button type="button">Execute</button>
+    <input type="text" value='$(sharedDom).attr("align","right")' size="40"/>
+  </div>
+  <div class="command">
+    <button type="button">Execute</button>
+    <input type="text" value='$(sharedDom).attr("style","color:blue;")' size="40"/>
+  </div>
+
+  <script>
+    var commands = document.querySelectorAll(".command");
+    Array.prototype.forEach.call(document.querySelectorAll('.command'), function (command) {
+      var execute = function(){
+        eval(command.querySelector("input").value);
+      }
+      command.querySelector("button").onclick = execute
+      $(command.querySelector("input")).keyup(function (e) {
+        if (e.keyCode == 13) {
+          execute()
+        }
+      })
+    })
+  </script>
+</body>
+</html>
--- a/examples/xml/index.js
+++ b/examples/xml/index.js
@@ -0,0 +1,21 @@
+/* global Y */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'Xml-example'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    xml: 'Xml("p")' // y.share.xml is of type Y.Xml with tagname "p"
+  }
+}).then(function (y) {
+  window.yXml = y
+  // bind xml type to a dom, and put it in body
+  window.sharedDom = y.share.xml.getDom()
+  document.body.appendChild(window.sharedDom)
+})
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -1,207 +0,0 @@
-/* eslint-env node */
-
-/** Gulp Commands
-
-  gulp command*
-    [--export ModuleType]
-    [--name ModuleName]
-    [--testport TestPort]
-    [--testfiles TestFiles]
-
-  Module name (ModuleName):
-    Compile this to "y.js" (default)
-
-  Supported module types (ModuleType):
-    - amd
-    - amdStrict
-    - common
-    - commonStrict
-    - ignore (default)
-    - system
-    - umd
-    - umdStrict
-
-  Test port (TestPort):
-    Serve the specs on port 8888 (default)
-
-  Test files (TestFiles):
-    Specify which specs to use!
-
-  Commands:
-    - build:deploy
-        Build this library for deployment (es6->es5, minified)
-    - dev:browser
-        Watch the ./src directory.
-        Builds the library on changes.
-        Starts an http-server and serves the test suite on http://127.0.0.1:8888.
-    - dev:node
-        Watch the ./src directory.
-        Builds and specs the library on changes.
-        Usefull to run with node-inspector.
-        `node-debug $(which gulp) dev:node
-    - test:
-        Test this library
-*/
-
-var gulp = require('gulp')
-var sourcemaps = require('gulp-sourcemaps')
-var babel = require('gulp-babel')
-var uglify = require('gulp-uglify')
-var minimist = require('minimist')
-var jasmine = require('gulp-jasmine')
-var jasmineBrowser = require('gulp-jasmine-browser')
-var concat = require('gulp-concat')
-var watch = require('gulp-watch')
-var shell = require('gulp-shell')
-var $ = require('gulp-load-plugins')()
-
-var options = minimist(process.argv.slice(2), {
-  string: ['export', 'name', 'testport', 'testfiles', 'regenerator'],
-  default: {
-    export: 'ignore',
-    name: 'y.js',
-    testport: '8888',
-    testfiles: 'src/**/*.js',
-    regenerator: process.version < 'v0.12'
-  }
-})
-
-var polyfills = [
-  './node_modules/gulp-babel/node_modules/babel-core/node_modules/regenerator/runtime.js'
-]
-
-var concatOrder = [
-  'y.js',
-  'Connector.js',
-  'Database.js',
-  'Transaction.js',
-  'Struct.js',
-  'Utils.js',
-  'Databases/RedBlackTree.js',
-  'Databases/Memory.js',
-  'Databases/IndexedDB.js',
-  'Connectors/Test.js',
-  'Connectors/WebRTC.js',
-  'Types/Array.js',
-  'Types/Map.js',
-  'Types/TextBind.js'
-]
-
-var files = {
-  src: polyfills.concat(concatOrder.map(function (f) {
-    return 'src/' + f
-  })),
-  test: ['build/Helper.spec.js'].concat(concatOrder.map(function (f) {
-    return 'build/' + f
-  }).concat(['build/**/*.spec.js']))
-}
-
-if (options.regenerator) {
-  files.test = polyfills.concat(files.test)
-}
-
-gulp.task('deploy:build', function () {
-  return gulp.src(files.src)
-    .pipe(sourcemaps.init())
-    .pipe(concat('y.js'))
-    .pipe(babel({
-      loose: 'all',
-      modules: 'ignore',
-      experimental: true
-    }))
-    .pipe(uglify())
-    .pipe(sourcemaps.write('.'))
-    .pipe(gulp.dest('.'))
-})
-
-gulp.task('deploy:updateSubmodule', function () {
-  return $.git.updateSubmodule({ args: '--init' })
-})
-
-gulp.task('deploy:copy', function () {
-  return gulp.src(['./y.js', './y.js.map', './README.md', 'package.json', 'LICENSE'])
-    .pipe(gulp.dest('./dist/'))
-})
-
-gulp.task('deploy:bump', function () {
-  return gulp.src('./package.json')
-    .pipe($.bump({type: 'patch'}))
-    .pipe(gulp.dest('./'))
-})
-
-gulp.task('deploy', ['deploy:updateSubmodule', 'deploy:bump', 'deploy:build', 'deploy:copy'], function () {
-  return gulp.src('./package.json', {read: false})
-    .pipe(shell([
-      'echo "Deploying version <%= getVersion(file.path) %>"',
-      'cd ./dist/',
-      'git add -A',
-      'git commit -am "Deploy <%= getVersion(file.path) %>" -n',
-      'git tag -a v<%= getVersion(file.path) %> -m "Release <%= getVersion(file.path) %>"',
-      'git push',
-      'git push origin --tags',
-      'cd ..',
-      'git commit -am "Release <%= getVersion(file.path) %>" -n',
-      'git push'
-    ], {
-      templateData: {
-        getVersion: function (s) {
-          return require(s).version
-        }
-      }
-    }))
-})
-
-gulp.task('build:test', function () {
-  var babelOptions = {
-    loose: 'all',
-    modules: 'ignore',
-    experimental: true
-  }
-  if (!options.regenerator) {
-    babelOptions.blacklist = 'regenerator'
-  }
-  gulp.src(files.src)
-    .pipe(sourcemaps.init())
-    .pipe(concat('y.js'))
-    .pipe(babel(babelOptions))
-    .pipe(sourcemaps.write())
-    .pipe(gulp.dest('.'))
-
-  return gulp.src('src/**/*.js')
-    .pipe(sourcemaps.init())
-    .pipe(babel(babelOptions))
-    .pipe(sourcemaps.write())
-    .pipe(gulp.dest('build'))
-})
-
-gulp.task('dev:node', ['test'], function () {
-  gulp.watch('src/**/*.js', ['test'])
-})
-
-gulp.task('dev:browser', ['build:test'], function () {
-  gulp.watch('src/**/*.js', ['build:test'])
-
-  gulp.src(files.test)
-    .pipe(watch(['build/**/*.js']))
-    .pipe(jasmineBrowser.specRunner())
-    .pipe(jasmineBrowser.server({port: options.testport}))
-})
-
-gulp.task('dev', ['build:test'], function () {
-  gulp.start('dev:browser')
-  gulp.start('dev:node')
-})
-
-gulp.task('test', ['build:test'], function () {
-  var testfiles = files.test
-  if (typeof Promise === 'undefined') {
-    testfiles.concat(['src/polyfills.js'])
-  }
-  return gulp.src(testfiles)
-    .pipe(jasmine({
-      verbose: true,
-      includeStuckTrace: true
-    }))
-})
-
-gulp.task('default', ['test'])
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,23 +1,23 @@
 {
  "name": "yjs",
-  "version": "0.6.20",
-  "description": "A framework for real-time p2p shared editing on arbitrary complex data types",
-  "main": "y.js",
+  "version": "13.0.0-3",
+  "description": "A framework for real-time p2p shared editing on any data",
+  "main": "./y.js",
  "scripts": {
-    "test": "node --harmony ./node_modules/.bin/gulp test",
-    "lint": "./node_modules/.bin/standard",
-    "build": "./node_modules/.bin/standard build"
+    "test": "npm run lint",
+    "lint": "standard",
+    "dist": "rollup -c rollup.dist.js",
+    "serve": "concurrently 'serve ..' 'rollup -wc rollup.dist.js -o examples/bower_components/yjs/y.js'",
+    "postversion": "npm run dist",
+    "postpublish": "tag-dist-files --overwrite-existing-tag"
  },
-  "pre-commit": [
-    "lint",
-    "test"
+  "files": [
+    "y.*"
  ],
  "standard": {
-    "parser": "babel-eslint",
    "ignore": [
-      "build/**",
-      "./y.js",
-      "./y.js.map"
+      "/y.js",
+      "/y.js.map"
    ]
  },
  "repository": {
@@ -25,13 +25,13 @@
    "url": "https://github.com/y-js/yjs.git"
  },
  "keywords": [
+    "Yjs",
    "OT",
-    "Operational Transformation",
-    "collaboration",
-    "synchronization",
-    "ShareJs",
-    "OpenCoweb",
-    "concurrency"
+    "Collaboration",
+    "Synchronization",
+    "ShareJS",
+    "Coweb",
+    "Concurrency"
  ],
  "author": "Kevin Jahns",
  "email": "kevin.jahns@rwth-aachen.de",
@@ -41,25 +41,25 @@
  },
  "homepage": "http://y-js.org",
  "devDependencies": {
-    "babel-eslint": "^4.1.2",
-    "gulp": "^3.9.0",
-    "gulp-babel": "^5.2.1",
-    "gulp-bump": "^1.0.0",
-    "gulp-concat": "^2.6.0",
-    "gulp-filter": "^3.0.1",
-    "gulp-git": "^1.6.0",
-    "gulp-jasmine": "^2.0.1",
-    "gulp-jasmine-browser": "^0.2.3",
-    "gulp-load-plugins": "^1.0.0",
-    "gulp-shell": "^0.5.1",
-    "gulp-sourcemaps": "^1.5.2",
-    "gulp-tag-version": "^1.3.0",
-    "gulp-uglify": "^1.4.1",
-    "gulp-util": "^3.0.6",
-    "gulp-watch": "^4.3.5",
-    "minimist": "^1.2.0",
-    "pre-commit": "^1.1.1",
-    "promise-polyfill": "^2.1.0",
-    "standard": "^5.2.2"
+    "babel-cli": "^6.24.1",
+    "babel-plugin-external-helpers": "^6.22.0",
+    "babel-plugin-transform-regenerator": "^6.24.1",
+    "babel-plugin-transform-runtime": "^6.23.0",
+    "babel-preset-latest": "^6.24.1",
+    "chance": "^1.0.9",
+    "concurrently": "^3.4.0",
+    "rollup-plugin-babel": "^2.7.1",
+    "rollup-plugin-commonjs": "^8.0.2",
+    "rollup-plugin-inject": "^2.0.0",
+    "rollup-plugin-multi-entry": "^2.0.1",
+    "rollup-plugin-node-resolve": "^3.0.0",
+    "rollup-plugin-uglify": "^1.0.2",
+    "rollup-regenerator-runtime": "^6.23.1",
+    "rollup-watch": "^3.2.2",
+    "standard": "^10.0.2",
+    "tag-dist-files": "^0.1.6"
+  },
+  "dependencies": {
+    "debug": "^2.6.8"
  }
 }
--- a/rollup.dist.js
+++ b/rollup.dist.js
@@ -0,0 +1,47 @@
+import inject from 'rollup-plugin-inject'
+import babel from 'rollup-plugin-babel'
+import uglify from 'rollup-plugin-uglify'
+import nodeResolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+var pkg = require('./package.json')
+
+export default {
+  entry: 'src/y.js',
+  moduleName: 'Y',
+  format: 'umd',
+  plugins: [
+    nodeResolve({
+      main: true,
+      module: true,
+      browser: true
+    }),
+    commonjs(),
+    babel({
+      runtimeHelpers: true
+    }),
+    inject({
+      regeneratorRuntime: 'regenerator-runtime'
+    }),
+    uglify({
+      output: {
+        comments: function (node, comment) {
+          var text = comment.value
+          var type = comment.type
+          if (type === 'comment2') {
+            // multiline comment
+            return /@license/i.test(text)
+          }
+        }
+      }
+    })
+  ],
+  dest: 'y.js',
+  sourceMap: true,
+  banner: `
+/**
+ * ${pkg.name} - ${pkg.description}
+ * @version v${pkg.version}
+ * @license ${pkg.license}
+ */
+`
+}
--- a/rollup.test.js
+++ b/rollup.test.js
@@ -0,0 +1,20 @@
+import nodeResolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+import multiEntry from 'rollup-plugin-multi-entry'
+
+export default {
+  entry: 'tests/*.js',
+  moduleName: 'y-array-tests',
+  format: 'umd',
+  plugins: [
+    nodeResolve({
+      main: true,
+      module: true,
+      browser: true
+    }),
+    commonjs(),
+    multiEntry()
+  ],
+  dest: 'y-array.test.js',
+  sourceMap: true
+}
--- a/src/Connector.js
+++ b/src/Connector.js
@@ -1,328 +1,493 @@
-/* globals Y */
+/* @flow */
 'use strict'

-class AbstractConnector {
-  /*
-    opts contains the following information:
-     role : String Role of this client ("master" or "slave")
-     userId : String Uniquely defines the user.
-     debug: Boolean Whether to print debug messages (optional)
-  */
-  constructor (y, opts) {
-    this.y = y
-    if (opts == null) {
-      opts = {}
+function canRead (auth) { return auth === 'read' || auth === 'write' }
+function canWrite (auth) { return auth === 'write' }
+
+export default function extendConnector (Y/* :any */) {
+  class AbstractConnector {
+    /* ::
+    y: YConfig;
+    role: SyncRole;
+    connections: Object;
+    isSynced: boolean;
+    userEventListeners: Array<Function>;
+    whenSyncedListeners: Array<Function>;
+    currentSyncTarget: ?UserId;
+    syncingClients: Array<UserId>;
+    forwardToSyncingClients: boolean;
+    debug: boolean;
+    syncStep2: Promise;
+    userId: UserId;
+    send: Function;
+    broadcast: Function;
+    broadcastOpBuffer: Array<Operation>;
+    protocolVersion: number;
+    */
+    /*
+      opts contains the following information:
+       role : String Role of this client ("master" or "slave")
+       userId : String Uniquely defines the user.
+       debug: Boolean Whether to print debug messages (optional)
+    */
+    constructor (y, opts) {
+      this.y = y
+      if (opts == null) {
+        opts = {}
+      }
+      // Prefer to receive untransformed operations. This does only work if
+      // this client receives operations from only one other client.
+      // In particular, this does not work with y-webrtc.
+      // It will work with y-websockets-client
+      this.preferUntransformed = opts.preferUntransformed || false
+      if (opts.role == null || opts.role === 'master') {
+        this.role = 'master'
+      } else if (opts.role === 'slave') {
+        this.role = 'slave'
+      } else {
+        throw new Error("Role must be either 'master' or 'slave'!")
+      }
+      this.log = Y.debug('y:connector')
+      this.logMessage = Y.debug('y:connector-message')
+      this.y.db.forwardAppliedOperations = opts.forwardAppliedOperations || false
+      this.role = opts.role
+      this.connections = {}
+      this.isSynced = false
+      this.userEventListeners = []
+      this.whenSyncedListeners = []
+      this.currentSyncTarget = null
+      this.syncingClients = []
+      this.forwardToSyncingClients = opts.forwardToSyncingClients !== false
+      this.debug = opts.debug === true
+      this.broadcastOpBuffer = []
+      this.protocolVersion = 11
+      this.authInfo = opts.auth || null
+      this.checkAuth = opts.checkAuth || function () { return Promise.resolve('write') } // default is everyone has write access
+      if (opts.generateUserId !== false) {
+        this.setUserId(Y.utils.generateGuid())
+      }
    }
-    if (opts.role == null || opts.role === 'master') {
-      this.role = 'master'
-    } else if (opts.role === 'slave') {
-      this.role = 'slave'
-    } else {
-      throw new Error("Role must be either 'master' or 'slave'!")
+    resetAuth (auth) {
+      if (this.authInfo !== auth) {
+        this.authInfo = auth
+        this.broadcast({
+          type: 'auth',
+          auth: this.authInfo
+        })
+      }
    }
-    this.role = opts.role
-    this.connections = {}
-    this.isSynced = false
-    this.userEventListeners = []
-    this.whenSyncedListeners = []
-    this.currentSyncTarget = null
-    this.syncingClients = []
-    this.forwardToSyncingClients = opts.forwardToSyncingClients !== false
-    this.debug = opts.debug === true
-    this.broadcastedHB = false
-    this.syncStep2 = Promise.resolve()
-  }
-  reconnect () {
-  }
-  disconnect () {
-    this.connections = {}
-    this.isSynced = false
-    this.currentSyncTarget = null
-    this.broadcastedHB = false
-    this.syncingClients = []
-    this.whenSyncedListeners = []
-    return this.y.db.stopGarbageCollector()
-  }
-  setUserId (userId) {
-    this.userId = userId
-    return this.y.db.setUserId(userId)
-  }
-  onUserEvent (f) {
-    this.userEventListeners.push(f)
-  }
-  userLeft (user) {
-    delete this.connections[user]
-    if (user === this.currentSyncTarget) {
+    reconnect () {
+      this.log('reconnecting..')
+      return this.y.db.startGarbageCollector()
+    }
+    disconnect () {
+      this.log('discronnecting..')
+      this.connections = {}
+      this.isSynced = false
+      this.currentSyncTarget = null
+      this.syncingClients = []
+      this.whenSyncedListeners = []
+      this.y.db.stopGarbageCollector()
+      return this.y.db.whenTransactionsFinished()
+    }
+    repair () {
+      this.log('Repairing the state of Yjs. This can happen if messages get lost, and Yjs detects that something is wrong. If this happens often, please report an issue here: https://github.com/y-js/yjs/issues')
+      for (var name in this.connections) {
+        this.connections[name].isSynced = false
+      }
+      this.isSynced = false
      this.currentSyncTarget = null
      this.findNextSyncTarget()
    }
-    this.syncingClients = this.syncingClients.filter(function (cli) {
-      return cli !== user
-    })
-    for (var f of this.userEventListeners) {
-      f({
-        action: 'userLeft',
-        user: user
-      })
-    }
-  }
-  userJoined (user, role) {
-    if (role == null) {
-      throw new Error('You must specify the role of the joined user!')
-    }
-    if (this.connections[user] != null) {
-      throw new Error('This user already joined!')
-    }
-    this.connections[user] = {
-      isSynced: false,
-      role: role
-    }
-    for (var f of this.userEventListeners) {
-      f({
-        action: 'userJoined',
-        user: user,
-        role: role
-      })
-    }
-    if (this.currentSyncTarget == null) {
-      this.findNextSyncTarget()
-    }
-  }
-  // Execute a function _when_ we are connected.
-  // If not connected, wait until connected
-  whenSynced (f) {
-    if (this.isSynced) {
-      f()
-    } else {
-      this.whenSyncedListeners.push(f)
-    }
-  }
-  /*
-
-   returns false, if there is no sync target
-   true otherwise
-  */
-  findNextSyncTarget () {
-    if (this.currentSyncTarget != null || this.isSynced) {
-      return // "The current sync has not finished!"
-    }
-
-    var syncUser = null
-    for (var uid in this.connections) {
-      if (!this.connections[uid].isSynced) {
-        syncUser = uid
-        break
+    setUserId (userId) {
+      if (this.userId == null) {
+        this.log('Set userId to "%s"', userId)
+        this.userId = userId
+        return this.y.db.setUserId(userId)
+      } else {
+        return null
      }
    }
-    if (syncUser != null) {
-      var conn = this
-      this.currentSyncTarget = syncUser
-      this.y.db.requestTransaction(function *() {
-        conn.send(syncUser, {
-          type: 'sync step 1',
-          stateSet: yield* this.getStateSet(),
-          deleteSet: yield* this.getDeleteSet()
+    onUserEvent (f) {
+      this.userEventListeners.push(f)
+    }
+    removeUserEventListener (f) {
+      this.userEventListeners = this.userEventListeners.filter(g => f !== g)
+    }
+    userLeft (user) {
+      if (this.connections[user] != null) {
+        this.log('User left: %s', user)
+        delete this.connections[user]
+        if (user === this.currentSyncTarget) {
+          this.currentSyncTarget = null
+          this.findNextSyncTarget()
+        }
+        this.syncingClients = this.syncingClients.filter(function (cli) {
+          return cli !== user
        })
-      })
-    } else {
-      this.isSynced = true
-      // call when synced listeners
-      for (var f of this.whenSyncedListeners) {
-        f()
-      }
-      this.whenSyncedListeners = []
-      this.y.db.requestTransaction(function *() {
-        yield* this.garbageCollectAfterSync()
-      })
-    }
-  }
-  send (uid, message) {
-    if (this.debug) {
-      console.log(`send ${this.userId} -> ${uid}: ${message.type}`, m) // eslint-disable-line
-    }
-  }
-  /*
-    You received a raw message, and you know that it is intended for Yjs. Then call this function.
-  */
-  receiveMessage (sender, m) {
-    if (sender === this.userId) {
-      return
-    }
-    if (this.debug) {
-      console.log(`receive ${sender} -> ${this.userId}: ${m.type}`, JSON.parse(JSON.stringify(m))) // eslint-disable-line
-    }
-    if (m.type === 'sync step 1') {
-      // TODO: make transaction, stream the ops
-      let conn = this
-      this.y.db.requestTransaction(function *() {
-        var currentStateSet = yield* this.getStateSet()
-        yield* this.applyDeleteSet(m.deleteSet)
-
-        var ds = yield* this.getDeleteSet()
-        var ops = yield* this.getOperations(m.stateSet)
-        conn.send(sender, {
-          type: 'sync step 2',
-          os: ops,
-          stateSet: currentStateSet,
-          deleteSet: ds
-        })
-        if (this.forwardToSyncingClients) {
-          conn.syncingClients.push(sender)
-          setTimeout(function () {
-            conn.syncingClients = conn.syncingClients.filter(function (cli) {
-              return cli !== sender
-            })
-            conn.send(sender, {
-              type: 'sync done'
-            })
-          }, conn.syncingClientDuration)
-        } else {
-          conn.send(sender, {
-            type: 'sync done'
+        for (var f of this.userEventListeners) {
+          f({
+            action: 'userLeft',
+            user: user
          })
        }
-        conn._setSyncedWith(sender)
-      })
-    } else if (m.type === 'sync step 2') {
-      let conn = this
-      var broadcastHB = !this.broadcastedHB
-      this.broadcastedHB = true
-      var db = this.y.db
-      this.syncStep2 = new Promise(function (resolve) {
-        db.requestTransaction(function * () {
-          yield* this.applyDeleteSet(m.deleteSet)
-          this.store.apply(m.os)
-          db.requestTransaction(function * () {
-            var ops = yield* this.getOperations(m.stateSet)
-            if (ops.length > 0) {
-              m = {
-                type: 'update',
-                ops: ops
+      }
+    }
+    userJoined (user, role) {
+      if (role == null) {
+        throw new Error('You must specify the role of the joined user!')
+      }
+      if (this.connections[user] != null) {
+        throw new Error('This user already joined!')
+      }
+      this.log('User joined: %s', user)
+      this.connections[user] = {
+        isSynced: false,
+        role: role
+      }
+      let defer = {}
+      defer.promise = new Promise(function (resolve) { defer.resolve = resolve })
+      this.connections[user].syncStep2 = defer
+      for (var f of this.userEventListeners) {
+        f({
+          action: 'userJoined',
+          user: user,
+          role: role
+        })
+      }
+      if (this.currentSyncTarget == null) {
+        this.findNextSyncTarget()
+      }
+    }
+    // Execute a function _when_ we are connected.
+    // If not connected, wait until connected
+    whenSynced (f) {
+      if (this.isSynced) {
+        f()
+      } else {
+        this.whenSyncedListeners.push(f)
+      }
+    }
+    findNextSyncTarget () {
+      if (this.currentSyncTarget != null) {
+        return // "The current sync has not finished!"
+      }
+
+      var syncUser = null
+      for (var uid in this.connections) {
+        if (!this.connections[uid].isSynced) {
+          syncUser = uid
+          break
+        }
+      }
+      var conn = this
+      if (syncUser != null) {
+        this.currentSyncTarget = syncUser
+        this.y.db.requestTransaction(function * () {
+          var stateSet = yield * this.getStateSet()
+          // var deleteSet = yield * this.getDeleteSet()
+          var answer = {
+            type: 'sync step 1',
+            stateSet: stateSet,
+            // deleteSet: deleteSet,
+            protocolVersion: conn.protocolVersion,
+            auth: conn.authInfo
+          }
+          if (conn.preferUntransformed && Object.keys(stateSet).length === 0) {
+            answer.preferUntransformed = true
+          }
+          conn.send(syncUser, answer)
+        })
+      } else {
+        if (!conn.isSynced) {
+          this.y.db.requestTransaction(function * () {
+            if (!conn.isSynced) {
+              // it is crucial that isSynced is set at the time garbageCollectAfterSync is called
+              conn.isSynced = true
+              // It is safer to remove this!
+              // TODO: remove: yield * this.garbageCollectAfterSync()
+              // call whensynced listeners
+              for (var f of conn.whenSyncedListeners) {
+                f()
              }
-              if (!broadcastHB) { // TODO: consider to broadcast here..
-                conn.send(sender, m)
+              conn.whenSyncedListeners = []
+            }
+          })
+        }
+      }
+    }
+    send (uid, message) {
+      this.log('Send \'%s\' to %s', message.type, uid)
+      this.logMessage('Message: %j', message)
+    }
+    broadcast (message) {
+      this.log('Broadcast \'%s\'', message.type)
+      this.logMessage('Message: %j', message)
+    }
+    /*
+      Buffer operations, and broadcast them when ready.
+    */
+    broadcastOps (ops) {
+      ops = ops.map(function (op) {
+        return Y.Struct[op.struct].encode(op)
+      })
+      var self = this
+      function broadcastOperations () {
+        if (self.broadcastOpBuffer.length > 0) {
+          self.broadcast({
+            type: 'update',
+            ops: self.broadcastOpBuffer
+          })
+          self.broadcastOpBuffer = []
+        }
+      }
+      if (this.broadcastOpBuffer.length === 0) {
+        this.broadcastOpBuffer = ops
+        this.y.db.whenTransactionsFinished().then(broadcastOperations)
+      } else {
+        this.broadcastOpBuffer = this.broadcastOpBuffer.concat(ops)
+      }
+    }
+    /*
+      You received a raw message, and you know that it is intended for Yjs. Then call this function.
+    */
+    receiveMessage (sender/* :UserId */, message/* :Message */) {
+      if (sender === this.userId) {
+        return Promise.resolve()
+      }
+      this.log('Receive \'%s\' from %s', message.type, sender)
+      this.logMessage('Message: %j', message)
+      if (message.protocolVersion != null && message.protocolVersion !== this.protocolVersion) {
+        this.log(
+          `You tried to sync with a yjs instance that has a different protocol version
+          (You: ${this.protocolVersion}, Client: ${message.protocolVersion}).
+          The sync was stopped. You need to upgrade your dependencies (especially Yjs & the Connector)!
+          `)
+        this.send(sender, {
+          type: 'sync stop',
+          protocolVersion: this.protocolVersion
+        })
+        return Promise.reject(new Error('Incompatible protocol version'))
+      }
+      if (message.auth != null && this.connections[sender] != null) {
+        // authenticate using auth in message
+        var auth = this.checkAuth(message.auth, this.y)
+        this.connections[sender].auth = auth
+        auth.then(auth => {
+          for (var f of this.userEventListeners) {
+            f({
+              action: 'userAuthenticated',
+              user: sender,
+              auth: auth
+            })
+          }
+        })
+      } else if (this.connections[sender] != null && this.connections[sender].auth == null) {
+        // authenticate without otherwise
+        this.connections[sender].auth = this.checkAuth(null, this.y)
+      }
+      if (this.connections[sender] != null && this.connections[sender].auth != null) {
+        return this.connections[sender].auth.then((auth) => {
+          if (message.type === 'sync step 1' && canRead(auth)) {
+            let conn = this
+            let m = message
+            let wait // wait for sync step 2 to complete
+            if (this.role === 'slave') {
+              wait = Promise.all(Object.keys(this.connections)
+                .map(uid => this.connections[uid])
+                .filter(conn => conn.role === 'master')
+                .map(conn => conn.syncStep2.promise)
+              )
+            } else {
+              wait = Promise.resolve()
+            }
+            wait.then(() => {
+              this.y.db.requestTransaction(function * () {
+                var currentStateSet = yield * this.getStateSet()
+                // TODO: remove
+                // if (canWrite(auth)) {
+                //  yield * this.applyDeleteSet(m.deleteSet)
+                // }
+
+                var ds = yield * this.getDeleteSet()
+                var answer = {
+                  type: 'sync step 2',
+                  stateSet: currentStateSet,
+                  deleteSet: ds,
+                  protocolVersion: this.protocolVersion,
+                  auth: this.authInfo
+                }
+                if (message.preferUntransformed === true && Object.keys(m.stateSet).length === 0) {
+                  answer.osUntransformed = yield * this.getOperationsUntransformed()
+                } else {
+                  answer.os = yield * this.getOperations(m.stateSet)
+                }
+                conn.send(sender, answer)
+                if (this.forwardToSyncingClients) {
+                  conn.syncingClients.push(sender)
+                  setTimeout(function () {
+                    conn.syncingClients = conn.syncingClients.filter(function (cli) {
+                      return cli !== sender
+                    })
+                    conn.send(sender, {
+                      type: 'sync done'
+                    })
+                  }, 5000) // TODO: conn.syncingClientDuration)
+                } else {
+                  conn.send(sender, {
+                    type: 'sync done'
+                  })
+                }
+              })
+            })
+          } else if (message.type === 'sync step 2' && canWrite(auth)) {
+            var db = this.y.db
+            let defer = this.connections[sender].syncStep2
+            let m = message
+            // apply operations first
+            db.requestTransaction(function * () {
+              // yield * this.applyDeleteSet(m.deleteSet)
+              if (m.osUntransformed != null) {
+                yield * this.applyOperationsUntransformed(m.osUntransformed, m.stateSet)
              } else {
-                // broadcast only once!
-                conn.broadcast(m)
+                this.store.apply(m.os)
+              }
+              // defer.resolve()
+            })
+            // then apply ds
+            db.whenTransactionsFinished().then(() => {
+              db.requestTransaction(function * () {
+                yield * this.applyDeleteSet(m.deleteSet)
+              })
+              defer.resolve()
+            })
+            return defer.promise
+          } else if (message.type === 'sync done') {
+            var self = this
+            this.connections[sender].syncStep2.promise.then(function () {
+              self._setSyncedWith(sender)
+            })
+          } else if (message.type === 'update' && canWrite(auth)) {
+            if (this.forwardToSyncingClients) {
+              for (var client of this.syncingClients) {
+                this.send(client, message)
              }
            }
-            resolve()
-          })
+            if (this.y.db.forwardAppliedOperations) {
+              var delops = message.ops.filter(function (o) {
+                return o.struct === 'Delete'
+              })
+              if (delops.length > 0) {
+                this.broadcastOps(delops)
+              }
+            }
+            this.y.db.apply(message.ops)
+          }
        })
-      })
-    } else if (m.type === 'sync done') {
-      var self = this
-      this.syncStep2.then(function () {
-        self._setSyncedWith(sender)
-      })
-    } else if (m.type === 'update') {
-      if (this.forwardToSyncingClients) {
-        for (var client of this.syncingClients) {
-          this.send(client, m)
-        }
+      } else {
+        return Promise.reject(new Error('Unable to deliver message'))
      }
-      this.y.db.apply(m.ops)
    }
-  }
-  _setSyncedWith (user) {
-    var conn = this.connections[user]
-    if (conn != null) {
-      conn.isSynced = true
+    _setSyncedWith (user) {
+      var conn = this.connections[user]
+      if (conn != null) {
+        conn.isSynced = true
+      }
+      if (user === this.currentSyncTarget) {
+        this.currentSyncTarget = null
+        this.findNextSyncTarget()
+      }
    }
-    if (user === this.currentSyncTarget) {
-      this.currentSyncTarget = null
-      this.findNextSyncTarget()
-    }
-  }
-  /*
-    Currently, the HB encodes operations as JSON. For the moment I want to keep it
-    that way. Maybe we support encoding in the HB as XML in the future, but for now I don't want
-    too much overhead. Y is very likely to get changed a lot in the future
+    /*
+      Currently, the HB encodes operations as JSON. For the moment I want to keep it
+      that way. Maybe we support encoding in the HB as XML in the future, but for now I don't want
+      too much overhead. Y is very likely to get changed a lot in the future

-    Because we don't want to encode JSON as string (with character escaping, wich makes it pretty much unreadable)
-    we encode the JSON as XML.
+      Because we don't want to encode JSON as string (with character escaping, wich makes it pretty much unreadable)
+      we encode the JSON as XML.

-    When the HB support encoding as XML, the format should look pretty much like this.
+      When the HB support encoding as XML, the format should look pretty much like this.

-    does not support primitive values as array elements
-    expects an ltx (less than xml) object
-  */
-  parseMessageFromXml (m) {
-    function parseArray (node) {
-      for (var n of node.children) {
-        if (n.getAttribute('isArray') === 'true') {
-          return parseArray(n)
-        } else {
-          return parseObject(n)
+      does not support primitive values as array elements
+      expects an ltx (less than xml) object
+    */
+    parseMessageFromXml (m/* :any */) {
+      function parseArray (node) {
+        for (var n of node.children) {
+          if (n.getAttribute('isArray') === 'true') {
+            return parseArray(n)
+          } else {
+            return parseObject(n)
+          }
        }
      }
+      function parseObject (node/* :any */) {
+        var json = {}
+        for (var attrName in node.attrs) {
+          var value = node.attrs[attrName]
+          var int = parseInt(value, 10)
+          if (isNaN(int) || ('' + int) !== value) {
+            json[attrName] = value
+          } else {
+            json[attrName] = int
+          }
+        }
+        for (var n/* :any */ in node.children) {
+          var name = n.name
+          if (n.getAttribute('isArray') === 'true') {
+            json[name] = parseArray(n)
+          } else {
+            json[name] = parseObject(n)
+          }
+        }
+        return json
+      }
+      parseObject(m)
    }
-    function parseObject (node) {
-      var json = {}
-      for (var attrName in node.attrs) {
-        var value = node.attrs[attrName]
-        var int = parseInt(value, 10)
-        if (isNaN(int) || ('' + int) !== value) {
-          json[attrName] = value
-        } else {
-          json[attrName] = int
+    /*
+      encode message in xml
+      we use string because Strophe only accepts an "xml-string"..
+      So {a:4,b:{c:5}} will look like
+      <y a="4">
+        <b c="5"></b>
+      </y>
+      m - ltx element
+      json - Object
+    */
+    encodeMessageToXml (msg, obj) {
+      // attributes is optional
+      function encodeObject (m, json) {
+        for (var name in json) {
+          var value = json[name]
+          if (name == null) {
+            // nop
+          } else if (value.constructor === Object) {
+            encodeObject(m.c(name), value)
+          } else if (value.constructor === Array) {
+            encodeArray(m.c(name), value)
+          } else {
+            m.setAttribute(name, value)
+          }
        }
      }
-      for (var n in node.children) {
-        var name = n.name
-        if (n.getAttribute('isArray') === 'true') {
-          json[name] = parseArray(n)
-        } else {
-          json[name] = parseObject(n)
+      function encodeArray (m, array) {
+        m.setAttribute('isArray', 'true')
+        for (var e of array) {
+          if (e.constructor === Object) {
+            encodeObject(m.c('array-element'), e)
+          } else {
+            encodeArray(m.c('array-element'), e)
+          }
        }
      }
-      return json
-    }
-    parseObject(m)
-  }
-  /*
-    encode message in xml
-    we use string because Strophe only accepts an "xml-string"..
-    So {a:4,b:{c:5}} will look like
-    <y a="4">
-      <b c="5"></b>
-    </y>
-    m - ltx element
-    json - Object
-  */
-  encodeMessageToXml (msg, obj) {
-    // attributes is optional
-    function encodeObject (m, json) {
-      for (var name in json) {
-        var value = json[name]
-        if (name == null) {
-          // nop
-        } else if (value.constructor === Object) {
-          encodeObject(m.c(name), value)
-        } else if (value.constructor === Array) {
-          encodeArray(m.c(name), value)
-        } else {
-          m.setAttribute(name, value)
-        }
+      if (obj.constructor === Object) {
+        encodeObject(msg.c('y', { xmlns: 'http://y.ninja/connector-stanza' }), obj)
+      } else if (obj.constructor === Array) {
+        encodeArray(msg.c('y', { xmlns: 'http://y.ninja/connector-stanza' }), obj)
+      } else {
+        throw new Error("I can't encode this json!")
      }
    }
-    function encodeArray (m, array) {
-      m.setAttribute('isArray', 'true')
-      for (var e of array) {
-        if (e.constructor === Object) {
-          encodeObject(m.c('array-element'), e)
-        } else {
-          encodeArray(m.c('array-element'), e)
-        }
-      }
-    }
-    if (obj.constructor === Object) {
-      encodeObject(msg.c('y', { xmlns: 'http://y.ninja/connector-stanza' }), obj)
-    } else if (obj.constructor === Array) {
-      encodeArray(msg.c('y', { xmlns: 'http://y.ninja/connector-stanza' }), obj)
-    } else {
-      throw new Error("I can't encode this json!")
-    }
  }
+  Y.AbstractConnector = AbstractConnector
 }
-Y.AbstractConnector = AbstractConnector
--- a/src/Connectors/Test.js
+++ b/src/Connectors/Test.js
@@ -1,136 +1,178 @@
-/* global getRandom, Y, wait, async */
+/* global getRandom, async */
 'use strict'

-var globalRoom = {
-  users: {},
-  buffers: {},
-  removeUser: function (user) {
-    for (var i in this.users) {
-      this.users[i].userLeft(user)
-    }
-    delete this.users[user]
-    delete this.buffers[user]
-  },
-  addUser: function (connector) {
-    this.users[connector.userId] = connector
-    this.buffers[connector.userId] = []
-    for (var uname in this.users) {
-      if (uname !== connector.userId) {
-        var u = this.users[uname]
-        u.userJoined(connector.userId, 'master')
-        connector.userJoined(u.userId, 'master')
+module.exports = function (Y) {
+  var globalRoom = {
+    users: {},
+    buffers: {},
+    removeUser: function (user) {
+      for (var i in this.users) {
+        this.users[i].userLeft(user)
      }
-    }
-  }
-}
-Y.utils.globalRoom = globalRoom
-
-function flushOne () {
-  var bufs = []
-  for (var i in globalRoom.buffers) {
-    if (globalRoom.buffers[i].length > 0) {
-      bufs.push(i)
-    }
-  }
-  if (bufs.length > 0) {
-    var userId = getRandom(bufs)
-    var m = globalRoom.buffers[userId].shift()
-    var user = globalRoom.users[userId]
-    user.receiveMessage(m[0], m[1])
-    return true
-  } else {
-    return false
-  }
-}
-
-// setInterval(flushOne, 10)
-
-var userIdCounter = 0
-
-class Test extends Y.AbstractConnector {
-  constructor (y, options) {
-    if (options === undefined) {
-      throw new Error('Options must not be undefined!')
-    }
-    options.role = 'master'
-    options.forwardToSyncingClients = false
-    super(y, options)
-    this.setUserId((userIdCounter++) + '').then(() => {
-      globalRoom.addUser(this)
-    })
-    this.globalRoom = globalRoom
-    this.syncingClientDuration = 0
-  }
-  receiveMessage (sender, m) {
-    super.receiveMessage(sender, JSON.parse(JSON.stringify(m)))
-  }
-  send (userId, message) {
-    var buffer = globalRoom.buffers[userId]
-    if (buffer != null) {
-      buffer.push(JSON.parse(JSON.stringify([this.userId, message])))
-    }
-  }
-  broadcast (message) {
-    for (var key in globalRoom.buffers) {
-      globalRoom.buffers[key].push(JSON.parse(JSON.stringify([this.userId, message])))
-    }
-  }
-  isDisconnected () {
-    return globalRoom.users[this.userId] == null
-  }
-  reconnect () {
-    if (this.isDisconnected()) {
-      globalRoom.addUser(this)
-      super.reconnect()
-    }
-    return this.flushAll()
-  }
-  disconnect () {
-    if (!this.isDisconnected()) {
-      globalRoom.removeUser(this.userId)
-      super.disconnect()
-    }
-    return wait()
-  }
-  flush () {
-    var self = this
-    return async(function * () {
-      yield wait()
-      while (globalRoom.buffers[self.userId].length > 0) {
-        var m = globalRoom.buffers[self.userId].shift()
-        this.receiveMessage(m[0], m[1])
-        yield wait()
-      }
-    })
-  }
-  flushAll () {
-    return new Promise(function (resolve) {
-      // flushes may result in more created operations,
-      // flush until there is nothing more to flush
-      function nextFlush () {
-        var c = flushOne()
-        if (c) {
-          while (flushOne()) {
-            // nop
-          }
-          wait().then(nextFlush)
-        } else {
-          wait().then(function () {
-            resolve()
-          })
+      delete this.users[user]
+      delete this.buffers[user]
+    },
+    addUser: function (connector) {
+      this.users[connector.userId] = connector
+      this.buffers[connector.userId] = {}
+      for (var uname in this.users) {
+        if (uname !== connector.userId) {
+          var u = this.users[uname]
+          u.userJoined(connector.userId, 'master')
+          connector.userJoined(u.userId, 'master')
        }
      }
-      // in the case that there are
-      // still actions that want to be performed
-      wait().then(nextFlush)
-    })
+    },
+    whenTransactionsFinished: function () {
+      var self = this
+      return new Promise(function (resolve, reject) {
+        // The connector first has to send the messages to the db.
+        // Wait for the checkAuth-function to resolve
+        // The test lib only has a simple checkAuth function: `() => Promise.resolve()`
+        // Just add a function to the event-queue, in order to wait for the event.
+        // TODO: this may be buggy in test applications (but it isn't be for real-life apps)
+        setTimeout(function () {
+          var ps = []
+          for (var name in self.users) {
+            ps.push(self.users[name].y.db.whenTransactionsFinished())
+          }
+          Promise.all(ps).then(resolve, reject)
+        }, 10)
+      })
+    },
+    flushOne: function flushOne () {
+      var bufs = []
+      for (var receiver in globalRoom.buffers) {
+        let buff = globalRoom.buffers[receiver]
+        var push = false
+        for (let sender in buff) {
+          if (buff[sender].length > 0) {
+            push = true
+            break
+          }
+        }
+        if (push) {
+          bufs.push(receiver)
+        }
+      }
+      if (bufs.length > 0) {
+        var userId = getRandom(bufs)
+        let buff = globalRoom.buffers[userId]
+        let sender = getRandom(Object.keys(buff))
+        var m = buff[sender].shift()
+        if (buff[sender].length === 0) {
+          delete buff[sender]
+        }
+        var user = globalRoom.users[userId]
+        return user.receiveMessage(m[0], m[1]).then(function () {
+          return user.y.db.whenTransactionsFinished()
+        }, function () {})
+      } else {
+        return false
+      }
+    },
+    flushAll: function () {
+      return new Promise(function (resolve) {
+        // flushes may result in more created operations,
+        // flush until there is nothing more to flush
+        function nextFlush () {
+          var c = globalRoom.flushOne()
+          if (c) {
+            while (c) {
+              c = globalRoom.flushOne()
+            }
+            globalRoom.whenTransactionsFinished().then(nextFlush)
+          } else {
+            c = globalRoom.flushOne()
+            if (c) {
+              c.then(function () {
+                globalRoom.whenTransactionsFinished().then(nextFlush)
+              })
+            } else {
+              resolve()
+            }
+          }
+        }
+        globalRoom.whenTransactionsFinished().then(nextFlush)
+      })
+    }
  }
-  /*
-    Flushes an operation for some user..
-  */
-  flushOne () {
-    flushOne()
-  }
-}
+  Y.utils.globalRoom = globalRoom

-Y.Test = Test
+  var userIdCounter = 0
+
+  class Test extends Y.AbstractConnector {
+    constructor (y, options) {
+      if (options === undefined) {
+        throw new Error('Options must not be undefined!')
+      }
+      options.role = 'master'
+      options.forwardToSyncingClients = false
+      super(y, options)
+      this.setUserId((userIdCounter++) + '').then(() => {
+        globalRoom.addUser(this)
+      })
+      this.globalRoom = globalRoom
+      this.syncingClientDuration = 0
+    }
+    receiveMessage (sender, m) {
+      return super.receiveMessage(sender, JSON.parse(JSON.stringify(m)))
+    }
+    send (userId, message) {
+      var buffer = globalRoom.buffers[userId]
+      if (buffer != null) {
+        if (buffer[this.userId] == null) {
+          buffer[this.userId] = []
+        }
+        buffer[this.userId].push(JSON.parse(JSON.stringify([this.userId, message])))
+      }
+    }
+    broadcast (message) {
+      for (var key in globalRoom.buffers) {
+        var buff = globalRoom.buffers[key]
+        if (buff[this.userId] == null) {
+          buff[this.userId] = []
+        }
+        buff[this.userId].push(JSON.parse(JSON.stringify([this.userId, message])))
+      }
+    }
+    isDisconnected () {
+      return globalRoom.users[this.userId] == null
+    }
+    reconnect () {
+      if (this.isDisconnected()) {
+        globalRoom.addUser(this)
+        super.reconnect()
+      }
+      return Y.utils.globalRoom.flushAll()
+    }
+    disconnect () {
+      var waitForMe = Promise.resolve()
+      if (!this.isDisconnected()) {
+        globalRoom.removeUser(this.userId)
+        waitForMe = super.disconnect()
+      }
+      var self = this
+      return waitForMe.then(function () {
+        return self.y.db.whenTransactionsFinished()
+      })
+    }
+    flush () {
+      var self = this
+      return async(function * () {
+        var buff = globalRoom.buffers[self.userId]
+        while (Object.keys(buff).length > 0) {
+          var sender = getRandom(Object.keys(buff))
+          var m = buff[sender].shift()
+          if (buff[sender].length === 0) {
+            delete buff[sender]
+          }
+          yield this.receiveMessage(m[0], m[1])
+        }
+        yield self.whenTransactionsFinished()
+      })
+    }
+  }
+
+  Y.Test = Test
+}
--- a/src/Connectors/WebRTC.js
+++ b/src/Connectors/WebRTC.js
@@ -1,94 +0,0 @@
-/* global Y, SimpleWebRTC */
-'use strict'
-
-class WebRTC extends Y.AbstractConnector {
-  constructor (y, options) {
-    if (options === undefined) {
-      throw new Error('Options must not be undefined!')
-    }
-    if (options.room == null) {
-      throw new Error('You must define a room name!')
-    }
-    options.role = 'slave'
-    super(y, options)
-    this.webrtcOptions = {
-      url: options.url || 'https://yatta.ninja:8888',
-      room: options.room
-    }
-    var swr = new SimpleWebRTC(this.webrtcOptions)
-    this.swr = swr
-    var self = this
-    swr.once('connectionReady', function (userId) {
-      // SimpleWebRTC (swr) is initialized
-      swr.joinRoom(self.webrtcOptions.room)
-
-      swr.once('joinedRoom', function () {
-        self.setUserId(userId)
-        /*
-        var i
-        // notify the connector class about all the users that already
-        // joined the session
-        for(i in self.swr.webrtc.peers){
-          self.userJoined(self.swr.webrtc.peers[i].id, "master")
-        }*/
-        swr.on('channelMessage', function (peer, room_, message) {
-          // The client received a message
-          // Check if the connector is already initialized,
-          // only then forward the message to the connector class
-          if (message.type != null) {
-            self.receiveMessage(peer.id, message.payload)
-          }
-        })
-      })
-
-      swr.on('createdPeer', function (peer) {
-        // a new peer/client joined the session.
-        // Notify the connector class, if the connector
-        // is already initialized
-        self.userJoined(peer.id, 'master')
-      })
-
-      swr.on('peerStreamRemoved', function (peer) {
-        // a client left the session.
-        // Notify the connector class, if the connector
-        // is already initialized
-        self.userLeft(peer.id)
-      })
-    })
-  }
-  disconnect () {
-    this.swr.leaveRoom()
-    super.disconnect()
-  }
-  reconnect () {
-    this.swr.joinRoom(this.webrtcOptions.room)
-    super.reconnect()
-  }
-  send (uid, message) {
-    var self = this
-    // we have to make sure that the message is sent under all circumstances
-    var send = function () {
-      // check if the clients still exists
-      var peer = self.swr.webrtc.getPeers(uid)[0]
-      var success
-      if (peer) {
-        // success is true, if the message is successfully sent
-        success = peer.sendDirectly('simplewebrtc', 'yjs', message)
-      }
-      if (!success) {
-        // resend the message if it didn't work
-        setTimeout(send, 500)
-      }
-    }
-    // try to send the message
-    send()
-  }
-  broadcast (message) {
-    this.swr.sendDirectlyToAll('simplewebrtc', 'yjs', message)
-  }
-  isDisconnected () {
-    return false
-  }
-}
-
-Y.WebRTC = WebRTC
--- a/src/Database.js
+++ b/src/Database.js
@@ -1,341 +1,605 @@
-/* global Y */
+/* @flow */
 'use strict'

-/*
-  Partial definition of an OperationStore.
-  TODO: name it Database, operation store only holds operations.
+export default function extendDatabase (Y /* :any */) {
+  /*
+    Partial definition of an OperationStore.
+    TODO: name it Database, operation store only holds operations.

-  A database definition must alse define the following methods:
-  * logTable() (optional)
-    - show relevant information information in a table
-  * requestTransaction(makeGen)
-    - request a transaction
-  * destroy()
-    - destroy the database
-*/
-class AbstractDatabase {
-  constructor (y, opts) {
-    this.y = y
-    // E.g. this.listenersById[id] : Array<Listener>
-    this.listenersById = {}
-    // Execute the next time a transaction is requested
-    this.listenersByIdExecuteNow = []
-    // A transaction is requested
-    this.listenersByIdRequestPending = false
-    /* To make things more clear, the following naming conventions:
-       * ls : we put this.listenersById on ls
-       * l : Array<Listener>
-       * id : Id (can't use as property name)
-       * sid : String (converted from id via JSON.stringify
-                       so we can use it as a property name)
-
-      Always remember to first overwrite
-      a property before you iterate over it!
+    A database definition must alse define the following methods:
+    * logTable() (optional)
+      - show relevant information information in a table
+    * requestTransaction(makeGen)
+      - request a transaction
+    * destroy()
+      - destroy the database
+  */
+  class AbstractDatabase {
+    /* ::
+    y: YConfig;
+    forwardAppliedOperations: boolean;
+    listenersById: Object;
+    listenersByIdExecuteNow: Array<Object>;
+    listenersByIdRequestPending: boolean;
+    initializedTypes: Object;
+    whenUserIdSetListener: ?Function;
+    waitingTransactions: Array<Transaction>;
+    transactionInProgress: boolean;
+    executeOrder: Array<Object>;
+    gc1: Array<Struct>;
+    gc2: Array<Struct>;
+    gcTimeout: number;
+    gcInterval: any;
+    garbageCollect: Function;
+    executeOrder: Array<any>; // for debugging only
+    userId: UserId;
+    opClock: number;
+    transactionsFinished: ?{promise: Promise, resolve: any};
+    transact: (x: ?Generator) => any;
    */
-    // TODO: Use ES7 Weak Maps. This way types that are no longer user,
-    // wont be kept in memory.
-    this.initializedTypes = {}
-    this.whenUserIdSetListener = null
-    this.waitingTransactions = []
-    this.transactionInProgress = false
-    if (typeof YConcurrency_TestingMode !== 'undefined') {
-      this.executeOrder = []
-    }
-    this.gc1 = [] // first stage
-    this.gc2 = [] // second stage -> after that, remove the op
-    this.gcTimeout = opts.gcTimeout || 5000
-    var os = this
-    function garbageCollect () {
-      return new Promise((resolve) => {
-        os.requestTransaction(function * () {
-          if (os.y.connector != null && os.y.connector.isSynced) {
-            for (var i in os.gc2) {
-              var oid = os.gc2[i]
-              yield* this.garbageCollectOperation(oid)
+    constructor (y, opts) {
+      this.y = y
+      opts.gc = opts.gc === true
+      this.dbOpts = opts
+      var os = this
+      this.userId = null
+      var resolve_
+      this.userIdPromise = new Promise(function (resolve) {
+        resolve_ = resolve
+      })
+      this.userIdPromise.resolve = resolve_
+      // whether to broadcast all applied operations (insert & delete hook)
+      this.forwardAppliedOperations = false
+      // E.g. this.listenersById[id] : Array<Listener>
+      this.listenersById = {}
+      // Execute the next time a transaction is requested
+      this.listenersByIdExecuteNow = []
+      // A transaction is requested
+      this.listenersByIdRequestPending = false
+      /* To make things more clear, the following naming conventions:
+         * ls : we put this.listenersById on ls
+         * l : Array<Listener>
+         * id : Id (can't use as property name)
+         * sid : String (converted from id via JSON.stringify
+                         so we can use it as a property name)
+
+        Always remember to first overwrite
+        a property before you iterate over it!
+      */
+      // TODO: Use ES7 Weak Maps. This way types that are no longer user,
+      // wont be kept in memory.
+      this.initializedTypes = {}
+      this.waitingTransactions = []
+      this.transactionInProgress = false
+      this.transactionIsFlushed = false
+      if (typeof YConcurrencyTestingMode !== 'undefined') {
+        this.executeOrder = []
+      }
+      this.gc1 = [] // first stage
+      this.gc2 = [] // second stage -> after that, remove the op
+
+      function garbageCollect () {
+        return os.whenTransactionsFinished().then(function () {
+          if (os.gcTimeout > 0 && (os.gc1.length > 0 || os.gc2.length > 0)) {
+            if (!os.y.connector.isSynced) {
+              console.warn('gc should be empty when not synced!')
            }
-            os.gc2 = os.gc1
-            os.gc1 = []
+            return new Promise((resolve) => {
+              os.requestTransaction(function * () {
+                if (os.y.connector != null && os.y.connector.isSynced) {
+                  for (var i = 0; i < os.gc2.length; i++) {
+                    var oid = os.gc2[i]
+                    yield * this.garbageCollectOperation(oid)
+                  }
+                  os.gc2 = os.gc1
+                  os.gc1 = []
+                }
+                // TODO: Use setInterval here instead (when garbageCollect is called several times there will be several timeouts..)
+                if (os.gcTimeout > 0) {
+                  os.gcInterval = setTimeout(garbageCollect, os.gcTimeout)
+                }
+                resolve()
+              })
+            })
+          } else {
+            // TODO: see above
+            if (os.gcTimeout > 0) {
+              os.gcInterval = setTimeout(garbageCollect, os.gcTimeout)
+            }
+            return Promise.resolve()
          }
-          if (os.gcTimeout > 0) {
-            os.gcInterval = setTimeout(garbageCollect, os.gcTimeout)
+        })
+      }
+      this.garbageCollect = garbageCollect
+      this.startGarbageCollector()
+
+      this.repairCheckInterval = !opts.repairCheckInterval ? 6000 : opts.repairCheckInterval
+      this.opsReceivedTimestamp = new Date()
+      this.startRepairCheck()
+    }
+    startGarbageCollector () {
+      this.gc = this.dbOpts.gc
+      if (this.gc) {
+        this.gcTimeout = !this.dbOpts.gcTimeout ? 100000 : this.dbOpts.gcTimeout
+      } else {
+        this.gcTimeout = -1
+      }
+      if (this.gcTimeout > 0) {
+        this.garbageCollect()
+      }
+    }
+    startRepairCheck () {
+      var os = this
+      if (this.repairCheckInterval > 0) {
+        this.repairCheckIntervalHandler = setInterval(function repairOnMissingOperations () {
+          /*
+            Case 1. No ops have been received in a while (new Date() - os.opsReceivedTimestamp > os.repairCheckInterval)
+              - 1.1 os.listenersById is empty. Then the state was correct the whole time. -> Nothing to do (nor to update)
+              - 1.2 os.listenersById is not empty.
+                      * Then the state was incorrect for at least {os.repairCheckInterval} seconds.
+                      * -> Remove everything in os.listenersById and sync again (connector.repair())
+            Case 2. An op has been received in the last {os.repairCheckInterval } seconds.
+                    It is not yet necessary to check for faulty behavior. Everything can still resolve itself. Wait for more messages.
+                    If nothing was received for a while and os.listenersById is still not emty, we are in case 1.2
+                    -> Do nothing
+
+            Baseline here is: we really only have to catch case 1.2..
+          */
+          if (
+            new Date() - os.opsReceivedTimestamp > os.repairCheckInterval &&
+            Object.keys(os.listenersById).length > 0 // os.listenersById is not empty
+          ) {
+            // haven't received operations for over {os.repairCheckInterval} seconds, resend state vector
+            os.listenersById = {}
+            os.opsReceivedTimestamp = new Date() // update so you don't send repair several times in a row
+            os.y.connector.repair()
+          }
+        }, this.repairCheckInterval)
+      }
+    }
+    stopRepairCheck () {
+      clearInterval(this.repairCheckIntervalHandler)
+    }
+    queueGarbageCollector (id) {
+      if (this.y.connector.isSynced && this.gc) {
+        this.gc1.push(id)
+      }
+    }
+    emptyGarbageCollector () {
+      return new Promise(resolve => {
+        var check = () => {
+          if (this.gc1.length > 0 || this.gc2.length > 0) {
+            this.garbageCollect().then(check)
+          } else {
+            resolve()
+          }
+        }
+        setTimeout(check, 0)
+      })
+    }
+    addToDebug () {
+      if (typeof YConcurrencyTestingMode !== 'undefined') {
+        var command /* :string */ = Array.prototype.map.call(arguments, function (s) {
+          if (typeof s === 'string') {
+            return s
+          } else {
+            return JSON.stringify(s)
+          }
+        }).join('').replace(/"/g, "'").replace(/,/g, ', ').replace(/:/g, ': ')
+        this.executeOrder.push(command)
+      }
+    }
+    getDebugData () {
+      console.log(this.executeOrder.join('\n'))
+    }
+    stopGarbageCollector () {
+      var self = this
+      this.gc = false
+      this.gcTimeout = -1
+      return new Promise(function (resolve) {
+        self.requestTransaction(function * () {
+          var ungc /* :Array<Struct> */ = self.gc1.concat(self.gc2)
+          self.gc1 = []
+          self.gc2 = []
+          for (var i = 0; i < ungc.length; i++) {
+            var op = yield * this.getOperation(ungc[i])
+            if (op != null) {
+              delete op.gc
+              yield * this.setOperation(op)
+            }
          }
          resolve()
        })
      })
    }
-    this.garbageCollect = garbageCollect
-    if (this.gcTimeout > 0) {
-      garbageCollect()
-    }
-  }
-  addToDebug () {
-    if (typeof YConcurrency_TestingMode !== 'undefined') {
-      var command = Array.prototype.map.call(arguments, function (s) {
-        if (typeof s === 'string') {
-          return s
-        } else {
-          return JSON.stringify(s)
+    /*
+      Try to add to GC.
+
+      TODO: rename this function
+
+      Rulez:
+      * Only gc if this user is online & gc turned on
+      * The most left element in a list must not be gc'd.
+        => There is at least one element in the list
+
+      returns true iff op was added to GC
+    */
+    * addToGarbageCollector (op, left) {
+      if (
+        op.gc == null &&
+        op.deleted === true &&
+        this.store.gc &&
+        this.store.y.connector.isSynced
+      ) {
+        var gc = false
+        if (left != null && left.deleted === true) {
+          gc = true
+        } else if (op.content != null && op.content.length > 1) {
+          op = yield * this.getInsertionCleanStart([op.id[0], op.id[1] + 1])
+          gc = true
        }
-      }).join('').replace(/"/g, "'").replace(/,/g, ', ').replace(/:/g, ': ')
-      this.executeOrder.push(command)
-    }
-  }
-  getDebugData () {
-    console.log(this.executeOrder.join('\n'))
-  }
-  stopGarbageCollector () {
-    var self = this
-    return new Promise(function (resolve) {
-      self.requestTransaction(function * () {
-        var ungc = self.gc1.concat(self.gc2)
-        self.gc1 = []
-        self.gc2 = []
-        for (var i in ungc) {
-          var op = yield* this.getOperation(ungc[i])
-          delete op.gc
-          yield* this.setOperation(op)
+        if (gc) {
+          op.gc = true
+          yield * this.setOperation(op)
+          this.store.queueGarbageCollector(op.id)
+          return true
        }
-        resolve()
-      })
-    })
-  }
-  /*
-    Try to add to GC.
-
-    TODO: rename this function
-
-    Rulez:
-    * Only gc if this user is online
-    * The most left element in a list must not be gc'd.
-      => There is at least one element in the list
-
-    returns true iff op was added to GC
-  */
-  addToGarbageCollector (op, left) {
-    if (
-      op.gc == null &&
-      op.deleted === true &&
-      this.y.connector.isSynced &&
-      left != null &&
-      left.deleted === true
-    ) {
-      op.gc = true
-      this.gc1.push(op.id)
-      return true
-    } else {
+      }
      return false
    }
-  }
-  removeFromGarbageCollector (op) {
-    function filter (o) {
-      return !Y.utils.compareIds(o, op.id)
-    }
-    this.gc1 = this.gc1.filter(filter)
-    this.gc2 = this.gc2.filter(filter)
-    delete op.gc
-  }
-  destroy () {
-    clearInterval(this.gcInterval)
-    this.gcInterval = null
-  }
-  setUserId (userId) {
-    var self = this
-    return new Promise(function (resolve) {
-      self.requestTransaction(function * () {
-        self.userId = userId
-        self.opClock = (yield* this.getState(userId)).clock
-        if (self.whenUserIdSetListener != null) {
-          self.whenUserIdSetListener()
-          self.whenUserIdSetListener = null
-        }
-        resolve()
-      })
-    })
-  }
-  whenUserIdSet (f) {
-    if (this.userId != null) {
-      f()
-    } else {
-      this.whenUserIdSetListener = f
-    }
-  }
-  getNextOpId () {
-    if (this.userId == null) {
-      throw new Error('OperationStore not yet initialized!')
-    }
-    return [this.userId, this.opClock++]
-  }
-  /*
-    Apply a list of operations.
-
-    * get a transaction
-    * check whether all Struct.*.requiredOps are in the OS
-    * check if it is an expected op (otherwise wait for it)
-    * check if was deleted, apply a delete operation after op was applied
-  */
-  apply (ops) {
-    for (var key in ops) {
-      var o = ops[key]
-      var required = Y.Struct[o.struct].requiredOps(o)
-      this.whenOperationsExist(required, o)
-    }
-  }
-  /*
-    op is executed as soon as every operation requested is available.
-    Note that Transaction can (and should) buffer requests.
-  */
-  whenOperationsExist (ids, op) {
-    if (ids.length > 0) {
-      let listener = {
-        op: op,
-        missing: ids.length
+    removeFromGarbageCollector (op) {
+      function filter (o) {
+        return !Y.utils.compareIds(o, op.id)
      }
-
-      for (let key in ids) {
-        let id = ids[key]
-        let sid = JSON.stringify(id)
-        let l = this.listenersById[sid]
-        if (l == null) {
-          l = []
-          this.listenersById[sid] = l
-        }
-        l.push(listener)
-      }
-    } else {
-      this.listenersByIdExecuteNow.push({
-        op: op
-      })
+      this.gc1 = this.gc1.filter(filter)
+      this.gc2 = this.gc2.filter(filter)
+      delete op.gc
    }
-
-    if (this.listenersByIdRequestPending) {
-      return
-    }
-
-    this.listenersByIdRequestPending = true
-    var store = this
-
-    this.requestTransaction(function * () {
-      var exeNow = store.listenersByIdExecuteNow
-      store.listenersByIdExecuteNow = []
-
-      var ls = store.listenersById
-      store.listenersById = {}
-
-      store.listenersByIdRequestPending = false
-
-      for (let key in exeNow) {
-        let o = exeNow[key].op
-        yield* store.tryExecute.call(this, o)
-      }
-
-      for (var sid in ls) {
-        var l = ls[sid]
-        var id = JSON.parse(sid)
-        if ((yield* this.getOperation(id)) == null) {
-          store.listenersById[sid] = l
+    destroyTypes () {
+      for (var key in this.initializedTypes) {
+        var type = this.initializedTypes[key]
+        if (type._destroy != null) {
+          type._destroy()
        } else {
-          for (let key in l) {
-            let listener = l[key]
-            let o = listener.op
-            if (--listener.missing === 0) {
-              yield* store.tryExecute.call(this, o)
+          console.error('The type you included does not provide destroy functionality, it will remain in memory (updating your packages will help).')
+        }
+      }
+    }
+    * destroy () {
+      clearTimeout(this.gcInterval)
+      this.gcInterval = null
+      this.stopRepairCheck()
+    }
+    setUserId (userId) {
+      if (!this.userIdPromise.inProgress) {
+        this.userIdPromise.inProgress = true
+        var self = this
+        self.requestTransaction(function * () {
+          self.userId = userId
+          var state = yield * this.getState(userId)
+          self.opClock = state.clock
+          self.userIdPromise.resolve(userId)
+        })
+      }
+      return this.userIdPromise
+    }
+    whenUserIdSet (f) {
+      this.userIdPromise.then(f)
+    }
+    getNextOpId (numberOfIds) {
+      if (numberOfIds == null) {
+        throw new Error('getNextOpId expects the number of created ids to create!')
+      } else if (this.userId == null) {
+        throw new Error('OperationStore not yet initialized!')
+      } else {
+        var id = [this.userId, this.opClock]
+        this.opClock += numberOfIds
+        return id
+      }
+    }
+    /*
+      Apply a list of operations.
+
+      * we save a timestamp, because we received new operations that could resolve ops in this.listenersById (see this.startRepairCheck)
+      * get a transaction
+      * check whether all Struct.*.requiredOps are in the OS
+      * check if it is an expected op (otherwise wait for it)
+      * check if was deleted, apply a delete operation after op was applied
+    */
+    apply (ops) {
+      this.opsReceivedTimestamp = new Date()
+      for (var i = 0; i < ops.length; i++) {
+        var o = ops[i]
+        if (o.id == null || o.id[0] !== this.y.connector.userId) {
+          var required = Y.Struct[o.struct].requiredOps(o)
+          if (o.requires != null) {
+            required = required.concat(o.requires)
+          }
+          this.whenOperationsExist(required, o)
+        }
+      }
+    }
+    /*
+      op is executed as soon as every operation requested is available.
+      Note that Transaction can (and should) buffer requests.
+    */
+    whenOperationsExist (ids, op) {
+      if (ids.length > 0) {
+        let listener = {
+          op: op,
+          missing: ids.length
+        }
+
+        for (let i = 0; i < ids.length; i++) {
+          let id = ids[i]
+          let sid = JSON.stringify(id)
+          let l = this.listenersById[sid]
+          if (l == null) {
+            l = []
+            this.listenersById[sid] = l
+          }
+          l.push(listener)
+        }
+      } else {
+        this.listenersByIdExecuteNow.push({
+          op: op
+        })
+      }
+
+      if (this.listenersByIdRequestPending) {
+        return
+      }
+
+      this.listenersByIdRequestPending = true
+      var store = this
+
+      this.requestTransaction(function * () {
+        var exeNow = store.listenersByIdExecuteNow
+        store.listenersByIdExecuteNow = []
+
+        var ls = store.listenersById
+        store.listenersById = {}
+
+        store.listenersByIdRequestPending = false
+
+        for (let key = 0; key < exeNow.length; key++) {
+          let o = exeNow[key].op
+          yield * store.tryExecute.call(this, o)
+        }
+
+        for (var sid in ls) {
+          var l = ls[sid]
+          var id = JSON.parse(sid)
+          var op
+          if (typeof id[1] === 'string') {
+            op = yield * this.getOperation(id)
+          } else {
+            op = yield * this.getInsertion(id)
+          }
+          if (op == null) {
+            store.listenersById[sid] = l
+          } else {
+            for (let i = 0; i < l.length; i++) {
+              let listener = l[i]
+              let o = listener.op
+              if (--listener.missing === 0) {
+                yield * store.tryExecute.call(this, o)
+              }
+            }
+          }
+        }
+      })
+    }
+    /*
+      Actually execute an operation, when all expected operations are available.
+    */
+    /* :: // TODO: this belongs somehow to transaction
+    store: Object;
+    getOperation: any;
+    isGarbageCollected: any;
+    addOperation: any;
+    whenOperationsExist: any;
+    */
+    * tryExecute (op) {
+      this.store.addToDebug('yield * this.store.tryExecute.call(this, ', JSON.stringify(op), ')')
+      if (op.struct === 'Delete') {
+        yield * Y.Struct.Delete.execute.call(this, op)
+        // this is now called in Transaction.deleteOperation!
+        // yield * this.store.operationAdded(this, op)
+      } else {
+        // check if this op was defined
+        var defined = yield * this.getInsertion(op.id)
+        while (defined != null && defined.content != null) {
+          // check if this op has a longer content in the case it is defined
+          if (defined.id[1] + defined.content.length < op.id[1] + op.content.length) {
+            var overlapSize = defined.content.length - (op.id[1] - defined.id[1])
+            op.content.splice(0, overlapSize)
+            op.id = [op.id[0], op.id[1] + overlapSize]
+            op.left = Y.utils.getLastId(defined)
+            op.origin = op.left
+            defined = yield * this.getOperation(op.id) // getOperation suffices here
+          } else {
+            break
+          }
+        }
+        if (defined == null) {
+          var opid = op.id
+          var isGarbageCollected = yield * this.isGarbageCollected(opid)
+          if (!isGarbageCollected) {
+            // TODO: reduce number of get / put calls for op ..
+            yield * Y.Struct[op.struct].execute.call(this, op)
+            yield * this.addOperation(op)
+            yield * this.store.operationAdded(this, op)
+            // operationAdded can change op..
+            op = yield * this.getOperation(opid)
+            // if insertion, try to combine with left
+            yield * this.tryCombineWithLeft(op)
+          }
+        }
+      }
+    }
+    /*
+     * Called by a transaction when an operation is added.
+     * This function is especially important for y-indexeddb, where several instances may share a single database.
+     * Every time an operation is created by one instance, it is send to all other instances and operationAdded is called
+     *
+     * If it's not a Delete operation:
+     *   * Checks if another operation is executable (listenersById)
+     *   * Update state, if possible
+     *
+     * Always:
+     *   * Call type
+     */
+    * operationAdded (transaction, op) {
+      if (op.struct === 'Delete') {
+        var type = this.initializedTypes[JSON.stringify(op.targetParent)]
+        if (type != null) {
+          yield * type._changed(transaction, op)
+        }
+      } else {
+        // increase SS
+        yield * transaction.updateState(op.id[0])
+        var opLen = op.content != null ? op.content.length : 1
+        for (let i = 0; i < opLen; i++) {
+          // notify whenOperation listeners (by id)
+          var sid = JSON.stringify([op.id[0], op.id[1] + i])
+          var l = this.listenersById[sid]
+          delete this.listenersById[sid]
+          if (l != null) {
+            for (var key in l) {
+              var listener = l[key]
+              if (--listener.missing === 0) {
+                this.whenOperationsExist([], listener.op)
+              }
+            }
+          }
+        }
+        var t = this.initializedTypes[JSON.stringify(op.parent)]
+
+        // if parent is deleted, mark as gc'd and return
+        if (op.parent != null) {
+          var parentIsDeleted = yield * transaction.isDeleted(op.parent)
+          if (parentIsDeleted) {
+            yield * transaction.deleteList(op.id)
+            return
+          }
+        }
+
+        // notify parent, if it was instanciated as a custom type
+        if (t != null) {
+          let o = Y.utils.copyOperation(op)
+          yield * t._changed(transaction, o)
+        }
+        if (!op.deleted) {
+          // Delete if DS says this is actually deleted
+          var len = op.content != null ? op.content.length : 1
+          var startId = op.id // You must not use op.id in the following loop, because op will change when deleted
+            // TODO: !! console.log('TODO: change this before commiting')
+          for (let i = 0; i < len; i++) {
+            var id = [startId[0], startId[1] + i]
+            var opIsDeleted = yield * transaction.isDeleted(id)
+            if (opIsDeleted) {
+              var delop = {
+                struct: 'Delete',
+                target: id
+              }
+              yield * this.tryExecute.call(transaction, delop)
            }
          }
        }
      }
-    })
-  }
-  /*
-    Actually execute an operation, when all expected operations are available.
-  */
-  * tryExecute (op) {
-    this.store.addToDebug('yield* this.store.tryExecute.call(this, ', JSON.stringify(op), ')')
-    if (op.struct === 'Delete') {
-      yield* Y.Struct.Delete.execute.call(this, op)
-      yield* this.store.operationAdded(this, op)
-    } else if ((yield* this.getOperation(op.id)) == null && !(yield* this.isGarbageCollected(op.id))) {
-      yield* Y.Struct[op.struct].execute.call(this, op)
-      yield* this.addOperation(op)
-      yield* this.store.operationAdded(this, op)
    }
-  }
-  // called by a transaction when an operation is added
-  * operationAdded (transaction, op) {
-    if (op.struct === 'Delete') {
-      var target = yield* transaction.getOperation(op.target)
-      if (target != null) {
-        var type = transaction.store.initializedTypes[JSON.stringify(target.parent)]
-        if (type != null) {
-          yield* type._changed(transaction, {
-            struct: 'Delete',
-            target: op.target
+    whenTransactionsFinished () {
+      if (this.transactionInProgress) {
+        if (this.transactionsFinished == null) {
+          var resolve_
+          var promise = new Promise(function (resolve) {
+            resolve_ = resolve
          })
-        }
-      }
-    } else {
-      // increase SS
-      var o = op
-      var state = yield* transaction.getState(op.id[0])
-      while (o != null && o.id[1] === state.clock && op.id[0] === o.id[0]) {
-        // either its a new operation (1. case), or it is an operation that was deleted, but is not yet in the OS
-        state.clock++
-        yield* transaction.checkDeleteStoreForState(state)
-        o = yield* transaction.os.findNext(o.id)
-      }
-      yield* transaction.setState(state)
-
-      // notify whenOperation listeners (by id)
-      var sid = JSON.stringify(op.id)
-      var l = this.listenersById[sid]
-      delete this.listenersById[sid]
-
-      if (l != null) {
-        for (var key in l) {
-          var listener = l[key]
-          if (--listener.missing === 0) {
-            this.whenOperationsExist([], listener.op)
+          this.transactionsFinished = {
+            resolve: resolve_,
+            promise: promise
          }
        }
-      }
-      var t = this.initializedTypes[JSON.stringify(op.parent)]
-      // notify parent, if it has been initialized as a custom type
-      if (t != null) {
-        yield* t._changed(transaction, Y.utils.copyObject(op))
-      }
-
-      // Delete if DS says this is actually deleted
-      if (!op.deleted && (yield* transaction.isDeleted(op.id))) {
-        var delop = {
-          struct: 'Delete',
-          target: op.id
-        }
-        yield* Y.Struct['Delete'].execute.call(transaction, delop)
-        if (t != null) {
-          yield* t._changed(transaction, delop)
-        }
+        return this.transactionsFinished.promise
+      } else {
+        return Promise.resolve()
      }
    }
-  }
-  getNextRequest () {
-    if (this.waitingTransactions.length === 0) {
-      this.transactionInProgress = false
-      return null
-    } else {
-      return this.waitingTransactions.shift()
+    // Check if there is another transaction request.
+    // * the last transaction is always a flush :)
+    getNextRequest () {
+      if (this.waitingTransactions.length === 0) {
+        if (this.transactionIsFlushed) {
+          this.transactionInProgress = false
+          this.transactionIsFlushed = false
+          if (this.transactionsFinished != null) {
+            this.transactionsFinished.resolve()
+            this.transactionsFinished = null
+          }
+          return null
+        } else {
+          this.transactionIsFlushed = true
+          return function * () {
+            yield * this.flush()
+          }
+        }
+      } else {
+        this.transactionIsFlushed = false
+        return this.waitingTransactions.shift()
+      }
    }
-  }
-  requestTransaction (makeGen, callImmediately) {
-    if (callImmediately) {
-      this.transact(makeGen)
-    } else if (!this.transactionInProgress) {
-      this.transactionInProgress = true
-      var self = this
-      setTimeout(function () {
-        self.transact(makeGen)
-      }, 0)
-    } else {
+    requestTransaction (makeGen/* :any */, callImmediately) {
      this.waitingTransactions.push(makeGen)
+      if (!this.transactionInProgress) {
+        this.transactionInProgress = true
+        setTimeout(() => {
+          this.transact(this.getNextRequest())
+        }, 0)
+      }
+    }
+    /*
+      Get a created/initialized type.
+    */
+    getType (id) {
+      return this.initializedTypes[JSON.stringify(id)]
+    }
+    /*
+      Init type. This is called when a remote operation is retrieved, and transformed to a type
+      TODO: delete type from store.initializedTypes[id] when corresponding id was deleted!
+    */
+    * initType (id, args) {
+      var sid = JSON.stringify(id)
+      var t = this.store.initializedTypes[sid]
+      if (t == null) {
+        var op/* :MapStruct | ListStruct */ = yield * this.getOperation(id)
+        if (op != null) {
+          t = yield * Y[op.type].typeDefinition.initType.call(this, this.store, op, args)
+          this.store.initializedTypes[sid] = t
+        }
+      }
+      return t
+    }
+    /*
+     Create type. This is called when the local user creates a type (which is a synchronous action)
+    */
+    createType (typedefinition, id) {
+      var structname = typedefinition[0].struct
+      id = id || this.getNextOpId(1)
+      var op = Y.Struct[structname].create(id)
+      op.type = typedefinition[0].name
+
+      this.requestTransaction(function * () {
+        if (op.id[0] === '_') {
+          yield * this.setOperation(op)
+        } else {
+          yield * this.applyCreatedOperations([op])
+        }
+      })
+      var t = Y[op.type].typeDefinition.createType(this, op, typedefinition[1])
+      this.initializedTypes[JSON.stringify(op.id)] = t
+      return t
    }
  }
+  Y.AbstractDatabase = AbstractDatabase
 }
-Y.AbstractDatabase = AbstractDatabase
--- a/src/Database.spec.js
+++ b/src/Database.spec.js
@@ -1,5 +1,8 @@
-/* global Y, async, databases */
+/* global async, databases, describe, beforeEach, afterEach */
 /* eslint-env browser,jasmine,console */
+'use strict'
+
+var Y = require('./SpecHelper.js')

 for (let database of databases) {
  describe(`Database (${database})`, function () {
@@ -14,141 +17,141 @@ for (let database of databases) {
        })
        afterEach(function (done) {
          store.requestTransaction(function * () {
-            yield* this.store.destroy()
+            yield * this.store.destroy()
            done()
          })
        })
        it('Deleted operation is deleted', async(function * (done) {
          store.requestTransaction(function * () {
-            yield* this.markDeleted(['u1', 10])
-            expect(yield* this.isDeleted(['u1', 10])).toBeTruthy()
-            expect(yield* this.getDeleteSet()).toEqual({'u1': [[10, 1, false]]})
+            yield * this.markDeleted(['u1', 10], 1)
+            expect(yield * this.isDeleted(['u1', 10])).toBeTruthy()
+            expect(yield * this.getDeleteSet()).toEqual({'u1': [[10, 1, false]]})
            done()
          })
        }))
        it('Deleted operation extends other deleted operation', async(function * (done) {
          store.requestTransaction(function * () {
-            yield* this.markDeleted(['u1', 10])
-            yield* this.markDeleted(['u1', 11])
-            expect(yield* this.isDeleted(['u1', 10])).toBeTruthy()
-            expect(yield* this.isDeleted(['u1', 11])).toBeTruthy()
-            expect(yield* this.getDeleteSet()).toEqual({'u1': [[10, 2, false]]})
+            yield * this.markDeleted(['u1', 10], 1)
+            yield * this.markDeleted(['u1', 11], 1)
+            expect(yield * this.isDeleted(['u1', 10])).toBeTruthy()
+            expect(yield * this.isDeleted(['u1', 11])).toBeTruthy()
+            expect(yield * this.getDeleteSet()).toEqual({'u1': [[10, 2, false]]})
            done()
          })
        }))
        it('Deleted operation extends other deleted operation', async(function * (done) {
          store.requestTransaction(function * () {
-            yield* this.markDeleted(['0', 3])
-            yield* this.markDeleted(['0', 4])
-            yield* this.markDeleted(['0', 2])
-            expect(yield* this.getDeleteSet()).toEqual({'0': [[2, 3, false]]})
+            yield * this.markDeleted(['0', 3], 1)
+            yield * this.markDeleted(['0', 4], 1)
+            yield * this.markDeleted(['0', 2], 1)
+            expect(yield * this.getDeleteSet()).toEqual({'0': [[2, 3, false]]})
            done()
          })
        }))
        it('Debug #1', async(function * (done) {
          store.requestTransaction(function * () {
-            yield* this.markDeleted(['166', 0])
-            yield* this.markDeleted(['166', 2])
-            yield* this.markDeleted(['166', 0])
-            yield* this.markDeleted(['166', 2])
-            yield* this.markGarbageCollected(['166', 2])
-            yield* this.markDeleted(['166', 1])
-            yield* this.markDeleted(['166', 3])
-            yield* this.markGarbageCollected(['166', 3])
-            yield* this.markDeleted(['166', 0])
-            expect(yield* this.getDeleteSet()).toEqual({'166': [[0, 2, false], [2, 2, true]]})
+            yield * this.markDeleted(['166', 0], 1)
+            yield * this.markDeleted(['166', 2], 1)
+            yield * this.markDeleted(['166', 0], 1)
+            yield * this.markDeleted(['166', 2], 1)
+            yield * this.markGarbageCollected(['166', 2], 1)
+            yield * this.markDeleted(['166', 1], 1)
+            yield * this.markDeleted(['166', 3], 1)
+            yield * this.markGarbageCollected(['166', 3], 1)
+            yield * this.markDeleted(['166', 0], 1)
+            expect(yield * this.getDeleteSet()).toEqual({'166': [[0, 2, false], [2, 2, true]]})
            done()
          })
        }))
        it('Debug #2', async(function * (done) {
          store.requestTransaction(function * () {
-            yield* this.markDeleted(['293', 0])
-            yield* this.markDeleted(['291', 2])
-            yield* this.markDeleted(['291', 2])
-            yield* this.markGarbageCollected(['293', 0])
-            yield* this.markDeleted(['293', 1])
-            yield* this.markGarbageCollected(['291', 2])
-            expect(yield* this.getDeleteSet()).toEqual({'291': [[2, 1, true]], '293': [[0, 1, true], [1, 1, false]]})
+            yield * this.markDeleted(['293', 0], 1)
+            yield * this.markDeleted(['291', 2], 1)
+            yield * this.markDeleted(['291', 2], 1)
+            yield * this.markGarbageCollected(['293', 0], 1)
+            yield * this.markDeleted(['293', 1], 1)
+            yield * this.markGarbageCollected(['291', 2], 1)
+            expect(yield * this.getDeleteSet()).toEqual({'291': [[2, 1, true]], '293': [[0, 1, true], [1, 1, false]]})
            done()
          })
        }))
        it('Debug #3', async(function * (done) {
          store.requestTransaction(function * () {
-            yield* this.markDeleted(['581', 0])
-            yield* this.markDeleted(['581', 1])
-            yield* this.markDeleted(['580', 0])
-            yield* this.markDeleted(['580', 0])
-            yield* this.markGarbageCollected(['581', 0])
-            yield* this.markDeleted(['581', 2])
-            yield* this.markDeleted(['580', 1])
-            yield* this.markDeleted(['580', 2])
-            yield* this.markDeleted(['580', 1])
-            yield* this.markDeleted(['580', 2])
-            yield* this.markGarbageCollected(['581', 2])
-            yield* this.markGarbageCollected(['581', 1])
-            yield* this.markGarbageCollected(['580', 1])
-            expect(yield* this.getDeleteSet()).toEqual({'580': [[0, 1, false], [1, 1, true], [2, 1, false]], '581': [[0, 3, true]]})
+            yield * this.markDeleted(['581', 0], 1)
+            yield * this.markDeleted(['581', 1], 1)
+            yield * this.markDeleted(['580', 0], 1)
+            yield * this.markDeleted(['580', 0], 1)
+            yield * this.markGarbageCollected(['581', 0], 1)
+            yield * this.markDeleted(['581', 2], 1)
+            yield * this.markDeleted(['580', 1], 1)
+            yield * this.markDeleted(['580', 2], 1)
+            yield * this.markDeleted(['580', 1], 1)
+            yield * this.markDeleted(['580', 2], 1)
+            yield * this.markGarbageCollected(['581', 2], 1)
+            yield * this.markGarbageCollected(['581', 1], 1)
+            yield * this.markGarbageCollected(['580', 1], 1)
+            expect(yield * this.getDeleteSet()).toEqual({'580': [[0, 1, false], [1, 1, true], [2, 1, false]], '581': [[0, 3, true]]})
            done()
          })
        }))
        it('Debug #4', async(function * (done) {
          store.requestTransaction(function * () {
-            yield* this.markDeleted(['544', 0])
-            yield* this.markDeleted(['543', 2])
-            yield* this.markDeleted(['544', 0])
-            yield* this.markDeleted(['543', 2])
-            yield* this.markGarbageCollected(['544', 0])
-            yield* this.markDeleted(['545', 1])
-            yield* this.markDeleted(['543', 4])
-            yield* this.markDeleted(['543', 3])
-            yield* this.markDeleted(['544', 1])
-            yield* this.markDeleted(['544', 2])
-            yield* this.markDeleted(['544', 1])
-            yield* this.markDeleted(['544', 2])
-            yield* this.markGarbageCollected(['543', 2])
-            yield* this.markGarbageCollected(['543', 4])
-            yield* this.markGarbageCollected(['544', 2])
-            yield* this.markGarbageCollected(['543', 3])
-            expect(yield* this.getDeleteSet()).toEqual({'543': [[2, 3, true]], '544': [[0, 1, true], [1, 1, false], [2, 1, true]], '545': [[1, 1, false]]})
+            yield * this.markDeleted(['544', 0], 1)
+            yield * this.markDeleted(['543', 2], 1)
+            yield * this.markDeleted(['544', 0], 1)
+            yield * this.markDeleted(['543', 2], 1)
+            yield * this.markGarbageCollected(['544', 0], 1)
+            yield * this.markDeleted(['545', 1], 1)
+            yield * this.markDeleted(['543', 4], 1)
+            yield * this.markDeleted(['543', 3], 1)
+            yield * this.markDeleted(['544', 1], 1)
+            yield * this.markDeleted(['544', 2], 1)
+            yield * this.markDeleted(['544', 1], 1)
+            yield * this.markDeleted(['544', 2], 1)
+            yield * this.markGarbageCollected(['543', 2], 1)
+            yield * this.markGarbageCollected(['543', 4], 1)
+            yield * this.markGarbageCollected(['544', 2], 1)
+            yield * this.markGarbageCollected(['543', 3], 1)
+            expect(yield * this.getDeleteSet()).toEqual({'543': [[2, 3, true]], '544': [[0, 1, true], [1, 1, false], [2, 1, true]], '545': [[1, 1, false]]})
            done()
          })
        }))
        it('Debug #5', async(function * (done) {
          store.requestTransaction(function * () {
-            yield* this.applyDeleteSet({'16': [[1, 2, false]], '17': [[0, 1, true], [1, 3, false]]})
-            expect(yield* this.getDeleteSet()).toEqual({'16': [[1, 2, false]], '17': [[0, 1, true], [1, 3, false]]})
-            yield* this.applyDeleteSet({'16': [[1, 2, false]], '17': [[0, 4, true]]})
-            expect(yield* this.getDeleteSet()).toEqual({'16': [[1, 2, false]], '17': [[0, 4, true]]})
+            yield * this.applyDeleteSet({'16': [[1, 2, false]], '17': [[0, 1, true], [1, 3, false]]})
+            expect(yield * this.getDeleteSet()).toEqual({'16': [[1, 2, false]], '17': [[0, 1, true], [1, 3, false]]})
+            yield * this.applyDeleteSet({'16': [[1, 2, false]], '17': [[0, 4, true]]})
+            expect(yield * this.getDeleteSet()).toEqual({'16': [[1, 2, false]], '17': [[0, 4, true]]})
            done()
          })
        }))
        it('Debug #6', async(function * (done) {
          store.requestTransaction(function * () {
-            yield* this.applyDeleteSet({'40': [[0, 3, false]]})
-            expect(yield* this.getDeleteSet()).toEqual({'40': [[0, 3, false]]})
-            yield* this.applyDeleteSet({'39': [[2, 2, false]], '40': [[0, 1, true], [1, 2, false]], '41': [[2, 1, false]]})
-            expect(yield* this.getDeleteSet()).toEqual({'39': [[2, 2, false]], '40': [[0, 1, true], [1, 2, false]], '41': [[2, 1, false]]})
+            yield * this.applyDeleteSet({'40': [[0, 3, false]]})
+            expect(yield * this.getDeleteSet()).toEqual({'40': [[0, 3, false]]})
+            yield * this.applyDeleteSet({'39': [[2, 2, false]], '40': [[0, 1, true], [1, 2, false]], '41': [[2, 1, false]]})
+            expect(yield * this.getDeleteSet()).toEqual({'39': [[2, 2, false]], '40': [[0, 1, true], [1, 2, false]], '41': [[2, 1, false]]})
            done()
          })
        }))
        it('Debug #7', async(function * (done) {
          store.requestTransaction(function * () {
-            yield* this.markDeleted(['9', 2])
-            yield* this.markDeleted(['11', 2])
-            yield* this.markDeleted(['11', 4])
-            yield* this.markDeleted(['11', 1])
-            yield* this.markDeleted(['9', 4])
-            yield* this.markDeleted(['10', 0])
-            yield* this.markGarbageCollected(['11', 2])
-            yield* this.markDeleted(['11', 2])
-            yield* this.markGarbageCollected(['11', 3])
-            yield* this.markDeleted(['11', 3])
-            yield* this.markDeleted(['11', 3])
-            yield* this.markDeleted(['9', 4])
-            yield* this.markDeleted(['10', 0])
-            yield* this.markGarbageCollected(['11', 1])
-            yield* this.markDeleted(['11', 1])
-            expect(yield* this.getDeleteSet()).toEqual({'9': [[2, 1, false], [4, 1, false]], '10': [[0, 1, false]], '11': [[1, 3, true], [4, 1, false]]})
+            yield * this.markDeleted(['9', 2], 1)
+            yield * this.markDeleted(['11', 2], 1)
+            yield * this.markDeleted(['11', 4], 1)
+            yield * this.markDeleted(['11', 1], 1)
+            yield * this.markDeleted(['9', 4], 1)
+            yield * this.markDeleted(['10', 0], 1)
+            yield * this.markGarbageCollected(['11', 2], 1)
+            yield * this.markDeleted(['11', 2], 1)
+            yield * this.markGarbageCollected(['11', 3], 1)
+            yield * this.markDeleted(['11', 3], 1)
+            yield * this.markDeleted(['11', 3], 1)
+            yield * this.markDeleted(['9', 4], 1)
+            yield * this.markDeleted(['10', 0], 1)
+            yield * this.markGarbageCollected(['11', 1], 1)
+            yield * this.markDeleted(['11', 1], 1)
+            expect(yield * this.getDeleteSet()).toEqual({'9': [[2, 1, false], [4, 1, false]], '10': [[0, 1, false]], '11': [[1, 3, true], [4, 1, false]]})
            done()
          })
        }))
@@ -164,54 +167,54 @@ for (let database of databases) {
        })
        afterEach(function (done) {
          store.requestTransaction(function * () {
-            yield* this.store.destroy()
+            yield * this.store.destroy()
            done()
          })
        })
        it('debug #1', function (done) {
          store.requestTransaction(function * () {
-            yield* this.os.put({id: [2]})
-            yield* this.os.put({id: [0]})
-            yield* this.os.delete([2])
-            yield* this.os.put({id: [1]})
-            expect(yield* this.os.find([0])).toBeTruthy()
-            expect(yield* this.os.find([1])).toBeTruthy()
-            expect(yield* this.os.find([2])).toBeFalsy()
+            yield * this.os.put({id: [2]})
+            yield * this.os.put({id: [0]})
+            yield * this.os.delete([2])
+            yield * this.os.put({id: [1]})
+            expect(yield * this.os.find([0])).toBeTruthy()
+            expect(yield * this.os.find([1])).toBeTruthy()
+            expect(yield * this.os.find([2])).toBeFalsy()
            done()
          })
        })
        it('can add&retrieve 5 elements', function (done) {
          store.requestTransaction(function * () {
-            yield* this.os.put({val: 'four', id: [4]})
-            yield* this.os.put({val: 'one', id: [1]})
-            yield* this.os.put({val: 'three', id: [3]})
-            yield* this.os.put({val: 'two', id: [2]})
-            yield* this.os.put({val: 'five', id: [5]})
-            expect((yield* this.os.find([1])).val).toEqual('one')
-            expect((yield* this.os.find([2])).val).toEqual('two')
-            expect((yield* this.os.find([3])).val).toEqual('three')
-            expect((yield* this.os.find([4])).val).toEqual('four')
-            expect((yield* this.os.find([5])).val).toEqual('five')
+            yield * this.os.put({val: 'four', id: [4]})
+            yield * this.os.put({val: 'one', id: [1]})
+            yield * this.os.put({val: 'three', id: [3]})
+            yield * this.os.put({val: 'two', id: [2]})
+            yield * this.os.put({val: 'five', id: [5]})
+            expect((yield * this.os.find([1])).val).toEqual('one')
+            expect((yield * this.os.find([2])).val).toEqual('two')
+            expect((yield * this.os.find([3])).val).toEqual('three')
+            expect((yield * this.os.find([4])).val).toEqual('four')
+            expect((yield * this.os.find([5])).val).toEqual('five')
            done()
          })
        })
        it('5 elements do not exist anymore after deleting them', function (done) {
          store.requestTransaction(function * () {
-            yield* this.os.put({val: 'four', id: [4]})
-            yield* this.os.put({val: 'one', id: [1]})
-            yield* this.os.put({val: 'three', id: [3]})
-            yield* this.os.put({val: 'two', id: [2]})
-            yield* this.os.put({val: 'five', id: [5]})
-            yield* this.os.delete([4])
-            expect(yield* this.os.find([4])).not.toBeTruthy()
-            yield* this.os.delete([3])
-            expect(yield* this.os.find([3])).not.toBeTruthy()
-            yield* this.os.delete([2])
-            expect(yield* this.os.find([2])).not.toBeTruthy()
-            yield* this.os.delete([1])
-            expect(yield* this.os.find([1])).not.toBeTruthy()
-            yield* this.os.delete([5])
-            expect(yield* this.os.find([5])).not.toBeTruthy()
+            yield * this.os.put({val: 'four', id: [4]})
+            yield * this.os.put({val: 'one', id: [1]})
+            yield * this.os.put({val: 'three', id: [3]})
+            yield * this.os.put({val: 'two', id: [2]})
+            yield * this.os.put({val: 'five', id: [5]})
+            yield * this.os.delete([4])
+            expect(yield * this.os.find([4])).not.toBeTruthy()
+            yield * this.os.delete([3])
+            expect(yield * this.os.find([3])).not.toBeTruthy()
+            yield * this.os.delete([2])
+            expect(yield * this.os.find([2])).not.toBeTruthy()
+            yield * this.os.delete([1])
+            expect(yield * this.os.find([1])).not.toBeTruthy()
+            yield * this.os.delete([5])
+            expect(yield * this.os.find([5])).not.toBeTruthy()
            done()
          })
        })
@@ -229,9 +232,9 @@ for (let database of databases) {
              var r = Math.random()
              if (r < 0.8) {
                var obj = [Math.floor(Math.random() * numberOfOSTests * 10000)]
-                if (!(yield* this.os.find(obj))) {
+                if (!(yield * this.os.find(obj))) {
                  elements.push(obj)
-                  yield* this.os.put({id: obj})
+                  yield * this.os.put({id: obj})
                }
              } else if (elements.length > 0) {
                var elemid = Math.floor(Math.random() * elements.length)
@@ -239,7 +242,7 @@ for (let database of databases) {
                elements = elements.filter(function (e) {
                  return !Y.utils.compareIds(e, elem)
                })
-                yield* this.os.delete(elem)
+                yield * this.os.delete(elem)
              }
            }
            done()
@@ -247,14 +250,14 @@ for (let database of databases) {
        })
        afterAll(function (done) {
          store.requestTransaction(function * () {
-            yield* this.store.destroy()
+            yield * this.store.destroy()
            done()
          })
        })
        it('can find every object', function (done) {
          store.requestTransaction(function * () {
            for (var id of elements) {
-              expect((yield* this.os.find(id)).id).toEqual(id)
+              expect((yield * this.os.find(id)).id).toEqual(id)
            }
            done()
          })
@@ -263,7 +266,7 @@ for (let database of databases) {
        it('can find every object with lower bound search', function (done) {
          store.requestTransaction(function * () {
            for (var id of elements) {
-              var e = yield* this.os.findWithLowerBound(id)
+              var e = yield * this.os.findWithLowerBound(id)
              expect(e.id).toEqual(id)
            }
            done()
@@ -278,7 +281,7 @@ for (let database of databases) {

          var actualResults = 0
          store.requestTransaction(function * () {
-            yield* this.os.iterate(this, lowerBound, null, function * (val) {
+            yield * this.os.iterate(this, lowerBound, null, function * (val) {
              expect(val).toBeDefined()
              actualResults++
            })
@@ -294,7 +297,7 @@ for (let database of databases) {
          }).length
          var actualResults = 0
          store.requestTransaction(function * () {
-            yield* this.os.iterate(this, lowerBound, null, function * (val) {
+            yield * this.os.iterate(this, lowerBound, null, function * (val) {
              expect(val).toBeDefined()
              actualResults++
            })
@@ -311,7 +314,7 @@ for (let database of databases) {

          var actualResults = 0
          store.requestTransaction(function * () {
-            yield* this.os.iterate(this, null, upperBound, function * (val) {
+            yield * this.os.iterate(this, null, upperBound, function * (val) {
              expect(val).toBeDefined()
              actualResults++
            })
@@ -337,7 +340,7 @@ for (let database of databases) {
          }).length
          var actualResults = 0
          store.requestTransaction(function * () {
-            yield* this.os.iterate(this, lowerBound, upperBound, function * (val) {
+            yield * this.os.iterate(this, lowerBound, upperBound, function * (val) {
              expect(val).toBeDefined()
              actualResults++
            })
--- a/src/Databases/IndexedDB.js
+++ b/src/Databases/IndexedDB.js
@@ -1,181 +0,0 @@
-/* global Y */
-
-'use strict'
-
-Y.IndexedDB = (function () {
-  class Store {
-    constructor (transaction, name) {
-      this.store = transaction.objectStore(name)
-    }
-    * find (id) {
-      return yield this.store.get(id)
-    }
-    * put (v) {
-      yield this.store.put(v)
-    }
-    * delete (id) {
-      yield this.store.delete(id)
-    }
-    * findWithLowerBound (start) {
-      return yield this.store.openCursor(window.IDBKeyRange.lowerBound(start))
-    }
-    * findWithUpperBound (end) {
-      return yield this.store.openCursor(window.IDBKeyRange.upperBound(end), 'prev')
-    }
-    * findNext (id) {
-      return yield* this.findWithLowerBound([id[0], id[1] + 1])
-    }
-    * findPrev (id) {
-      return yield* this.findWithUpperBound([id[0], id[1] - 1])
-    }
-    * iterate (t, start, end, gen) {
-      var range = null
-      if (start != null && end != null) {
-        range = window.IDBKeyRange.bound(start, end)
-      } else if (start != null) {
-        range = window.IDBKeyRange.lowerBound(start)
-      } else if (end != null) {
-        range = window.IDBKeyRange.upperBound(end)
-      }
-      var cursorResult = this.store.openCursor(range)
-      while ((yield cursorResult) != null) {
-        yield* gen.call(t, cursorResult.result.value)
-        cursorResult.result.continue()
-      }
-    }
-
-  }
-  class Transaction extends Y.Transaction {
-    constructor (store) {
-      super(store)
-      var transaction = store.db.transaction(['OperationStore', 'StateStore', 'DeleteStore'], 'readwrite')
-      this.store = store
-      this.ss = new Store(transaction, 'StateStore')
-      this.os = new Store(transaction, 'OperationStore')
-      this.ds = new Store(transaction, 'DeleteStore')
-    }
-  }
-  class OperationStore extends Y.AbstractDatabase {
-    constructor (y, opts) {
-      super(y, opts)
-      if (opts == null) {
-        opts = {}
-      }
-      if (opts.namespace == null || typeof opts.namespace !== 'string') {
-        throw new Error('IndexedDB: expect a string (opts.namespace)!')
-      } else {
-        this.namespace = opts.namespace
-      }
-      if (opts.idbVersion != null) {
-        this.idbVersion = opts.idbVersion
-      } else {
-        this.idbVersion = 5
-      }
-      var store = this
-      // initialize database!
-      this.requestTransaction(function * () {
-        store.db = yield window.indexedDB.open(opts.namespace, store.idbVersion)
-      })
-      if (opts.cleanStart) {
-        this.requestTransaction(function * () {
-          yield this.os.store.clear()
-          yield this.ds.store.clear()
-          yield this.ss.store.clear()
-        })
-      }
-      var operationsToAdd = []
-      window.addEventListener('storage', function (event) {
-        if (event.key === '__YJS__' + store.namespace) {
-          operationsToAdd.push(event.newValue)
-          if (operationsToAdd.length === 1) {
-            store.requestTransaction(function * () {
-              var add = operationsToAdd
-              operationsToAdd = []
-              for (var i in add) {
-                // don't call the localStorage event twice..
-                var op = JSON.parse(add[i])
-                if (op.struct !== 'Delete') {
-                  op = yield* this.getOperation(op.id)
-                }
-                yield* this.store.operationAdded(this, op, true)
-              }
-            })
-          }
-        }
-      }, false)
-    }
-    * operationAdded (transaction, op, noAdd) {
-      yield* super.operationAdded(transaction, op)
-      if (!noAdd) {
-        window.localStorage['__YJS__' + this.namespace] = JSON.stringify(op)
-      }
-    }
-    transact (makeGen) {
-      var transaction = this.db != null ? new Transaction(this) : null
-      var store = this
-
-      var gen = makeGen.call(transaction)
-      handleTransactions(gen.next())
-
-      function handleTransactions (result) {
-        var request = result.value
-        if (result.done) {
-          makeGen = store.getNextRequest()
-          if (makeGen != null) {
-            if (transaction == null && store.db != null) {
-              transaction = new Transaction(store)
-            }
-            gen = makeGen.call(transaction)
-            handleTransactions(gen.next())
-          } // else no transaction in progress!
-          return
-        }
-        if (request.constructor === window.IDBRequest) {
-          request.onsuccess = function () {
-            var res = request.result
-            if (res != null && res.constructor === window.IDBCursorWithValue) {
-              res = res.value
-            }
-            handleTransactions(gen.next(res))
-          }
-          request.onerror = function (err) {
-            gen.throw(err)
-          }
-        } else if (request.constructor === window.IDBCursor) {
-          request.onsuccess = function () {
-            handleTransactions(gen.next(request.result != null ? request.result.value : null))
-          }
-          request.onerror = function (err) {
-            gen.throw(err)
-          }
-        } else if (request.constructor === window.IDBOpenDBRequest) {
-          request.onsuccess = function (event) {
-            var db = event.target.result
-            handleTransactions(gen.next(db))
-          }
-          request.onerror = function () {
-            gen.throw("Couldn't open IndexedDB database!")
-          }
-          request.onupgradeneeded = function (event) {
-            var db = event.target.result
-            try {
-              db.createObjectStore('OperationStore', {keyPath: 'id'})
-              db.createObjectStore('DeleteStore', {keyPath: 'id'})
-              db.createObjectStore('StateStore', {keyPath: 'id'})
-            } catch (e) {
-              console.log('Store already exists!')
-            }
-          }
-        } else {
-          gen.throw('You must not yield this type!')
-        }
-      }
-    }
-    // TODO: implement "free"..
-    * destroy () {
-      this.db.close()
-      yield window.indexedDB.deleteDatabase(this.namespace)
-    }
-  }
-  return OperationStore
-})()
--- a/src/Databases/IndexedDB.spec.js
+++ b/src/Databases/IndexedDB.spec.js
@@ -1,19 +0,0 @@
-/* global Y */
-/* eslint-env browser,jasmine */
-
-if (typeof window !== 'undefined' && false) {
-  describe('IndexedDB', function () {
-    var ob
-    beforeAll(function () {
-      ob = new Y.IndexedDB(null, {namespace: 'Test', gcTimeout: -1})
-    })
-
-    afterAll(function (done) {
-      ob.requestTransaction(function *() {
-        yield* ob.removeDatabase()
-        ob = null
-        done()
-      })
-    })
-  })
-}
--- a/src/Databases/Memory.js
+++ b/src/Databases/Memory.js
@@ -1,63 +0,0 @@
-/* global Y */
-'use strict'
-
-Y.Memory = (function () {
-  class Transaction extends Y.Transaction {
-    constructor (store) {
-      super(store)
-      this.store = store
-      this.ss = store.ss
-      this.os = store.os
-      this.ds = store.ds
-    }
-  }
-  class Database extends Y.AbstractDatabase {
-    constructor (y, opts) {
-      super(y, opts)
-      this.os = new Y.utils.RBTree()
-      this.ds = new Y.utils.RBTree()
-      this.ss = new Y.utils.RBTree()
-    }
-    logTable () {
-      var self = this
-      self.requestTransaction(function * () {
-        console.log('User: ', this.store.y.connector.userId, "==============================") // eslint-disable-line
-        console.log("State Set (SS):", yield* this.getStateSet()) // eslint-disable-line
-        console.log("Operation Store (OS):") // eslint-disable-line
-        yield* this.os.logTable() // eslint-disable-line
-        console.log("Deletion Store (DS):") //eslint-disable-line
-        yield* this.ds.logTable() // eslint-disable-line
-        if (this.store.gc1.length > 0 || this.store.gc2.length > 0) {
-          console.warn('GC1|2 not empty!', this.store.gc1, this.store.gc2)
-        }
-        if (JSON.stringify(this.store.listenersById) !== '{}') {
-          console.warn('listenersById not empty!')
-        }
-        if (JSON.stringify(this.store.listenersByIdExecuteNow) !== '[]') {
-          console.warn('listenersByIdExecuteNow not empty!')
-        }
-        if (this.store.transactionInProgress) {
-          console.warn('Transaction still in progress!')
-        }
-      }, true)
-    }
-    transact (makeGen) {
-      var t = new Transaction(this)
-      while (makeGen !== null) {
-        var gen = makeGen.call(t)
-        var res = gen.next()
-        while (!res.done) {
-          res = gen.next(res.value)
-        }
-        makeGen = this.getNextRequest()
-      }
-    }
-    * destroy () {
-      super.destroy()
-      delete this.os
-      delete this.ss
-      delete this.ds
-    }
-  }
-  return Database
-})()
--- a/src/Databases/RedBlackTree.js
+++ b/src/Databases/RedBlackTree.js
@@ -1,489 +0,0 @@
-/* global Y */
-'use strict'
-
-/*
-  This file contains a not so fancy implemantion of a Red Black Tree.
-*/
-
-class N {
-  // A created node is always red!
-  constructor (val) {
-    this.val = val
-    this.color = true
-    this._left = null
-    this._right = null
-    this._parent = null
-    if (val.id === null) {
-      throw new Error('You must define id!')
-    }
-  }
-  isRed () { return this.color }
-  isBlack () { return !this.color }
-  redden () { this.color = true; return this }
-  blacken () { this.color = false; return this }
-  get grandparent () {
-    return this.parent.parent
-  }
-  get parent () {
-    return this._parent
-  }
-  get sibling () {
-    return (this === this.parent.left)
-      ? this.parent.right : this.parent.left
-  }
-  get left () {
-    return this._left
-  }
-  get right () {
-    return this._right
-  }
-  set left (n) {
-    if (n !== null) {
-      n._parent = this
-    }
-    this._left = n
-  }
-  set right (n) {
-    if (n !== null) {
-      n._parent = this
-    }
-    this._right = n
-  }
-  rotateLeft (tree) {
-    var parent = this.parent
-    var newParent = this.right
-    var newRight = this.right.left
-    newParent.left = this
-    this.right = newRight
-    if (parent === null) {
-      tree.root = newParent
-      newParent._parent = null
-    } else if (parent.left === this) {
-      parent.left = newParent
-    } else if (parent.right === this) {
-      parent.right = newParent
-    } else {
-      throw new Error('The elements are wrongly connected!')
-    }
-  }
-  next () {
-    if (this.right !== null) {
-      // search the most left node in the right tree
-      var o = this.right
-      while (o.left !== null) {
-        o = o.left
-      }
-      return o
-    } else {
-      var p = this
-      while (p.parent !== null && p !== p.parent.left) {
-        p = p.parent
-      }
-      return p.parent
-    }
-  }
-  prev () {
-    if (this.left !== null) {
-      // search the most right node in the left tree
-      var o = this.left
-      while (o.right !== null) {
-        o = o.right
-      }
-      return o
-    } else {
-      var p = this
-      while (p.parent !== null && p !== p.parent.right) {
-        p = p.parent
-      }
-      return p.parent
-    }
-  }
-  rotateRight (tree) {
-    var parent = this.parent
-    var newParent = this.left
-    var newLeft = this.left.right
-    newParent.right = this
-    this.left = newLeft
-    if (parent === null) {
-      tree.root = newParent
-      newParent._parent = null
-    } else if (parent.left === this) {
-      parent.left = newParent
-    } else if (parent.right === this) {
-      parent.right = newParent
-    } else {
-      throw new Error('The elements are wrongly connected!')
-    }
-  }
-  getUncle () {
-    // we can assume that grandparent exists when this is called!
-    if (this.parent === this.parent.parent.left) {
-      return this.parent.parent.right
-    } else {
-      return this.parent.parent.left
-    }
-  }
-}
-
-class RBTree {
-  constructor () {
-    this.root = null
-    this.length = 0
-  }
-  * findNext (id) {
-    return yield* this.findWithLowerBound([id[0], id[1] + 1])
-  }
-  * findPrev (id) {
-    return yield* this.findWithUpperBound([id[0], id[1] - 1])
-  }
-  findNodeWithLowerBound (from) {
-    if (from === void 0) {
-      throw new Error('You must define from!')
-    }
-    var o = this.root
-    if (o === null) {
-      return null
-    } else {
-      while (true) {
-        if ((from === null || Y.utils.smaller(from, o.val.id)) && o.left !== null) {
-          // o is included in the bound
-          // try to find an element that is closer to the bound
-          o = o.left
-        } else if (from !== null && Y.utils.smaller(o.val.id, from)) {
-          // o is not within the bound, maybe one of the right elements is..
-          if (o.right !== null) {
-            o = o.right
-          } else {
-            // there is no right element. Search for the next bigger element,
-            // this should be within the bounds
-            return o.next()
-          }
-        } else {
-          return o
-        }
-      }
-    }
-  }
-  findNodeWithUpperBound (to) {
-    if (to === void 0) {
-      throw new Error('You must define from!')
-    }
-    var o = this.root
-    if (o === null) {
-      return null
-    } else {
-      while (true) {
-        if ((to === null || Y.utils.smaller(o.val.id, to)) && o.right !== null) {
-          // o is included in the bound
-          // try to find an element that is closer to the bound
-          o = o.right
-        } else if (to !== null && Y.utils.smaller(to, o.val.id)) {
-          // o is not within the bound, maybe one of the left elements is..
-          if (o.left !== null) {
-            o = o.left
-          } else {
-            // there is no left element. Search for the prev smaller element,
-            // this should be within the bounds
-            return o.prev()
-          }
-        } else {
-          return o
-        }
-      }
-    }
-  }
-  * findWithLowerBound (from) {
-    var n = this.findNodeWithLowerBound(from)
-    return n == null ? null : n.val
-  }
-  * findWithUpperBound (to) {
-    var n = this.findNodeWithUpperBound(to)
-    return n == null ? null : n.val
-  }
-  * iterate (t, from, to, f) {
-    var o = this.findNodeWithLowerBound(from)
-    while (o !== null && (to === null || Y.utils.smaller(o.val.id, to) || Y.utils.compareIds(o.val.id, to))) {
-      yield* f.call(t, o.val)
-      o = o.next()
-    }
-    return true
-  }
-  * logTable (from, to, filter) {
-    if (filter == null) {
-      filter = function () {
-        return true
-      }
-    }
-    if (from == null) { from = null }
-    if (to == null) { to = null }
-    var os = []
-    yield* this.iterate(this, from, to, function * (o) {
-      if (filter(o)) {
-        var o_ = {}
-        for (var key in o) {
-          if (typeof o[key] === 'object') {
-            o_[key] = JSON.stringify(o[key])
-          } else {
-            o_[key] = o[key]
-          }
-        }
-        os.push(o_)
-      }
-    })
-    if (console.table != null) {
-      console.table(os)
-    }
-  }
-  * find (id) {
-    var n
-    return (n = this.findNode(id)) ? n.val : null
-  }
-  findNode (id) {
-    if (id == null || id.constructor !== Array) {
-      throw new Error('Expect id to be an array!')
-    }
-    var o = this.root
-    if (o === null) {
-      return false
-    } else {
-      while (true) {
-        if (o === null) {
-          return false
-        }
-        if (Y.utils.smaller(id, o.val.id)) {
-          o = o.left
-        } else if (Y.utils.smaller(o.val.id, id)) {
-          o = o.right
-        } else {
-          return o
-        }
-      }
-    }
-  }
-  * delete (id) {
-    if (id == null || id.constructor !== Array) {
-      throw new Error('id is expected to be an Array!')
-    }
-    var d = this.findNode(id)
-    if (d == null) {
-      throw new Error('Element does not exist!')
-    }
-    this.length--
-    if (d.left !== null && d.right !== null) {
-      // switch d with the greates element in the left subtree.
-      // o should have at most one child.
-      var o = d.left
-      // find
-      while (o.right !== null) {
-        o = o.right
-      }
-      // switch
-      d.val = o.val
-      d = o
-    }
-    // d has at most one child
-    // let n be the node that replaces d
-    var isFakeChild
-    var child = d.left || d.right
-    if (child === null) {
-      isFakeChild = true
-      child = new N({id: 0})
-      child.blacken()
-      d.right = child
-    } else {
-      isFakeChild = false
-    }
-
-    if (d.parent === null) {
-      if (!isFakeChild) {
-        this.root = child
-        child.blacken()
-        child._parent = null
-      } else {
-        this.root = null
-      }
-      return
-    } else if (d.parent.left === d) {
-      d.parent.left = child
-    } else if (d.parent.right === d) {
-      d.parent.right = child
-    } else {
-      throw new Error('Impossible!')
-    }
-    if (d.isBlack()) {
-      if (child.isRed()) {
-        child.blacken()
-      } else {
-        this._fixDelete(child)
-      }
-    }
-    this.root.blacken()
-    if (isFakeChild) {
-      if (child.parent.left === child) {
-        child.parent.left = null
-      } else if (child.parent.right === child) {
-        child.parent.right = null
-      } else {
-        throw new Error('Impossible #3')
-      }
-    }
-  }
-  _fixDelete (n) {
-    function isBlack (node) {
-      return node !== null ? node.isBlack() : true
-    }
-    function isRed (node) {
-      return node !== null ? node.isRed() : false
-    }
-    if (n.parent === null) {
-      // this can only be called after the first iteration of fixDelete.
-      return
-    }
-    // d was already replaced by the child
-    // d is not the root
-    // d and child are black
-    var sibling = n.sibling
-    if (isRed(sibling)) {
-      // make sibling the grandfather
-      n.parent.redden()
-      sibling.blacken()
-      if (n === n.parent.left) {
-        n.parent.rotateLeft(this)
-      } else if (n === n.parent.right) {
-        n.parent.rotateRight(this)
-      } else {
-        throw new Error('Impossible #2')
-      }
-      sibling = n.sibling
-    }
-    // parent, sibling, and children of n are black
-    if (n.parent.isBlack() &&
-      sibling.isBlack() &&
-      isBlack(sibling.left) &&
-      isBlack(sibling.right)
-    ) {
-      sibling.redden()
-      this._fixDelete(n.parent)
-    } else if (n.parent.isRed() &&
-      sibling.isBlack() &&
-      isBlack(sibling.left) &&
-      isBlack(sibling.right)
-    ) {
-      sibling.redden()
-      n.parent.blacken()
-    } else {
-      if (n === n.parent.left &&
-        sibling.isBlack() &&
-        isRed(sibling.left) &&
-        isBlack(sibling.right)
-      ) {
-        sibling.redden()
-        sibling.left.blacken()
-        sibling.rotateRight(this)
-        sibling = n.sibling
-      } else if (n === n.parent.right &&
-        sibling.isBlack() &&
-        isRed(sibling.right) &&
-        isBlack(sibling.left)
-      ) {
-        sibling.redden()
-        sibling.right.blacken()
-        sibling.rotateLeft(this)
-        sibling = n.sibling
-      }
-      sibling.color = n.parent.color
-      n.parent.blacken()
-      if (n === n.parent.left) {
-        sibling.right.blacken()
-        n.parent.rotateLeft(this)
-      } else {
-        sibling.left.blacken()
-        n.parent.rotateRight(this)
-      }
-    }
-  }
-  * put (v) {
-    if (v == null || v.id == null || v.id.constructor !== Array) {
-      throw new Error('v is expected to have an id property which is an Array!')
-    }
-    var node = new N(v)
-    if (this.root !== null) {
-      var p = this.root // p abbrev. parent
-      while (true) {
-        if (Y.utils.smaller(node.val.id, p.val.id)) {
-          if (p.left === null) {
-            p.left = node
-            break
-          } else {
-            p = p.left
-          }
-        } else if (Y.utils.smaller(p.val.id, node.val.id)) {
-          if (p.right === null) {
-            p.right = node
-            break
-          } else {
-            p = p.right
-          }
-        } else {
-          p.val = node.val
-          return p
-        }
-      }
-      this._fixInsert(node)
-    } else {
-      this.root = node
-    }
-    this.length++
-    this.root.blacken()
-    return node
-  }
-  _fixInsert (n) {
-    if (n.parent === null) {
-      n.blacken()
-      return
-    } else if (n.parent.isBlack()) {
-      return
-    }
-    var uncle = n.getUncle()
-    if (uncle !== null && uncle.isRed()) {
-      // Note: parent: red, uncle: red
-      n.parent.blacken()
-      uncle.blacken()
-      n.grandparent.redden()
-      this._fixInsert(n.grandparent)
-    } else {
-      // Note: parent: red, uncle: black or null
-      // Now we transform the tree in such a way that
-      // either of these holds:
-      //   1) grandparent.left.isRed
-      //     and grandparent.left.left.isRed
-      //   2) grandparent.right.isRed
-      //     and grandparent.right.right.isRed
-      if (n === n.parent.right && n.parent === n.grandparent.left) {
-        n.parent.rotateLeft(this)
-        // Since we rotated and want to use the previous
-        // cases, we need to set n in such a way that
-        // n.parent.isRed again
-        n = n.left
-      } else if (n === n.parent.left && n.parent === n.grandparent.right) {
-        n.parent.rotateRight(this)
-        // see above
-        n = n.right
-      }
-      // Case 1) or 2) hold from here on.
-      // Now traverse grandparent, make parent a black node
-      // on the highest level which holds two red nodes.
-      n.parent.blacken()
-      n.grandparent.redden()
-      if (n === n.parent.left) {
-        // Case 1
-        n.grandparent.rotateRight(this)
-      } else {
-        // Case 2
-        n.grandparent.rotateLeft(this)
-      }
-    }
-  }
-}
-
-Y.utils.RBTree = RBTree
--- a/src/Databases/RedBlackTree.spec.js
+++ b/src/Databases/RedBlackTree.spec.js
@@ -1,212 +0,0 @@
-/* global Y */
-/* eslint-env browser,jasmine,console */
-
-var numberOfRBTreeTests = 1000
-
-function itRedNodesDoNotHaveBlackChildren () {
-  it('Red nodes do not have black children', function () {
-    function traverse (n) {
-      if (n == null) {
-        return
-      }
-      if (n.isRed()) {
-        if (n.left != null) {
-          expect(n.left.isRed()).not.toBeTruthy()
-        }
-        if (n.right != null) {
-          expect(n.right.isRed()).not.toBeTruthy()
-        }
-      }
-      traverse(n.left)
-      traverse(n.right)
-    }
-    traverse(this.tree.root)
-  })
-}
-
-function itBlackHeightOfSubTreesAreEqual () {
-  it('Black-height of sub-trees are equal', function () {
-    function traverse (n) {
-      if (n == null) {
-        return 0
-      }
-      var sub1 = traverse(n.left)
-      var sub2 = traverse(n.right)
-      expect(sub1).toEqual(sub2)
-      if (n.isRed()) {
-        return sub1
-      } else {
-        return sub1 + 1
-      }
-    }
-    traverse(this.tree.root)
-  })
-}
-
-function itRootNodeIsBlack () {
-  it('root node is black', function () {
-    expect(this.tree.root == null || this.tree.root.isBlack()).toBeTruthy()
-  })
-}
-
-describe('RedBlack Tree', function () {
-  var tree, memory
-  describe('debug #2', function () {
-    beforeAll(function (done) {
-      this.memory = new Y.Memory(null, {
-        name: 'Memory',
-        gcTimeout: -1
-      })
-      this.tree = this.memory.os
-      tree = this.tree
-      memory = this.memory
-      memory.requestTransaction(function * () {
-        yield* tree.put({id: [8433]})
-        yield* tree.put({id: [12844]})
-        yield* tree.put({id: [1795]})
-        yield* tree.put({id: [30302]})
-        yield* tree.put({id: [64287]})
-        yield* tree.delete([8433])
-        yield* tree.put({id: [28996]})
-        yield* tree.delete([64287])
-        yield* tree.put({id: [22721]})
-        done()
-      })
-    })
-
-    itRootNodeIsBlack()
-    itBlackHeightOfSubTreesAreEqual([])
-  })
-
-  describe(`After adding&deleting (0.8/0.2) ${numberOfRBTreeTests} times`, function () {
-    var elements = []
-    beforeAll(function (done) {
-      this.memory = new Y.Memory(null, {
-        name: 'Memory',
-        gcTimeout: -1
-      })
-      this.tree = this.memory.os
-      tree = this.tree
-      memory = this.memory
-      memory.requestTransaction(function * () {
-        for (var i = 0; i < numberOfRBTreeTests; i++) {
-          var r = Math.random()
-          if (r < 0.8) {
-            var obj = [Math.floor(Math.random() * numberOfRBTreeTests * 10000)]
-            if (!tree.findNode(obj)) {
-              elements.push(obj)
-              yield* tree.put({id: obj})
-            }
-          } else if (elements.length > 0) {
-            var elemid = Math.floor(Math.random() * elements.length)
-            var elem = elements[elemid]
-            elements = elements.filter(function (e) {
-              return !Y.utils.compareIds(e, elem)
-            })
-            yield* tree.delete(elem)
-          }
-        }
-        done()
-      })
-    })
-
-    itRootNodeIsBlack()
-
-    it('can find every object', function (done) {
-      memory.requestTransaction(function * () {
-        for (var id of elements) {
-          expect((yield* tree.find(id)).id).toEqual(id)
-        }
-        done()
-      })
-    })
-
-    it('can find every object with lower bound search', function (done) {
-      this.memory.requestTransaction(function * () {
-        for (var id of elements) {
-          expect((yield* tree.findWithLowerBound(id)).id).toEqual(id)
-        }
-        done()
-      })
-    })
-    itRedNodesDoNotHaveBlackChildren()
-
-    itBlackHeightOfSubTreesAreEqual()
-
-    it('iterating over a tree with lower bound yields the right amount of results', function (done) {
-      var lowerBound = elements[Math.floor(Math.random() * elements.length)]
-      var expectedResults = elements.filter(function (e, pos) {
-        return (Y.utils.smaller(lowerBound, e) || Y.utils.compareIds(e, lowerBound)) && elements.indexOf(e) === pos
-      }).length
-
-      var actualResults = 0
-      this.memory.requestTransaction(function * () {
-        yield* tree.iterate(this, lowerBound, null, function * (val) {
-          expect(val).toBeDefined()
-          actualResults++
-        })
-        expect(expectedResults).toEqual(actualResults)
-        done()
-      })
-    })
-
-    it('iterating over a tree without bounds yield the right amount of results', function (done) {
-      var lowerBound = null
-      var expectedResults = elements.filter(function (e, pos) {
-        return elements.indexOf(e) === pos
-      }).length
-      var actualResults = 0
-      this.memory.requestTransaction(function * () {
-        yield* tree.iterate(this, lowerBound, null, function * (val) {
-          expect(val).toBeDefined()
-          actualResults++
-        })
-        expect(expectedResults).toEqual(actualResults)
-        done()
-      })
-    })
-
-    it('iterating over a tree with upper bound yields the right amount of results', function (done) {
-      var upperBound = elements[Math.floor(Math.random() * elements.length)]
-      var expectedResults = elements.filter(function (e, pos) {
-        return (Y.utils.smaller(e, upperBound) || Y.utils.compareIds(e, upperBound)) && elements.indexOf(e) === pos
-      }).length
-
-      var actualResults = 0
-      this.memory.requestTransaction(function * () {
-        yield* tree.iterate(this, null, upperBound, function * (val) {
-          expect(val).toBeDefined()
-          actualResults++
-        })
-        expect(expectedResults).toEqual(actualResults)
-        done()
-      })
-    })
-
-    it('iterating over a tree with upper and lower bounds yield the right amount of results', function (done) {
-      var b1 = elements[Math.floor(Math.random() * elements.length)]
-      var b2 = elements[Math.floor(Math.random() * elements.length)]
-      var upperBound, lowerBound
-      if (Y.utils.smaller(b1, b2)) {
-        lowerBound = b1
-        upperBound = b2
-      } else {
-        lowerBound = b2
-        upperBound = b1
-      }
-      var expectedResults = elements.filter(function (e, pos) {
-        return (Y.utils.smaller(lowerBound, e) || Y.utils.compareIds(e, lowerBound)) &&
-          (Y.utils.smaller(e, upperBound) || Y.utils.compareIds(e, upperBound)) && elements.indexOf(e) === pos
-      }).length
-      var actualResults = 0
-      this.memory.requestTransaction(function * () {
-        yield* tree.iterate(this, lowerBound, upperBound, function * (val) {
-          expect(val).toBeDefined()
-          actualResults++
-        })
-        expect(expectedResults).toEqual(actualResults)
-        done()
-      })
-    })
-  })
-})
--- a/src/Helper.spec.js
+++ b/src/Helper.spec.js
@@ -1,288 +0,0 @@
-/* global Y */
-/* eslint-env browser, jasmine */
-
-/*
-  This is just a compilation of functions that help to test this library!
-*/
-
-// When testing, you store everything on the global object. We call it g
-var g
-if (typeof global !== 'undefined') {
-  g = global
-} else if (typeof window !== 'undefined') {
-  g = window
-} else {
-  throw new Error('No global object?')
-}
-g.g = g
-
-g.YConcurrency_TestingMode = true
-
-jasmine.DEFAULT_TIMEOUT_INTERVAL = 20000
-
-g.describeManyTimes = function describeManyTimes (times, name, f) {
-  for (var i = 0; i < times; i++) {
-    describe(name, f)
-  }
-}
-
-/*
-  Wait for a specified amount of time (in ms). defaults to 5ms
-*/
-function wait (t) {
-  if (t == null) {
-    t = 80
-  }
-  return new Promise(function (resolve) {
-    setTimeout(function () {
-      resolve()
-    }, t * 2)
-  })
-}
-g.wait = wait
-
-g.databases = ['Memory']
-if (typeof window !== 'undefined') {
-  g.databases.push('IndexedDB')
-}
-
-/*
-  returns a random element of o.
-  works on Object, and Array
-*/
-function getRandom (o) {
-  if (o instanceof Array) {
-    return o[Math.floor(Math.random() * o.length)]
-  } else if (o.constructor === Object) {
-    var ks = []
-    for (var key in o) {
-      ks.push(key)
-    }
-    return o[getRandom(ks)]
-  }
-}
-g.getRandom = getRandom
-
-function getRandomNumber (n) {
-  if (n == null) {
-    n = 9999
-  }
-  return Math.floor(Math.random() * n)
-}
-g.getRandomNumber = getRandomNumber
-
-function * applyTransactions (relAmount, numberOfTransactions, objects, users, transactions) {
-  function randomTransaction (root) {
-    var f = getRandom(transactions)
-    f(root)
-  }
-  for (var i = 0; i < numberOfTransactions * relAmount + 1; i++) {
-    var r = Math.random()
-    if (r >= 0.5) {
-      // 50% chance to flush
-      users[0].connector.flushOne() // flushes for some user.. (not necessarily 0)
-    } else if (r >= 0.05) {
-      // 45% chance to create operation
-      randomTransaction(getRandom(objects))
-    } else {
-      // 5% chance to disconnect/reconnect
-      var u = getRandom(users)
-      if (u.connector.isDisconnected()) {
-        yield u.reconnect()
-      } else {
-        yield u.disconnect()
-      }
-    }
-    yield wait()
-  }
-}
-
-g.applyRandomTransactionsAllRejoinNoGC = async(function * applyRandomTransactions (users, objects, transactions, numberOfTransactions) {
-  yield* applyTransactions(1, numberOfTransactions, objects, users, transactions)
-  yield users[0].connector.flushAll()
-  yield wait()
-  for (var u in users) {
-    yield users[u].reconnect()
-  }
-  yield wait(100)
-  yield users[0].connector.flushAll()
-  yield g.garbageCollectAllUsers(users)
-})
-
-g.applyRandomTransactionsWithGC = async(function * applyRandomTransactions (users, objects, transactions, numberOfTransactions) {
-  yield* applyTransactions(1, numberOfTransactions, objects, users.slice(1), transactions)
-  yield users[0].connector.flushAll()
-  yield g.garbageCollectAllUsers(users)
-  yield wait(100)
-  for (var u in users) {
-    // TODO: here, we enforce that two users never sync at the same time with u[0]
-    //       enforce that in the connector itself!
-    yield users[u].reconnect()
-  }
-  yield wait(100)
-  yield users[0].connector.flushAll()
-  yield wait(100)
-  yield g.garbageCollectAllUsers(users)
-})
-
-g.garbageCollectAllUsers = async(function * garbageCollectAllUsers (users) {
-  // gc two times because of the two gc phases (really collect everything)
-  yield wait(100)
-  for (var i in users) {
-    yield users[i].db.garbageCollect()
-    yield users[i].db.garbageCollect()
-  }
-  yield wait(100)
-})
-
-g.compareAllUsers = async(function * compareAllUsers (users) {
-  var s1, s2 // state sets
-  var ds1, ds2 // delete sets
-  var allDels1, allDels2 // all deletions
-  var db1 = [] // operation store of user1
-
-  // t1 and t2 basically do the same. They define t[1,2], ds[1,2], and allDels[1,2]
-  function * t1 () {
-    s1 = yield* this.getStateSet()
-    ds1 = yield* this.getDeleteSet()
-    allDels1 = []
-    yield* this.ds.iterate(this, null, null, function * (d) {
-      allDels1.push(d)
-    })
-  }
-  function * t2 () {
-    s2 = yield* this.getStateSet()
-    ds2 = yield* this.getDeleteSet()
-    allDels2 = []
-    yield* this.ds.iterate(this, null, null, function * (d) {
-      allDels2.push(d)
-    })
-  }
-  yield users[0].connector.flushAll()
-  yield wait()
-  yield g.garbageCollectAllUsers(users)
-
-  for (var uid = 0; uid < users.length; uid++) {
-    var u = users[uid]
-    u.db.requestTransaction(function * () {
-      // compare deleted ops against deleteStore
-      yield* this.os.iterate(this, null, null, function * (o) {
-        if (o.deleted === true) {
-          expect(yield* this.isDeleted(o.id)).toBeTruthy()
-        }
-      })
-      // compare deleteStore against deleted ops
-      var ds = []
-      yield* this.ds.iterate(this, null, null, function * (d) {
-        ds.push(d)
-      })
-      for (var j in ds) {
-        var d = ds[j]
-        for (var i = 0; i < d.len; i++) {
-          var o = yield* this.getOperation([d.id[0], d.id[1] + i])
-          // gc'd or deleted
-          if (d.gc) {
-            expect(o).toBeFalsy()
-          } else {
-            expect(o.deleted).toBeTruthy()
-          }
-        }
-      }
-    })
-    // compare allDels tree
-    yield wait()
-    if (s1 == null) {
-      u.db.requestTransaction(function * () {
-        yield* t1.call(this)
-        yield* this.os.iterate(this, null, null, function * (o) {
-          o = Y.utils.copyObject(o)
-          delete o.origin
-          db1.push(o)
-        })
-      })
-      yield wait()
-    } else {
-      // TODO: make requestTransaction return a promise..
-      u.db.requestTransaction(function * () {
-        yield* t2.call(this)
-        expect(s1).toEqual(s2)
-        expect(allDels1).toEqual(allDels2) // inner structure
-        expect(ds1).toEqual(ds2) // exported structure
-        var count = 0
-        yield* this.os.iterate(this, null, null, function * (o) {
-          o = Y.utils.copyObject(o)
-          delete o.origin
-          expect(db1[count++]).toEqual(o)
-        })
-      })
-      yield wait()
-    }
-  }
-})
-
-g.createUsers = async(function * createUsers (self, numberOfUsers, database) {
-  if (Y.utils.globalRoom.users[0] != null) {
-    yield Y.utils.globalRoom.users[0].flushAll()
-  }
-  // destroy old users
-  for (var u in Y.utils.globalRoom.users) {
-    Y.utils.globalRoom.users[u].y.destroy()
-  }
-  self.users = null
-
-  var promises = []
-  for (var i = 0; i < numberOfUsers; i++) {
-    promises.push(Y({
-      db: {
-        name: database,
-        namespace: 'User ' + i,
-        cleanStart: true,
-        gcTimeout: -1
-      },
-      connector: {
-        name: 'Test',
-        debug: false
-      }
-    }))
-  }
-  self.users = yield Promise.all(promises)
-  return self.users
-})
-
-/*
-  Until async/await arrives in js, we use this function to wait for promises
-  by yielding them.
-*/
-function async (makeGenerator) {
-  return function (arg) {
-    var generator = makeGenerator.apply(this, arguments)
-
-    function handle (result) {
-      if (result.done) return Promise.resolve(result.value)
-
-      return Promise.resolve(result.value).then(function (res) {
-        return handle(generator.next(res))
-      }, function (err) {
-        return handle(generator.throw(err))
-      })
-    }
-    try {
-      return handle(generator.next())
-    } catch (ex) {
-      generator.throw(ex)
-      // return Promise.reject(ex)
-    }
-  }
-}
-g.async = async
-
-function logUsers (self) {
-  if (self.constructor === Array) {
-    self = {users: self}
-  }
-  self.users[0].db.logTable()
-  self.users[1].db.logTable()
-  self.users[2].db.logTable()
-}
-
-g.logUsers = logUsers
--- a/src/SpecHelper.js
+++ b/src/SpecHelper.js
@@ -0,0 +1,404 @@
+/* eslint-env browser, jasmine */
+
+/*
+  This is just a compilation of functions that help to test this library!
+*/
+
+// When testing, you store everything on the global object. We call it g
+
+var Y = require('./y.js')
+require('../../y-memory/src/Memory.js')(Y)
+require('../../y-array/src/Array.js')(Y)
+require('../../y-map/src/Map.js')(Y)
+require('../../y-indexeddb/src/IndexedDB.js')(Y)
+
+module.exports = Y
+
+var g
+if (typeof global !== 'undefined') {
+  g = global
+} else if (typeof window !== 'undefined') {
+  g = window
+} else {
+  throw new Error('No global object?')
+}
+g.g = g
+
+// Helper methods for the random number generator
+Math.seedrandom = require('seedrandom')
+
+g.generateRandomSeed = function generateRandomSeed () {
+  var seed
+  if (typeof window !== 'undefined' && window.location.hash.length > 1) {
+    seed = window.location.hash.slice(1) // first character is the hash!
+    console.warn('Using random seed that was specified in the url!')
+  } else {
+    seed = JSON.stringify(Math.random())
+  }
+  console.info('Using random seed: ' + seed)
+  g.setRandomSeed(seed)
+}
+
+g.setRandomSeed = function setRandomSeed (seed) {
+  Math.seedrandom.currentSeed = seed
+  Math.seedrandom(Math.seedrandom.currentSeed, { global: true })
+}
+
+g.generateRandomSeed()
+
+g.YConcurrencyTestingMode = true
+
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 200000
+
+g.describeManyTimes = function describeManyTimes (times, name, f) {
+  for (var i = 0; i < times; i++) {
+    describe(name, f)
+  }
+}
+
+/*
+  Wait for a specified amount of time (in ms). defaults to 5ms
+*/
+function wait (t) {
+  if (t == null) {
+    t = 0
+  }
+  return new Promise(function (resolve) {
+    setTimeout(function () {
+      resolve()
+    }, t)
+  })
+}
+g.wait = wait
+
+g.databases = ['memory']
+if (typeof window !== 'undefined') {
+  g.databases.push('indexeddb')
+} else {
+  g.databases.push('leveldb')
+}
+/*
+  returns a random element of o.
+  works on Object, and Array
+*/
+function getRandom (o) {
+  if (o instanceof Array) {
+    return o[Math.floor(Math.random() * o.length)]
+  } else if (o.constructor === Object) {
+    return o[getRandom(Object.keys(o))]
+  }
+}
+g.getRandom = getRandom
+
+function getRandomNumber (n) {
+  if (n == null) {
+    n = 9999
+  }
+  return Math.floor(Math.random() * n)
+}
+g.getRandomNumber = getRandomNumber
+
+function getRandomString () {
+  var chars = 'abcdefghijklmnopqrstuvwxyzäüöABCDEFGHIJKLMNOPQRSTUVWXYZÄÜÖ'
+  var char = chars[getRandomNumber(chars.length)] // ü\n\n\n\n\n\n\n'
+  var length = getRandomNumber(7)
+  var string = ''
+  for (var i = 0; i < length; i++) {
+    string += char
+  }
+  return string
+}
+g.getRandomString = getRandomString
+
+function * applyTransactions (relAmount, numberOfTransactions, objects, users, transactions, noReconnect) {
+  g.generateRandomSeed() // create a new seed, so we can re-create the behavior
+  for (var i = 0; i < numberOfTransactions * relAmount + 1; i++) {
+    var r = Math.random()
+    if (r > 0.95) {
+      // 10% chance of toggling concurrent user interactions.
+      // There will be an artificial delay until ops can be executed by the type,
+      // therefore, operations of the database will be (pre)transformed until user operations arrive
+      yield (function simulateConcurrentUserInteractions (type) {
+        if (!(type instanceof Y.utils.CustomType) && type.y instanceof Y.utils.CustomType) {
+          // usually we expect type to be a custom type. But in YXml we share an object {y: YXml, dom: Dom} instead
+          type = type.y
+        }
+        if (type.eventHandler.awaiting === 0 && type.eventHandler._debuggingAwaiting !== true) {
+          type.eventHandler.awaiting = 1
+          type.eventHandler._debuggingAwaiting = true
+        } else {
+          // fixAwaitingInType will handle _debuggingAwaiting
+          return fixAwaitingInType(type)
+        }
+      })(getRandom(objects))
+    } else if (r >= 0.5) {
+      // 40% chance to flush
+      yield Y.utils.globalRoom.flushOne() // flushes for some user.. (not necessarily 0)
+    } else if (noReconnect || r >= 0.05) {
+      // 45% chance to create operation
+      var done = getRandom(transactions)(getRandom(objects))
+      if (done != null) {
+        yield done
+      } else {
+        yield wait()
+      }
+      yield Y.utils.globalRoom.whenTransactionsFinished()
+    } else {
+      // 5% chance to disconnect/reconnect
+      var u = getRandom(users)
+      yield Promise.all(objects.map(fixAwaitingInType))
+      if (u.connector.isDisconnected()) {
+        yield u.reconnect()
+      } else {
+        yield u.disconnect()
+      }
+      yield Promise.all(objects.map(fixAwaitingInType))
+    }
+  }
+}
+
+function fixAwaitingInType (type) {
+  if (!(type instanceof Y.utils.CustomType) && type.y instanceof Y.utils.CustomType) {
+    // usually we expect type to be a custom type. But in YXml we share an object {y: YXml, dom: Dom} instead
+    type = type.y
+  }
+  return new Promise(function (resolve) {
+    type.os.whenTransactionsFinished().then(function () {
+      // _debuggingAwaiting artificially increases the awaiting property. We need to make sure that we only do that once / reverse the effect once
+      type.os.requestTransaction(function * () {
+        if (type.eventHandler.awaiting > 0 && type.eventHandler._debuggingAwaiting === true) {
+          type.eventHandler._debuggingAwaiting = false
+          yield * type.eventHandler.awaitOps(this, function * () { /* mock function */ })
+        }
+        wait(50).then(type.os.whenTransactionsFinished()).then(wait(50)).then(resolve)
+      })
+    })
+  })
+}
+g.fixAwaitingInType = fixAwaitingInType
+
+g.applyRandomTransactionsNoGCNoDisconnect = async(function * applyRandomTransactions (users, objects, transactions, numberOfTransactions) {
+  yield * applyTransactions(1, numberOfTransactions, objects, users, transactions, true)
+  yield Y.utils.globalRoom.flushAll()
+  yield Promise.all(objects.map(fixAwaitingInType))
+})
+
+g.applyRandomTransactionsAllRejoinNoGC = async(function * applyRandomTransactions (users, objects, transactions, numberOfTransactions) {
+  yield * applyTransactions(1, numberOfTransactions, objects, users, transactions)
+  yield Promise.all(objects.map(fixAwaitingInType))
+  yield Y.utils.globalRoom.flushAll()
+  yield Promise.all(objects.map(fixAwaitingInType))
+  for (var u in users) {
+    yield Promise.all(objects.map(fixAwaitingInType))
+    yield users[u].reconnect()
+    yield Promise.all(objects.map(fixAwaitingInType))
+  }
+  yield Promise.all(objects.map(fixAwaitingInType))
+  yield Y.utils.globalRoom.flushAll()
+  yield Promise.all(objects.map(fixAwaitingInType))
+  yield g.garbageCollectAllUsers(users)
+})
+
+g.applyRandomTransactionsWithGC = async(function * applyRandomTransactions (users, objects, transactions, numberOfTransactions) {
+  yield * applyTransactions(1, numberOfTransactions, objects, users.slice(1), transactions)
+  yield Y.utils.globalRoom.flushAll()
+  yield Promise.all(objects.map(fixAwaitingInType))
+  for (var u in users) {
+    // TODO: here, we enforce that two users never sync at the same time with u[0]
+    //       enforce that in the connector itself!
+    yield users[u].reconnect()
+  }
+  yield Y.utils.globalRoom.flushAll()
+  yield Promise.all(objects.map(fixAwaitingInType))
+  yield g.garbageCollectAllUsers(users)
+})
+
+g.garbageCollectAllUsers = async(function * garbageCollectAllUsers (users) {
+  yield Y.utils.globalRoom.flushAll()
+  for (var i in users) {
+    yield users[i].db.emptyGarbageCollector()
+  }
+})
+
+g.compareAllUsers = async(function * compareAllUsers (users) {
+  var s1, s2 // state sets
+  var ds1, ds2 // delete sets
+  var allDels1, allDels2 // all deletions
+  var db1 = [] // operation store of user1
+
+  yield Y.utils.globalRoom.flushAll()
+  yield g.garbageCollectAllUsers(users)
+  yield Y.utils.globalRoom.flushAll()
+
+  // disconnect, then reconnect all users
+  // We do this to make sure that the gc is updated by everyone
+  for (var i = 0; i < users.length; i++) {
+    yield users[i].disconnect()
+    yield wait()
+    yield users[i].reconnect()
+  }
+  yield wait()
+  yield Y.utils.globalRoom.flushAll()
+
+  // t1 and t2 basically do the same. They define t[1,2], ds[1,2], and allDels[1,2]
+  function * t1 () {
+    s1 = yield * this.getStateSet()
+    ds1 = yield * this.getDeleteSet()
+    allDels1 = []
+    yield * this.ds.iterate(this, null, null, function * (d) {
+      allDels1.push(d)
+    })
+  }
+  function * t2 () {
+    s2 = yield * this.getStateSet()
+    ds2 = yield * this.getDeleteSet()
+    allDels2 = []
+    yield * this.ds.iterate(this, null, null, function * (d) {
+      allDels2.push(d)
+    })
+  }
+
+  var buffer = Y.utils.globalRoom.buffers
+  for (var name in buffer) {
+    if (buffer[name].length > 0) {
+      // not all ops were transmitted..
+      debugger // eslint-disable-line
+    }
+  }
+
+  for (var uid = 0; uid < users.length; uid++) {
+    var u = users[uid]
+    u.db.requestTransaction(function * () {
+      var sv = yield * this.getStateVector()
+      for (var s of sv) {
+        yield * this.updateState(s.user)
+      }
+      // compare deleted ops against deleteStore
+      yield * this.os.iterate(this, null, null, function * (o) {
+        if (o.deleted === true) {
+          expect(yield * this.isDeleted(o.id)).toBeTruthy()
+        }
+      })
+      // compare deleteStore against deleted ops
+      var ds = []
+      yield * this.ds.iterate(this, null, null, function * (d) {
+        ds.push(d)
+      })
+      for (var j in ds) {
+        var d = ds[j]
+        for (var i = 0; i < d.len; i++) {
+          var o = yield * this.getInsertion([d.id[0], d.id[1] + i])
+          // gc'd or deleted
+          if (d.gc) {
+            expect(o).toBeFalsy()
+          } else {
+            expect(o.deleted).toBeTruthy()
+          }
+        }
+      }
+    })
+    // compare allDels tree
+    if (s1 == null) {
+      u.db.requestTransaction(function * () {
+        yield * t1.call(this)
+        yield * this.os.iterate(this, null, null, function * (o) {
+          o = Y.utils.copyObject(o)
+          delete o.origin
+          delete o.originOf
+          db1.push(o)
+        })
+      })
+    } else {
+      u.db.requestTransaction(function * () {
+        yield * t2.call(this)
+        var db2 = []
+        yield * this.os.iterate(this, null, null, function * (o) {
+          o = Y.utils.copyObject(o)
+          delete o.origin
+          delete o.originOf
+          db2.push(o)
+        })
+        expect(s1).toEqual(s2)
+        expect(allDels1).toEqual(allDels2) // inner structure
+        expect(ds1).toEqual(ds2) // exported structure
+        db2.forEach((o, i) => {
+          expect(db1[i]).toEqual(o)
+        })
+      })
+    }
+    yield u.db.whenTransactionsFinished()
+  }
+})
+
+g.createUsers = async(function * createUsers (self, numberOfUsers, database, initType) {
+  if (Y.utils.globalRoom.users[0] != null) {
+    yield Y.utils.globalRoom.flushAll()
+  }
+  // destroy old users
+  for (var u in Y.utils.globalRoom.users) {
+    Y.utils.globalRoom.users[u].y.destroy()
+  }
+  self.users = null
+
+  var promises = []
+  for (var i = 0; i < numberOfUsers; i++) {
+    promises.push(Y({
+      db: {
+        name: database,
+        namespace: 'User ' + i,
+        cleanStart: true,
+        gcTimeout: -1,
+        gc: true,
+        repairCheckInterval: -1
+      },
+      connector: {
+        name: 'Test',
+        debug: false
+      },
+      share: {
+        root: initType || 'Map'
+      }
+    }))
+  }
+  self.users = yield Promise.all(promises)
+  self.types = self.users.map(function (u) { return u.share.root })
+  return self.users
+})
+
+/*
+  Until async/await arrives in js, we use this function to wait for promises
+  by yielding them.
+*/
+function async (makeGenerator) {
+  return function (arg) {
+    var generator = makeGenerator.apply(this, arguments)
+
+    function handle (result) {
+      if (result.done) return Promise.resolve(result.value)
+
+      return Promise.resolve(result.value).then(function (res) {
+        return handle(generator.next(res))
+      }, function (err) {
+        return handle(generator.throw(err))
+      })
+    }
+    try {
+      return handle(generator.next())
+    } catch (ex) {
+      generator.throw(ex)
+      // return Promise.reject(ex)
+    }
+  }
+}
+g.async = async
+
+function logUsers (self) {
+  if (self.constructor === Array) {
+    self = {users: self}
+  }
+  self.users[0].db.logTable()
+  self.users[1].db.logTable()
+  self.users[2].db.logTable()
+}
+
+g.logUsers = logUsers
--- a/src/Struct.js
+++ b/src/Struct.js
@@ -1,4 +1,4 @@
-/* global Y */
+/* @flow */
 'use strict'

 /*
@@ -19,318 +19,396 @@
 * requiredOps
     - Operations that are required to execute this operation.
 */
+export default function extendStruct (Y) {
+  var Struct = {
+    /* This is the only operation that is actually not a structure, because
+    it is not stored in the OS. This is why it _does not_ have an id

-var Struct = {
-  /* This is the only operation that is actually not a structure, because
-  it is not stored in the OS. This is why it _does not_ have an id
-
-  op = {
-    target: Id
-  }
-  */
-  Delete: {
-    encode: function (op) {
-      return op
-    },
-    requiredOps: function (op) {
-      return [] // [op.target]
-    },
-    execute: function * (op) {
-      return yield* this.deleteOperation(op.target)
-    }
-  },
-  Insert: {
-    /* {
-        content: any,
-        id: Id,
-        left: Id,
-        origin: Id,
-        right: Id,
-        parent: Id,
-        parentSub: string (optional), // child of Map type
-      }
-    */
-    encode: function (op) {
-      // TODO: you could not send the "left" property, then you also have to
-      // "op.left = null" in $execute or $decode
-      var e = {
-        id: op.id,
-        left: op.left,
-        right: op.right,
-        origin: op.origin,
-        parent: op.parent,
-        struct: op.struct
-      }
-      if (op.parentSub != null) {
-        e.parentSub = op.parentSub
-      }
-      if (op.opContent != null) {
-        e.opContent = op.opContent
-      } else {
-        e.content = op.content
-      }
-
-      return e
-    },
-    requiredOps: function (op) {
-      var ids = []
-      if (op.left != null) {
-        ids.push(op.left)
-      }
-      if (op.right != null) {
-        ids.push(op.right)
-      }
-      if (op.origin != null && !Y.utils.compareIds(op.left, op.origin)) {
-        ids.push(op.origin)
-      }
-      // if (op.right == null && op.left == null) {
-      ids.push(op.parent)
-
-      if (op.opContent != null) {
-        ids.push(op.opContent)
-      }
-      return ids
-    },
-    getDistanceToOrigin: function * (op) {
-      if (op.left == null) {
-        return 0
-      } else {
-        var d = 0
-        var o = yield* this.getOperation(op.left)
-        while (!Y.utils.compareIds(op.origin, (o ? o.id : null))) {
-          d++
-          if (o.left == null) {
-            break
-          } else {
-            o = yield* this.getOperation(o.left)
-          }
-        }
-        return d
-      }
-    },
-    /*
-    # $this has to find a unique position between origin and the next known character
-    # case 1: $origin equals $o.origin: the $creator parameter decides if left or right
-    #         let $OL= [o1,o2,o3,o4], whereby $this is to be inserted between o1 and o4
-    #         o2,o3 and o4 origin is 1 (the position of o2)
-    #         there is the case that $this.creator < o2.creator, but o3.creator < $this.creator
-    #         then o2 knows o3. Since on another client $OL could be [o1,o3,o4] the problem is complex
-    #         therefore $this would be always to the right of o3
-    # case 2: $origin < $o.origin
-    #         if current $this insert_position > $o origin: $this ins
-    #         else $insert_position will not change
-    #         (maybe we encounter case 1 later, then this will be to the right of $o)
-    # case 3: $origin > $o.origin
-    #         $this insert_position is to the left of $o (forever!)
-    */
-    execute: function *(op) {
-      var i // loop counter
-      var distanceToOrigin = i = yield* Struct.Insert.getDistanceToOrigin.call(this, op) // most cases: 0 (starts from 0)
-      var o
-      var parent
-      var start
-
-      // find o. o is the first conflicting operation
-      if (op.left != null) {
-        o = yield* this.getOperation(op.left)
-        o = (o.right == null) ? null : yield* this.getOperation(o.right)
-      } else { // left == null
-        parent = yield* this.getOperation(op.parent)
-        let startId = op.parentSub ? parent.map[op.parentSub] : parent.start
-        start = startId == null ? null : yield* this.getOperation(startId)
-        o = start
-      }
-
-      // handle conflicts
-      while (true) {
-        if (o != null && !Y.utils.compareIds(o.id, op.right)) {
-          var oOriginDistance = yield* Struct.Insert.getDistanceToOrigin.call(this, o)
-          if (oOriginDistance === i) {
-            // case 1
-            if (o.id[0] < op.id[0]) {
-              op.left = o.id
-              distanceToOrigin = i + 1
-            }
-          } else if (oOriginDistance < i) {
-            // case 2
-            if (i - distanceToOrigin <= oOriginDistance) {
-              op.left = o.id
-              distanceToOrigin = i + 1
-            }
-          } else {
-            break
-          }
-          i++
-          o = o.right ? yield* this.getOperation(o.right) : null
-        } else {
-          break
-        }
-      }
-
-      // reconnect..
-      var left = null
-      var right = null
-      parent = parent || (yield* this.getOperation(op.parent))
-
-      // reconnect left and set right of op
-      if (op.left != null) {
-        left = yield* this.getOperation(op.left)
-        op.right = left.right
-        left.right = op.id
-
-        yield* this.setOperation(left)
-      } else {
-        op.right = op.parentSub ? parent.map[op.parentSub] || null : parent.start
-      }
-      // reconnect right
-      if (op.right != null) {
-        right = yield* this.getOperation(op.right)
-        right.left = op.id
-
-        // if right exists, and it is supposed to be gc'd. Remove it from the gc
-        if (right.gc != null) {
-          this.store.removeFromGarbageCollector(right)
-        }
-        yield* this.setOperation(right)
-      }
-
-      // update parents .map/start/end properties
-      if (op.parentSub != null) {
-        if (left == null) {
-          parent.map[op.parentSub] = op.id
-          yield* this.setOperation(parent)
-        }
-        // is a child of a map struct.
-        // Then also make sure that only the most left element is not deleted
-        if (op.right != null) {
-          yield* this.deleteOperation(op.right, true)
-        }
-        if (op.left != null) {
-          yield* this.deleteOperation(op.id, true)
-        }
-      } else {
-        if (right == null || left == null) {
-          if (right == null) {
-            parent.end = op.id
-          }
-          if (left == null) {
-            parent.start = op.id
-          }
-          yield* this.setOperation(parent)
-        }
-      }
-    }
-  },
-  List: {
-    /*
-    {
-      start: null,
-      end: null,
-      struct: "List",
-      type: "",
-      id: this.os.getNextOpId()
+    op = {
+      target: Id
    }
    */
-    encode: function (op) {
-      return {
-        struct: 'List',
-        id: op.id,
-        type: op.type
+    Delete: {
+      encode: function (op) {
+        return {
+          target: op.target,
+          length: op.length || 0,
+          struct: 'Delete'
+        }
+      },
+      requiredOps: function (op) {
+        return [] // [op.target]
+      },
+      execute: function * (op) {
+        return yield * this.deleteOperation(op.target, op.length || 1)
      }
    },
-    requiredOps: function () {
-      /*
-      var ids = []
-      if (op.start != null) {
-        ids.push(op.start)
-      }
-      if (op.end != null){
-        ids.push(op.end)
-      }
-      return ids
+    Insert: {
+      /* {
+          content: [any],
+          opContent: Id,
+          id: Id,
+          left: Id,
+          origin: Id,
+          right: Id,
+          parent: Id,
+          parentSub: string (optional), // child of Map type
+        }
      */
-      return []
-    },
-    execute: function * (op) {
-      op.start = null
-      op.end = null
-    },
-    ref: function * (op, pos) {
-      if (op.start == null) {
-        return null
-      }
-      var res = null
-      var o = yield* this.getOperation(op.start)
-
-      while (true) {
-        if (!o.deleted) {
-          res = o
-          pos--
+      encode: function (op/* :Insertion */) /* :Insertion */ {
+        // TODO: you could not send the "left" property, then you also have to
+        // "op.left = null" in $execute or $decode
+        var e/* :any */ = {
+          id: op.id,
+          left: op.left,
+          right: op.right,
+          origin: op.origin,
+          parent: op.parent,
+          struct: op.struct
        }
-        if (pos >= 0 && o.right != null) {
-          o = (yield* this.getOperation(o.right))
+        if (op.parentSub != null) {
+          e.parentSub = op.parentSub
+        }
+        if (op.hasOwnProperty('opContent')) {
+          e.opContent = op.opContent
        } else {
-          break
+          e.content = op.content.slice()
+        }
+
+        return e
+      },
+      requiredOps: function (op) {
+        var ids = []
+        if (op.left != null) {
+          ids.push(op.left)
+        }
+        if (op.right != null) {
+          ids.push(op.right)
+        }
+        if (op.origin != null && !Y.utils.compareIds(op.left, op.origin)) {
+          ids.push(op.origin)
+        }
+        // if (op.right == null && op.left == null) {
+        ids.push(op.parent)
+
+        if (op.opContent != null) {
+          ids.push(op.opContent)
+        }
+        return ids
+      },
+      getDistanceToOrigin: function * (op) {
+        if (op.left == null) {
+          return 0
+        } else {
+          var d = 0
+          var o = yield * this.getInsertion(op.left)
+          while (!Y.utils.matchesId(o, op.origin)) {
+            d++
+            if (o.left == null) {
+              break
+            } else {
+              o = yield * this.getInsertion(o.left)
+            }
+          }
+          return d
+        }
+      },
+      /*
+      # $this has to find a unique position between origin and the next known character
+      # case 1: $origin equals $o.origin: the $creator parameter decides if left or right
+      #         let $OL= [o1,o2,o3,o4], whereby $this is to be inserted between o1 and o4
+      #         o2,o3 and o4 origin is 1 (the position of o2)
+      #         there is the case that $this.creator < o2.creator, but o3.creator < $this.creator
+      #         then o2 knows o3. Since on another client $OL could be [o1,o3,o4] the problem is complex
+      #         therefore $this would be always to the right of o3
+      # case 2: $origin < $o.origin
+      #         if current $this insert_position > $o origin: $this ins
+      #         else $insert_position will not change
+      #         (maybe we encounter case 1 later, then this will be to the right of $o)
+      # case 3: $origin > $o.origin
+      #         $this insert_position is to the left of $o (forever!)
+      */
+      execute: function * (op) {
+        var i // loop counter
+
+        // during this function some ops may get split into two pieces (e.g. with getInsertionCleanEnd)
+        // We try to merge them later, if possible
+        var tryToRemergeLater = []
+
+        if (op.origin != null) { // TODO: !== instead of !=
+          // we save in origin that op originates in it
+          // we need that later when we eventually garbage collect origin (see transaction)
+          var origin = yield * this.getInsertionCleanEnd(op.origin)
+          if (origin.originOf == null) {
+            origin.originOf = []
+          }
+          origin.originOf.push(op.id)
+          yield * this.setOperation(origin)
+          if (origin.right != null) {
+            tryToRemergeLater.push(origin.right)
+          }
+        }
+        var distanceToOrigin = i = yield * Struct.Insert.getDistanceToOrigin.call(this, op) // most cases: 0 (starts from 0)
+
+        // now we begin to insert op in the list of insertions..
+        var o
+        var parent
+        var start
+
+        // find o. o is the first conflicting operation
+        if (op.left != null) {
+          o = yield * this.getInsertionCleanEnd(op.left)
+          if (!Y.utils.compareIds(op.left, op.origin) && o.right != null) {
+            // only if not added previously
+            tryToRemergeLater.push(o.right)
+          }
+          o = (o.right == null) ? null : yield * this.getOperation(o.right)
+        } else { // left == null
+          parent = yield * this.getOperation(op.parent)
+          let startId = op.parentSub ? parent.map[op.parentSub] : parent.start
+          start = startId == null ? null : yield * this.getOperation(startId)
+          o = start
+        }
+
+        // make sure to split op.right if necessary (also add to tryCombineWithLeft)
+        if (op.right != null) {
+          tryToRemergeLater.push(op.right)
+          yield * this.getInsertionCleanStart(op.right)
+        }
+
+        // handle conflicts
+        while (true) {
+          if (o != null && !Y.utils.compareIds(o.id, op.right)) {
+            var oOriginDistance = yield * Struct.Insert.getDistanceToOrigin.call(this, o)
+            if (oOriginDistance === i) {
+              // case 1
+              if (o.id[0] < op.id[0]) {
+                op.left = Y.utils.getLastId(o)
+                distanceToOrigin = i + 1 // just ignore o.content.length, doesn't make a difference
+              }
+            } else if (oOriginDistance < i) {
+              // case 2
+              if (i - distanceToOrigin <= oOriginDistance) {
+                op.left = Y.utils.getLastId(o)
+                distanceToOrigin = i + 1 // just ignore o.content.length, doesn't make a difference
+              }
+            } else {
+              break
+            }
+            i++
+            if (o.right != null) {
+              o = yield * this.getInsertion(o.right)
+            } else {
+              o = null
+            }
+          } else {
+            break
+          }
+        }
+
+        // reconnect..
+        var left = null
+        var right = null
+        if (parent == null) {
+          parent = yield * this.getOperation(op.parent)
+        }
+
+        // reconnect left and set right of op
+        if (op.left != null) {
+          left = yield * this.getInsertion(op.left)
+          // link left
+          op.right = left.right
+          left.right = op.id
+
+          yield * this.setOperation(left)
+        } else {
+          // set op.right from parent, if necessary
+          op.right = op.parentSub ? parent.map[op.parentSub] || null : parent.start
+        }
+        // reconnect right
+        if (op.right != null) {
+          // TODO: wanna connect right too?
+          right = yield * this.getOperation(op.right)
+          right.left = Y.utils.getLastId(op)
+
+          // if right exists, and it is supposed to be gc'd. Remove it from the gc
+          if (right.gc != null) {
+            if (right.content != null && right.content.length > 1) {
+              right = yield * this.getInsertionCleanEnd(right.id)
+            }
+            this.store.removeFromGarbageCollector(right)
+          }
+          yield * this.setOperation(right)
+        }
+
+        // update parents .map/start/end properties
+        if (op.parentSub != null) {
+          if (left == null) {
+            parent.map[op.parentSub] = op.id
+            yield * this.setOperation(parent)
+          }
+          // is a child of a map struct.
+          // Then also make sure that only the most left element is not deleted
+          // We do not call the type in this case (this is what the third parameter is for)
+          if (op.right != null) {
+            yield * this.deleteOperation(op.right, 1, true)
+          }
+          if (op.left != null) {
+            yield * this.deleteOperation(op.id, 1, true)
+          }
+        } else {
+          if (right == null || left == null) {
+            if (right == null) {
+              parent.end = Y.utils.getLastId(op)
+            }
+            if (left == null) {
+              parent.start = op.id
+            }
+            yield * this.setOperation(parent)
+          }
+        }
+
+        // try to merge original op.left and op.origin
+        for (i = 0; i < tryToRemergeLater.length; i++) {
+          var m = yield * this.getOperation(tryToRemergeLater[i])
+          yield * this.tryCombineWithLeft(m)
        }
      }
-      return res
    },
-    map: function * (o, f) {
-      o = o.start
-      var res = []
-      while (o != null) { // TODO: change to != (at least some convention)
-        var operation = yield* this.getOperation(o)
-        if (!operation.deleted) {
-          res.push(f(operation))
-        }
-        o = operation.right
-      }
-      return res
-    }
-  },
-  Map: {
-    /*
+    List: {
+      /*
      {
-        map: {},
-        struct: "Map",
+        start: null,
+        end: null,
+        struct: "List",
        type: "",
-        id: this.os.getNextOpId()
+        id: this.os.getNextOpId(1)
      }
-    */
-    encode: function (op) {
-      return {
-        struct: 'Map',
-        type: op.type,
-        id: op.id,
-        map: {} // overwrite map!!
+      */
+      create: function (id) {
+        return {
+          start: null,
+          end: null,
+          struct: 'List',
+          id: id
+        }
+      },
+      encode: function (op) {
+        var e = {
+          struct: 'List',
+          id: op.id,
+          type: op.type
+        }
+        if (op.requires != null) {
+          e.requires = op.requires
+        }
+        if (op.info != null) {
+          e.info = op.info
+        }
+        return e
+      },
+      requiredOps: function () {
+        /*
+        var ids = []
+        if (op.start != null) {
+          ids.push(op.start)
+        }
+        if (op.end != null){
+          ids.push(op.end)
+        }
+        return ids
+        */
+        return []
+      },
+      execute: function * (op) {
+        op.start = null
+        op.end = null
+      },
+      ref: function * (op, pos) {
+        if (op.start == null) {
+          return null
+        }
+        var res = null
+        var o = yield * this.getOperation(op.start)
+
+        while (true) {
+          if (!o.deleted) {
+            res = o
+            pos--
+          }
+          if (pos >= 0 && o.right != null) {
+            o = yield * this.getOperation(o.right)
+          } else {
+            break
+          }
+        }
+        return res
+      },
+      map: function * (o, f) {
+        o = o.start
+        var res = []
+        while (o != null) { // TODO: change to != (at least some convention)
+          var operation = yield * this.getOperation(o)
+          if (!operation.deleted) {
+            res.push(f(operation))
+          }
+          o = operation.right
+        }
+        return res
      }
    },
-    requiredOps: function () {
-      return []
-    },
-    execute: function * () {},
-    /*
-      Get a property by name
-    */
-    get: function * (op, name) {
-      var oid = op.map[name]
-      if (oid != null) {
-        var res = yield* this.getOperation(oid)
-        return (res == null || res.deleted) ? void 0 : (res.opContent == null
-          ? res.content : yield* this.getType(res.opContent))
-      }
-    },
-    /*
-      Delete a property by name
-    */
-    delete: function * (op, name) {
-      var v = op.map[name] || null
-      if (v != null) {
-        yield* Struct.Delete.create.call(this, {
-          target: v
-        })
+    Map: {
+      /*
+        {
+          map: {},
+          struct: "Map",
+          type: "",
+          id: this.os.getNextOpId(1)
+        }
+      */
+      create: function (id) {
+        return {
+          id: id,
+          map: {},
+          struct: 'Map'
+        }
+      },
+      encode: function (op) {
+        var e = {
+          struct: 'Map',
+          type: op.type,
+          id: op.id,
+          map: {} // overwrite map!!
+        }
+        if (op.requires != null) {
+          e.requires = op.requires
+        }
+        if (op.info != null) {
+          e.info = op.info
+        }
+        return e
+      },
+      requiredOps: function () {
+        return []
+      },
+      execute: function * () {},
+      /*
+        Get a property by name
+      */
+      get: function * (op, name) {
+        var oid = op.map[name]
+        if (oid != null) {
+          var res = yield * this.getOperation(oid)
+          if (res == null || res.deleted) {
+            return void 0
+          } else if (res.opContent == null) {
+            return res.content[0]
+          } else {
+            return yield * this.getType(res.opContent)
+          }
+        }
      }
    }
  }
+  Y.Struct = Struct
 }
-Y.Struct = Struct
--- a/src/Transaction.js
+++ b/src/Transaction.js
--- a/src/Types/Array.js
+++ b/src/Types/Array.js
@@ -1,192 +0,0 @@
-/* global Y */
-'use strict'
-
-;(function () {
-  class YArray {
-    constructor (os, _model, idArray, valArray) {
-      this.os = os
-      this._model = _model
-      // Array of all the operation id's
-      this.idArray = idArray
-      // Array of all the values
-      this.valArray = valArray
-      this.eventHandler = new Y.utils.EventHandler(ops => {
-        var userEvents = []
-        for (var i in ops) {
-          var op = ops[i]
-          if (op.struct === 'Insert') {
-            let pos
-            // we check op.left only!,
-            // because op.right might not be defined when this is called
-            if (op.left === null) {
-              pos = 0
-            } else {
-              var sid = JSON.stringify(op.left)
-              pos = this.idArray.indexOf(sid) + 1
-              if (pos <= 0) {
-                throw new Error('Unexpected operation!')
-              }
-            }
-            this.idArray.splice(pos, 0, JSON.stringify(op.id))
-            this.valArray.splice(pos, 0, op.content)
-            userEvents.push({
-              type: 'insert',
-              object: this,
-              index: pos,
-              length: 1
-            })
-          } else if (op.struct === 'Delete') {
-            let pos = this.idArray.indexOf(JSON.stringify(op.target))
-            if (pos >= 0) {
-              this.idArray.splice(pos, 1)
-              this.valArray.splice(pos, 1)
-              userEvents.push({
-                type: 'delete',
-                object: this,
-                index: pos,
-                length: 1
-              })
-            }
-          } else {
-            throw new Error('Unexpected struct!')
-          }
-        }
-        this.eventHandler.callEventListeners(userEvents)
-      })
-    }
-    get length () {
-      return this.idArray.length
-    }
-    get (pos) {
-      if (pos == null || typeof pos !== 'number') {
-        throw new Error('pos must be a number!')
-      }
-      return this.valArray[pos]
-    }
-    toArray () {
-      return this.valArray.slice()
-    }
-    insert (pos, contents) {
-      if (typeof pos !== 'number') {
-        throw new Error('pos must be a number!')
-      }
-      if (!(contents instanceof Array)) {
-        throw new Error('contents must be an Array of objects!')
-      }
-      if (contents.length === 0) {
-        return
-      }
-      if (pos > this.idArray.length || pos < 0) {
-        throw new Error('This position exceeds the range of the array!')
-      }
-      var mostLeft = pos === 0 ? null : JSON.parse(this.idArray[pos - 1])
-
-      var ops = []
-      var prevId = mostLeft
-      for (var i = 0; i < contents.length; i++) {
-        var op = {
-          left: prevId,
-          origin: prevId,
-          // right: mostRight,
-          // NOTE: I intentionally do not define right here, because it could be deleted
-          // at the time of creating this operation, and is therefore not defined in idArray
-          parent: this._model,
-          content: contents[i],
-          struct: 'Insert',
-          id: this.os.getNextOpId()
-        }
-        ops.push(op)
-        prevId = op.id
-      }
-      var eventHandler = this.eventHandler
-      eventHandler.awaitAndPrematurelyCall(ops)
-      this.os.requestTransaction(function *() {
-        // now we can set the right reference.
-        var mostRight
-        if (mostLeft != null) {
-          mostRight = (yield* this.getOperation(mostLeft)).right
-        } else {
-          mostRight = (yield* this.getOperation(ops[0].parent)).start
-        }
-        for (var j in ops) {
-          ops[j].right = mostRight
-        }
-        yield* this.applyCreatedOperations(ops)
-        eventHandler.awaitedInserts(ops.length)
-      })
-    }
-    delete (pos, length) {
-      if (length == null) { length = 1 }
-      if (typeof length !== 'number') {
-        throw new Error('pos must be a number!')
-      }
-      if (typeof pos !== 'number') {
-        throw new Error('pos must be a number!')
-      }
-      if (pos + length > this.idArray.length || pos < 0 || length < 0) {
-        throw new Error('The deletion range exceeds the range of the array!')
-      }
-      if (length === 0) {
-        return
-      }
-      var eventHandler = this.eventHandler
-      var newLeft = pos > 0 ? JSON.parse(this.idArray[pos - 1]) : null
-      var dels = []
-      for (var i = 0; i < length; i++) {
-        dels.push({
-          target: JSON.parse(this.idArray[pos + i]),
-          struct: 'Delete'
-        })
-      }
-      eventHandler.awaitAndPrematurelyCall(dels)
-      this.os.requestTransaction(function *() {
-        yield* this.applyCreatedOperations(dels)
-        eventHandler.awaitedDeletes(dels.length, newLeft)
-      })
-    }
-    observe (f) {
-      this.eventHandler.addEventListener(f)
-    }
-    * _changed (transaction, op) {
-      if (!op.deleted) {
-        if (op.struct === 'Insert') {
-          var l = op.left
-          var left
-          while (l != null) {
-            left = yield* transaction.getOperation(l)
-            if (!left.deleted) {
-              break
-            }
-            l = left.left
-          }
-          op.left = l
-        }
-        this.eventHandler.receivedOp(op)
-      }
-    }
-  }
-
-  Y.Array = new Y.utils.CustomType({
-    class: YArray,
-    createType: function * YArrayCreator () {
-      var modelid = this.store.getNextOpId()
-      var model = {
-        struct: 'List',
-        type: 'Array',
-        start: null,
-        end: null,
-        id: modelid
-      }
-      yield* this.applyCreatedOperations([model])
-      return modelid
-    },
-    initType: function * YArrayInitializer (os, model) {
-      var valArray = []
-      var idArray = yield* Y.Struct.List.map.call(this, model, function (c) {
-        valArray.push(c.content)
-        return JSON.stringify(c.id)
-      })
-      return new YArray(os, model.id, idArray, valArray)
-    }
-  })
-})()
--- a/src/Types/Array.spec.js
+++ b/src/Types/Array.spec.js
@@ -1,310 +0,0 @@
-/* global createUsers, databases, wait, Y, compareAllUsers, getRandomNumber, applyRandomTransactionsAllRejoinNoGC, applyRandomTransactionsWithGC, async, garbageCollectAllUsers, describeManyTimes */
-/* eslint-env browser,jasmine */
-
-var numberOfYArrayTests = 50
-var repeatArrayTests = 2
-
-for (let database of databases) {
-  describe(`Array Type (DB: ${database})`, function () {
-    var y1, y2, y3, yconfig1, yconfig2, yconfig3, flushAll
-
-    beforeEach(async(function * (done) {
-      yield createUsers(this, 3, database)
-      y1 = (yconfig1 = this.users[0]).root
-      y2 = (yconfig2 = this.users[1]).root
-      y3 = (yconfig3 = this.users[2]).root
-      flushAll = this.users[0].connector.flushAll
-      yield wait(10)
-      done()
-    }))
-    afterEach(async(function * (done) {
-      yield compareAllUsers(this.users)
-      done()
-    }))
-
-    describe('Basic tests', function () {
-      it('insert three elements, try re-get property', async(function * (done) {
-        var array = yield y1.set('Array', Y.Array)
-        array.insert(0, [1, 2, 3])
-        array = yield y1.get('Array') // re-get property
-        expect(array.toArray()).toEqual([1, 2, 3])
-        done()
-      }))
-      it('Basic insert in array (handle three conflicts)', async(function * (done) {
-        yield y1.set('Array', Y.Array)
-        yield flushAll()
-        var l1 = yield y1.get('Array')
-        l1.insert(0, [0])
-        var l2 = yield y2.get('Array')
-        l2.insert(0, [1])
-        var l3 = yield y3.get('Array')
-        l3.insert(0, [2])
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        done()
-      }))
-      it('Basic insert&delete in array (handle three conflicts)', async(function * (done) {
-        var l1, l2, l3
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y', 'z'])
-        yield flushAll()
-        l1.insert(1, [0])
-        l2 = yield y2.get('Array')
-        l2.delete(0)
-        l2.delete(1)
-        l3 = yield y3.get('Array')
-        l3.insert(1, [2])
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        expect(l2.toArray()).toEqual([0, 2, 'y'])
-        done()
-      }))
-      it('Handles getOperations ascending ids bug in late sync', async(function * (done) {
-        var l1, l2
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y'])
-        yield flushAll()
-        yconfig3.disconnect()
-        yconfig2.disconnect()
-        yield wait()
-        l2 = yield y2.get('Array')
-        l2.insert(1, [2])
-        l2.insert(1, [3])
-        yield yconfig2.reconnect()
-        yield yconfig3.reconnect()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        done()
-      }))
-      it('Handles deletions in late sync', async(function * (done) {
-        var l1, l2
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y'])
-        yield flushAll()
-        yield yconfig2.disconnect()
-        yield wait()
-        l2 = yield y2.get('Array')
-        l2.delete(1, 1)
-        l1.delete(0, 2)
-        yield yconfig2.reconnect()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        done()
-      }))
-      it('Handles deletions in late sync (2)', async(function * (done) {
-        var l1, l2
-        l1 = yield y1.set('Array', Y.Array)
-        yield flushAll()
-        l2 = yield y2.get('Array')
-        l1.insert(0, ['x', 'y'])
-        l1.delete(0, 2)
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        done()
-      }))
-      it('Basic insert. Then delete the whole array', async(function * (done) {
-        var l1, l2, l3
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y', 'z'])
-        yield flushAll()
-        l1.delete(0, 3)
-        l2 = yield y2.get('Array')
-        l3 = yield y3.get('Array')
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        expect(l2.toArray()).toEqual([])
-        done()
-      }))
-      it('Basic insert. Then delete the whole array (merge listeners on late sync)', async(function * (done) {
-        var l1, l2, l3
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y', 'z'])
-        yield flushAll()
-        yconfig2.disconnect()
-        l1.delete(0, 3)
-        l2 = yield y2.get('Array')
-        yield wait()
-        yield yconfig2.reconnect()
-        yield wait()
-        l3 = yield y3.get('Array')
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        expect(l2.toArray()).toEqual([])
-        done()
-      }))
-      // TODO?
-      /* it('Basic insert. Then delete the whole array (merge deleter on late sync)', async(function * (done) {
-        var l1, l2, l3
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y', 'z'])
-        yield flushAll()
-        yconfig1.disconnect()
-        l1.delete(0, 3)
-        l2 = yield y2.get('Array')
-        yield yconfig1.reconnect()
-        l3 = yield y3.get('Array')
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        expect(l2.toArray()).toEqual([])
-        done()
-      })) */
-      it('throw insert & delete events', async(function * (done) {
-        var array = yield this.users[0].root.set('array', Y.Array)
-        var event
-        array.observe(function (e) {
-          event = e
-        })
-        array.insert(0, [0])
-        expect(event).toEqual([{
-          type: 'insert',
-          object: array,
-          index: 0,
-          length: 1
-        }])
-        array.delete(0)
-        expect(event).toEqual([{
-          type: 'delete',
-          object: array,
-          index: 0,
-          length: 1
-        }])
-        yield wait(50)
-        done()
-      }))
-      it('garbage collects', async(function * (done) {
-        var l1, l2, l3
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y', 'z'])
-        yield flushAll()
-        yconfig1.disconnect()
-        l1.delete(0, 3)
-        l2 = yield y2.get('Array')
-        yield wait()
-        yield yconfig1.reconnect()
-        yield wait()
-        l3 = yield y3.get('Array')
-        yield flushAll()
-        yield garbageCollectAllUsers(this.users)
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        expect(l2.toArray()).toEqual([])
-        done()
-      }))
-      it('debug right not existend in Insert.execute', async(function * (done) {
-        yconfig1.db.requestTransaction(function * () {
-          var ops = [{'struct':'Map','type':'Map','id':['130',0],'map':{}},{'id':['130',1],'left':null,'right':null,'origin':null,'parent':['_',0],'struct':'Insert','parentSub':'Map','opContent':['130',0]},{'struct':'Map','type':'Map','id':['130',0],'map':{}},{'id':['130',1],'left':null,'right':null,'origin':null,'parent':['_',0],'struct':'Insert','parentSub':'Map','opContent':['130',0]},{'struct':'Map','type':'Map','id':['130',0],'map':{}},{'id':['130',1],'left':null,'right':null,'origin':null,'parent':['_',0],'struct':'Insert','parentSub':'Map','opContent':['130',0]},{'left':null,'right':null,'origin':null,'parent':['130',0],'parentSub':'somekey','struct':'Insert','content':512,'id':['133',0]},{'id':['130',2],'left':null,'right':null,'origin':null,'parent':['130',0],'struct':'Insert','parentSub':'somekey','content':1131},{'id':['130',3],'left':null,'right':['130',2],'origin':null,'parent':['130',0],'struct':'Insert','parentSub':'somekey','content':4196},{'id':['131',3],'left':null,'right':null,'origin':null,'parent':['130',0],'struct':'Insert','parentSub':'somekey','content':5022}]//eslint-disable-line
-
-          for (var o of ops) {
-            yield* this.store.tryExecute.call(this, o)
-          }
-        })
-        yield wait()
-        yield yconfig3.disconnect()
-        yield yconfig2.disconnect()
-        yield flushAll()
-        wait()
-        yield yconfig3.reconnect()
-        yield yconfig2.reconnect()
-        yield wait()
-        yield flushAll()
-        done()
-      }))
-      it('debug right not existend in Insert.execute (2)', async(function * (done) {
-        yconfig1.db.requestTransaction(function * () {
-          yield* this.store.tryExecute.call(this, {'struct': 'Map', 'type': 'Map', 'id': ['153', 0], 'map': {}})
-          yield* this.store.tryExecute.call(this, {'id': ['153', 1], 'left': null, 'right': null, 'origin': null, 'parent': ['_', 0], 'struct': 'Insert', 'parentSub': 'Map', 'opContent': ['153', 0]})
-          yield* this.store.tryExecute.call(this, {'struct': 'Map', 'type': 'Map', 'id': ['153', 0], 'map': {}})
-          yield* this.store.tryExecute.call(this, {'id': ['153', 1], 'left': null, 'right': null, 'origin': null, 'parent': ['_', 0], 'struct': 'Insert', 'parentSub': 'Map', 'opContent': ['153', 0]})
-          yield* this.store.tryExecute.call(this, {'struct': 'Map', 'type': 'Map', 'id': ['153', 0], 'map': {}})
-          yield* this.store.tryExecute.call(this, {'id': ['153', 1], 'left': null, 'right': null, 'origin': null, 'parent': ['_', 0], 'struct': 'Insert', 'parentSub': 'Map', 'opContent': ['153', 0]})
-          yield* this.store.tryExecute.call(this, {'left': null, 'right': null, 'origin': null, 'parent': ['153', 0], 'parentSub': 'somekey', 'struct': 'Insert', 'content': 3784, 'id': ['154', 0]})
-          yield* this.store.tryExecute.call(this, {'left': null, 'right': ['154', 0], 'origin': null, 'parent': ['153', 0], 'parentSub': 'somekey', 'struct': 'Insert', 'content': 8217, 'id': ['154', 1]})
-          yield* this.store.tryExecute.call(this, {'left': null, 'right': ['154', 1], 'origin': null, 'parent': ['153', 0], 'parentSub': 'somekey', 'struct': 'Insert', 'content': 5036, 'id': ['154', 2]})
-          yield* this.store.tryExecute.call(this, {'id': ['153', 2], 'left': null, 'right': null, 'origin': null, 'parent': ['153', 0], 'struct': 'Insert', 'parentSub': 'somekey', 'content': 417})
-          yield* this.store.tryExecute.call(this, {'id': ['155', 0], 'left': null, 'right': null, 'origin': null, 'parent': ['153', 0], 'struct': 'Insert', 'parentSub': 'somekey', 'content': 2202})
-          yield* this.garbageCollectOperation(['153', 2])
-          yield* this.garbageCollectOperation(['154', 0])
-          yield* this.garbageCollectOperation(['154', 1])
-          yield* this.garbageCollectOperation(['154', 2])
-          yield* this.garbageCollectOperation(['155', 0])
-          yield* this.garbageCollectOperation(['156', 0])
-          yield* this.garbageCollectOperation(['157', 0])
-          yield* this.garbageCollectOperation(['157', 1])
-          yield* this.store.tryExecute.call(this, {'id': ['153', 3], 'left': null, 'right': null, 'origin': null, 'parent': ['153', 0], 'struct': 'Insert', 'parentSub': 'somekey', 'content': 4372})
-        })
-        yield wait()
-        yield yconfig3.disconnect()
-        yield yconfig2.disconnect()
-        yield flushAll()
-        wait()
-        yield yconfig3.reconnect()
-        yield yconfig2.reconnect()
-        yield wait()
-        yield flushAll()
-        done()
-      }))
-    })
-    describeManyTimes(repeatArrayTests, `Random tests`, function () {
-      var randomArrayTransactions = [
-        function insert (array) {
-          array.insert(getRandomNumber(array.toArray().length), [getRandomNumber()])
-        },
-        function _delete (array) {
-          var length = array.toArray().length
-          if (length > 0) {
-            array.delete(getRandomNumber(length - 1))
-          }
-        }
-      ]
-      function compareArrayValues (arrays) {
-        var firstArray
-        for (var l of arrays) {
-          var val = l.toArray()
-          if (firstArray == null) {
-            firstArray = val
-          } else {
-            expect(val).toEqual(firstArray)
-          }
-        }
-      }
-      beforeEach(async(function * (done) {
-        yield this.users[0].root.set('Array', Y.Array)
-        yield flushAll()
-
-        var promises = []
-        for (var u = 0; u < this.users.length; u++) {
-          promises.push(this.users[u].root.get('Array'))
-        }
-        this.arrays = yield Promise.all(promises)
-        done()
-      }))
-      it('arrays.length equals users.length', async(function * (done) {
-        expect(this.arrays.length).toEqual(this.users.length)
-        done()
-      }))
-      it(`succeed after ${numberOfYArrayTests} actions, no GC, all users disconnecting/reconnecting`, async(function * (done) {
-        for (var u of this.users) {
-          u.connector.debug = true
-        }
-        yield applyRandomTransactionsAllRejoinNoGC(this.users, this.arrays, randomArrayTransactions, numberOfYArrayTests)
-        yield flushAll()
-        yield compareArrayValues(this.arrays)
-        yield compareAllUsers(this.users)
-        done()
-      }))
-      it(`succeed after ${numberOfYArrayTests} actions, GC, user[0] is not disconnecting`, async(function * (done) {
-        for (var u of this.users) {
-          u.connector.debug = true
-        }
-        yield applyRandomTransactionsWithGC(this.users, this.arrays, randomArrayTransactions, numberOfYArrayTests)
-        yield flushAll()
-        yield compareArrayValues(this.arrays)
-        yield compareAllUsers(this.users)
-        done()
-      }))
-    })
-  })
-}
--- a/src/Types/Map.js
+++ b/src/Types/Map.js
@@ -1,295 +0,0 @@
-/* global Y */
-'use strict'
-
-;(function () {
-  class YMap {
-    constructor (os, model, contents, opContents) {
-      this._model = model.id
-      this.os = os
-      this.map = Y.utils.copyObject(model.map)
-      this.contents = contents
-      this.opContents = opContents
-      this.eventHandler = new Y.utils.EventHandler(ops => {
-        var userEvents = []
-        for (var i in ops) {
-          var op = ops[i]
-          var oldValue
-          // key is the name to use to access (op)content
-          var key = op.struct === 'Delete' ? op.key : op.parentSub
-
-          // compute oldValue
-          if (this.opContents[key] != null) {
-            let prevType = this.opContents[key]
-            oldValue = () => {// eslint-disable-line
-              return new Promise((resolve) => {
-                this.os.requestTransaction(function *() {// eslint-disable-line
-                  resolve(yield* this.getType(prevType))
-                })
-              })
-            }
-          } else {
-            oldValue = this.contents[key]
-          }
-          // compute op event
-          if (op.struct === 'Insert') {
-            if (op.left === null) {
-              if (op.opContent != null) {
-                delete this.contents[key]
-                if (op.deleted) {
-                  delete this.opContents[key]
-                } else {
-                  this.opContents[key] = op.opContent
-                }
-              } else {
-                delete this.opContents[key]
-                if (op.deleted) {
-                  delete this.contents[key]
-                } else {
-                  this.contents[key] = op.content
-                }
-              }
-              this.map[key] = op.id
-              var insertEvent = {
-                name: key,
-                object: this
-              }
-              if (oldValue === undefined) {
-                insertEvent.type = 'add'
-              } else {
-                insertEvent.type = 'update'
-                insertEvent.oldValue = oldValue
-              }
-              userEvents.push(insertEvent)
-            }
-          } else if (op.struct === 'Delete') {
-            if (Y.utils.compareIds(this.map[key], op.target)) {
-              delete this.opContents[key]
-              delete this.contents[key]
-              var deleteEvent = {
-                name: key,
-                object: this,
-                oldValue: oldValue,
-                type: 'delete'
-              }
-              userEvents.push(deleteEvent)
-            }
-          } else {
-            throw new Error('Unexpected Operation!')
-          }
-        }
-        this.eventHandler.callEventListeners(userEvents)
-      })
-    }
-    get (key) {
-      // return property.
-      // if property does not exist, return null
-      // if property is a type, return a promise
-      if (key == null) {
-        throw new Error('You must specify key!')
-      }
-      if (this.opContents[key] == null) {
-        return this.contents[key]
-      } else {
-        return new Promise((resolve) => {
-          var oid = this.opContents[key]
-          this.os.requestTransaction(function *() {
-            resolve(yield* this.getType(oid))
-          })
-        })
-      }
-    }
-    /*
-      If there is a primitive (not a custom type), then return it.
-      Returns all primitive values, if propertyName is specified!
-      Note: modifying the return value could result in inconsistencies!
-        -- so make sure to copy it first!
-    */
-    getPrimitive (key) {
-      if (key == null) {
-        return Y.utils.copyObject(this.contents)
-      } else {
-        return this.contents[key]
-      }
-    }
-    delete (key) {
-      var right = this.map[key]
-      if (right != null) {
-        var del = {
-          target: right,
-          struct: 'Delete'
-        }
-        var eventHandler = this.eventHandler
-        var modDel = Y.utils.copyObject(del)
-        modDel.key = key
-        eventHandler.awaitAndPrematurelyCall([modDel])
-        this.os.requestTransaction(function *() {
-          yield* this.applyCreatedOperations([del])
-          eventHandler.awaitedDeletes(1)
-        })
-      }
-    }
-    set (key, value) {
-      // set property.
-      // if property is a type, return a promise
-      // if not, apply immediately on this type an call event
-
-      var right = this.map[key] || null
-      var insert = {
-        left: null,
-        right: right,
-        origin: null,
-        parent: this._model,
-        parentSub: key,
-        struct: 'Insert'
-      }
-      return new Promise((resolve) => {
-        if (value instanceof Y.utils.CustomType) {
-          // construct a new type
-          this.os.requestTransaction(function *() {
-            var typeid = yield* value.createType.call(this)
-            var type = yield* this.getType(typeid)
-            insert.opContent = typeid
-            insert.id = this.store.getNextOpId()
-            yield* this.applyCreatedOperations([insert])
-            resolve(type)
-          })
-        } else {
-          insert.content = value
-          insert.id = this.os.getNextOpId()
-          var eventHandler = this.eventHandler
-          eventHandler.awaitAndPrematurelyCall([insert])
-
-          this.os.requestTransaction(function *() {
-            yield* this.applyCreatedOperations([insert])
-            eventHandler.awaitedInserts(1)
-          })
-          resolve(value)
-        }
-      })
-    }
-    observe (f) {
-      this.eventHandler.addEventListener(f)
-    }
-    unobserve (f) {
-      this.eventHandler.removeEventListener(f)
-    }
-    /*
-      Observe a path.
-
-      E.g.
-      ```
-      o.set('textarea', Y.TextBind)
-      o.observePath(['textarea'], function(t){
-        // is called whenever textarea is replaced
-        t.bind(textarea)
-      })
-
-      returns a Promise that contains a function that removes the observer from the path.
-    */
-    observePath (path, f) {
-      var self = this
-      function observeProperty (events) {
-        // call f whenever path changes
-        for (var i = 0; i < events.length; i++) {
-          var event = events[i]
-          if (event.name === propertyName) {
-            // call this also for delete events!
-            var property = self.get(propertyName)
-            if (property instanceof Promise) {
-              property.then(f)
-            } else {
-              f(property)
-            }
-          }
-        }
-      }
-
-      if (path.length < 1) {
-        throw new Error('Path must contain at least one element!')
-      } else if (path.length === 1) {
-        var propertyName = path[0]
-        var property = self.get(propertyName)
-        if (property instanceof Promise) {
-          property.then(f)
-        } else {
-          f(property)
-        }
-        this.observe(observeProperty)
-        return Promise.resolve(function () {
-          self.unobserve(f)
-        })
-      } else {
-        var deleteChildObservers
-        var resetObserverPath = function () {
-          var promise = self.get(path[0])
-          if (!promise instanceof Promise) {
-            // its either not defined or a primitive value
-            promise = self.set(path[0], Y.Map)
-          }
-          return promise.then(function (map) {
-            return map.observePath(path.slice(1), f)
-          }).then(function (_deleteChildObservers) {
-            // update deleteChildObservers
-            deleteChildObservers = _deleteChildObservers
-            return Promise.resolve() // Promise does not return anything
-          })
-        }
-        var observer = function (events) {
-          for (var e in events) {
-            var event = events[e]
-            if (event.name === path[0]) {
-              deleteChildObservers()
-              if (event.type === 'add' || event.type === 'update') {
-                resetObserverPath()
-              }
-              // TODO: what about the delete events?
-            }
-          }
-        }
-        self.observe(observer)
-        return resetObserverPath().then(
-          // this promise contains a function that deletes all the child observers
-          // and how to unobserve the observe from this object
-          Promise.resolve(function () {
-            deleteChildObservers()
-            self.unobserve(observer)
-          })
-        )
-      }
-    }
-    * _changed (transaction, op) {
-      if (op.struct === 'Delete') {
-        op.key = (yield* transaction.getOperation(op.target)).parentSub
-      }
-      this.eventHandler.receivedOp(op)
-    }
-  }
-  Y.Map = new Y.utils.CustomType({
-    class: YMap,
-    createType: function * YMapCreator () {
-      var modelid = this.store.getNextOpId()
-      var model = {
-        map: {},
-        struct: 'Map',
-        type: 'Map',
-        id: modelid
-      }
-      yield* this.applyCreatedOperations([model])
-      return modelid
-    },
-    initType: function * YMapInitializer (os, model) {
-      var contents = {}
-      var opContents = {}
-      var map = model.map
-      for (var name in map) {
-        var op = yield* this.getOperation(map[name])
-        if (op.opContent != null) {
-          opContents[name] = op.opContent
-        } else {
-          contents[name] = op.content
-        }
-      }
-      return new YMap(os, model, contents, opContents)
-    }
-  })
-})()
--- a/src/Types/Map.spec.js
+++ b/src/Types/Map.spec.js
@@ -1,219 +0,0 @@
-/* global createUsers, Y, databases, compareAllUsers, getRandomNumber, applyRandomTransactionsAllRejoinNoGC, applyRandomTransactionsWithGC, async, describeManyTimes */
-/* eslint-env browser,jasmine */
-
-var numberOfYMapTests = 40
-var repeatMapTeasts = 2
-
-for (let database of databases) {
-  describe(`Map Type (DB: ${database})`, function () {
-    var y1, y2, y3, y4, flushAll
-
-    beforeEach(async(function * (done) {
-      yield createUsers(this, 5, database)
-      y1 = this.users[0].root
-      y2 = this.users[1].root
-      y3 = this.users[2].root
-      y4 = this.users[3].root
-      flushAll = this.users[0].connector.flushAll
-      done()
-    }))
-    afterEach(async(function * (done) {
-      yield compareAllUsers(this.users)
-      done()
-    }), 5000)
-
-    describe('Basic tests', function () {
-      it('Basic get&set of Map property (converge via sync)', async(function * (done) {
-        y1.set('stuff', 'stuffy')
-        expect(y1.get('stuff')).toEqual('stuffy')
-        yield flushAll()
-        for (var key in this.users) {
-          var u = this.users[key].root
-          expect(u.get('stuff')).toEqual('stuffy')
-        }
-        done()
-      }))
-      it('Map can set custom types (Map)', async(function * (done) {
-        var map = yield y1.set('Map', Y.Map)
-        map.set('one', 1)
-        map = yield y1.get('Map')
-        expect(map.get('one')).toEqual(1)
-        done()
-      }))
-      it('Map can set custom types (Array)', async(function * (done) {
-        var array = yield y1.set('Array', Y.Array)
-        array.insert(0, [1, 2, 3])
-        array = yield y1.get('Array')
-        expect(array.toArray()).toEqual([1, 2, 3])
-        done()
-      }))
-      it('Basic get&set of Map property (converge via update)', async(function * (done) {
-        yield flushAll()
-        y1.set('stuff', 'stuffy')
-        expect(y1.get('stuff')).toEqual('stuffy')
-
-        yield flushAll()
-        for (var key in this.users) {
-          var r = this.users[key].root
-          expect(r.get('stuff')).toEqual('stuffy')
-        }
-        done()
-      }))
-      it('Basic get&set of Map property (handle conflict)', async(function * (done) {
-        yield flushAll()
-        y1.set('stuff', 'c0')
-        y2.set('stuff', 'c1')
-
-        yield flushAll()
-        for (var key in this.users) {
-          var u = this.users[key]
-          expect(u.root.get('stuff')).toEqual('c0')
-        }
-        done()
-      }))
-      it('Basic get&set&delete of Map property (handle conflict)', async(function * (done) {
-        yield flushAll()
-        y1.set('stuff', 'c0')
-        y1.delete('stuff')
-        y2.set('stuff', 'c1')
-        yield flushAll()
-
-        for (var key in this.users) {
-          var u = this.users[key]
-          expect(u.root.get('stuff')).toBeUndefined()
-        }
-        done()
-      }))
-      it('Basic get&set of Map property (handle three conflicts)', async(function * (done) {
-        yield flushAll()
-        y1.set('stuff', 'c0')
-        y2.set('stuff', 'c1')
-        y2.set('stuff', 'c2')
-        y3.set('stuff', 'c3')
-        yield flushAll()
-
-        for (var key in this.users) {
-          var u = this.users[key]
-          expect(u.root.get('stuff')).toEqual('c0')
-        }
-        done()
-      }))
-      it('Basic get&set&delete of Map property (handle three conflicts)', async(function * (done) {
-        yield flushAll()
-        y1.set('stuff', 'c0')
-        y2.set('stuff', 'c1')
-        y2.set('stuff', 'c2')
-        y3.set('stuff', 'c3')
-        yield flushAll()
-        y1.set('stuff', 'deleteme')
-        y1.delete('stuff')
-        y2.set('stuff', 'c1')
-        y3.set('stuff', 'c2')
-        y4.set('stuff', 'c3')
-        yield flushAll()
-
-        for (var key in this.users) {
-          var u = this.users[key]
-          expect(u.root.get('stuff')).toBeUndefined()
-        }
-        done()
-      }))
-      it('observePath properties', async(function * (done) {
-        y1.observePath(['map'], function (map) {
-          if (map != null) {
-            map.set('yay', 4)
-          }
-        })
-        yield y2.set('map', Y.Map)
-        yield flushAll()
-        var map = yield y3.get('map')
-        expect(map.get('yay')).toEqual(4)
-        done()
-      }))
-      it('throws add & update & delete events (with type and primitive content)', async(function * (done) {
-        var event
-        yield flushAll()
-        y1.observe(function (e) {
-          event = e // just put it on event, should be thrown synchronously anyway
-        })
-        y1.set('stuff', 4)
-        expect(event).toEqual([{
-          type: 'add',
-          object: y1,
-          name: 'stuff'
-        }])
-        // update, oldValue is in contents
-        yield y1.set('stuff', Y.Array)
-        expect(event).toEqual([{
-          type: 'update',
-          object: y1,
-          name: 'stuff',
-          oldValue: 4
-        }])
-        y1.get('stuff').then(function (replacedArray) {
-          // update, oldValue is in opContents
-          y1.set('stuff', 5)
-          var getYArray = event[0].oldValue
-          expect(typeof getYArray.constructor === 'function').toBeTruthy()
-          getYArray().then(function (array) {
-            expect(array).toEqual(replacedArray)
-
-            // delete
-            y1.delete('stuff')
-            expect(event).toEqual([{
-              type: 'delete',
-              name: 'stuff',
-              object: y1,
-              oldValue: 5
-            }])
-            done()
-          })
-        })
-      }))
-    })
-    describeManyTimes(repeatMapTeasts, `${numberOfYMapTests} Random tests`, function () {
-      var randomMapTransactions = [
-        function set (map) {
-          map.set('somekey', getRandomNumber())
-        },
-        function delete_ (map) {
-          map.delete('somekey')
-        }
-      ]
-      function compareMapValues (maps) {
-        var firstMap
-        for (var map of maps) {
-          var val = map.getPrimitive()
-          if (firstMap == null) {
-            firstMap = val
-          } else {
-            expect(val).toEqual(firstMap)
-          }
-        }
-      }
-      beforeEach(async(function * (done) {
-        yield y1.set('Map', Y.Map)
-        yield flushAll()
-
-        var promises = []
-        for (var u = 0; u < this.users.length; u++) {
-          promises.push(this.users[u].root.get('Map'))
-        }
-        this.maps = yield Promise.all(promises)
-        done()
-      }))
-      it(`succeed after ${numberOfYMapTests} actions, no GC, all users disconnecting/reconnecting`, async(function * (done) {
-        yield applyRandomTransactionsAllRejoinNoGC(this.users, this.maps, randomMapTransactions, numberOfYMapTests)
-        yield flushAll()
-        yield compareMapValues(this.maps)
-        done()
-      }))
-      it(`succeed after ${numberOfYMapTests} actions, GC, user[0] is not disconnecting`, async(function * (done) {
-        yield applyRandomTransactionsWithGC(this.users, this.maps, randomMapTransactions, numberOfYMapTests)
-        yield flushAll()
-        yield compareMapValues(this.maps)
-        done()
-      }))
-    })
-  })
-}
--- a/src/Types/TextBind.js
+++ b/src/Types/TextBind.js
@@ -1,290 +0,0 @@
-/* global Y */
-'use strict'
-
-;(function () {
-  class YTextBind extends Y.Array['class'] {
-    constructor (os, _model, idArray, valArray) {
-      super(os, _model, idArray, valArray)
-      this.textfields = []
-    }
-    toString () {
-      return this.valArray.join('')
-    }
-    insert (pos, content) {
-      super.insert(pos, content.split(''))
-    }
-    bind (textfield, domRoot) {
-      domRoot = domRoot || window; // eslint-disable-line
-      if (domRoot.getSelection == null) {
-        domRoot = window;// eslint-disable-line
-      }
-
-      // don't duplicate!
-      for (var t in this.textfields) {
-        if (this.textfields[t] === textfield) {
-          return
-        }
-      }
-      var creatorToken = false
-
-      var word = this
-      textfield.value = this.toString()
-      this.textfields.push(textfield)
-      var createRange, writeRange, writeContent
-      if (textfield.selectionStart != null && textfield.setSelectionRange != null) {
-        createRange = function (fix) {
-          var left = textfield.selectionStart
-          var right = textfield.selectionEnd
-          if (fix != null) {
-            left = fix(left)
-            right = fix(right)
-          }
-          return {
-            left: left,
-            right: right
-          }
-        }
-        writeRange = function (range) {
-          writeContent(word.toString())
-          textfield.setSelectionRange(range.left, range.right)
-        }
-        writeContent = function (content) {
-          textfield.value = content
-        }
-      } else {
-        createRange = function (fix) {
-          var range = {}
-          var s = domRoot.getSelection()
-          var clength = textfield.textContent.length
-          range.left = Math.min(s.anchorOffset, clength)
-          range.right = Math.min(s.focusOffset, clength)
-          if (fix != null) {
-            range.left = fix(range.left)
-            range.right = fix(range.right)
-          }
-          var editedElement = s.focusNode
-          if (editedElement === textfield || editedElement === textfield.childNodes[0]) {
-            range.isReal = true
-          } else {
-            range.isReal = false
-          }
-          return range
-        }
-
-        writeRange = function (range) {
-          writeContent(word.toString())
-          var textnode = textfield.childNodes[0]
-          if (range.isReal && textnode != null) {
-            if (range.left < 0) {
-              range.left = 0
-            }
-            range.right = Math.max(range.left, range.right)
-            if (range.right > textnode.length) {
-              range.right = textnode.length
-            }
-            range.left = Math.min(range.left, range.right)
-            var r = document.createRange(); // eslint-disable-line
-            r.setStart(textnode, range.left)
-            r.setEnd(textnode, range.right)
-            var s = window.getSelection(); // eslint-disable-line
-            s.removeAllRanges()
-            s.addRange(r)
-          }
-        }
-        writeContent = function (content) {
-          var contentArray = content.replace(new RegExp('\n', 'g'), ' ').split(' ');// eslint-disable-line
-          textfield.innerText = ''
-          for (var i in contentArray) {
-            var c = contentArray[i]
-            textfield.innerText += c
-            if (i !== contentArray.length - 1) {
-              textfield.innerHTML += '&nbsp;'
-            }
-          }
-        }
-      }
-      writeContent(this.toString())
-
-      this.observe(function (events) {
-        for (var e in events) {
-          var event = events[e]
-          if (!creatorToken) {
-            var oPos, fix
-            if (event.type === 'insert') {
-              oPos = event.index
-              fix = function (cursor) {// eslint-disable-line
-                if (cursor <= oPos) {
-                  return cursor
-                } else {
-                  cursor += 1
-                  return cursor
-                }
-              }
-              var r = createRange(fix)
-              writeRange(r)
-            } else if (event.type === 'delete') {
-              oPos = event.index
-              fix = function (cursor) {// eslint-disable-line
-                if (cursor < oPos) {
-                  return cursor
-                } else {
-                  cursor -= 1
-                  return cursor
-                }
-              }
-              r = createRange(fix)
-              writeRange(r)
-            }
-          }
-        }
-      })
-      // consume all text-insert changes.
-      textfield.onkeypress = function (event) {
-        if (word.is_deleted) {
-          // if word is deleted, do not do anything ever again
-          textfield.onkeypress = null
-          return true
-        }
-        creatorToken = true
-        var char
-        if (event.keyCode === 13) {
-          char = '\n'
-        } else if (event.key != null) {
-          if (event.charCode === 32) {
-            char = ' '
-          } else {
-            char = event.key
-          }
-        } else {
-          char = window.String.fromCharCode(event.keyCode); // eslint-disable-line
-        }
-        if (char.length > 1) {
-          return true
-        } else if (char.length > 0) {
-          var r = createRange()
-          var pos = Math.min(r.left, r.right, word.length)
-          var diff = Math.abs(r.right - r.left)
-          word.delete(pos, diff)
-          word.insert(pos, char)
-          r.left = pos + char.length
-          r.right = r.left
-          writeRange(r)
-        }
-        event.preventDefault()
-        creatorToken = false
-        return false
-      }
-      textfield.onpaste = function (event) {
-        if (word.is_deleted) {
-          // if word is deleted, do not do anything ever again
-          textfield.onpaste = null
-          return true
-        }
-        event.preventDefault()
-      }
-      textfield.oncut = function (event) {
-        if (word.is_deleted) {
-          // if word is deleted, do not do anything ever again
-          textfield.oncut = null
-          return true
-        }
-        event.preventDefault()
-      }
-      //
-      // consume deletes. Note that
-      //   chrome: won't consume deletions on keypress event.
-      //   keyCode is deprecated. BUT: I don't see another way.
-      //     since event.key is not implemented in the current version of chrome.
-      //     Every browser supports keyCode. Let's stick with it for now..
-      //
-      textfield.onkeydown = function (event) {
-        creatorToken = true
-        if (word.is_deleted) {
-          // if word is deleted, do not do anything ever again
-          textfield.onkeydown = null
-          return true
-        }
-        var r = createRange()
-        var pos = Math.min(r.left, r.right, word.toString().length)
-        var diff = Math.abs(r.left - r.right)
-        if (event.keyCode != null && event.keyCode === 8) { // Backspace
-          if (diff > 0) {
-            word.delete(pos, diff)
-            r.left = pos
-            r.right = pos
-            writeRange(r)
-          } else {
-            if (event.ctrlKey != null && event.ctrlKey) {
-              var val = word.toString()
-              var newPos = pos
-              var delLength = 0
-              if (pos > 0) {
-                newPos--
-                delLength++
-              }
-              while (newPos > 0 && val[newPos] !== ' ' && val[newPos] !== '\n') {
-                newPos--
-                delLength++
-              }
-              word.delete(newPos, pos - newPos)
-              r.left = newPos
-              r.right = newPos
-              writeRange(r)
-            } else {
-              if (pos > 0) {
-                word.delete(pos - 1, 1)
-                r.left = pos - 1
-                r.right = pos - 1
-                writeRange(r)
-              }
-            }
-          }
-          event.preventDefault()
-          creatorToken = false
-          return false
-        } else if (event.keyCode != null && event.keyCode === 46) { // Delete
-          if (diff > 0) {
-            word.delete(pos, diff)
-            r.left = pos
-            r.right = pos
-            writeRange(r)
-          } else {
-            word.delete(pos, 1)
-            r.left = pos
-            r.right = pos
-            writeRange(r)
-          }
-          event.preventDefault()
-          creatorToken = false
-          return false
-        } else {
-          creatorToken = false
-          return true
-        }
-      }
-    }
-  }
-  Y.TextBind = new Y.utils.CustomType({
-    class: YTextBind,
-    createType: function * YTextBindCreator () {
-      var modelid = this.store.getNextOpId()
-      var model = {
-        start: null,
-        end: null,
-        struct: 'List',
-        type: 'TextBind',
-        id: modelid
-      }
-      yield* this.applyCreatedOperations([model])
-      return modelid
-    },
-    initType: function * YTextBindInitializer (os, model) {
-      var valArray = []
-      var idArray = yield* Y.Struct.List.map.call(this, model, function (c) {
-        valArray.push(c.content)
-        return JSON.stringify(c.id)
-      })
-      return new YTextBind(os, model.id, idArray, valArray)
-    }
-  })
-})()
--- a/src/Utils.js
+++ b/src/Utils.js
@@ -1,198 +1,825 @@
-/* global Y */
-'use strict'
-
 /*
  EventHandler is an helper class for constructing custom types.

  Why: When constructing custom types, you sometimes want your types to work
  synchronous: E.g.
  ``` Synchronous
-  mytype.setSomething("yay")
-  mytype.getSomething() === "yay"
-  ```
-  ``` Asynchronous
-  mytype.setSomething("yay")
-  mytype.getSomething() === undefined
-  mytype.waitForSomething().then(function(){
+    mytype.setSomething("yay")
    mytype.getSomething() === "yay"
-  })
+  ```
+  versus
+  ``` Asynchronous
+    mytype.setSomething("yay")
+    mytype.getSomething() === undefined
+    mytype.waitForSomething().then(function(){
+      mytype.getSomething() === "yay"
+    })
+  ```

  The structures usually work asynchronously (you have to wait for the
-  database request to finish). EventHandler will help you to make your type
-  synchronously.
+  database request to finish). EventHandler helps you to make your type
+  synchronous.
 */
-class EventHandler {
-  /*
-    onevent: is called when the structure changes.

-    Note: "awaiting opertations" is used to denote operations that were
-    prematurely called. Events for received operations can not be executed until
-    all prematurely called operations were executed ("waiting operations")
-  */
-  constructor (onevent) {
-    this.waiting = []
-    this.awaiting = 0
-    this.onevent = onevent
-    this.eventListeners = []
-  }
-  /*
-    Call this when a new operation arrives. It will be executed right away if
-    there are no waiting operations, that you prematurely executed
-  */
-  receivedOp (op) {
-    if (this.awaiting <= 0) {
-      this.onevent([op])
-    } else {
-      this.waiting.push(Y.utils.copyObject(op))
-    }
-  }
-  /*
-    You created some operations, and you want the `onevent` function to be
-    called right away. Received operations will not be executed untill all
-    prematurely called operations are executed
-  */
-  awaitAndPrematurelyCall (ops) {
-    this.awaiting++
-    this.onevent(ops)
-  }
-  /*
-    Basic event listener boilerplate...
-    TODO: maybe put this in a different type..
-  */
-  addEventListener (f) {
-    this.eventListeners.push(f)
-  }
-  removeEventListener (f) {
-    this.eventListeners = this.eventListeners.filter(function (g) {
-      return f !== g
-    })
-  }
-  removeAllEventListeners () {
-    this.eventListeners = []
-  }
-  callEventListeners (event) {
-    for (var i in this.eventListeners) {
-      try {
-        this.eventListeners[i](event)
-      } catch (e) {
-        console.log('User events must not throw Errors!') // eslint-disable-line
+export default function Utils (Y) {
+  Y.utils = {}
+
+  Y.utils.bubbleEvent = function (type, event) {
+    type.eventHandler.callEventListeners(event)
+    event.path = []
+    while (type != null && type._deepEventHandler != null) {
+      type._deepEventHandler.callEventListeners(event)
+      var parent = null
+      if (type._parent != null) {
+        parent = type.os.getType(type._parent)
+      }
+      if (parent != null && parent._getPathToChild != null) {
+        event.path = [parent._getPathToChild(type._model)].concat(event.path)
+        type = parent
+      } else {
+        type = null
      }
    }
  }
-  /*
-    Call this when you successfully awaited the execution of n Insert operations
-  */
-  awaitedInserts (n) {
-    var ops = this.waiting.splice(this.waiting.length - n)
-    for (var oid = 0; oid < ops.length; oid++) {
-      var op = ops[oid]
-      for (var i = this.waiting.length - 1; i >= 0; i--) {
-        let w = this.waiting[i]
-        if (Y.utils.compareIds(op.left, w.id)) {
-          // include the effect of op in w
-          w.right = op.id
-          // exclude the effect of w in op
-          op.left = w.left
-        } else if (Y.utils.compareIds(op.right, w.id)) {
-          // similar..
-          w.left = op.id
-          op.right = w.right
+
+  class NamedEventHandler {
+    constructor () {
+      this._eventListener = {}
+    }
+    on (name, f) {
+      if (this._eventListener[name] == null) {
+        this._eventListener[name] = []
+      }
+      this._eventListener[name].push(f)
+    }
+    off (name, f) {
+      if (name == null || f == null) {
+        throw new Error('You must specify event name and function!')
+      }
+      let listener = this._eventListener[name] || []
+      this._eventListener[name] = listener.filter(e => e !== f)
+    }
+    emit (name, value) {
+      (this._eventListener[name] || []).forEach(l => l(value))
+    }
+    destroy () {
+      this._eventListener = null
+    }
+  }
+  Y.utils.NamedEventHandler = NamedEventHandler
+
+  class EventListenerHandler {
+    constructor () {
+      this.eventListeners = []
+    }
+    destroy () {
+      this.eventListeners = null
+    }
+     /*
+      Basic event listener boilerplate...
+    */
+    addEventListener (f) {
+      this.eventListeners.push(f)
+    }
+    removeEventListener (f) {
+      this.eventListeners = this.eventListeners.filter(function (g) {
+        return f !== g
+      })
+    }
+    removeAllEventListeners () {
+      this.eventListeners = []
+    }
+    callEventListeners (event) {
+      for (var i = 0; i < this.eventListeners.length; i++) {
+        try {
+          var _event = {}
+          for (var name in event) {
+            _event[name] = event[name]
+          }
+          this.eventListeners[i](_event)
+        } catch (e) {
+          /*
+            Your observer threw an error. This error was caught so that Yjs
+            can ensure data consistency! In order to debug this error you
+            have to check "Pause On Caught Exceptions" in developer tools.
+          */
+          console.error(e)
        }
      }
    }
-    this._tryCallEvents()
  }
-  /*
-    Call this when you successfully awaited the execution of n Delete operations
-  */
-  awaitedDeletes (n, newLeft) {
-    var ops = this.waiting.splice(this.waiting.length - n)
-    for (var j in ops) {
-      var del = ops[j]
-      if (newLeft != null) {
-        for (var i in this.waiting) {
-          let w = this.waiting[i]
-          // We will just care about w.left
-          if (Y.utils.compareIds(del.target, w.left)) {
-            del.left = newLeft
+  Y.utils.EventListenerHandler = EventListenerHandler
+
+  class EventHandler extends EventListenerHandler {
+    /* ::
+    waiting: Array<Insertion | Deletion>;
+    awaiting: number;
+    onevent: Function;
+    eventListeners: Array<Function>;
+    */
+    /*
+      onevent: is called when the structure changes.
+
+      Note: "awaiting opertations" is used to denote operations that were
+      prematurely called. Events for received operations can not be executed until
+      all prematurely called operations were executed ("waiting operations")
+    */
+    constructor (onevent /* : Function */) {
+      super()
+      this.waiting = []
+      this.awaiting = 0
+      this.onevent = onevent
+    }
+    destroy () {
+      super.destroy()
+      this.waiting = null
+      this.onevent = null
+    }
+    /*
+      Call this when a new operation arrives. It will be executed right away if
+      there are no waiting operations, that you prematurely executed
+    */
+    receivedOp (op) {
+      if (this.awaiting <= 0) {
+        this.onevent(op)
+      } else if (op.struct === 'Delete') {
+        var self = this
+        var checkDelete = function checkDelete (d) {
+          if (d.length == null) {
+            throw new Error('This shouldn\'t happen! d.length must be defined!')
+          }
+          // we check if o deletes something in self.waiting
+          // if so, we remove the deleted operation
+          for (var w = 0; w < self.waiting.length; w++) {
+            var i = self.waiting[w]
+            if (i.struct === 'Insert' && i.id[0] === d.target[0]) {
+              var iLength = i.hasOwnProperty('content') ? i.content.length : 1
+              var dStart = d.target[1]
+              var dEnd = d.target[1] + (d.length || 1)
+              var iStart = i.id[1]
+              var iEnd = i.id[1] + iLength
+              // Check if they don't overlap
+              if (iEnd <= dStart || dEnd <= iStart) {
+                // no overlapping
+                continue
+              }
+              // we check all overlapping cases. All cases:
+              /*
+                1)  iiiii
+                      ddddd
+                    --> modify i and d
+                2)  iiiiiii
+                      ddddd
+                    --> modify i, remove d
+                3)  iiiiiii
+                      ddd
+                    --> remove d, modify i, and create another i (for the right hand side)
+                4)  iiiii
+                    ddddddd
+                    --> remove i, modify d
+                5)  iiiiiii
+                    ddddddd
+                    --> remove both i and d (**)
+                6)  iiiiiii
+                    ddddd
+                    --> modify i, remove d
+                7)    iii
+                    ddddddd
+                    --> remove i, create and apply two d with checkDelete(d) (**)
+                8)    iiiii
+                    ddddddd
+                    --> remove i, modify d (**)
+                9)    iiiii
+                    ddddd
+                    --> modify i and d
+                (**) (also check if i contains content or type)
+              */
+              // TODO: I left some debugger statements, because I want to debug all cases once in production. REMEMBER END TODO
+              if (iStart < dStart) {
+                if (dStart < iEnd) {
+                  if (iEnd < dEnd) {
+                    // Case 1
+                    // remove the right part of i's content
+                    i.content.splice(dStart - iStart)
+                    // remove the start of d's deletion
+                    d.length = dEnd - iEnd
+                    d.target = [d.target[0], iEnd]
+                    continue
+                  } else if (iEnd === dEnd) {
+                    // Case 2
+                    i.content.splice(dStart - iStart)
+                    // remove d, we do that by simply ending this function
+                    return
+                  } else { // (dEnd < iEnd)
+                    // Case 3
+                    var newI = {
+                      id: [i.id[0], dEnd],
+                      content: i.content.slice(dEnd - iStart),
+                      struct: 'Insert'
+                    }
+                    self.waiting.push(newI)
+                    i.content.splice(dStart - iStart)
+                    return
+                  }
+                }
+              } else if (dStart === iStart) {
+                if (iEnd < dEnd) {
+                  // Case 4
+                  d.length = dEnd - iEnd
+                  d.target = [d.target[0], iEnd]
+                  i.content = []
+                  continue
+                } else if (iEnd === dEnd) {
+                  // Case 5
+                  self.waiting.splice(w, 1)
+                  return
+                } else { // (dEnd < iEnd)
+                  // Case 6
+                  i.content = i.content.slice(dEnd - iStart)
+                  i.id = [i.id[0], dEnd]
+                  return
+                }
+              } else { // (dStart < iStart)
+                if (iStart < dEnd) {
+                  // they overlap
+                  /*
+                  7)    iii
+                      ddddddd
+                      --> remove i, create and apply two d with checkDelete(d) (**)
+                  8)    iiiii
+                      ddddddd
+                      --> remove i, modify d (**)
+                  9)    iiiii
+                      ddddd
+                      --> modify i and d
+                  */
+                  if (iEnd < dEnd) {
+                    // Case 7
+                    // debugger // TODO: You did not test this case yet!!!! (add the debugger here)
+                    self.waiting.splice(w, 1)
+                    checkDelete({
+                      target: [d.target[0], dStart],
+                      length: iStart - dStart,
+                      struct: 'Delete'
+                    })
+                    checkDelete({
+                      target: [d.target[0], iEnd],
+                      length: iEnd - dEnd,
+                      struct: 'Delete'
+                    })
+                    return
+                  } else if (iEnd === dEnd) {
+                    // Case 8
+                    self.waiting.splice(w, 1)
+                    w--
+                    d.length -= iLength
+                    continue
+                  } else { // dEnd < iEnd
+                    // Case 9
+                    d.length = iStart - dStart
+                    i.content.splice(0, dEnd - iStart)
+                    i.id = [i.id[0], dEnd]
+                    continue
+                  }
+                }
+              }
+            }
+          }
+          // finished with remaining operations
+          self.waiting.push(d)
+        }
+        if (op.key == null) {
+          // deletes in list
+          checkDelete(op)
+        } else {
+          // deletes in map
+          this.waiting.push(op)
+        }
+      } else {
+        this.waiting.push(op)
+      }
+    }
+    /*
+      You created some operations, and you want the `onevent` function to be
+      called right away. Received operations will not be executed untill all
+      prematurely called operations are executed
+    */
+    awaitAndPrematurelyCall (ops) {
+      this.awaiting++
+      ops.map(Y.utils.copyOperation).forEach(this.onevent)
+    }
+    * awaitOps (transaction, f, args) {
+      function notSoSmartSort (array) {
+        // this function sorts insertions in a executable order
+        var result = []
+        while (array.length > 0) {
+          for (var i = 0; i < array.length; i++) {
+            var independent = true
+            for (var j = 0; j < array.length; j++) {
+              if (Y.utils.matchesId(array[j], array[i].left)) {
+                // array[i] depends on array[j]
+                independent = false
+                break
+              }
+            }
+            if (independent) {
+              result.push(array.splice(i, 1)[0])
+              i--
+            }
+          }
+        }
+        return result
+      }
+      var before = this.waiting.length
+      // somehow create new operations
+      yield * f.apply(transaction, args)
+      // remove all appended ops / awaited ops
+      this.waiting.splice(before)
+      if (this.awaiting > 0) this.awaiting--
+      // if there are no awaited ops anymore, we can update all waiting ops, and send execute them (if there are still no awaited ops)
+      if (this.awaiting === 0 && this.waiting.length > 0) {
+        // update all waiting ops
+        for (let i = 0; i < this.waiting.length; i++) {
+          var o = this.waiting[i]
+          if (o.struct === 'Insert') {
+            var _o = yield * transaction.getInsertion(o.id)
+            if (_o.parentSub != null && _o.left != null) {
+              // if o is an insertion of a map struc (parentSub is defined), then it shouldn't be necessary to compute left
+              this.waiting.splice(i, 1)
+              i-- // update index
+            } else if (!Y.utils.compareIds(_o.id, o.id)) {
+              // o got extended
+              o.left = [o.id[0], o.id[1] - 1]
+            } else if (_o.left == null) {
+              o.left = null
+            } else {
+              // find next undeleted op
+              var left = yield * transaction.getInsertion(_o.left)
+              while (left.deleted != null) {
+                if (left.left != null) {
+                  left = yield * transaction.getInsertion(left.left)
+                } else {
+                  left = null
+                  break
+                }
+              }
+              o.left = left != null ? Y.utils.getLastId(left) : null
+            }
+          }
+        }
+        // the previous stuff was async, so we have to check again!
+        // We also pull changes from the bindings, if there exists such a method, this could increase awaiting too
+        if (this._pullChanges != null) {
+          this._pullChanges()
+        }
+        if (this.awaiting === 0) {
+          // sort by type, execute inserts first
+          var ins = []
+          var dels = []
+          this.waiting.forEach(function (o) {
+            if (o.struct === 'Delete') {
+              dels.push(o)
+            } else {
+              ins.push(o)
+            }
+          })
+          this.waiting = []
+          // put in executable order
+          ins = notSoSmartSort(ins)
+          // this.onevent can trigger the creation of another operation
+          // -> check if this.awaiting increased & stop computation if it does
+          for (var i = 0; i < ins.length; i++) {
+            if (this.awaiting === 0) {
+              this.onevent(ins[i])
+            } else {
+              this.waiting = this.waiting.concat(ins.slice(i))
+              break
+            }
+          }
+          for (i = 0; i < dels.length; i++) {
+            if (this.awaiting === 0) {
+              this.onevent(dels[i])
+            } else {
+              this.waiting = this.waiting.concat(dels.slice(i))
+              break
+            }
          }
        }
      }
    }
-    this._tryCallEvents()
+    // TODO: Remove awaitedInserts and awaitedDeletes in favor of awaitedOps, as they are deprecated and do not always work
+    // Do this in one of the coming releases that are breaking anyway
+    /*
+      Call this when you successfully awaited the execution of n Insert operations
+    */
+    awaitedInserts (n) {
+      var ops = this.waiting.splice(this.waiting.length - n)
+      for (var oid = 0; oid < ops.length; oid++) {
+        var op = ops[oid]
+        if (op.struct === 'Insert') {
+          for (var i = this.waiting.length - 1; i >= 0; i--) {
+            let w = this.waiting[i]
+            // TODO: do I handle split operations correctly here? Super unlikely, but yeah..
+            // Also: can this case happen? Can op be inserted in the middle of a larger op that is in $waiting?
+            if (w.struct === 'Insert') {
+              if (Y.utils.matchesId(w, op.left)) {
+                // include the effect of op in w
+                w.right = op.id
+                // exclude the effect of w in op
+                op.left = w.left
+              } else if (Y.utils.compareIds(w.id, op.right)) {
+                // similar..
+                w.left = Y.utils.getLastId(op)
+                op.right = w.right
+              }
+            }
+          }
+        } else {
+          throw new Error('Expected Insert Operation!')
+        }
+      }
+      this._tryCallEvents(n)
+    }
+    /*
+      Call this when you successfully awaited the execution of n Delete operations
+    */
+    awaitedDeletes (n, newLeft) {
+      var ops = this.waiting.splice(this.waiting.length - n)
+      for (var j = 0; j < ops.length; j++) {
+        var del = ops[j]
+        if (del.struct === 'Delete') {
+          if (newLeft != null) {
+            for (var i = 0; i < this.waiting.length; i++) {
+              let w = this.waiting[i]
+              // We will just care about w.left
+              if (w.struct === 'Insert' && Y.utils.compareIds(del.target, w.left)) {
+                w.left = newLeft
+              }
+            }
+          }
+        } else {
+          throw new Error('Expected Delete Operation!')
+        }
+      }
+      this._tryCallEvents(n)
+    }
+    /* (private)
+      Try to execute the events for the waiting operations
+    */
+    _tryCallEvents () {
+      function notSoSmartSort (array) {
+        var result = []
+        while (array.length > 0) {
+          for (var i = 0; i < array.length; i++) {
+            var independent = true
+            for (var j = 0; j < array.length; j++) {
+              if (Y.utils.matchesId(array[j], array[i].left)) {
+                // array[i] depends on array[j]
+                independent = false
+                break
+              }
+            }
+            if (independent) {
+              result.push(array.splice(i, 1)[0])
+              i--
+            }
+          }
+        }
+        return result
+      }
+      if (this.awaiting > 0) this.awaiting--
+      if (this.awaiting === 0 && this.waiting.length > 0) {
+        var ins = []
+        var dels = []
+        this.waiting.forEach(function (o) {
+          if (o.struct === 'Delete') {
+            dels.push(o)
+          } else {
+            ins.push(o)
+          }
+        })
+        ins = notSoSmartSort(ins)
+        ins.forEach(this.onevent)
+        dels.forEach(this.onevent)
+        this.waiting = []
+      }
+    }
  }
-  /* (private)
-    Try to execute the events for the waiting operations
+  Y.utils.EventHandler = EventHandler
+
+  /*
+    Default class of custom types!
  */
-  _tryCallEvents () {
-    this.awaiting--
-    if (this.awaiting <= 0 && this.waiting.length > 0) {
-      var events = this.waiting
-      this.waiting = []
-      this.onevent(events)
+  class CustomType {
+    getPath () {
+      var parent = null
+      if (this._parent != null) {
+        parent = this.os.getType(this._parent)
+      }
+      if (parent != null && parent._getPathToChild != null) {
+        var firstKey = parent._getPathToChild(this._model)
+        var parentKeys = parent.getPath()
+        parentKeys.push(firstKey)
+        return parentKeys
+      } else {
+        return []
+      }
    }
  }
-}
-Y.utils.EventHandler = EventHandler
+  Y.utils.CustomType = CustomType

-/*
-  A wrapper for the definition of a custom type.
-  Every custom type must have three properties:
+  /*
+    A wrapper for the definition of a custom type.
+    Every custom type must have three properties:

-  * createType
-    - Defines the model of a newly created custom type and returns the type
-  * initType
-    - Given a model, creates a custom type
-  * class
-    - the constructor of the custom type (e.g. in order to inherit from a type)
-*/
-class CustomType { // eslint-disable-line
-  constructor (def) {
-    if (def.createType == null ||
-      def.initType == null ||
-      def.class == null
-    ) {
-      throw new Error('Custom type was not initialized correctly!')
+    * struct
+      - Structname of this type
+    * initType
+      - Given a model, creates a custom type
+    * class
+      - the constructor of the custom type (e.g. in order to inherit from a type)
+  */
+  class CustomTypeDefinition { // eslint-disable-line
+    /* ::
+    struct: any;
+    initType: any;
+    class: Function;
+    name: String;
+    */
+    constructor (def) {
+      if (def.struct == null ||
+        def.initType == null ||
+        def.class == null ||
+        def.name == null ||
+        def.createType == null
+      ) {
+        throw new Error('Custom type was not initialized correctly!')
+      }
+      this.struct = def.struct
+      this.initType = def.initType
+      this.createType = def.createType
+      this.class = def.class
+      this.name = def.name
+      if (def.appendAdditionalInfo != null) {
+        this.appendAdditionalInfo = def.appendAdditionalInfo
+      }
+      this.parseArguments = (def.parseArguments || function () {
+        return [this]
+      }).bind(this)
+      this.parseArguments.typeDefinition = this
    }
-    this.createType = def.createType
-    this.initType = def.initType
-    this.class = def.class
  }
-}
-Y.utils.CustomType = CustomType
+  Y.utils.CustomTypeDefinition = CustomTypeDefinition

-/*
-  Make a flat copy of an object
-  (just copy properties)
-*/
-function copyObject (o) {
-  var c = {}
-  for (var key in o) {
-    c[key] = o[key]
-  }
-  return c
-}
-Y.utils.copyObject = copyObject
-
-/*
-  Defines a smaller relation on Id's
-*/
-function smaller (a, b) {
-  return a[0] < b[0] || (a[0] === b[0] && a[1] < b[1])
-}
-Y.utils.smaller = smaller
-
-function compareIds (id1, id2) {
-  if (id1 == null || id2 == null) {
-    if (id1 == null && id2 == null) {
-      return true
+  Y.utils.isTypeDefinition = function isTypeDefinition (v) {
+    if (v != null) {
+      if (v instanceof Y.utils.CustomTypeDefinition) return [v]
+      else if (v.constructor === Array && v[0] instanceof Y.utils.CustomTypeDefinition) return v
+      else if (v instanceof Function && v.typeDefinition instanceof Y.utils.CustomTypeDefinition) return [v.typeDefinition]
    }
    return false
  }
-  if (id1[0] === id2[0] && id1[1] === id2[1]) {
-    return true
-  } else {
+
+  /*
+    Make a flat copy of an object
+    (just copy properties)
+  */
+  function copyObject (o) {
+    var c = {}
+    for (var key in o) {
+      c[key] = o[key]
+    }
+    return c
+  }
+  Y.utils.copyObject = copyObject
+
+  /*
+    Copy an operation, so that it can be manipulated.
+    Note: You must not change subproperties (except o.content)!
+  */
+  function copyOperation (o) {
+    o = copyObject(o)
+    if (o.content != null) {
+      o.content = o.content.map(function (c) { return c })
+    }
+    return o
+  }
+
+  Y.utils.copyOperation = copyOperation
+
+  /*
+    Defines a smaller relation on Id's
+  */
+  function smaller (a, b) {
+    return a[0] < b[0] || (a[0] === b[0] && (a[1] < b[1] || typeof a[1] < typeof b[1]))
+  }
+  Y.utils.smaller = smaller
+
+  function inDeletionRange (del, ins) {
+    return del.target[0] === ins[0] && del.target[1] <= ins[1] && ins[1] < del.target[1] + (del.length || 1)
+  }
+  Y.utils.inDeletionRange = inDeletionRange
+
+  function compareIds (id1, id2) {
+    if (id1 == null || id2 == null) {
+      return id1 === id2
+    } else {
+      return id1[0] === id2[0] && id1[1] === id2[1]
+    }
+  }
+  Y.utils.compareIds = compareIds
+
+  function matchesId (op, id) {
+    if (id == null || op == null) {
+      return id === op
+    } else {
+      if (id[0] === op.id[0]) {
+        if (op.content == null) {
+          return id[1] === op.id[1]
+        } else {
+          return id[1] >= op.id[1] && id[1] < op.id[1] + op.content.length
+        }
+      }
+    }
    return false
  }
+  Y.utils.matchesId = matchesId
+
+  function getLastId (op) {
+    if (op.content == null || op.content.length === 1) {
+      return op.id
+    } else {
+      return [op.id[0], op.id[1] + op.content.length - 1]
+    }
+  }
+  Y.utils.getLastId = getLastId
+
+  function createEmptyOpsArray (n) {
+    var a = new Array(n)
+    for (var i = 0; i < a.length; i++) {
+      a[i] = {
+        id: [null, null]
+      }
+    }
+    return a
+  }
+
+  function createSmallLookupBuffer (Store) {
+    /*
+      This buffer implements a very small buffer that temporarily stores operations
+      after they are read / before they are written.
+      The buffer basically implements FIFO. Often requested lookups will be re-queued every time they are looked up / written.
+
+      It can speed up lookups on Operation Stores and State Stores. But it does not require notable use of memory or processing power.
+
+      Good for os and ss, bot not for ds (because it often uses methods that require a flush)
+
+      I tried to optimize this for performance, therefore no highlevel operations.
+    */
+    class SmallLookupBuffer extends Store {
+      constructor (arg1, arg2) {
+        // super(...arguments) -- do this when this is supported by stable nodejs
+        super(arg1, arg2)
+        this.writeBuffer = createEmptyOpsArray(5)
+        this.readBuffer = createEmptyOpsArray(10)
+      }
+      * find (id, noSuperCall) {
+        var i, r
+        for (i = this.readBuffer.length - 1; i >= 0; i--) {
+          r = this.readBuffer[i]
+          // we don't have to use compareids, because id is always defined!
+          if (r.id[1] === id[1] && r.id[0] === id[0]) {
+            // found r
+            // move r to the end of readBuffer
+            for (; i < this.readBuffer.length - 1; i++) {
+              this.readBuffer[i] = this.readBuffer[i + 1]
+            }
+            this.readBuffer[this.readBuffer.length - 1] = r
+            return r
+          }
+        }
+        var o
+        for (i = this.writeBuffer.length - 1; i >= 0; i--) {
+          r = this.writeBuffer[i]
+          if (r.id[1] === id[1] && r.id[0] === id[0]) {
+            o = r
+            break
+          }
+        }
+        if (i < 0 && noSuperCall === undefined) {
+          // did not reach break in last loop
+          // read id and put it to the end of readBuffer
+          o = yield * super.find(id)
+        }
+        if (o != null) {
+          for (i = 0; i < this.readBuffer.length - 1; i++) {
+            this.readBuffer[i] = this.readBuffer[i + 1]
+          }
+          this.readBuffer[this.readBuffer.length - 1] = o
+        }
+        return o
+      }
+      * put (o) {
+        var id = o.id
+        var i, r // helper variables
+        for (i = this.writeBuffer.length - 1; i >= 0; i--) {
+          r = this.writeBuffer[i]
+          if (r.id[1] === id[1] && r.id[0] === id[0]) {
+            // is already in buffer
+            // forget r, and move o to the end of writeBuffer
+            for (; i < this.writeBuffer.length - 1; i++) {
+              this.writeBuffer[i] = this.writeBuffer[i + 1]
+            }
+            this.writeBuffer[this.writeBuffer.length - 1] = o
+            break
+          }
+        }
+        if (i < 0) {
+          // did not reach break in last loop
+          // write writeBuffer[0]
+          var write = this.writeBuffer[0]
+          if (write.id[0] !== null) {
+            yield * super.put(write)
+          }
+          // put o to the end of writeBuffer
+          for (i = 0; i < this.writeBuffer.length - 1; i++) {
+            this.writeBuffer[i] = this.writeBuffer[i + 1]
+          }
+          this.writeBuffer[this.writeBuffer.length - 1] = o
+        }
+        // check readBuffer for every occurence of o.id, overwrite if found
+        // whether found or not, we'll append o to the readbuffer
+        for (i = 0; i < this.readBuffer.length - 1; i++) {
+          r = this.readBuffer[i + 1]
+          if (r.id[1] === id[1] && r.id[0] === id[0]) {
+            this.readBuffer[i] = o
+          } else {
+            this.readBuffer[i] = r
+          }
+        }
+        this.readBuffer[this.readBuffer.length - 1] = o
+      }
+      * delete (id) {
+        var i, r
+        for (i = 0; i < this.readBuffer.length; i++) {
+          r = this.readBuffer[i]
+          if (r.id[1] === id[1] && r.id[0] === id[0]) {
+            this.readBuffer[i] = {
+              id: [null, null]
+            }
+          }
+        }
+        yield * this.flush()
+        yield * super.delete(id)
+      }
+      * findWithLowerBound (id) {
+        var o = yield * this.find(id, true)
+        if (o != null) {
+          return o
+        } else {
+          yield * this.flush()
+          return yield * super.findWithLowerBound.apply(this, arguments)
+        }
+      }
+      * findWithUpperBound (id) {
+        var o = yield * this.find(id, true)
+        if (o != null) {
+          return o
+        } else {
+          yield * this.flush()
+          return yield * super.findWithUpperBound.apply(this, arguments)
+        }
+      }
+      * findNext () {
+        yield * this.flush()
+        return yield * super.findNext.apply(this, arguments)
+      }
+      * findPrev () {
+        yield * this.flush()
+        return yield * super.findPrev.apply(this, arguments)
+      }
+      * iterate () {
+        yield * this.flush()
+        yield * super.iterate.apply(this, arguments)
+      }
+      * flush () {
+        for (var i = 0; i < this.writeBuffer.length; i++) {
+          var write = this.writeBuffer[i]
+          if (write.id[0] !== null) {
+            yield * super.put(write)
+            this.writeBuffer[i] = {
+              id: [null, null]
+            }
+          }
+        }
+      }
+    }
+    return SmallLookupBuffer
+  }
+  Y.utils.createSmallLookupBuffer = createSmallLookupBuffer
+
+  // Generates a unique id, for use as a user id.
+  // Thx to @jed for this script https://gist.github.com/jed/982883
+  function generateGuid(a){return a?(a^Math.random()*16>>a/4).toString(16):([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g,generateGuid)} // eslint-disable-line
+  Y.utils.generateGuid = generateGuid
 }
-Y.utils.compareIds = compareIds
--- a/src/y.js
+++ b/src/y.js
@@ -1,53 +1,241 @@
-/* @flow */
-'use strict'
+import debug from 'debug'
+import extendConnector from './Connector.js'
+import extendDatabase from './Database.js'
+import extendTransaction from './Transaction.js'
+import extendStruct from './Struct.js'
+import extendUtils from './Utils.js'

-function Y (opts) {
-  return new Promise(function (resolve) {
-    var yconfig = new YConfig(opts, function () {
-      yconfig.db.whenUserIdSet(function () {
-        resolve(yconfig)
-      })
-    })
+extendConnector(Y)
+extendDatabase(Y)
+extendTransaction(Y)
+extendStruct(Y)
+extendUtils(Y)
+
+Y.debug = debug
+
+var requiringModules = {}
+
+Y.requiringModules = requiringModules
+
+Y.extend = function (name, value) {
+  if (arguments.length === 2 && typeof name === 'string') {
+    if (value instanceof Y.utils.CustomTypeDefinition) {
+      Y[name] = value.parseArguments
+    } else {
+      Y[name] = value
+    }
+    if (requiringModules[name] != null) {
+      requiringModules[name].resolve()
+      delete requiringModules[name]
+    }
+  } else {
+    for (var i = 0; i < arguments.length; i++) {
+      var f = arguments[i]
+      if (typeof f === 'function') {
+        f(Y)
+      } else {
+        throw new Error('Expected function!')
+      }
+    }
+  }
+}
+
+Y.requestModules = requestModules
+function requestModules (modules) {
+  var sourceDir
+  if (Y.sourceDir === null) {
+    sourceDir = null
+  } else {
+    sourceDir = Y.sourceDir || '/bower_components'
+  }
+  // determine if this module was compiled for es5 or es6 (y.js vs. y.es6)
+  // if Insert.execute is a Function, then it isnt a generator..
+  // then load the es5(.js) files..
+  var extention = typeof regeneratorRuntime !== 'undefined' ? '.js' : '.es6'
+  var promises = []
+  for (var i = 0; i < modules.length; i++) {
+    var module = modules[i].split('(')[0]
+    var modulename = 'y-' + module.toLowerCase()
+    if (Y[module] == null) {
+      if (requiringModules[module] == null) {
+        // module does not exist
+        if (typeof window !== 'undefined' && window.Y !== 'undefined') {
+          if (sourceDir != null) {
+            var imported = document.createElement('script')
+            imported.src = sourceDir + '/' + modulename + '/' + modulename + extention
+            document.head.appendChild(imported)
+          }
+          let requireModule = {}
+          requiringModules[module] = requireModule
+          requireModule.promise = new Promise(function (resolve) {
+            requireModule.resolve = resolve
+          })
+          promises.push(requireModule.promise)
+        } else {
+          console.info('YJS: Please do not depend on automatic requiring of modules anymore! Extend modules as follows `require(\'y-modulename\')(Y)`')
+          require(modulename)(Y)
+        }
+      } else {
+        promises.push(requiringModules[modules[i]].promise)
+      }
+    }
+  }
+  return Promise.all(promises)
+}
+
+/* ::
+type MemoryOptions = {
+  name: 'memory'
+}
+type IndexedDBOptions = {
+  name: 'indexeddb',
+  namespace: string
+}
+type DbOptions = MemoryOptions | IndexedDBOptions
+
+type WebRTCOptions = {
+  name: 'webrtc',
+  room: string
+}
+type WebsocketsClientOptions = {
+  name: 'websockets-client',
+  room: string
+}
+type ConnectionOptions = WebRTCOptions | WebsocketsClientOptions
+
+type YOptions = {
+  connector: ConnectionOptions,
+  db: DbOptions,
+  types: Array<TypeName>,
+  sourceDir: string,
+  share: {[key: string]: TypeName}
+}
+*/
+
+export default function Y (opts/* :YOptions */) /* :Promise<YConfig> */ {
+  if (opts.hasOwnProperty('sourceDir')) {
+    Y.sourceDir = opts.sourceDir
+  }
+  opts.types = opts.types != null ? opts.types : []
+  var modules = [opts.db.name, opts.connector.name].concat(opts.types)
+  for (var name in opts.share) {
+    modules.push(opts.share[name])
+  }
+  return new Promise(function (resolve, reject) {
+    if (opts == null) reject(new Error('An options object is expected!'))
+    else if (opts.connector == null) reject(new Error('You must specify a connector! (missing connector property)'))
+    else if (opts.connector.name == null) reject(new Error('You must specify connector name! (missing connector.name property)'))
+    else if (opts.db == null) reject(new Error('You must specify a database! (missing db property)'))
+    else if (opts.connector.name == null) reject(new Error('You must specify db name! (missing db.name property)'))
+    else {
+      opts = Y.utils.copyObject(opts)
+      opts.connector = Y.utils.copyObject(opts.connector)
+      opts.db = Y.utils.copyObject(opts.db)
+      opts.share = Y.utils.copyObject(opts.share)
+      Y.requestModules(modules).then(function () {
+        var yconfig = new YConfig(opts)
+        yconfig.db.whenUserIdSet(function () {
+          yconfig.init(function () {
+            resolve(yconfig)
+          })
+        })
+      }).catch(reject)
+    }
  })
 }

-class YConfig {
+class YConfig extends Y.utils.NamedEventHandler {
+  /* ::
+  db: Y.AbstractDatabase;
+  connector: Y.AbstractConnector;
+  share: {[key: string]: any};
+  options: Object;
+  */
  constructor (opts, callback) {
+    super()
+    this.options = opts
    this.db = new Y[opts.db.name](this, opts.db)
    this.connector = new Y[opts.connector.name](this, opts.connector)
+    this.connected = true
+  }
+  init (callback) {
+    var opts = this.options
+    var share = {}
+    this.share = share
    this.db.requestTransaction(function * requestTransaction () {
-      // create initial Map type
-      var model = {
-        id: ['_', 0],
-        struct: 'Map',
-        type: 'Map',
-        map: {}
+      // create shared object
+      for (var propertyname in opts.share) {
+        var typeConstructor = opts.share[propertyname].split('(')
+        var typeName = typeConstructor.splice(0, 1)
+        var type = Y[typeName]
+        var typedef = type.typeDefinition
+        var id = ['_', typedef.struct + '_' + typeName + '_' + propertyname + '_' + typeConstructor]
+        var args = []
+        if (typeConstructor.length === 1) {
+          try {
+            args = JSON.parse('[' + typeConstructor[0].split(')')[0] + ']')
+          } catch (e) {
+            throw new Error('Was not able to parse type definition! (share.' + propertyname + ')')
+          }
+          if (type.typeDefinition.parseArguments == null) {
+            throw new Error(typeName + ' does not expect arguments!')
+          } else {
+            args = typedef.parseArguments(args[0])[1]
+          }
+        }
+        share[propertyname] = yield * this.store.initType.call(this, id, args)
      }
-      yield* this.store.tryExecute.call(this, model)
-      var root = yield* this.getType(model.id)
-      this.store.y.root = root
-      callback()
+      this.store.whenTransactionsFinished()
+        .then(callback)
    })
  }
  isConnected () {
    return this.connector.isSynced
  }
  disconnect () {
-    return this.connector.disconnect()
+    if (this.connected) {
+      this.connected = false
+      return this.connector.disconnect()
+    } else {
+      return Promise.resolve()
+    }
  }
  reconnect () {
-    return this.connector.reconnect()
+    if (!this.connected) {
+      this.connected = true
+      return this.connector.reconnect()
+    } else {
+      return Promise.resolve()
+    }
  }
  destroy () {
-    this.disconnect()
-    this.db.destroy()
-    this.connector = null
-    this.db = null
+    var self = this
+    return this.close().then(function () {
+      if (self.db.deleteDB != null) {
+        return self.db.deleteDB()
+      } else {
+        return Promise.resolve()
+      }
+    }).then(() => {
+      // remove existing event listener
+      super.destroy()
+    })
+  }
+  close () {
+    var self = this
+    this.share = null
+    if (this.connector.destroy != null) {
+      this.connector.destroy()
+    } else {
+      this.connector.disconnect()
+    }
+    return this.db.whenTransactionsFinished().then(function () {
+      self.db.destroyTypes()
+      // make sure to wait for all transactions before destroying the db
+      self.db.requestTransaction(function * () {
+        yield * self.db.destroy()
+      })
+      return self.db.whenTransactionsFinished()
+    })
  }
 }
-
-if (typeof YConcurrency_TestingMode !== 'undefined') {
-  g.Y = Y //eslint-disable-line
-  // debugger //eslint-disable-line
-}
-Y.utils = {}
--- a/tests-lib/helper.js
+++ b/tests-lib/helper.js
@@ -0,0 +1,191 @@
+
+import _Y from '../../yjs/src/y.js'
+
+import yMemory from '../../y-memory/src/y-memory.js'
+import yArray from '../../y-array/src/y-array.js'
+import yMap from '../../y-map/src/Map.js'
+import yTest from './test-connector.js'
+
+import Chance from 'chance'
+
+export let Y = _Y
+
+Y.extend(yMemory, yArray, yMap, yTest)
+
+export async function garbageCollectUsers (t, users) {
+  await flushAll(t, users)
+  await Promise.all(users.map(u => u.db.emptyGarbageCollector()))
+}
+
+/*
+ * 1. reconnect and flush all
+ * 2. user 0 gc
+ * 3. get type content
+ * 4. disconnect & reconnect all (so gc is propagated)
+ * 5. compare os, ds, ss
+ */
+export async function compareUsers (t, users) {
+  await Promise.all(users.map(u => u.reconnect()))
+  if (users[0].connector.testRoom == null) {
+    await wait(100)
+  }
+  await flushAll(t, users)
+  await wait()
+  await flushAll(t, users)
+
+  var userTypeContents = users.map(u => u.share.array._content.map(c => c.val || JSON.stringify(c.type)))
+
+  await users[0].db.garbageCollect()
+  await users[0].db.garbageCollect()
+
+  // disconnect all except user 0
+  await Promise.all(users.slice(1).map(async u =>
+    u.disconnect()
+  ))
+  if (users[0].connector.testRoom == null) {
+    await wait(100)
+  }
+  // reconnect all
+  await Promise.all(users.map(u => u.reconnect()))
+  if (users[0].connector.testRoom == null) {
+    await wait(100)
+  }
+  await users[0].connector.testRoom.flushAll(users)
+  await Promise.all(users.map(u =>
+    new Promise(function (resolve) {
+      u.connector.whenSynced(resolve)
+    })
+  ))
+  let filterDeletedOps = users.every(u => u.db.gc === false)
+  var data = await Promise.all(users.map(async (u) => {
+    var data = {}
+    u.db.requestTransaction(function * () {
+      var os = yield * this.getOperationsUntransformed()
+      data.os = {}
+      for (let i = 0; i < os.untransformed.length; i++) {
+        let op = os.untransformed[i]
+        op = Y.Struct[op.struct].encode(op)
+        delete op.origin
+        /*
+          If gc = false, it is necessary to filter deleted ops
+          as they might have been split up differently..
+         */
+        if (filterDeletedOps) {
+          let opIsDeleted = yield * this.isDeleted(op.id)
+          if (!opIsDeleted) {
+            data.os[JSON.stringify(op.id)] = op
+          }
+        } else {
+          data.os[JSON.stringify(op.id)] = op
+        }
+      }
+      data.ds = yield * this.getDeleteSet()
+      data.ss = yield * this.getStateSet()
+    })
+    await u.db.whenTransactionsFinished()
+    return data
+  }))
+  for (var i = 0; i < data.length - 1; i++) {
+    await t.asyncGroup(async () => {
+      t.compare(userTypeContents[i], userTypeContents[i + 1], 'types')
+      t.compare(data[i].os, data[i + 1].os, 'os')
+      t.compare(data[i].ds, data[i + 1].ds, 'ds')
+      t.compare(data[i].ss, data[i + 1].ss, 'ss')
+    }, `Compare user${i} with user${i + 1}`)
+  }
+  await Promise.all(users.map(async (u) => {
+    await u.close()
+  }))
+}
+
+export async function initArrays (t, opts) {
+  var result = {
+    users: []
+  }
+  var share = Object.assign({ flushHelper: 'Map', array: 'Array' }, opts.share)
+  var chance = opts.chance || new Chance(t.getSeed() * 1000000000)
+  var connector = Object.assign({ room: 'debugging_' + t.name, testContext: t, chance }, opts.connector)
+  for (let i = 0; i < opts.users; i++) {
+    let dbOpts
+    let connOpts
+    if (i === 0) {
+      // Only one instance can gc!
+      dbOpts = Object.assign({ gc: true }, opts.db)
+      connOpts = Object.assign({ role: 'master' }, connector)
+    } else {
+      dbOpts = Object.assign({ gc: false }, opts.db)
+      connOpts = Object.assign({ role: 'slave' }, connector)
+    }
+    let y = await Y({
+      connector: connOpts,
+      db: dbOpts,
+      share: share
+    })
+    result.users.push(y)
+    for (let name in share) {
+      result[name + i] = y.share[name]
+    }
+  }
+  result.array0.delete(0, result.array0.length)
+  if (result.users[0].connector.testRoom != null) {
+    // flush for sync if test-connector
+    await result.users[0].connector.testRoom.flushAll(result.users)
+  }
+  await Promise.all(result.users.map(u => {
+    return new Promise(function (resolve) {
+      u.connector.whenSynced(resolve)
+    })
+  }))
+  await flushAll(t, result.users)
+  return result
+}
+
+export async function flushAll (t, users) {
+  // users = users.filter(u => u.connector.isSynced)
+  if (users.length === 0) {
+    return
+  }
+  await wait(0)
+  if (users[0].connector.testRoom != null) {
+    // use flushAll method specified in Test Connector
+    await users[0].connector.testRoom.flushAll(users)
+  } else {
+    // flush for any connector
+    await Promise.all(users.map(u => { return u.db.whenTransactionsFinished() }))
+
+    var flushCounter = users[0].share.flushHelper.get('0') || 0
+    flushCounter++
+    await Promise.all(users.map(async (u, i) => {
+      // wait for all users to set the flush counter to the same value
+      await new Promise(resolve => {
+        function observer () {
+          var allUsersReceivedUpdate = true
+          for (var i = 0; i < users.length; i++) {
+            if (u.share.flushHelper.get(i + '') !== flushCounter) {
+              allUsersReceivedUpdate = false
+              break
+            }
+          }
+          if (allUsersReceivedUpdate) {
+            resolve()
+          }
+        }
+        u.share.flushHelper.observe(observer)
+        u.share.flushHelper.set(i + '', flushCounter)
+      })
+    }))
+  }
+}
+
+export async function flushSome (t, users) {
+  if (users[0].connector.testRoom == null) {
+    // if not test-connector, wait for some time for operations to arrive
+    await wait(100)
+  }
+}
+
+export function wait (t) {
+  return new Promise(function (resolve) {
+    setTimeout(resolve, t != null ? t : 100)
+  })
+}
--- a/tests-lib/test-connector.js
+++ b/tests-lib/test-connector.js
@@ -0,0 +1,156 @@
+/* global Y */
+import { wait } from './helper.js'
+
+var rooms = {}
+
+export class TestRoom {
+  constructor (roomname) {
+    this.room = roomname
+    this.users = {}
+    this.nextUserId = 0
+  }
+  join (connector) {
+    if (connector.userId == null) {
+      connector.setUserId('' + (this.nextUserId++))
+    }
+    Object.keys(this.users).forEach(uid => {
+      let user = this.users[uid]
+      if (user.role === 'master' || connector.role === 'master') {
+        this.users[uid].userJoined(connector.userId, connector.role)
+        connector.userJoined(uid, this.users[uid].role)
+      }
+    })
+    this.users[connector.userId] = connector
+  }
+  leave (connector) {
+    delete this.users[connector.userId]
+    Object.keys(this.users).forEach(uid => {
+      this.users[uid].userLeft(connector.userId)
+    })
+  }
+  send (sender, receiver, m) {
+    m = JSON.parse(JSON.stringify(m))
+    var user = this.users[receiver]
+    if (user != null) {
+      user.receiveMessage(sender, m)
+    }
+  }
+  broadcast (sender, m) {
+    Object.keys(this.users).forEach(receiver => {
+      this.send(sender, receiver, m)
+    })
+  }
+  async flushAll (users) {
+    let flushing = true
+    let allUserIds = Object.keys(this.users)
+    if (users == null) {
+      users = allUserIds.map(id => this.users[id].y)
+    }
+    while (flushing) {
+      await wait(10)
+      let res = await Promise.all(allUserIds.map(id => this.users[id]._flushAll(users)))
+      flushing = res.some(status => status === 'flushing')
+    }
+  }
+}
+
+function getTestRoom (roomname) {
+  if (rooms[roomname] == null) {
+    rooms[roomname] = new TestRoom(roomname)
+  }
+  return rooms[roomname]
+}
+
+export default function extendTestConnector (Y) {
+  class TestConnector extends Y.AbstractConnector {
+    constructor (y, options) {
+      if (options === undefined) {
+        throw new Error('Options must not be undefined!')
+      }
+      if (options.room == null) {
+        throw new Error('You must define a room name!')
+      }
+      options.forwardAppliedOperations = options.role === 'master'
+      super(y, options)
+      this.options = options
+      this.room = options.room
+      this.chance = options.chance
+      this.testRoom = getTestRoom(this.room)
+      this.testRoom.join(this)
+    }
+    disconnect () {
+      this.testRoom.leave(this)
+      return super.disconnect()
+    }
+    reconnect () {
+      this.testRoom.join(this)
+      return super.reconnect()
+    }
+    send (uid, message) {
+      this.testRoom.send(this.userId, uid, message)
+    }
+    broadcast (message) {
+      this.testRoom.broadcast(this.userId, message)
+    }
+    async whenSynced (f) {
+      var synced = false
+      var periodicFlushTillSync = () => {
+        if (synced) {
+          f()
+        } else {
+          this.testRoom.flushAll([this.y]).then(function () {
+            setTimeout(periodicFlushTillSync, 10)
+          })
+        }
+      }
+      periodicFlushTillSync()
+      return super.whenSynced(function () {
+        synced = true
+      })
+    }
+    receiveMessage (sender, m) {
+      if (this.userId !== sender && this.connections[sender] != null) {
+        var buffer = this.connections[sender].buffer
+        if (buffer == null) {
+          buffer = this.connections[sender].buffer = []
+        }
+        buffer.push(m)
+        if (this.chance.bool({likelihood: 30})) {
+          // flush 1/2 with 30% chance
+          var flushLength = Math.round(buffer.length / 2)
+          buffer.splice(0, flushLength).forEach(m => {
+            super.receiveMessage(sender, m)
+          })
+        }
+      }
+    }
+    async _flushAll (flushUsers) {
+      if (flushUsers.some(u => u.connector.userId === this.userId)) {
+        // this one needs to sync with every other user
+        flushUsers = Object.keys(this.connections).map(id => this.testRoom.users[id].y)
+      }
+      var finished = []
+      for (let i = 0; i < flushUsers.length; i++) {
+        let userId = flushUsers[i].connector.userId
+        if (userId !== this.userId && this.connections[userId] != null) {
+          let buffer = this.connections[userId].buffer
+          if (buffer != null) {
+            var messages = buffer.splice(0)
+            for (let j = 0; j < messages.length; j++) {
+              let p = super.receiveMessage(userId, messages[j])
+              finished.push(p)
+            }
+          }
+        }
+      }
+      await Promise.all(finished)
+      await this.y.db.whenTransactionsFinished()
+      return finished.length > 0 ? 'flushing' : 'done'
+    }
+  }
+  Y.extend('test', TestConnector)
+}
+
+if (typeof Y !== 'undefined') {
+  extendTestConnector(Y)
+}
--- a/y.js
+++ b/y.js
--- a/y.js.map
+++ b/y.js.map