diff --git a/.babelrc b/.babelrc
index 2d4d503..63d065b 100644
--- a/.babelrc
+++ b/.babelrc
@@ -1,3 +1,3 @@
 {
-    "presets": ["es2015", "stage-2"]
+    "presets": ["es2015", "stage-1"]
 }
diff --git a/.gitignore b/.gitignore
index 7c4bc80..b2cc0b3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 lib
 node_modules
 coverage
+*.log
diff --git a/README.md b/README.md
index 6e2e09c..5da0d53 100644
--- a/README.md
+++ b/README.md
@@ -2,37 +2,31 @@
 
 [![npm version](https://img.shields.io/npm/v/react-router-redux.svg?style=flat-square)](https://www.npmjs.com/package/react-router-redux) [![npm downloads](https://img.shields.io/npm/dm/react-router-redux.svg?style=flat-square)](https://www.npmjs.com/package/react-router-redux) [![build status](https://img.shields.io/travis/reactjs/react-router-redux/master.svg?style=flat-square)](https://travis-ci.org/reactjs/react-router-redux)
 
-**Let react-router do all the work**  :sparkles:
+> **Keep your router in sync with application state** :sparkles:
 
 _Formerly known as redux-simple-router_
 
-[Redux](https://github.com/rackt/redux) is awesome. [React Router](https://github.com/reactjs/react-router) is cool. The problem is that react-router manages an important piece of your application state: the URL. If you are using redux, you want your app state to fully represent your UI; if you snapshotted the app state, you should be able to load it up later and see the same thing.
+You're a smart person. You use [Redux](https://github.com/rackt/redux) to manage your application state. You use [React Router](https://github.com/reactjs/react-router) to do routing. All is good.
 
-react-router does a great job of mapping the current URL to a component tree, and continually does so with any URL changes. This is very useful, but we really want to store this state in redux as well.
+But the two libraries don't coordinate. You want to do time travel with your application state, but React Router doesn't navigate between pages when you replay actions. It controls an important part of application state: the URL.
 
-The entire state that we are interested in boils down to one thing: the URL. This is an extremely simple library that just puts the URL in redux state and keeps it in sync with any react-router changes. Additionally, you can change the URL via redux and react-router will change accordingly.
+This library helps you keep that bit of state in sync with your Redux store. We keep a copy of the current location hidden in state. When you rewind your application state with a tool like [Redux DevTools](https://github.com/gaearon/redux-devtools), that state change is propagated to React Router so it can adjust the component tree accordingly. You can jump around in state, rewinding, replaying, and resetting as much as you'd like, and this library will ensure the two stay in sync at all times.
+
+## Installation
 
 ```
-npm install react-router-redux
+npm install --save react-router-redux
 ```
 
 If you want to install the next major version, use `react-router-redux@next`. Run `npm dist-tag ls react-router-redux` to see what `next` is aliased to.
 
-View the [CHANGELOG](https://github.com/reactjs/react-router-redux/blob/master/CHANGELOG.md) for recent changes.
-
-Read the [API docs](#api) farther down this page.
-
-**Note:** We are [currently working on some major changes/improvements](https://github.com/reactjs/react-router-redux/issues/259) to the library. [React Router's API in 2.0](https://github.com/reactjs/react-router/blob/master/upgrade-guides/v2.0.0.md) is significantly improved and obseletes the need for things like action creators and reading location state from the Redux. This library is still critical to enable things like time traveling and persisting state, so we're not going anywhere. But in many cases, you may not need this library and can simply use the provided React Router APIs. Go check them out and drop some technical debt. :smile:
-
-### Usage
+## How It Works
 
-The idea of this library is to use react-router's functionality exactly like its documentation tells you to. You can access all of its APIs in routing components. Additionally, you can use redux like you normally would, with a single app state.
+This library allows you to use React Router's APIs as they are documented. And, you can use redux like you normally would, with a single app state. The library simply enhances a history instance to allow it to synchronize any changes it receives into application state.
 
-[redux](https://github.com/rackt/redux) (`store.routing`)  ↔  [**react-router-redux**](https://github.com/reactjs/react-router-redux)  ↔  [history](https://github.com/reactjs/history) (`history.location`)  ↔  [react-router](https://github.com/reactjs/react-router)
+[history](https://github.com/reactjs/history) + `store` ([redux](https://github.com/rackt/redux)) → [**react-router-redux**](https://github.com/reactjs/react-router-redux) → enhanced [history](https://github.com/reactjs/history) → [react-router](https://github.com/reactjs/react-router)
 
-We only store current URL and state, whereas redux-router stores the entire location object from react-router. You can read it, and also change it with an action.
-
-### Tutorial
+## Tutorial
 
 Let's take a look at a simple example.
 
@@ -44,25 +38,25 @@ import ReactDOM from 'react-dom'
 import { createStore, combineReducers, applyMiddleware } from 'redux'
 import { Provider } from 'react-redux'
 import { Router, Route, browserHistory } from 'react-router'
-import { syncHistory, routeReducer } from 'react-router-redux'
-import reducers from '<project-path>/reducers'
-
-const reducer = combineReducers(Object.assign({}, reducers, {
-  routing: routeReducer
-}))
+import { syncHistoryWithStore, routerReducer } from 'react-router-redux'
 
-// Sync dispatched route actions to the history
-const reduxRouterMiddleware = syncHistory(browserHistory)
-const createStoreWithMiddleware = applyMiddleware(reduxRouterMiddleware)(createStore)
+import reducers from '<project-path>/reducers'
 
-const store = createStoreWithMiddleware(reducer)
+// Add the reducer to your store on the `routing` key
+const store = createStore(
+  combineReducers({
+    ...reducers,
+    routing: routerReducer
+  })
+)
 
-// Required for replaying actions from devtools to work
-reduxRouterMiddleware.listenForReplays(store)
+// Create an enhanced history that syncs navigation events with the store
+const history = syncHistoryWithStore(browserHistory, store)
 
 ReactDOM.render(
   <Provider store={store}>
-    <Router history={browserHistory}>
+    /* Tell the Router to use our enhanced history */
+    <Router history={history}>
       <Route path="/" component={App}>
         <Route path="foo" component={Foo}/>
         <Route path="bar" component={Bar}/>
@@ -73,31 +67,32 @@ ReactDOM.render(
 )
 ```
 
-Now you can read from `state.routing.location.pathname` to get the URL. It's far more likely that you want to change the URL more often, however. You can use the `push` action creator that we provide:
+Now any time you navigate, which can come from pressing browser buttons or navigating in your application code, the enhanced history will first pass the new location through the Redux store and then on to React Router to update the component tree. If you time travel, it will also pass the new state to React Router to update the component tree again.
+
+#### How do I watch for navigation events, such as for analytics?
+
+Simply listen to the enhanced history via `history.listen`. This takes in a function that will receive a `location` any time the store updates. This includes any time travel activity performed on the store.
 
 ```js
-import { routeActions } from 'react-router-redux'
+const history = syncHistoryWithStore(browserHistory, store)
 
-function MyComponent({ dispatch }) {
-  return <Button onClick={() => dispatch(routeActions.push('/foo'))}/>;
-}
+history.listen(location => analyticsService.track(location.pathname))
 ```
 
-This will change the state, which will trigger a change in react-router. Additionally, if you want to respond to the path update action, just handle the `UPDATE_LOCATION` constant that we provide:
+For other kinds of events in your system, you can use middleware on your Redux store like normal to watch any action that is dispatched to the store.
 
-```js
-import { UPDATE_LOCATION } from 'react-router-redux'
+#### What if I use Immutable.js with my Redux store?
 
-function update(state, action) {
-  switch(action.type) {
-  case UPDATE_LOCATION:
-    // do something here
-  }
-}
-```
-**But how do I access router props in a Container component?**
+When using a wrapper for your store's state, such as Immutable.js, you will need to change two things from the standard setup:
+
+1. Provide your own reducer function that will receive actions of type  `LOCATION_CHANGE` and return the payload merged into state.
+2. Pass a selector to access the payload state via the `selectLocationState` option on `syncHistoryWithStore`.
+
+These two hooks will allow you to store the state that this library uses in whatever format or wrapper you would like.
 
-react-router [injects route information via a child component's props](https://github.com/reactjs/react-router/blob/latest/docs/Introduction.md#getting-url-parameters). This makes accessing them from a simple component easy. When using a react-redux Container to connect simple components to the store state and dispatch you can access these injected route information from the [2nd argument of `mapStateToProps`](https://github.com/rackt/react-redux/blob/master/docs/api.md#connectmapstatetoprops-mapdispatchtoprops-mergeprops-options) as follows:
+#### How do I access router state in a container component?
+
+React Router [provides route information via a route component's props](https://github.com/reactjs/react-router/blob/latest/docs/Introduction.md#getting-url-parameters). This makes it easy to access them from a container component. When using [react-redux](https://github.com/rackt/react-redux) to `connect()` your components to state, you can access the router's props from the [2nd argument of `mapStateToProps`](https://github.com/rackt/react-redux/blob/master/docs/api.md#connectmapstatetoprops-mapdispatchtoprops-mergeprops-options):
 
 ```js
 function mapStateToProps(state, ownProps) {
@@ -108,64 +103,74 @@ function mapStateToProps(state, ownProps) {
 }
 ```
 
+You should not read the location state directly from the Redux store. This is because React Router operates asynchronously (to handle things such as dynamically-loaded components) and your component tree may not yet be updated in sync with your Redux state. You should rely on the props passed by React Router, as they are only updated after it has processed all asynchronous code.
+
+#### What if I want to issue navigation events via Redux actions?
+
+React Router provides singleton versions of history (`browserHistory` and `hashHistory`) that you can import and use from anywhere in your application. However, if you prefer Redux style actions, the library also provides a set of action creators and a middleware to capture them and redirect them to your history instance.
+
+```js
+import { routerMiddleware, push } from 'react-router-redux'
+
+// Apply the middleware to the store
+const middleware = routerMiddleware(browserHistory)
+const store = createStore(
+  reducers,
+  applyMiddleware(middleware)
+)
+
+// Dispatch from anywhere like normal.
+store.dispatch(push('/foo'))
+```
 
-### Examples
+## Examples
 
-* [examples/basic](https://github.com/reactjs/react-router-redux/blob/master/examples/basic) - basic reference implementation
+- [examples/basic](/examples/basic) - basic reference implementation
 
 Examples from the community:
 
+* [shakacode/react-webpack-rails-tutorial](https://github.com/shakacode/react-webpack-rails-tutorial) - react-router-redux including **Server Rendering** using [React on Rails](https://github.com/shakacode/react_on_rails/), live at [www.reactrails.com](http://www.reactrails.com/).
 * [davezuko/react-redux-starter-kit](https://github.com/davezuko/react-redux-starter-kit) - popular redux starter kit
-  * **tip**: migrating from redux-router? use [this commit](https://github.com/davezuko/react-redux-starter-kit/commit/db66626ca8a02ecf030a3f7f5a669ac338fd5897) as a reference
-* [freeqaz/redux-simple-router-example](https://github.com/freeqaz/redux-simple-router-example) - example implementation
-* [choonkending/react-webpack-node](https://github.com/choonkending/react-webpack-node) - boilerplate for universal redux and react-router
-* [tj/frontend-boilerplate](https://github.com/tj/frontend-boilerplate)
-* [bdefore/universal-redux](https://github.com/bdefore/universal-redux) - npm package for universally rendered redux applications
-* [tomatau/breko-hub](https://github.com/tomatau/breko-hub) - Babel, React & Koa, Hot Universal Boilerplate - focused on developer experience.
-* [yangli1990/react-redux-isomorphic](https://github.com/yangli1990/Isomorphic-Universal-React-Template) - boilerplate for universal redux and redux-simple-router
-* [StevenIseki/redux-simple-router-example](https://github.com/StevenIseki/redux-simple-router-example)
-* [mattkrick/meatier](https://github.com/mattkrick/meatier) - SSR, dual dev/prod client builds
-* [mxstbr/react-boilerplate](https://github.com/mxstbr/react-boilerplate/tree/v3.0.0) - :fire: Quick setup for performance orientated, offline first React.js applications
-  * **Tip**: Upgrading from react-router w/o react-router-redux? Use [this PR](https://github.com/mxstbr/react-boilerplate/pull/98/files) as a reference!
-* [erikras/react-redux-universal-hot-example](https://github.com/erikras/react-redux-universal-hot-example) - Universal rendering with Webpack
-* [chentsulin/redux-boilerplate](https://github.com/chentsulin/redux-boilerplate) - Extend redux counter examples with react-router and react-router-redux
+  * **tip**: migrating from react-router-redux `^3.0.0`? use [this commit](https://github.com/davezuko/react-redux-starter-kit/commit/0df26907) as a reference
+* [svrcekmichal/universal-react](https://github.com/svrcekmichal/universal-react) - Universal react app with async actions provided by [svrcekmichal/reasync](https://github.com/svrcekmichal/reasync) package
 
-_Have an example to add? Send us a PR!_
+&rarr; _Have an example to add? Send us a PR!_ &larr;
 
-### API
+## API
 
-#### `syncHistory(history: History) => ReduxMiddleware`
+#### `routerReducer()`
 
-Call this to create a middleware that can be applied with Redux's `applyMiddleware` to allow actions to call history methods. The middleware will look for route actions created by `push`, `replace`, etc. and applies them to the history.
+**You must add this reducer to your store for syncing to work.**
 
-#### `ReduxMiddleware.listenForReplays(store: ReduxStore, selectLocationState?: function)`
+A reducer function that stores location updates from `history`. If you use `combineReducers`, it should be nested under the `routing` key.
 
-By default, the syncing logic will not respond to replaying of actions, which means it won't work with projects like redux-devtools. Call this function on the middleware object returned from `syncHistory` and give it the store to listen to, and it will properly work with action replays. Obviously, you would do that after you have created the store and everything else has been set up.
+#### `history = syncHistoryWithStore(history, store, [options])`
 
-Supply an optional function `selectLocationState` to customize where to find the location state on your app state. It defaults to `state => state.routing.location`, so you would install the reducer under the name "routing". Feel free to change this to whatever you like.
+Creates an enhanced history from the provided history. This history changes `history.listen` to pass all location updates through the provided store first. This ensures if the store is updated either from a navigation event or from a time travel action, such as a replay, the listeners of the enhanced history will stay in sync.
 
-#### `ReduxMiddleware.unsubscribe()`
+**You must provide the enhanced history to your `<Router>` component.** This ensures your routes stay in sync with your location and your store at the same time.
 
-Call this on the middleware returned from `syncHistory` to stop the syncing process set up by `listenForReplays`.
+The `options` object takes in the following optional keys:
 
-#### `routeReducer`
+- `selectLocationState` - (default `state => state.routing`) A selector function to obtain the history state from your store. Useful when not using the provided `routerReducer` to store history state. Allows you to use wrappers, such as Immutable.js.
+- `adjustUrlOnReplay` - (default `true`) When `false`, the URL will not be kept in sync during time travel. This is useful when using `persistState` from Redux DevTools and not wanting to maintain the URL state when restoring state.
 
-A reducer function that keeps track of the router state. You must add this reducer to your app reducers when creating the store. It will return a `location` property in state. If you use `combineReducers`, it will be nested under wherever property you add it to (`state.routing` in the example above).
+#### `push(location)`, `replace(location)`, `go(number)`, `goBack()`, `goForward()`
 
-**Warning:** It is a bad pattern to use `react-redux`'s `connect` decorator to map the state from this reducer to props on your `Route` components. This can lead to infinite loops and performance problems. `react-router` already provides this for you via `this.props.location`.
+**You must install `routerMiddleware` for these action creators to work.**
 
-#### `UPDATE_LOCATION`
+Action creators that correspond with the [history methods of the same name](https://github.com/reactjs/history/blob/master/docs/GettingStarted.md#navigation). For reference they are defined as follows:
 
-An action type that you can listen for in your reducers to be notified of route updates.
+- `push` - Pushes a new location to history, becoming the current location.
+- `replace` - Replaces the current location in history.
+- `go` - Moves backwards or forwards a relative number of locations in history.
+- `goForward` - Moves forward one location. Equivalent to `go(1)`
+- `goBack` - Moves backwards one location. Equivalent to `go(-1)`
 
-#### `routeActions`
+Both `push` and `replace` take in a [location descriptor](https://github.com/reactjs/history/blob/master/docs/Glossary.md#locationdescriptor), which can be an object describing the URL or a plain string URL.
 
-An object that contains all the actions creators you can use to manipulate history:
+These action creators are also available in one single object as `routerActions`, which can be used as a convenience when using Redux's `bindActionCreators()`.
 
-* `push(nextLocation: LocationDescriptor)`
-* `replace(nextLocation: LocationDescriptor)`
-* `go(n: number)`
-* `goForward()`
-* `goBack()`
+#### `routerMiddleware(history)`
 
-A [location descriptor](https://github.com/reactjs/history/blob/master/docs/Glossary.md#locationdescriptor) can be a descriptive object (see the link) or a normal URL string. The most common action is to push a new URL via `routeActions.push(...)`. These all directly call the analogous [history methods](https://github.com/reactjs/history/blob/master/docs/GettingStarted.md#navigation).
+A middleware you can apply to your Redux `store` to capture dispatched actions created by the action creators. It will redirect those actions to the provided `history` instance.
diff --git a/examples/basic/README.md b/examples/basic/README.md
index a4cbb2e..087f629 100644
--- a/examples/basic/README.md
+++ b/examples/basic/README.md
@@ -13,8 +13,8 @@ This example also demonstrates integration with
 
 1. Install dependencies with `npm install` in this directory (make sure it creates a local node_modules)
 2. By default, it uses the local version from `src` of react-router-redux, so you need to run `npm install` from there first. If you want to use a version straight from npm, remove the lines in `webpack.config.js` at the bottom.
-3. Build with `webpack --watch`
-4. Open `index.html`
+3. Start build with `npm start`
+4. Open [http://localhost:8080/](http://localhost:8080/)
 
 -
 
diff --git a/examples/basic/app.js b/examples/basic/app.js
index 9395bd9..bbe78c2 100644
--- a/examples/basic/app.js
+++ b/examples/basic/app.js
@@ -4,38 +4,35 @@ import DockMonitor from 'redux-devtools-dock-monitor'
 
 import React from 'react'
 import ReactDOM from 'react-dom'
-import { applyMiddleware, compose, createStore, combineReducers } from 'redux'
+import { createStore, combineReducers } from 'redux'
 import { Provider } from 'react-redux'
 import { Router, Route, IndexRoute, browserHistory } from 'react-router'
-import { syncHistory, routeReducer } from 'react-router-redux'
+import { syncHistoryWithStore, routerReducer } from 'react-router-redux'
 
 import * as reducers from './reducers'
 import { App, Home, Foo, Bar } from './components'
 
-const middleware = syncHistory(browserHistory)
 const reducer = combineReducers({
   ...reducers,
-  routing: routeReducer
+  routing: routerReducer
 })
 
 const DevTools = createDevTools(
-  <DockMonitor toggleVisibilityKey="ctrl-h"
-               changePositionKey="ctrl-q">
+  <DockMonitor toggleVisibilityKey="ctrl-h" changePositionKey="ctrl-q">
     <LogMonitor theme="tomorrow" preserveScrollTop={false} />
   </DockMonitor>
 )
 
-const finalCreateStore = compose(
-  applyMiddleware(middleware),
+const store = createStore(
+  reducer,
   DevTools.instrument()
-)(createStore)
-const store = finalCreateStore(reducer)
-middleware.listenForReplays(store)
+)
+const history = syncHistoryWithStore(browserHistory, store)
 
 ReactDOM.render(
   <Provider store={store}>
     <div>
-      <Router history={browserHistory}>
+      <Router history={history}>
         <Route path="/" component={App}>
           <IndexRoute component={Home}/>
           <Route path="foo" component={Foo}/>
diff --git a/examples/basic/components/App.js b/examples/basic/components/App.js
index 2facee0..22a42a2 100644
--- a/examples/basic/components/App.js
+++ b/examples/basic/components/App.js
@@ -1,9 +1,7 @@
 import React from 'react'
-import { Link } from 'react-router'
-import { connect } from 'react-redux'
-import { routeActions } from 'react-router-redux'
+import { Link, hashHistory } from 'react-router'
 
-function App({ push, children }) {
+export default function App({ children }) {
   return (
     <div>
       <header>
@@ -16,14 +14,9 @@ function App({ push, children }) {
         <Link to="/bar">Bar</Link>
       </header>
       <div>
-        <button onClick={() => push('/foo')}>Go to /foo</button>
+        <button onClick={() => hashHistory.push('/foo')}>Go to /foo</button>
       </div>
       <div style={{ marginTop: '1.5em' }}>{children}</div>
     </div>
   )
 }
-
-export default connect(
-  null,
-  routeActions
-)(App)
diff --git a/examples/basic/index.html b/examples/basic/index.html
index 9bc05ca..5452876 100644
--- a/examples/basic/index.html
+++ b/examples/basic/index.html
@@ -6,6 +6,6 @@
   </head>
   <body>
     <div id="mount"></div>
-    <script src="dist/bundle.js"></script>
+    <script src="/bundle.js"></script>
   </body>
 </html>
diff --git a/examples/basic/package.json b/examples/basic/package.json
index ba0db2f..9458dab 100644
--- a/examples/basic/package.json
+++ b/examples/basic/package.json
@@ -4,29 +4,30 @@
   "repository": "reactjs/react-router-redux",
   "license": "MIT",
   "dependencies": {
-    "react": "^0.14.2",
-    "react-dom": "^0.14.2",
-    "react-redux": "^4.0.0",
+    "react": "^0.14.7",
+    "react-dom": "^0.14.7",
+    "react-redux": "^4.3.0",
     "react-router": "^2.0.0",
-    "redux": "^3.0.4",
-    "react-router-redux": "^2.1.0"
+    "redux": "^3.2.1",
+    "react-router-redux": "^3.0.0"
   },
   "devDependencies": {
-    "babel-core": "^6.1.21",
-    "babel-eslint": "^5.0.0-beta6",
-    "babel-loader": "^6.2.0",
-    "babel-preset-es2015": "^6.1.18",
-    "babel-preset-react": "^6.1.18",
+    "babel-core": "^6.4.5",
+    "babel-eslint": "^5.0.0-beta9",
+    "babel-loader": "^6.2.2",
+    "babel-preset-es2015": "^6.3.13",
+    "babel-preset-react": "^6.3.13",
     "babel-preset-stage-1": "^6.3.13",
     "eslint": "^1.10.3",
     "eslint-config-rackt": "^1.1.1",
-    "eslint-plugin-react": "^3.15.0",
-    "redux-devtools": "^3.0.0",
+    "eslint-plugin-react": "^3.16.1",
+    "redux-devtools": "^3.1.0",
     "redux-devtools-dock-monitor": "^1.0.1",
-    "redux-devtools-log-monitor": "^1.0.1",
-    "webpack": "^1.12.6"
+    "redux-devtools-log-monitor": "^1.0.4",
+    "webpack": "^1.12.13",
+    "webpack-dev-server": "^1.14.1"
   },
   "scripts": {
-    "start": "webpack --watch"
+    "start": "webpack-dev-server --history-api-fallback --no-info --open"
   }
 }
diff --git a/examples/server/.babelrc b/examples/server/.babelrc
new file mode 100644
index 0000000..a1e122a
--- /dev/null
+++ b/examples/server/.babelrc
@@ -0,0 +1,8 @@
+{
+  "presets": ["es2015", "react", "stage-1"],
+  "plugins": [
+    ["babel-plugin-module-alias", [
+      { "src": "../../src", "expose": "react-router-redux" }
+    ]]
+  ]
+}
diff --git a/examples/server/client.js b/examples/server/client.js
new file mode 100644
index 0000000..a2940b2
--- /dev/null
+++ b/examples/server/client.js
@@ -0,0 +1,28 @@
+import 'babel-polyfill'
+
+import React from 'react'
+import { render } from 'react-dom'
+
+import { Provider } from 'react-redux'
+import { Router, browserHistory } from 'react-router'
+import { syncHistoryWithStore } from 'react-router-redux'
+
+import { configureStore, DevTools } from './store'
+import routes from './routes'
+
+const store = configureStore(browserHistory, window.__initialState__)
+const history = syncHistoryWithStore(browserHistory, store)
+
+render(
+  <Provider store={store}>
+    <Router history={history} routes={routes} />
+  </Provider>,
+  document.getElementById('root')
+)
+
+render(
+  <Provider store={store}>
+    <DevTools/>
+  </Provider>,
+  document.getElementById('devtools')
+)
diff --git a/examples/server/index.html b/examples/server/index.html
new file mode 100644
index 0000000..fa87359
--- /dev/null
+++ b/examples/server/index.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>react-router-redux server rendering example</title>
+    <meta charset="utf8"/>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script src="/bundle.js"></script>
+  </body>
+</html>
diff --git a/examples/server/package.json b/examples/server/package.json
new file mode 100644
index 0000000..82ec6d8
--- /dev/null
+++ b/examples/server/package.json
@@ -0,0 +1,38 @@
+{
+  "name": "rrr-server-example",
+  "version": "0.0.0",
+  "repository": "reactjs/react-router-redux",
+  "license": "MIT",
+  "dependencies": {
+    "react": "^0.14.7",
+    "react-dom": "^0.14.7",
+    "react-redux": "^4.3.0",
+    "react-router": "^2.0.0",
+    "react-router-redux": "^3.0.0",
+    "redux": "^3.2.1",
+    "serialize-javascript": "^1.1.2"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.5.1",
+    "babel-core": "^6.4.5",
+    "babel-eslint": "^5.0.0-beta9",
+    "babel-loader": "^6.2.2",
+    "babel-plugin-module-alias": "^1.2.0",
+    "babel-preset-es2015": "^6.3.13",
+    "babel-preset-react": "^6.3.13",
+    "babel-preset-stage-1": "^6.3.13",
+    "babel-register": "^6.5.2",
+    "eslint": "^1.10.3",
+    "eslint-config-rackt": "^1.1.1",
+    "eslint-plugin-react": "^3.16.1",
+    "express": "^4.13.4",
+    "redux-devtools": "^3.1.1",
+    "redux-devtools-dock-monitor": "^1.0.1",
+    "redux-devtools-log-monitor": "^1.0.4",
+    "webpack": "^1.12.13",
+    "webpack-dev-middleware": "^1.5.1"
+  },
+  "scripts": {
+    "start": "babel-node server.js"
+  }
+}
diff --git a/examples/server/routes.js b/examples/server/routes.js
new file mode 100644
index 0000000..5164adf
--- /dev/null
+++ b/examples/server/routes.js
@@ -0,0 +1,31 @@
+import React from 'react'
+import { Route, IndexRoute, Link } from 'react-router'
+
+const App = ({ children }) => (
+  <div>
+    <header>
+      Links:
+      {' '}
+      <Link to="/">Home</Link>
+      {' '}
+      <Link to="/foo">Foo</Link>
+      {' '}
+      <Link to="/bar">Bar</Link>
+    </header>
+    {children}
+  </div>
+)
+
+const Home = () => (<div>Home!</div>)
+const Foo = () => (<div>Foo!</div>)
+const Bar = () => (<div>Bar!</div>)
+
+const routes = (
+  <Route path="/" component={App}>
+    <IndexRoute component={Home}/>
+    <Route path="foo" component={Foo}/>
+    <Route path="bar" component={Bar}/>
+  </Route>
+)
+
+export default routes
diff --git a/examples/server/server.js b/examples/server/server.js
new file mode 100644
index 0000000..9a4ecef
--- /dev/null
+++ b/examples/server/server.js
@@ -0,0 +1,62 @@
+/*eslint-disable no-console */
+import express from 'express'
+import serialize from 'serialize-javascript'
+
+import webpack from 'webpack'
+import webpackDevMiddleware from 'webpack-dev-middleware'
+import webpackConfig from './webpack.config'
+
+import React from 'react'
+import { renderToString } from 'react-dom/server'
+import { Provider } from 'react-redux'
+import { createMemoryHistory, match, RouterContext } from 'react-router'
+import { syncHistoryWithStore } from '../../src'
+
+import { configureStore } from './store'
+import routes from './routes'
+
+const app = express()
+
+app.use(webpackDevMiddleware(webpack(webpackConfig), {
+  publicPath: '/__build__/',
+  stats: {
+    colors: true
+  }
+}))
+
+const HTML = ({ content, store }) => (
+  <html>
+    <body>
+      <div id="root" dangerouslySetInnerHTML={{ __html: content }}/>
+      <div id="devtools"/>
+      <script dangerouslySetInnerHTML={{ __html: `window.__initialState__=${serialize(store.getState())};` }}/>
+      <script src="/__build__/bundle.js"/>
+    </body>
+  </html>
+)
+
+app.use(function (req, res) {
+  const memoryHistory = createMemoryHistory(req.path)
+  const store = configureStore(memoryHistory)
+  const history = syncHistoryWithStore(memoryHistory, store)
+
+  match({ history, routes, location: req.url }, (error, redirectLocation, renderProps) => {
+    if (error) {
+      res.status(500).send(error.message)
+    } else if (redirectLocation) {
+      res.redirect(302, redirectLocation.pathname + redirectLocation.search)
+    } else if (renderProps) {
+      const content = renderToString(
+        <Provider store={store}>
+          <RouterContext {...renderProps}/>
+        </Provider>
+      )
+
+      res.send('<!doctype html>\n' + renderToString(<HTML content={content} store={store}/>))
+    }
+  })
+})
+
+app.listen(8080, function () {
+  console.log('Server listening on http://localhost:8080, Ctrl+C to stop')
+})
diff --git a/examples/server/store.js b/examples/server/store.js
new file mode 100644
index 0000000..12de656
--- /dev/null
+++ b/examples/server/store.js
@@ -0,0 +1,38 @@
+import React from 'react'
+
+import { createStore, combineReducers, compose, applyMiddleware } from 'redux'
+import { createDevTools } from 'redux-devtools'
+import LogMonitor from 'redux-devtools-log-monitor'
+import DockMonitor from 'redux-devtools-dock-monitor'
+
+import { routerReducer, routerMiddleware } from 'react-router-redux'
+
+export const DevTools = createDevTools(
+  <DockMonitor toggleVisibilityKey="ctrl-h" changePositionKey="ctrl-q">
+    <LogMonitor theme="tomorrow" preserveScrollTop={false} />
+  </DockMonitor>
+)
+
+export function configureStore(history, initialState) {
+  const reducer = combineReducers({
+    routing: routerReducer
+  })
+
+  let devTools = []
+  if (typeof document !== 'undefined') {
+    devTools = [ DevTools.instrument() ]
+  }
+
+  const store = createStore(
+    reducer,
+    initialState,
+    compose(
+      applyMiddleware(
+        routerMiddleware(history)
+      ),
+      ...devTools
+    )
+  )
+
+  return store
+}
diff --git a/examples/server/webpack.config.js b/examples/server/webpack.config.js
new file mode 100644
index 0000000..47f4146
--- /dev/null
+++ b/examples/server/webpack.config.js
@@ -0,0 +1,37 @@
+/* eslint-disable */
+const path = require('path')
+const webpack = require('webpack')
+
+module.exports = {
+  devtool: 'inline-source-map',
+  entry: './client.js',
+  output: {
+    path: path.join(__dirname, 'dist'),
+    filename: 'bundle.js',
+    publicPath: '/__build__/'
+  },
+  module: {
+    loaders: [{
+      test: /\.js$/,
+      loader: 'babel',
+      exclude: /node_modules/,
+      query: { plugins: [] }
+    }]
+  }
+}
+
+
+// This will make the redux-simpler-router module resolve to the
+// latest src instead of using it from npm. Remove this if running
+// outside of the source.
+var src = path.join(__dirname, '../../src')
+var fs = require('fs')
+if (fs.existsSync(src)) {
+  // Use the latest src
+  module.exports.resolve = { alias: { 'react-router-redux': src } }
+  module.exports.module.loaders.push({
+    test: /\.js$/,
+    loaders: ['babel'],
+    include: src
+  });
+}
diff --git a/karma.conf.js b/karma.conf.js
index 027abcb..20567c2 100644
--- a/karma.conf.js
+++ b/karma.conf.js
@@ -1,12 +1,13 @@
-var path = require('path');
-var webpack = require('webpack');
+'use strict'
+
+const path = require('path')
 
 module.exports = function (config) {
 
-  var runCoverage = process.env.COVERAGE === 'true';
+  let runCoverage = process.env.COVERAGE === 'true'
 
-  var coverageLoaders = [];
-  var coverageReporters = [];
+  let coverageLoaders = []
+  let coverageReporters = []
 
   if (runCoverage) {
     coverageLoaders.push({
@@ -15,7 +16,7 @@ module.exports = function (config) {
       loader: 'isparta'
     }),
 
-    coverageReporters.push('coverage');
+    coverageReporters.push('coverage')
   }
 
   config.set({
@@ -39,12 +40,14 @@ module.exports = function (config) {
       module: {
         preLoaders: [
           {
+            loader: 'babel',
             test: /\.js$/,
-            exclude: [
-              path.resolve('node_modules/')
-            ],
-            loader: 'babel'
-          },
+            include: [
+              path.resolve('src/'),
+              path.resolve('test/')
+            ]
+
+          }
         ].concat(coverageLoaders)
       }
     },
@@ -59,5 +62,5 @@ module.exports = function (config) {
         { type: 'json', subdir: 'browser-coverage', file: 'coverage.json' }
       ]
     }
-  });
-};
+  })
+}
diff --git a/package.json b/package.json
index f0c8c22..2aa5453 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-router-redux",
-  "version": "3.0.0",
+  "version": "4.0.0-beta.1",
   "description": "Ruthlessly simple bindings to keep react-router and redux in sync",
   "main": "lib/index",
   "files": [
@@ -16,10 +16,10 @@
   ],
   "license": "MIT",
   "scripts": {
-    "build": "mkdir -p lib && babel ./src/index.js --out-file ./lib/index.js",
+    "build": "mkdir -p lib && babel ./src -d lib",
     "lint": "eslint examples src test",
     "test": "npm run lint && npm run test:node && npm run test:browser",
-    "test:node": "mocha --compilers js:babel-core/register --recursive ./test/node",
+    "test:node": "mocha --compilers js:babel-register --recursive ./test/*.spec.js",
     "test:browser": "karma start",
     "test:cov": "npm run test:cov:browser && npm run test:cov:node && npm run test:cov:report",
     "test:cov:node": "babel-node $(npm bin)/isparta cover $(npm bin)/_mocha report --dir ./coverage/node-coverage -- --recursive ./test/node",
@@ -41,13 +41,15 @@
     "babel-core": "^6.2.1",
     "babel-eslint": "^4.1.6",
     "babel-loader": "^6.2.0",
-    "babel-preset-es2015": "^6.1.2",
-    "babel-preset-stage-2": "^6.3.13",
+    "babel-polyfill": "^6.3.14",
+    "babel-preset-es2015": "^6.3.13",
+    "babel-preset-stage-1": "^6.3.13",
+    "babel-register": "^6.4.3",
     "eslint": "^1.10.3",
     "eslint-config-rackt": "^1.1.1",
     "eslint-plugin-react": "^3.15.0",
     "expect": "^1.13.0",
-    "history": "^1.14.0",
+    "history": "^2.0.0",
     "isparta": "^4.0.0",
     "isparta-loader": "^2.0.0",
     "karma": "^0.13.3",
diff --git a/src/actions.js b/src/actions.js
new file mode 100644
index 0000000..38e4485
--- /dev/null
+++ b/src/actions.js
@@ -0,0 +1,26 @@
+/**
+ * This action type will be dispatched by the history actions below.
+ * If you're writing a middleware to watch for navigation events, be sure to
+ * look for actions of this type.
+ */
+export const CALL_HISTORY_METHOD = '@@router/CALL_HISTORY_METHOD'
+
+function updateLocation(method) {
+  return (...args) => ({
+    type: CALL_HISTORY_METHOD,
+    payload: { method, args }
+  })
+}
+
+/**
+ * These actions correspond to the history API.
+ * The associated routerMiddleware will capture these events before they get to
+ * your reducer and reissue them as the matching function on your history.
+ */
+export const push = updateLocation('push')
+export const replace = updateLocation('replace')
+export const go = updateLocation('go')
+export const goBack = updateLocation('goBack')
+export const goForward = updateLocation('goForward')
+
+export const routerActions = { push, replace, go, goBack, goForward }
diff --git a/src/index.js b/src/index.js
index 8c62ec8..e08d844 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,112 +1,9 @@
-// Constants
-
-export const TRANSITION = '@@router/TRANSITION'
-export const UPDATE_LOCATION = '@@router/UPDATE_LOCATION'
-
-const SELECT_LOCATION = state => state.routing.location
-
-function transition(method) {
-  return (...args) => ({
-    type: TRANSITION,
-    payload: { method, args }
-  })
-}
-
-export const push = transition('push')
-export const replace = transition('replace')
-export const go = transition('go')
-export const goBack = transition('goBack')
-export const goForward = transition('goForward')
-
-export const routeActions = { push, replace, go, goBack, goForward }
-
-function updateLocation(location) {
-  return {
-    type: UPDATE_LOCATION,
-    payload: location
-  }
-}
-
-// Reducer
-
-const initialState = {
-  location: undefined
-}
-
-export function routeReducer(state = initialState, { type, payload: location }) {
-  if (type !== UPDATE_LOCATION) {
-    return state
-  }
-
-  return { ...state, location }
-}
-
-// Syncing
-
-export function syncHistory(history) {
-  let unsubscribeHistory, currentKey, unsubscribeStore
-  let connected = false, syncing = false
-
-  history.listen(location => { initialState.location = location })()
-
-  function middleware(store) {
-    unsubscribeHistory = history.listen(location => {
-      currentKey = location.key
-      if (syncing) {
-        // Don't dispatch a new action if we're replaying location.
-        return
-      }
-
-      store.dispatch(updateLocation(location))
-    })
-
-    connected = true
-
-    return next => action => {
-      if (action.type !== TRANSITION || !connected) {
-        return next(action)
-      }
-
-      const { payload: { method, args } } = action
-      history[method](...args)
-    }
-  }
-
-  middleware.listenForReplays =
-    (store, selectLocationState = SELECT_LOCATION) => {
-      const getLocationState = () => selectLocationState(store.getState())
-      const initialLocation = getLocationState()
-
-      unsubscribeStore = store.subscribe(() => {
-        const location = getLocationState()
-
-        // If we're resetting to the beginning, use the saved initial value. We
-        // need to dispatch a new action at this point to populate the store
-        // appropriately.
-        if (location.key === initialLocation.key) {
-          history.replace(initialLocation)
-          return
-        }
-
-        // Otherwise, if we need to update the history location, do so without
-        // dispatching a new action, as we're just bringing history in sync
-        // with the store.
-        if (location.key !== currentKey) {
-          syncing = true
-          history.transitionTo(location)
-          syncing = false
-        }
-      })
-    }
-
-  middleware.unsubscribe = () => {
-    unsubscribeHistory()
-    if (unsubscribeStore) {
-      unsubscribeStore()
-    }
-
-    connected = false
-  }
-
-  return middleware
-}
+export syncHistoryWithStore from './sync'
+export { LOCATION_CHANGE, routerReducer } from './reducer'
+
+export {
+  CALL_HISTORY_METHOD,
+  push, replace, go, goBack, goForward,
+  routerActions
+} from './actions'
+export routerMiddleware from './middleware'
diff --git a/src/middleware.js b/src/middleware.js
new file mode 100644
index 0000000..ad5d5ab
--- /dev/null
+++ b/src/middleware.js
@@ -0,0 +1,17 @@
+import { CALL_HISTORY_METHOD } from './actions'
+
+/**
+ * This middleware captures CALL_HISTORY_METHOD actions to redirect to the
+ * provided history object. This will prevent these actions from reaching your
+ * reducer or any middleware that comes after this one.
+ */
+export default function routerMiddleware(history) {
+  return () => next => action => {
+    if (action.type !== CALL_HISTORY_METHOD) {
+      return next(action)
+    }
+
+    const { payload: { method, args } } = action
+    history[method](...args)
+  }
+}
diff --git a/src/reducer.js b/src/reducer.js
new file mode 100644
index 0000000..1d9a6c0
--- /dev/null
+++ b/src/reducer.js
@@ -0,0 +1,23 @@
+/**
+ * This action type will be dispatched when your history
+ * receives a location change.
+ */
+export const LOCATION_CHANGE = '@@router/LOCATION_CHANGE'
+
+const initialState = {
+  locationBeforeTransitions: null
+}
+
+/**
+ * This reducer will update the state with the most recent location history
+ * has transitioned to. This may not be in sync with the router, particularly
+ * if you have asynchronously-loaded routes, so reading from and relying on
+ * this state it is discouraged.
+ */
+export function routerReducer(state = initialState, { type, payload }) {
+  if (type === LOCATION_CHANGE) {
+    return { ...state, locationBeforeTransitions: payload }
+  }
+
+  return state
+}
diff --git a/src/sync.js b/src/sync.js
new file mode 100644
index 0000000..935eb32
--- /dev/null
+++ b/src/sync.js
@@ -0,0 +1,136 @@
+import { LOCATION_CHANGE } from './reducer'
+
+const defaultSelectLocationState = state => state.routing
+
+/**
+ * This function synchronizes your history state with the Redux store.
+ * Location changes flow from history to the store. An enhanced history is
+ * returned with a listen method that responds to store updates for location.
+ *
+ * When this history is provided to the router, this means the location data
+ * will flow like this:
+ * history.push -> store.dispatch -> enhancedHistory.listen -> router
+ * This ensures that when the store state changes due to a replay or other
+ * event, the router will be updated appropriately and can transition to the
+ * correct router state.
+ */
+export default function syncHistoryWithStore(history, store, {
+  selectLocationState = defaultSelectLocationState,
+  adjustUrlOnReplay = true
+} = {}) {
+  // Ensure that the reducer is mounted on the store and functioning properly.
+  if (typeof selectLocationState(store.getState()) === 'undefined') {
+    throw new Error(
+      'Expected the routing state to be available either as `state.routing` ' +
+      'or as the custom expression you can specify as `selectLocationState` ' +
+      'in the `syncHistoryWithStore()` options. ' +
+      'Ensure you have added the `routerReducer` to your store\'s ' +
+      'reducers via `combineReducers` or whatever method you use to isolate ' +
+      'your reducers.'
+    )
+  }
+
+  let initialLocation
+  let currentLocation
+  let isTimeTraveling
+  let unsubscribeFromStore
+  let unsubscribeFromHistory
+
+  // What does the store say about current location?
+  const getLocationInStore = (useInitialIfEmpty) => {
+    const locationState = selectLocationState(store.getState())
+    return locationState.locationBeforeTransitions ||
+      (useInitialIfEmpty ? initialLocation : undefined)
+  }
+
+  // If the store is replayed, update the URL in the browser to match.
+  if (adjustUrlOnReplay) {
+    const handleStoreChange = () => {
+      const locationInStore = getLocationInStore(true)
+      if (currentLocation === locationInStore) {
+        return
+      }
+
+      // Update address bar to reflect store state
+      isTimeTraveling = true
+      currentLocation = locationInStore
+      history.transitionTo({
+        ...locationInStore,
+        action: 'PUSH'
+      })
+      isTimeTraveling = false
+    }
+
+    unsubscribeFromStore = store.subscribe(handleStoreChange)
+    handleStoreChange()
+  }
+
+  // Whenever location changes, dispatch an action to get it in the store
+  const handleLocationChange = (location) => {
+    // ... unless we just caused that location change
+    if (isTimeTraveling) {
+      return
+    }
+
+    // Remember where we are
+    currentLocation = location
+
+    // Are we being called for the first time?
+    if (!initialLocation) {
+      // Remember as a fallback in case state is reset
+      initialLocation = location
+
+      // Respect persisted location, if any
+      if (getLocationInStore()) {
+        return
+      }
+    }
+
+    // Tell the store to update by dispatching an action
+    store.dispatch({
+      type: LOCATION_CHANGE,
+      payload: location
+    })
+  }
+  unsubscribeFromHistory = history.listen(handleLocationChange)
+
+  // The enhanced history uses store as source of truth
+  return {
+    ...history,
+    // The listeners are subscribed to the store instead of history
+    listen(listener) {
+      // Copy of last location.
+      let lastPublishedLocation = getLocationInStore(true)
+      // History listeners expect a synchronous call
+      listener(lastPublishedLocation)
+
+      // Keep track of whether we unsubscribed, as Redux store
+      // only applies changes in subscriptions on next dispatch
+      let unsubscribed = false
+      const unsubscribeFromStore = store.subscribe(() => {
+        const currentLocation = getLocationInStore(true)
+        if (currentLocation === lastPublishedLocation) {
+          return
+        }
+        lastPublishedLocation = currentLocation
+        if (!unsubscribed) {
+          listener(lastPublishedLocation)
+        }
+      })
+
+      // Let user unsubscribe later
+      return () => {
+        unsubscribed = true
+        unsubscribeFromStore()
+      }
+    },
+
+    // It also provides a way to destroy internal listeners
+    unsubscribe() {
+      if (adjustUrlOnReplay) {
+        unsubscribeFromStore()
+      }
+      unsubscribeFromHistory()
+    }
+  }
+}
diff --git a/test/.eslintrc b/test/.eslintrc
new file mode 100644
index 0000000..7eeefc3
--- /dev/null
+++ b/test/.eslintrc
@@ -0,0 +1,5 @@
+{
+  "env": {
+    "mocha": true
+  }
+}
diff --git a/test/_createSyncTest.js b/test/_createSyncTest.js
new file mode 100644
index 0000000..a000b96
--- /dev/null
+++ b/test/_createSyncTest.js
@@ -0,0 +1,218 @@
+import expect from 'expect'
+
+import { createStore, combineReducers } from 'redux'
+import { ActionCreators, instrument } from 'redux-devtools'
+
+import syncHistoryWithStore from '../src/sync'
+import { routerReducer } from '../src/reducer'
+
+expect.extend({
+  toContainLocation({
+    pathname,
+    search = '',
+    hash = '',
+    state = null,
+    query,
+    action = 'PUSH'
+  }) {
+    const { locationBeforeTransitions } = this.actual.getState().routing
+    const location = locationBeforeTransitions
+
+    expect(location.pathname).toEqual(pathname)
+    expect(location.search).toEqual(search)
+    expect(location.hash).toEqual(hash)
+    expect(location.state).toEqual(state)
+    expect(location.query).toEqual(query)
+    expect(location.action).toEqual(action)
+  }
+})
+
+
+function createSyncedHistoryAndStore(originalHistory) {
+
+  const store = createStore(combineReducers({
+    routing: routerReducer
+  }))
+  const history = syncHistoryWithStore(originalHistory, store)
+
+  return { history, store }
+}
+
+const defaultReset = () => {}
+
+export default function createTests(createHistory, name, reset = defaultReset) {
+  describe(name, () => {
+
+    beforeEach(reset)
+
+    describe('syncHistoryWithStore', () => {
+      let history, store
+
+      beforeEach(() => {
+        let synced = createSyncedHistoryAndStore(createHistory())
+        history = synced.history
+        store = synced.store
+      })
+
+      afterEach(() => {
+        history.unsubscribe()
+      })
+
+      it('syncs history -> redux', () => {
+        expect(store).toContainLocation({
+          pathname: '/',
+          action: 'POP'
+        })
+
+        history.push('/foo')
+        expect(store).toContainLocation({
+          pathname: '/foo'
+        })
+
+        history.push({ state: { bar: 'baz' }, pathname: '/foo' })
+        expect(store).toContainLocation({
+          pathname: '/foo',
+          state: { bar: 'baz' },
+          action: 'PUSH'
+        })
+
+        history.replace('/bar')
+        expect(store).toContainLocation({
+          pathname: '/bar',
+          action: 'REPLACE'
+        })
+
+        history.push('/bar')
+        expect(store).toContainLocation({
+          pathname: '/bar',
+          action: 'REPLACE' // Converted by history.
+        })
+
+        history.push('/bar?query=1')
+        expect(store).toContainLocation({
+          pathname: '/bar',
+          search: '?query=1'
+        })
+
+        history.push('/bar#baz')
+        expect(store).toContainLocation({
+          pathname: '/bar',
+          hash: '#baz'
+        })
+
+        history.replace({
+          pathname: '/bar',
+          search: '?query=1',
+          state: { bar: 'baz' }
+        })
+        expect(store).toContainLocation({
+          pathname: '/bar',
+          search: '?query=1',
+          state: { bar: 'baz' },
+          action: 'REPLACE'
+        })
+
+        history.replace({
+          pathname: '/bar',
+          search: '?query=1',
+          hash: '#hash=2',
+          state: { bar: 'baz' }
+        })
+        expect(store).toContainLocation({
+          pathname: '/bar',
+          search: '?query=1',
+          hash: '#hash=2',
+          state: { bar: 'baz' },
+          action: 'REPLACE'
+        })
+      })
+
+      it('provices an unsubscribe method to stop listening to history and store', () => {
+        history.push('/foo')
+        expect(store).toContainLocation({
+          pathname: '/foo'
+        })
+
+        history.unsubscribe()
+
+        history.push('/bar')
+        expect(store).toContainLocation({
+          pathname: '/foo'
+        })
+      })
+
+      it('updates the router even if path is the same', () => {
+        history.push('/')
+
+        const updates = []
+        const historyUnsubscribe = history.listen(location => {
+          updates.push(location.pathname)
+        })
+
+        history.push('/foo')
+        history.push('/foo')
+        history.replace('/foo')
+
+        expect(updates).toEqual([ '/', '/foo', '/foo', '/foo' ])
+
+        historyUnsubscribe()
+      })
+    })
+
+    describe('Redux DevTools', () => {
+      let originalHistory, history, store, devToolsStore
+
+      beforeEach(() => {
+        originalHistory = createHistory()
+
+        // Set initial URL before syncing
+        originalHistory.push('/foo')
+
+        store = createStore(
+          combineReducers({
+            routing: routerReducer
+          }),
+          instrument()
+        )
+        devToolsStore = store.liftedStore
+
+        history = syncHistoryWithStore(originalHistory, store)
+      })
+
+      afterEach(() => {
+        history.unsubscribe()
+      })
+
+      it('resets to the initial url', () => {
+        let currentPath
+        const historyUnsubscribe = history.listen(location => {
+          currentPath = location.pathname
+        })
+
+        history.push('/bar')
+        devToolsStore.dispatch(ActionCreators.reset())
+
+        expect(currentPath).toEqual('/foo')
+
+        historyUnsubscribe()
+      })
+
+      it('handles toggle after history change', () => {
+        let currentPath
+        const historyUnsubscribe = history.listen(location => {
+          currentPath = location.pathname
+        })
+
+        history.push('/foo2') // DevTools action #2
+        history.push('/foo3') // DevTools action #3
+
+        // When we toggle an action, the devtools will revert the action
+        // and we therefore expect the history to update to the previous path
+        devToolsStore.dispatch(ActionCreators.toggleAction(3))
+        expect(currentPath).toEqual('/foo2')
+
+        historyUnsubscribe()
+      })
+    })
+  })
+}
diff --git a/test/actions.spec.js b/test/actions.spec.js
new file mode 100644
index 0000000..e4a5060
--- /dev/null
+++ b/test/actions.spec.js
@@ -0,0 +1,100 @@
+import expect from 'expect'
+
+import {
+  CALL_HISTORY_METHOD,
+  push, replace, go, goBack, goForward
+} from '../src/actions'
+
+describe('routerActions', () => {
+
+  describe('push', () => {
+    it('creates actions', () => {
+      expect(push('/foo')).toEqual({
+        type: CALL_HISTORY_METHOD,
+        payload: {
+          method: 'push',
+          args: [ '/foo' ]
+        }
+      })
+
+      expect(push({ pathname: '/foo', state: { the: 'state' } })).toEqual({
+        type: CALL_HISTORY_METHOD,
+        payload: {
+          method: 'push',
+          args: [ {
+            pathname: '/foo',
+            state: { the: 'state' }
+          } ]
+        }
+      })
+
+      expect(push('/foo', 'baz', 123)).toEqual({
+        type: CALL_HISTORY_METHOD,
+        payload: {
+          method: 'push',
+          args: [ '/foo' , 'baz', 123 ]
+        }
+      })
+    })
+  })
+
+  describe('replace', () => {
+    it('creates actions', () => {
+      expect(replace('/foo')).toEqual({
+        type: CALL_HISTORY_METHOD,
+        payload: {
+          method: 'replace',
+          args: [ '/foo' ]
+        }
+      })
+
+      expect(replace({ pathname: '/foo', state: { the: 'state' } })).toEqual({
+        type: CALL_HISTORY_METHOD,
+        payload: {
+          method: 'replace',
+          args: [ {
+            pathname: '/foo',
+            state: { the: 'state' }
+          } ]
+        }
+      })
+    })
+  })
+
+  describe('go', () => {
+    it('creates actions', () => {
+      expect(go(1)).toEqual({
+        type: CALL_HISTORY_METHOD,
+        payload: {
+          method: 'go',
+          args: [ 1 ]
+        }
+      })
+    })
+  })
+
+  describe('goBack', () => {
+    it('creates actions', () => {
+      expect(goBack()).toEqual({
+        type: CALL_HISTORY_METHOD,
+        payload: {
+          method: 'goBack',
+          args: []
+        }
+      })
+    })
+  })
+
+  describe('goForward', () => {
+    it('creates actions', () => {
+      expect(goForward()).toEqual({
+        type: CALL_HISTORY_METHOD,
+        payload: {
+          method: 'goForward',
+          args: []
+        }
+      })
+    })
+  })
+
+})
diff --git a/test/browser/index.js b/test/browser/index.js
index 5310155..b05135e 100644
--- a/test/browser/index.js
+++ b/test/browser/index.js
@@ -1,5 +1,7 @@
+import 'babel-polyfill'
+
 import { createHashHistory, createHistory } from 'history'
-import createTests from '../createTests.js'
+import createTests from '../_createSyncTest'
 
 createTests(createHashHistory, 'Hash History', () => window.location = '#/')
 createTests(createHistory, 'Browser History', () => window.history.replaceState(null, null, '/'))
diff --git a/test/createTests.js b/test/createTests.js
deleted file mode 100644
index dcfbfad..0000000
--- a/test/createTests.js
+++ /dev/null
@@ -1,610 +0,0 @@
-/*eslint-env mocha */
-
-import expect from 'expect'
-import {
-  routeActions, TRANSITION, UPDATE_LOCATION, routeReducer, syncHistory
-} from '../src/index'
-import { applyMiddleware, createStore, combineReducers, compose } from 'redux'
-import { ActionCreators, instrument } from 'redux-devtools'
-import { useBasename, useQueries } from 'history'
-
-expect.extend({
-  toContainLocation({
-    pathname,
-    search = '',
-    hash = '',
-    state = null,
-    query,
-    action = 'PUSH'
-  }) {
-    const { location } = this.actual.getState().routing
-
-    expect(location.pathname).toEqual(pathname)
-    expect(location.search).toEqual(search)
-    expect(location.hash).toEqual(hash)
-    expect(location.state).toEqual(state)
-    expect(location.query).toEqual(query)
-    expect(location.action).toEqual(action)
-  }
-})
-
-function createSyncedHistoryAndStore(createHistory) {
-  const history = createHistory()
-  const middleware = syncHistory(history)
-  const { unsubscribe } = middleware
-
-  const createStoreWithMiddleware = applyMiddleware(middleware)(createStore)
-  const store = createStoreWithMiddleware(combineReducers({
-    routing: routeReducer
-  }))
-
-  return { history, store, unsubscribe }
-}
-
-const defaultReset = () => {}
-
-const { push, replace, go, goBack, goForward } = routeActions
-
-module.exports = function createTests(createHistory, name, reset = defaultReset) {
-  describe(name, () => {
-
-    beforeEach(reset)
-
-    describe('routeActions', () => {
-
-      describe('push', () => {
-        it('creates actions', () => {
-          expect(push('/foo')).toEqual({
-            type: TRANSITION,
-            payload: {
-              method: 'push',
-              args: [ '/foo' ]
-            }
-          })
-
-          expect(push({ pathname: '/foo', state: { the: 'state' } })).toEqual({
-            type: TRANSITION,
-            payload: {
-              method: 'push',
-              args: [ {
-                pathname: '/foo',
-                state: { the: 'state' }
-              } ]
-            }
-          })
-
-          expect(push('/foo', 'baz', 123)).toEqual({
-            type: TRANSITION,
-            payload: {
-              method: 'push',
-              args: [ '/foo' , 'baz', 123 ]
-            }
-          })
-        })
-      })
-
-      describe('replace', () => {
-        it('creates actions', () => {
-          expect(replace('/foo')).toEqual({
-            type: TRANSITION,
-            payload: {
-              method: 'replace',
-              args: [ '/foo' ]
-            }
-          })
-
-          expect(replace({ pathname: '/foo', state: { the: 'state' } })).toEqual({
-            type: TRANSITION,
-            payload: {
-              method: 'replace',
-              args: [ {
-                pathname: '/foo',
-                state: { the: 'state' }
-              } ]
-            }
-          })
-        })
-      })
-
-      describe('go', () => {
-        it('creates actions', () => {
-          expect(go(1)).toEqual({
-            type: TRANSITION,
-            payload: {
-              method: 'go',
-              args: [ 1 ]
-            }
-          })
-        })
-      })
-
-      describe('goBack', () => {
-        it('creates actions', () => {
-          expect(goBack()).toEqual({
-            type: TRANSITION,
-            payload: {
-              method: 'goBack',
-              args: []
-            }
-          })
-        })
-      })
-
-      describe('goForward', () => {
-        it('creates actions', () => {
-          expect(goForward()).toEqual({
-            type: TRANSITION,
-            payload: {
-              method: 'goForward',
-              args: []
-            }
-          })
-        })
-      })
-
-    })
-
-    describe('routeReducer', () => {
-      const state = {
-        location: {
-          pathname: '/foo',
-          action: 'POP'
-        }
-      }
-
-      it('updates the path', () => {
-        expect(routeReducer(state, {
-          type: UPDATE_LOCATION,
-          payload: {
-            path: '/bar',
-            action: 'PUSH'
-          }
-        })).toEqual({
-          location: {
-            path: '/bar',
-            action: 'PUSH'
-          }
-        })
-      })
-
-      it('respects replace', () => {
-        expect(routeReducer(state, {
-          type: UPDATE_LOCATION,
-          payload: {
-            path: '/bar',
-            action: 'REPLACE'
-          }
-        })).toEqual({
-          location: {
-            path: '/bar',
-            action: 'REPLACE'
-          }
-        })
-      })
-    })
-
-    // To ensure that "Revert" and toggling actions work as expected in
-    // Redux DevTools we need a couple of tests for it. In these tests we
-    // rely directly on the DevTools, as they implement these actions as
-    // middleware, and we don't want to implement this ourselves.
-    describe('devtools', () => {
-      let history, store, devToolsStore, unsubscribe
-
-      beforeEach(() => {
-        history = createHistory()
-
-        // Set initial URL before syncing
-        history.push('/foo')
-
-        const middleware = syncHistory(history)
-        unsubscribe = middleware.unsubscribe
-
-        const finalCreateStore = compose(
-          applyMiddleware(middleware),
-          instrument()
-        )(createStore)
-        store = finalCreateStore(combineReducers({
-          routing: routeReducer
-        }))
-        devToolsStore = store.liftedStore
-
-        middleware.listenForReplays(store)
-      })
-
-      afterEach(() => {
-        unsubscribe()
-      })
-
-      it('resets to the initial url', () => {
-        let currentPath
-        const historyUnsubscribe = history.listen(location => {
-          currentPath = location.pathname
-        })
-
-        history.push('/bar')
-        store.dispatch(push('/baz'))
-
-        // By calling reset we expect DevTools to re-play the initial state
-        // and the history to update to the initial path
-        devToolsStore.dispatch(ActionCreators.reset())
-
-        expect(store.getState().routing.location.pathname).toEqual('/foo')
-        expect(currentPath).toEqual('/foo')
-
-        historyUnsubscribe()
-      })
-
-      it('handles toggle after history change', () => {
-        let currentPath
-        const historyUnsubscribe = history.listen(location => {
-          currentPath = location.pathname
-        })
-
-        // DevTools action #2
-        history.push('/foo2')
-        // DevTools action #3
-        history.push('/foo3')
-
-        // When we toggle an action, the devtools will revert the action
-        // and we therefore expect the history to update to the previous path
-        devToolsStore.dispatch(ActionCreators.toggleAction(3))
-        expect(currentPath).toEqual('/foo2')
-
-        historyUnsubscribe()
-      })
-
-      it('handles toggle after store change', () => {
-        let currentPath
-        const historyUnsubscribe = history.listen(location => {
-          currentPath = location.pathname
-        })
-
-        // DevTools action #2
-        store.dispatch(push('/foo2'))
-        // DevTools action #3
-        store.dispatch(push('/foo3'))
-
-        // When we toggle an action, the devtools will revert the action
-        // and we therefore expect the history to update to the previous path
-        devToolsStore.dispatch(ActionCreators.toggleAction(3))
-        expect(currentPath).toEqual('/foo2')
-
-        historyUnsubscribe()
-      })
-    })
-
-    describe('syncReduxAndRouter', () => {
-      let history, store, unsubscribe
-
-      beforeEach(() => {
-        let synced = createSyncedHistoryAndStore(createHistory)
-        history = synced.history
-        store = synced.store
-        unsubscribe = synced.unsubscribe
-      })
-
-      afterEach(() => {
-        unsubscribe()
-      })
-
-      it('syncs router -> redux', () => {
-        expect(store).toContainLocation({
-          pathname: '/',
-          action: 'POP'
-        })
-
-        history.push('/foo')
-        expect(store).toContainLocation({
-          pathname: '/foo'
-        })
-
-        history.push({ state: { bar: 'baz' }, pathname: '/foo' })
-        expect(store).toContainLocation({
-          pathname: '/foo',
-          state: { bar: 'baz' },
-          action: 'REPLACE' // Converted by history.
-        })
-
-        history.replace('/bar')
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          action: 'REPLACE'
-        })
-
-        history.push('/bar')
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          action: 'REPLACE' // Converted by history.
-        })
-
-        history.push('/bar?query=1')
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          search: '?query=1'
-        })
-
-        history.push('/bar#baz')
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          hash: '#baz'
-        })
-
-        history.replace({
-          pathname: '/bar',
-          search: '?query=1',
-          state: { bar: 'baz' }
-        })
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          search: '?query=1',
-          state: { bar: 'baz' },
-          action: 'REPLACE'
-        })
-
-        history.replace({
-          pathname: '/bar',
-          search: '?query=1',
-          hash: '#hash=2',
-          state: { bar: 'baz' }
-        })
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          search: '?query=1',
-          hash: '#hash=2',
-          state: { bar: 'baz' },
-          action: 'REPLACE'
-        })
-      })
-
-      it('syncs redux -> router', () => {
-        expect(store).toContainLocation({
-          pathname: '/',
-          action: 'POP'
-        })
-
-        store.dispatch(push('/foo'))
-        expect(store).toContainLocation({
-          pathname: '/foo'
-        })
-
-        store.dispatch(push({ pathname: '/foo', state: { bar: 'baz' } }))
-        expect(store).toContainLocation({
-          pathname: '/foo',
-          state: { bar: 'baz' },
-          action: 'REPLACE' // Converted by history.
-        })
-
-        store.dispatch(replace({ pathname: '/bar', state: { bar: 'foo' } }))
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          state: { bar: 'foo' },
-          action: 'REPLACE'
-        })
-
-        store.dispatch(push('/bar'))
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          action: 'REPLACE' // Converted by history.
-        })
-
-        store.dispatch(push('/bar?query=1'))
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          search: '?query=1'
-        })
-
-        store.dispatch(push('/bar?query=1#hash=2'))
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          search: '?query=1',
-          hash: '#hash=2'
-        })
-      })
-
-      it('updates the router even if path is the same', () => {
-        const updates = []
-        const historyUnsubscribe = history.listen(location => {
-          updates.push(location.pathname)
-        })
-
-        store.dispatch(push('/foo'))
-        store.dispatch(push('/foo'))
-        store.dispatch(replace('/foo'))
-
-        expect(updates).toEqual([ '/', '/foo', '/foo', '/foo' ])
-
-        historyUnsubscribe()
-      })
-
-      it('does not update the router for other state changes', () => {
-        const state = store.getState()
-
-        store.dispatch({
-          type: 'RANDOM_ACTION',
-          payload: {
-            payload: {
-              value: 5
-            }
-          }
-        })
-
-        expect(state).toEqual(store.getState())
-      })
-
-      it('only updates the router once when dispatching from `listenBefore`', () => {
-        history.listenBefore(location => {
-          expect(location.pathname).toEqual('/foo')
-          store.dispatch({
-            type: 'RANDOM_ACTION',
-            payload: {
-              payload: {
-                value: 5
-              }
-            }
-          })
-        })
-
-        const updates = []
-        history.listen(location => {
-          updates.push(location.pathname)
-        })
-
-        store.dispatch(push('/foo'))
-
-        expect(updates).toEqual([ '/', '/foo' ])
-      })
-
-      it('allows updating the route from within `listenBefore`', () => {
-        history.listenBefore(location => {
-          if(location.pathname === '/foo') {
-            store.dispatch(push('/bar'))
-          }
-          else if(location.pathname === '/replace') {
-            store.dispatch(replace({ pathname: '/baz', state: { foo: 'bar' } }))
-          }
-        })
-
-        const updates = []
-        history.listen(location => {
-          updates.push(location.pathname)
-        })
-
-        store.dispatch(push('/foo'))
-        expect(store).toContainLocation({
-          pathname: '/bar'
-        })
-
-        store.dispatch(push({ pathname: '/replace', state: { bar: 'baz' } }))
-        expect(store).toContainLocation({
-          pathname: '/baz',
-          state: { foo: 'bar' },
-          action: 'REPLACE'
-        })
-
-        expect(updates).toEqual([ '/', '/bar', '/baz' ])
-      })
-
-      it('returns unsubscribe to stop listening to history and store', () => {
-        history.push('/foo')
-        expect(store).toContainLocation({
-          pathname: '/foo'
-        })
-
-        store.dispatch(push('/bar'))
-        expect(store).toContainLocation({
-          pathname: '/bar'
-        })
-
-        unsubscribe()
-
-        // Make the teardown a no-op.
-        unsubscribe = () => {}
-
-        history.push('/foo')
-        expect(store).toContainLocation({
-          pathname: '/bar'
-        })
-
-        history.listenBefore(() => {
-          throw new Error()
-        })
-        expect(
-          () => store.dispatch(push('/foo'))
-        ).toNotThrow()
-      })
-
-      it('only triggers history once when updating path via store', () => {
-        const updates = []
-        const historyUnsubscribe = history.listen(location => {
-          updates.push(location.pathname)
-        })
-
-        store.dispatch(push('/bar'))
-        store.dispatch(push('/baz'))
-        expect(updates).toEqual([ '/', '/bar', '/baz' ])
-
-        historyUnsubscribe()
-      })
-
-      it('only triggers store once when updating path via store', () => {
-        const updates = []
-        const storeUnsubscribe = store.subscribe(() => {
-          updates.push(store.getState().routing.location.pathname)
-        })
-
-        store.dispatch(push('/bar'))
-        store.dispatch(push('/baz'))
-        store.dispatch(replace('/foo'))
-        expect(updates).toEqual([ '/bar', '/baz', '/foo' ])
-
-        storeUnsubscribe()
-      })
-    })
-
-    describe('query support', () => {
-      let history, store, unsubscribe
-
-      beforeEach(() => {
-        const synced = createSyncedHistoryAndStore(useQueries(createHistory))
-        history = synced.history
-        store = synced.store
-        unsubscribe = synced.unsubscribe
-      })
-
-      afterEach(() => {
-        unsubscribe()
-      })
-
-      it('handles location queries', () => {
-        store.dispatch(push({ pathname: '/bar', query: { the: 'query' } }))
-        expect(store).toContainLocation({
-          pathname: '/bar',
-          query: { the: 'query' },
-          search: '?the=query'
-        })
-
-        history.push({ pathname: '/baz', query: { other: 'query' } })
-        expect(store).toContainLocation({
-          pathname: '/baz',
-          query: { other: 'query' },
-          search: '?other=query'
-        })
-
-        store.dispatch(push('/foo'))
-        expect(store).toContainLocation({
-          pathname: '/foo',
-          query: {}
-        })
-      })
-    })
-
-    describe('basename support', () => {
-      let history, store, unsubscribe
-
-      beforeEach(() => {
-        const synced = createSyncedHistoryAndStore(
-          () => useBasename(createHistory)({ basename: '/foobar' })
-        )
-        history = synced.history
-        store = synced.store
-        unsubscribe = synced.unsubscribe
-      })
-
-      afterEach(() => {
-        unsubscribe()
-      })
-
-      it('handles basename history option', () => {
-        store.dispatch(push('/bar'))
-        expect(store).toContainLocation({
-          pathname: '/bar'
-        })
-
-        history.push('/baz')
-        expect(store).toContainLocation({
-          pathname: '/baz'
-        })
-      })
-    })
-  })
-}
diff --git a/test/middleware.spec.js b/test/middleware.spec.js
new file mode 100644
index 0000000..ec9569c
--- /dev/null
+++ b/test/middleware.spec.js
@@ -0,0 +1,34 @@
+import expect, { createSpy } from 'expect'
+
+import { push, replace } from '../src/actions'
+import routerMiddleware from '../src/middleware'
+
+describe('routerMiddleware', () => {
+  let history, next, dispatch
+
+  beforeEach(() => {
+    history = {
+      push: createSpy(),
+      replace: createSpy()
+    }
+    next = createSpy()
+
+    dispatch = routerMiddleware(history)()(next)
+  })
+
+
+  it('calls the appropriate history method', () => {
+    dispatch(push('/foo'))
+    expect(history.push).toHaveBeenCalled()
+
+    dispatch(replace('/foo'))
+    expect(history.replace).toHaveBeenCalled()
+
+    expect(next).toNotHaveBeenCalled()
+  })
+
+  it('ignores other actions', () => {
+    dispatch({ type: 'FOO' })
+    expect(next).toHaveBeenCalled()
+  })
+})
diff --git a/test/reducer.spec.js b/test/reducer.spec.js
new file mode 100644
index 0000000..e764005
--- /dev/null
+++ b/test/reducer.spec.js
@@ -0,0 +1,58 @@
+import expect from 'expect'
+
+import { LOCATION_CHANGE, routerReducer } from '../src/reducer'
+
+describe('routerReducer', () => {
+  const state = {
+    locationBeforeTransitions: {
+      pathname: '/foo',
+      action: 'POP'
+    }
+  }
+
+  it('updates the path', () => {
+    expect(routerReducer(state, {
+      type: LOCATION_CHANGE,
+      payload: {
+        path: '/bar',
+        action: 'PUSH'
+      }
+    })).toEqual({
+      locationBeforeTransitions: {
+        path: '/bar',
+        action: 'PUSH'
+      }
+    })
+  })
+
+  it('works with initialState', () => {
+    expect(routerReducer(undefined, {
+      type: LOCATION_CHANGE,
+      payload: {
+        path: '/bar',
+        action: 'PUSH'
+      }
+    })).toEqual({
+      locationBeforeTransitions: {
+        path: '/bar',
+        action: 'PUSH'
+      }
+    })
+  })
+
+
+  it('respects replace', () => {
+    expect(routerReducer(state, {
+      type: LOCATION_CHANGE,
+      payload: {
+        path: '/bar',
+        action: 'REPLACE'
+      }
+    })).toEqual({
+      locationBeforeTransitions: {
+        path: '/bar',
+        action: 'REPLACE'
+      }
+    })
+  })
+})
diff --git a/test/node/index.js b/test/sync.spec.js
similarity index 69%
rename from test/node/index.js
rename to test/sync.spec.js
index fe092ba..55a63fa 100644
--- a/test/node/index.js
+++ b/test/sync.spec.js
@@ -1,4 +1,4 @@
 import { createMemoryHistory } from 'history'
-import createTests from '../createTests.js'
+import createTests from './_createSyncTest'
 
 createTests(createMemoryHistory, 'Memory History')
diff --git a/tests.webpack.js b/tests.webpack.js
index 15df5a3..1ef2212 100644
--- a/tests.webpack.js
+++ b/tests.webpack.js
@@ -1,2 +1,2 @@
-const browserContext = require.context('./test/browser', true, /\.js$/);
-browserContext.keys().forEach(browserContext);
+const browserContext = require.context('./test/browser')
+browserContext.keys().forEach(browserContext)