     @decisions = { root, initial, subsequent, swap, penultimate }
 
 class Level
-  constructor: (exclusive) ->
-    @lock = if exclusive then @lockExclusive else @lockShared
-  lockExclusive: (mutation, tier, callback) ->
-    strata = mutation.strata
-    locks = strata.locks
-    if locks.exclusive[tier.id] or locks.shared[tier.id]
-      @exclusiveQueue.push [ mutation, tier, callback ]
-    else
-      strata.locks.exclusive[tier.id]++
-      callback()
-  lockShared: (mutation, tier, callback) ->
-    strata = mutation.strata
-    if locks.exclusive[tier.id]
-      @sharedQueue.push [ mutation, tier, callback ]
-    else
-      strata.locks.shared[tier.id]++
-      callback()
+  constructor: (@exclusive) ->
+  lock: (strata, mutation, tier, callback) ->
+    @tierId = tier.id
+    locks = (strata.locks[@tierId] or= [ [] ])
+    if @exclusive
+      locks.push [ @lockCallback = [ callback, strata, mutation ] ]
+      locks.push []
+      if locks.length is 3 and locks[0].length is 0
+        callback.call strata
+    else
+      locks[locks.length - 1].push @lockCallback = [ callback, strata, mutation ]
+      if locks.length is 1
+        callback.call strata
 
 class module.exports.MemoryIO
   root: (map) -> map

  # single branch to the parent, this operation will empty the root into two
  # separate tiers, creating an almost empty root each time it is split.
  _drainRoot: (mutation) ->

  # Determine if the root inner tier should be filled with contents of a two
  # extra remaining inner tier children. When an root inner tier has only one

    else
      false

  # Shorthand to allocate a new inner tier.
  _newInnerTier: (mutation, leafChildren) ->
    inner = @io.allocate false, leafChildren
    inner.leafChildren = true

  # To split the root, we copy the contents of the root into two children,
  # splitting the contents between the children, then make the two children the
  # only two nodes of the root tier. The address of the root tier does not
