diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6b942932..d42793db 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,30 @@
 # Changelog
 
+## v2.0.0 [**alpha**] _Second Toughest in the Infants_
+- **BREAKING**: "Node-style" error-first callbacks (_e.g._ `.get( ( err, data ) => {} )`) are no longer supported. All transport request methods return Promises.
+- **BREAKING**: The module exported as `wpapi` no longer includes HTTP methods. Install `superagent` as a peer dependency and `require( 'wpapi/superagent' )` in order to make HTTP requests.
+- **BREAKING**: Autodiscovery now either succeeds or fails; a WPAPI instance configured with default routes will no longer be returned.
+
+
+## v1.2.2 _(future release)_
+
+- Throw an error early when `.file()` is passed a Buffer object without an accompanying name string, props @cungminh2710 & @mvhirsch
+
+
+## v1.2.1 _Colomb_
+
+- Fix issue where `li` was improperly declared as a dev-only dependency, props @el-lsan & @jerolan.
+
+
+## v1.2.0 _Space Is Only Noise_
+
+- **BREAKING**: The minimum supported node version is now v8.6, or v8.2.1 with the `--harmony` flag.
+- **BREAKING**: `._paging.total` and `._paging.totalPages` response properties are now returned as integers, not strings.
+- Bundled route handlers are now available for new first-party endpoints in WordPress 5.0.
+- The project now uses Jest and ESLint in place of Mocha, Chai, JSCS and JSHint. Thank you for your years of service, ["nyan" reporter](https://mochajs.org/#nyan)!
+- Browser bundle size has been reduced.
+
+
 ## v1.1.2 _If I Survive_
 
 - Resolves an issue where authentication credentials where not maintained properly when iterating through pages of a connection with `._paging.next` or `._paging.prev`, props @motleydev for the reproducible bug report
@@ -43,9 +68,9 @@ v1.0 namesake album _Emotional Technology_ by BT.
 
 - Add CHANGELOG.md
 - Reduce complexity of, and rename, default routes JSON file
-- BREAKING: Remove third "merge" argument from `.param()` method signature
+- **BREAKING**: Remove third "merge" argument from `.param()` method signature
 - Document `.settings()` top-level route handler
-- BREAKING: Return API error objects directly from HTTP transport: only return a transport-level error object in the event of a non-API error
+- **BREAKING**: Return API error objects directly from HTTP transport: only return a transport-level error object in the event of a non-API error
 - Add `.status()` parameter method mixin
 - Properly register `.password()` and `.sticky()` parameter mixins
 - Utilize the HTTP transport methods during auto-discovery process
diff --git a/README.md b/README.md
index 349408c3..3668a032 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 A WordPress REST API client for JavaScript
 ==========================================
 
-This library is an isomorphic client for the [WordPress REST API](http://developer.wordpress.org/rest-api), designed to work with WordPress 4.7 or later. If you are using the older [WP REST API plugin](https://github.com/WP-API/WP-API), some commands will not work.
+This library is an isomorphic client for the [WordPress REST API](http://developer.wordpress.org/rest-api), designed to work with WordPress 5.0 or later. If you are using the older [WP REST API plugin](https://github.com/WP-API/WP-API) or WordPress 4.9, some commands will not work.
 
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/wp-api/node-wpapi?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
@@ -11,6 +11,7 @@ This library is an isomorphic client for the [WordPress REST API](http://develop
 
 - [About](#about)
 - [Installation](#installation)
+  - [Upgrading from v1](#upgrading-from-v1)
 - [Using the Client](#using-the-client)
   - [Auto-Discovery](#auto-discovery)
   - [Creating Posts](#creating-posts)
@@ -18,7 +19,7 @@ This library is an isomorphic client for the [WordPress REST API](http://develop
   - [Requesting Different Resources](#requesting-different-resources)
   - [API Query Parameters & Filtering Collections](#api-query-parameters)
   - [Uploading Media](#uploading-media)
-- [Custom Routes](#custom-routes)
+- [Querying Custom Routes](#custom-routes)
   - [Setter Method Naming](#setter-method-naming-for-named-route-components)
   - [Query Parameters & Filtering](#query-parameters--filtering-custom-routes)
   - [Mixins](#mixins)
@@ -35,13 +36,13 @@ This library is an isomorphic client for the [WordPress REST API](http://develop
 
 `node-wpapi` is an isomorphic JavaScript client for the [WordPress REST API](https://developer.wordpress.org/rest-api) that makes it easy for your JavaScript application to request specific resources from a [WordPress](https://wordpress.org) website. It uses a query builder-style syntax to let you craft the request being made to REST API endpoints, then returns the API's response to your application as a JSON object. And don't let the name fool you: with [Webpack](https://webpack.github.io/) or [Browserify](http://browserify.org/), `node-wpapi` works just as well in the browser as it does on the server!
 
-This library is maintained by K. Adam White at [Bocoup](https://bocoup.com), with contributions from a [great community](https://github.com/WP-API/node-wpapi/graphs/contributors) of WordPress and JavaScript developers.
+This library is maintained by K. Adam White at [Human Made](https://humanmade.com), with contributions from a [great community](https://github.com/WP-API/node-wpapi/graphs/contributors) of WordPress and JavaScript developers.
 
 To get started, `npm install wpapi` or [download the browser build](https://wp-api.github.io/node-wpapi/wpapi.zip) and check out "Installation" and "Using the Client" below.
 
 ## Installation
 
-`node-wpapi` works both on the server or in the browser. Node.js version 8 or higher is required, and the latest LTS release is recommended.
+`node-wpapi` works both on the server or in the browser. Node.js version 8.6 or higher (or version 8.2.1 with the `--harmony` flag) is required, and the latest LTS release is recommended.
 
 In the browser `node-wpapi` officially supports the latest two versions of all evergreen browsers, and Internet Explorer 11.
 
@@ -53,45 +54,83 @@ To use the library from Node, install it with [npm](http://npmjs.org):
 npm install --save wpapi
 ```
 
-Then, within your application's script files, `require` the module to gain access to it:
+Then, within your application's script files, `require` the module to gain access to it. As `wpapi` is both a query builder and a transport layer (_i.e._ a tool for getting and sending HTTP requests), we leave it up to you as the author of your application whether you need both parts of this functionality. You may use `wpapi` with [superagent](https://www.npmjs.com/package/superagent) if you wish to send and receive HTTP requests using this library, but you may also use only the query builder part of the library if you intend to submit your HTTP requests with `fetch`, `axios` or other tools.
+
+To import only the query builder (without the `.get()`, `.create()`, `.delete()`, `.update()` or `.then()` chaining methods):
 
 ```javascript
 var WPAPI = require( 'wpapi' );
 ```
 
-This library is designed to work in the browser as well, via a build system such as Browserify or Webpack; just install the package and `require( 'wpapi' )` from your application code.
+To import the superagent bundle, which contains the full suite of HTTP interaction methods:
+
+```js
+var WPAPI = require( 'wpapi/superagent' );
+```
+
+This library is designed to work in the browser as well, via a build system such as Browserify or Webpack; just install the package and `require( 'wpapi' )` (or `'wpapi/superagent'`) from your application code.
 
 ### Download the UMD Bundle
 
 Alternatively, you may download a [ZIP archive of the bundled library code](https://wp-api.github.io/node-wpapi/wpapi.zip). These files are UMD modules, which may be included directly on a page using a regular `<script>` tag _or_ required via AMD or CommonJS module systems. In the absence of a module system, the UMD modules will export the browser global variable `WPAPI`, which can be used in place of `require( 'wpapi' )` to access the library from your code.
 
+At present this browser bundle tracks the `wpapi/superagent` module, and includes Superagent itself.
+
+### Upgrading from v1
+
+### Require `wpapi/superagent`
+
+Prior to version 2.0 (currently `alpha` status) this library shipped with built-in HTTP functionality using Superagent.
+
+If you maintain an existing project which uses this library and wish to upgrade to v2, you may do so by manually installing Superagent:
+
+```sh
+npm i --save wpapi@alpha superagent
+```
+
+and then changing your `require` statements to use the `wpapi/superagent` entrypoint:
+
+```diff
+--- const WPAPI = require( 'wpapi' );
++++ const WPAPI = require( 'wpapi/superagent' );
+```
+
+### Use Promises instead of Callbacks
+
+In version 1, you could use "Node-style" error-first callback functions instead of chaining promises. As of version 2, this callback style is no longer supported; use Promise `.then` syntax or [`async`/`await`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function) instead.
+
+```js
+// Version 1
+wp.posts().get( function( error, posts ) { /* ... */ } );
+
+// Version 2, Promises syntax
+wp.posts().get().then( posts => { /* ... */ } );
+
+// Version 2, await syntax
+await wp.posts().get();
+```
+
 ## Using the Client
 
 The module is a constructor, so you can create an instance of the API client bound to the endpoint for your WordPress install:
 
 ```javascript
-var WPAPI = require( 'wpapi' );
+var WPAPI = require( 'wpapi/superagent' );
 var wp = new WPAPI({ endpoint: 'http://src.wordpress-develop.dev/wp-json' });
 ```
 Once an instance is constructed, you can chain off of it to construct a specific request. (Think of it as a query-builder for WordPress!)
 
-We support requesting posts using either a callback-style or promise-style syntax:
+**Compatibility Note:** As of Version 2.0, Node-style error-first callbacks are no longer supported by this library. All request methods return Promises.
 
 ```javascript
-// Callbacks
-wp.posts().get(function( err, data ) {
-    if ( err ) {
-        // handle err
-    }
-    // do something with the returned posts
-});
-
-// Promises
-wp.posts().then(function( data ) {
-    // do something with the returned posts
-}).catch(function( err ) {
-    // handle error
-});
+// Request methods return Promises.
+wp.posts().get()
+    .then(function( data ) {
+        // do something with the returned posts
+    })
+    .catch(function( err ) {
+        // handle error
+    });
 ```
 The `wp` object has endpoint handler methods for every endpoint that ships with the default WordPress REST API plugin.
 
@@ -263,8 +302,11 @@ A WPAPI instance object provides the following basic request methods:
 * `wp.categories()...`: Get or create categories with the `/categories` endpoint
 * `wp.statuses()...`: Get resources within the `/statuses` endpoints
 * `wp.users()...`: Get resources within the `/users` endpoints
+* `wp.search()...`: Find resources of any [REST-enabled] post type matching a `?search=` string
 * `wp.media()...`: Get Media collections and objects from the `/media` endpoints
+* `wp.themes()...`: Read information about the active theme from the `/themes` endpoint (always requires authentication)
 * `wp.settings()...`: Read or update site settings from the `/settings` endpoint (always requires authentication)
+* `wp.blocks()...`: Create queries against the `blocks` endpoint
 
 All of these methods return a customizable request object. The request object can be further refined with chaining methods, and/or sent to the server via `.get()`, `.create()`, `.update()`, `.delete()`, `.headers()`, or `.then()`. (Not all endpoints support all methods; for example, you cannot POST or PUT records on `/types`, as these are defined in WordPress plugin or theme code.)
 
@@ -524,7 +566,7 @@ Files may be uploaded to the WordPress media library by creating a media record
 The file to upload can be specified as
 
 - a `String` describing an image file path, _e.g._ `'/path/to/the/image.jpg'`
-- a `Buffer` with file content, _e.g._ `new Buffer()`
+- a `Buffer` with file content, _e.g._ `Buffer.from()` (or the result of a `readFile` call)
 - a file object from a `<input>` element, _e.g._ `document.getElementById( 'file-input' ).files[0]`
 
 The file is passed into the `.file()` method:
@@ -533,7 +575,7 @@ The file is passed into the `.file()` method:
 wp.media().file(content [, name])...
 ```
 
-The optional second string argument specifies the file name to use for the uploaded media. If the name argument is omitted `file()` will try to infer a filename from the provided content.
+The optional second string argument specifies the file name to use for the uploaded media. If the name argument is omitted `file()` will try to infer a filename from the provided file path. Note that when uploading a Buffer object `name` is a required argument, because no name can be automatically inferred from the buffer.
 
 #### Adding Media to a Post
 
@@ -767,7 +809,9 @@ By default `node-wpapi` uses the [superagent](https://www.npmjs.com/package/supe
 
 **This is advanced behavior; you will only need to utilize this functionality if your application has very specific HTTP handling or caching requirements.**
 
-In order to maintain consistency with the rest of the API, custom transport methods should take in a WordPress API route handler query object (_e.g._ the result of calling `wp.posts()...` or any of the other chaining resource handlers), a `data` object (for POST, PUT and DELETE requests), and an optional callback function (as `node-wpapi` transport methods both return Promise objects _and_ support traditional `function( err, response )` callbacks).
+In order to maintain consistency with the rest of the API, custom transport methods should take in a WordPress API route handler query object (_e.g._ the result of calling `wp.posts()...` or any of the other chaining resource handlers)and a `data` object (for POST, PUT and DELETE requests).
+
+**Note:** Node-style error-first callbacks are no longer supported by this library as of version 2.0. Custom transport methods should therefore not accept or expect a third optional callback parameter.
 
 The default HTTP transport methods are available as `WPAPI.transport` (a property of the constructor object) and may be called within your transports if you wish to extend the existing behavior, as in the example below.
 
@@ -778,16 +822,11 @@ var site = new WPAPI({
   endpoint: 'http://my-site.com/wp-json',
   transport: {
     // Only override the transport for the GET method, in this example
-    // Transport methods should take a wpreq object and a callback:
-    get: function( wpreq, cb ) {
+    // Transport methods should take a wpreq object:
+    get: function( wpreq ) {
       var result = cache[ wpreq ];
-      // If a cache hit is found, return it via the same callback/promise
-      // signature as the default transport method:
+      // If a cache hit is found, return it wrapped in a Promise:
       if ( result ) {
-        if ( cb && typeof cb === 'function' ) {
-          // Invoke the callback function, if one was provided
-          cb( null, result );
-        }
         // Return the data as a promise
         return Promise.resolve( result );
       }
@@ -806,8 +845,8 @@ You may set one or many custom HTTP transport methods on an existing WP site cli
 
 ```js
 site.transport({
-    get: function( wpreq, callbackFn ) { /* ... */},
-    put: function( wpreq, callbackFn ) { /* ... */}
+    get: function( wpreq ) { /* ... */},
+    put: function( wpreq, data ) { /* ... */}
 });
 ```
 
@@ -921,7 +960,7 @@ add_action( 'wp_enqueue_scripts', 'my_enqueue_scripts' );
 And then use this nonce when initializing the library:
 
 ```javascript
-var WPAPI = require( 'wpapi' );
+var WPAPI = require( 'wpapi/superagent' );
 var wp = new WPAPI({
     endpoint: window.WP_API_Settings.endpoint,
     nonce: window.WP_API_Settings.nonce
diff --git a/bin/jekyll b/bin/jekyll
deleted file mode 100755
index 1b0a8d32..00000000
--- a/bin/jekyll
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/bin/sh
-':' //; exec "$(command -v nodejs || command -v node)" "$0" "$@"
-// ^^^ Lovely polyglot script to permit usage via node _or_ via bash: see
-// http://unix.stackexchange.com/questions/65235/universal-node-js-shebang
-/**
- * This script will start the Jekyll server in the context of the docs
- * directory. It is only for use in local development, and sets the --baseurl
- * option to override the production-only baseurl in _config.yml.
- */
-'use strict';
-
-const path = require( 'path' );
-const spawn = require( 'child_process' ).spawn;
-const argv = require( 'minimist' )( process.argv.slice( 2 ) );
-
-// Execute within the context of the docs directory
-const docsDir = path.resolve( __dirname, '../documentation' );
-
-if ( argv.install || argv.i ) {
-  // Install the ruby bundle needed to run jekyll
-  const server = spawn( 'bundle', [ 'install' ], {
-    cwd: docsDir,
-    stdio: 'inherit'
-  });
-
-  server.on( 'error', err => console.error( err ) );
-} else {
-  // Start the server in local dev mode
-  const bundleOptions = [ 'exec', 'jekyll', 'serve', '--baseurl', '' ];
-  if ( argv.host ) {
-    bundleOptions.push( '--host', argv.host );
-  }
-
-  const server = spawn( 'bundle', bundleOptions, {
-    cwd: docsDir,
-    stdio: 'inherit'
-  });
-
-  server.on( 'error', err => console.error( err ) );
-}
diff --git a/bin/jekyll.js b/bin/jekyll.js
new file mode 100755
index 00000000..4b94ed08
--- /dev/null
+++ b/bin/jekyll.js
@@ -0,0 +1,37 @@
+/**
+ * This script will start the Jekyll server in the context of the docs
+ * directory. It is only for use in local development, and sets the --baseurl
+ * option to override the production-only baseurl in _config.yml.
+ */
+/* eslint-disable no-console */
+'use strict';
+
+const path = require( 'path' );
+const spawn = require( 'child_process' ).spawn;
+const argv = require( 'minimist' )( process.argv.slice( 2 ) );
+
+// Execute within the context of the docs directory
+const docsDir = path.resolve( __dirname, '../documentation' );
+
+if ( argv.install || argv.i ) {
+	// Install the ruby bundle needed to run jekyll
+	const server = spawn( 'bundle', [ 'install' ], {
+		cwd: docsDir,
+		stdio: 'inherit',
+	} );
+
+	server.on( 'error', err => console.error( err ) );
+} else {
+	// Start the server in local dev mode
+	const bundleOptions = [ 'exec', 'jekyll', 'serve', '--baseurl', '' ];
+	if ( argv.host ) {
+		bundleOptions.push( '--host', argv.host );
+	}
+
+	const server = spawn( 'bundle', bundleOptions, {
+		cwd: docsDir,
+		stdio: 'inherit',
+	} );
+
+	server.on( 'error', err => console.error( err ) );
+}
diff --git a/fetch/README.md b/fetch/README.md
new file mode 100644
index 00000000..07cd2a92
--- /dev/null
+++ b/fetch/README.md
@@ -0,0 +1,14 @@
+# `wpapi/fetch`
+
+This endpoint returns a version of the WPAPI library configured to use Fetch for HTTP requests.
+
+## Installation & Usage
+
+Install both `wpapi` and `isomorphic-unfetch` using the command `npm install --save wpapi isomorphic-unfetch`.
+
+```js
+import WPAPI from 'wpapi/fetch';
+
+// Configure and use WPAPI as normal
+const site = new WPAPI( { /* ... */ } );
+```
diff --git a/fetch/fetch-transport.js b/fetch/fetch-transport.js
new file mode 100644
index 00000000..023f1af1
--- /dev/null
+++ b/fetch/fetch-transport.js
@@ -0,0 +1,271 @@
+/**
+ * @module fetch-transport
+ */
+'use strict';
+
+const fetch = require( 'node-fetch' );
+const FormData = require( 'form-data' );
+const fs = require( 'fs' );
+
+const objectReduce = require( '../lib/util/object-reduce' );
+const { createPaginationObject } = require( '../lib/pagination' );
+
+/**
+ * Utility method to set a header value on a fetch configuration object.
+ *
+ * @method _setHeader
+ * @private
+ * @param {Object} config A configuration object of unknown completeness
+ * @param {string} header String name of the header to set
+ * @param {string} value  Value of the header to set
+ * @returns {Object} The modified configuration object
+ */
+const _setHeader = ( config, header, value ) => ( {
+	...config,
+	headers: {
+		...( config && config.headers ? config.headers : null ),
+		[ header ]: value,
+	},
+} );
+
+/**
+ * Set any provided headers on the outgoing request object. Runs after _auth.
+ *
+ * @method _setHeaders
+ * @private
+ * @param {Object} config A fetch request configuration object
+ * @param {Object} options A WPRequest _options object
+ * @param {Object} A fetch config object, with any available headers set
+ */
+function _setHeaders( config, options ) {
+	// If there's no headers, do nothing
+	if ( ! options.headers ) {
+		return config;
+	}
+
+	return objectReduce(
+		options.headers,
+		( config, value, key ) => _setHeader( config, key, value ),
+		config,
+	);
+}
+
+/**
+ * Conditionally set basic or nonce authentication on a server request object.
+ *
+ * @method _auth
+ * @private
+ * @param {Object} config A fetch request configuration object
+ * @param {Object} options A WPRequest _options object
+ * @param {Boolean} forceAuthentication whether to force authentication on the request
+ * @param {Object} A fetch request object, conditionally configured to use basic auth
+ */
+function _auth( config, options, forceAuthentication ) {
+	// If we're not supposed to authenticate, don't even start
+	if ( ! forceAuthentication && ! options.auth && ! options.nonce ) {
+		return config;
+	}
+
+	// Enable nonce in options for Cookie authentication http://wp-api.org/guides/authentication.html
+	if ( options.nonce ) {
+		config.credentials = 'same-origin';
+		return _setHeader( config, 'X-WP-Nonce', options.nonce );
+	}
+
+	// If no username or no password, can't authenticate
+	if ( ! options.username || ! options.password ) {
+		return config;
+	}
+
+	// Can authenticate: set basic auth parameters on the config
+	let authorization = `${ options.username }:${ options.password }`;
+	if ( global.Buffer ) {
+		authorization = global.Buffer.from( authorization ).toString( 'base64' );
+	} else if ( global.btoa ) {
+		authorization = global.btoa( authorization );
+	}
+
+	return _setHeader( config, 'Authorization', `Basic ${ authorization }` );
+}
+
+// HTTP-Related Helpers
+// ====================
+
+/**
+ * Get the response headers as a regular JavaScript object.
+ *
+ * @param {Object} response Fetch response object.
+ */
+function getHeaders( response ) {
+	const headers = {};
+	response.headers.forEach( ( value, key ) => {
+		headers[ key ] = value;
+	} );
+	return headers;
+}
+
+/**
+ * Return the body of the request, augmented with pagination information if the
+ * result is a paged collection.
+ *
+ * @private
+ * @param {WPRequest} wpreq The WPRequest representing the returned HTTP response
+ * @param {Object} response The fetch response object for the HTTP call
+ * @returns {Object} The JSON data of the response, conditionally augmented with
+ *                   pagination information if the response is a partial collection.
+ */
+const parseFetchResponse = ( response, wpreq ) => {
+	// Check if an HTTP error occurred.
+	if ( ! response.ok ) {
+		// Extract and return the API-provided error object if the response is
+		// not ok, i.e. if the error was from the API and not internal to fetch.
+		return response.json().then( ( err ) => {
+			// Throw the error object to permit proper error handling.
+			throw err;
+		}, () => {
+			// JSON serialization failed; throw the underlying response.
+			throw response;
+		} );
+	}
+
+	// If the response is OK, process & return the JSON data.
+	return response.json().then( ( body ) => {
+		// Construct a response the pagination helper can understand.
+		const mockResponse = {
+			headers: getHeaders( response ),
+		};
+
+		const _paging = createPaginationObject( mockResponse, wpreq._options, wpreq.transport );
+		if ( _paging ) {
+			body._paging = _paging;
+		}
+		return body;
+	} );
+};
+
+// HTTP Methods: Private HTTP-verb versions
+// ========================================
+
+const send = ( wpreq, config ) => fetch(
+	wpreq.toString(),
+	_setHeaders( _auth( config, wpreq._options ), wpreq._options )
+).then( ( response ) => {
+	// return response.headers.get( 'Link' );
+	return parseFetchResponse( response, wpreq );
+} );
+
+/**
+ * @method get
+ * @async
+ * @param {WPRequest} wpreq A WPRequest query object
+ * @returns {Promise} A promise to the results of the HTTP request
+ */
+function _httpGet( wpreq ) {
+	return send( wpreq, {
+		method: 'GET',
+	} );
+}
+
+/**
+ * Invoke an HTTP "POST" request against the provided endpoint
+ * @method post
+ * @async
+ * @param {WPRequest} wpreq A WPRequest query object
+ * @param {Object} data The data for the POST request
+ * @returns {Promise} A promise to the results of the HTTP request
+ */
+function _httpPost( wpreq, data = {} ) {
+	let file = wpreq._attachment;
+	if ( file ) {
+		// Handle files provided as a path string
+		if ( typeof file === 'string' ) {
+			file = fs.createReadStream( file );
+		}
+
+		// Build the form data object
+		const form = new FormData();
+		form.append( 'file', file, wpreq._attachmentName );
+		Object.keys( data ).forEach( key => form.append( key, data[ key ] ) );
+
+		// Fire off the media upload request
+		return send( wpreq, {
+			method: 'POST',
+			redirect: 'follow',
+			body: form,
+		} );
+	}
+
+	return send( wpreq, {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		redirect: 'follow',
+		body: JSON.stringify( data ),
+	} );
+}
+
+/**
+ * @method put
+ * @async
+ * @param {WPRequest} wpreq A WPRequest query object
+ * @param {Object} data The data for the PUT request
+ * @returns {Promise} A promise to the results of the HTTP request
+ */
+function _httpPut( wpreq, data = {} ) {
+	return send( wpreq, {
+		method: 'PUT',
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		redirect: 'follow',
+		body: JSON.stringify( data ),
+	} );
+}
+
+/**
+ * @method delete
+ * @async
+ * @param {WPRequest} wpreq A WPRequest query object
+ * @param {Object} [data] Data to send along with the DELETE request
+ * @returns {Promise} A promise to the results of the HTTP request
+ */
+function _httpDelete( wpreq, data ) {
+	const config = {
+		method: 'DELETE',
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		redirect: 'follow',
+	};
+
+	if ( data ) {
+		config.body = JSON.stringify( data );
+	}
+
+	return send( wpreq, config );
+}
+
+/**
+ * @method head
+ * @async
+ * @param {WPRequest} wpreq A WPRequest query object
+ * @returns {Promise} A promise to the header results of the HTTP request
+ */
+function _httpHead( wpreq ) {
+	const url = wpreq.toString();
+	const config = _setHeaders( _auth( {
+		method: 'HEAD',
+	}, wpreq._options, true ), wpreq._options );
+
+	return fetch( url, config )
+		.then( response => getHeaders( response ) );
+}
+
+module.exports = {
+	delete: _httpDelete,
+	get: _httpGet,
+	head: _httpHead,
+	post: _httpPost,
+	put: _httpPut,
+};
diff --git a/fetch/index.js b/fetch/index.js
new file mode 100644
index 00000000..b9403e54
--- /dev/null
+++ b/fetch/index.js
@@ -0,0 +1,6 @@
+const WPAPI = require( '../wpapi' );
+const fetchTransport = require( './fetch-transport' );
+const bindTransport = require( '../lib/bind-transport' );
+
+// Bind the fetch-based HTTP transport to the WPAPI constructor
+module.exports = bindTransport( WPAPI, fetchTransport );
diff --git a/fetch/tests/.eslintrc.js b/fetch/tests/.eslintrc.js
new file mode 100644
index 00000000..bd527d76
--- /dev/null
+++ b/fetch/tests/.eslintrc.js
@@ -0,0 +1,5 @@
+module.exports = {
+	'env': {
+		jest: true,
+	},
+};
diff --git a/fetch/tests/unit/fetch.js b/fetch/tests/unit/fetch.js
new file mode 100644
index 00000000..ba37ae8e
--- /dev/null
+++ b/fetch/tests/unit/fetch.js
@@ -0,0 +1,164 @@
+'use strict';
+
+const WPAPI = require( '../..' );
+
+// HTTP transport, for stubbing
+const fetchTransport = require( '../../fetch-transport' );
+
+// Variable to use as our "success token" in promise assertions
+const SUCCESS = 'success';
+
+describe( 'WPAPI', () => {
+
+	describe( 'constructor', () => {
+
+		describe( 'assigns default HTTP transport', () => {
+
+			it( 'for GET requests', () => {
+				jest.spyOn( fetchTransport, 'get' ).mockImplementation( () => {} );
+				const site = new WPAPI( {
+					endpoint: 'http://some.url.com/wp-json',
+				} );
+				const query = site.root( '' );
+				query.get();
+				expect( fetchTransport.get ).toHaveBeenCalledWith( query );
+				fetchTransport.get.mockRestore();
+			} );
+
+			it( 'for POST requests', () => {
+				jest.spyOn( fetchTransport, 'post' ).mockImplementation( () => {} );
+				const site = new WPAPI( {
+					endpoint: 'http://some.url.com/wp-json',
+				} );
+				const query = site.root( '' );
+				const data = {};
+				query.create( data );
+				expect( fetchTransport.post ).toHaveBeenCalledWith( query, data );
+				fetchTransport.post.mockRestore();
+			} );
+
+			it( 'for POST requests', () => {
+				jest.spyOn( fetchTransport, 'post' ).mockImplementation( () => {} );
+				const site = new WPAPI( {
+					endpoint: 'http://some.url.com/wp-json',
+				} );
+				const query = site.root( '' );
+				const data = {};
+				query.create( data );
+				expect( fetchTransport.post ).toHaveBeenCalledWith( query, data );
+				fetchTransport.post.mockRestore();
+			} );
+
+			it( 'for PUT requests', () => {
+				jest.spyOn( fetchTransport, 'put' ).mockImplementation( () => {} );
+				const site = new WPAPI( {
+					endpoint: 'http://some.url.com/wp-json',
+				} );
+				const query = site.root( 'a-resource' );
+				const data = {};
+				query.update( data );
+				expect( fetchTransport.put ).toHaveBeenCalledWith( query, data );
+				fetchTransport.put.mockRestore();
+			} );
+
+			it( 'for DELETE requests', () => {
+				jest.spyOn( fetchTransport, 'delete' ).mockImplementation( () => {} );
+				const site = new WPAPI( {
+					endpoint: 'http://some.url.com/wp-json',
+				} );
+				const query = site.root( 'a-resource' );
+				const data = {
+					force: true,
+				};
+				query.delete( data );
+				expect( fetchTransport.delete ).toHaveBeenCalledWith( query, data );
+				fetchTransport.delete.mockRestore();
+			} );
+
+		} );
+
+	} );
+
+	describe( '.transport constructor property', () => {
+
+		it( 'is defined', () => {
+			expect( WPAPI ).toHaveProperty( 'transport' );
+		} );
+
+		it( 'is an object', () => {
+			expect( typeof WPAPI.transport ).toBe( 'object' );
+		} );
+
+		it( 'has methods for each http transport action', () => {
+			expect( typeof WPAPI.transport.delete ).toBe( 'function' );
+			expect( typeof WPAPI.transport.get ).toBe( 'function' );
+			expect( typeof WPAPI.transport.head ).toBe( 'function' );
+			expect( typeof WPAPI.transport.post ).toBe( 'function' );
+			expect( typeof WPAPI.transport.put ).toBe( 'function' );
+		} );
+
+		it( 'is frozen (properties cannot be modified directly)', () => {
+			expect( () => {
+				WPAPI.transport.get = () => {};
+			} ).toThrow();
+		} );
+
+	} );
+
+	describe( '.discover() constructor method', () => {
+
+		beforeEach( () => {
+			jest.spyOn( fetchTransport, 'get' ).mockImplementation( () => {} );
+		} );
+
+		afterEach( () => {
+			fetchTransport.get.mockRestore();
+		} );
+
+		it( 'is a function', () => {
+			expect( WPAPI ).toHaveProperty( 'discover' );
+			expect( typeof WPAPI.discover ).toBe( 'function' );
+		} );
+
+		it( 'discovers the API root with a GET request', () => {
+			const url = 'http://mozarts.house';
+			fetchTransport.get.mockImplementation( () => Promise.resolve( {
+				name: 'Skip Beats',
+				descrition: 'Just another WordPress weblog',
+				routes: {
+					'/': {
+						_links: {
+							self: 'http://mozarts.house/wp-json/',
+						},
+					},
+					'list': {},
+					'of': {},
+					'routes': {},
+				},
+			} ) );
+			const prom = WPAPI.discover( url )
+				.then( ( result ) => {
+					expect( result ).toBeInstanceOf( WPAPI );
+					expect( result.root().toString() ).toBe( 'http://mozarts.house/wp-json/' );
+					expect( fetchTransport.get ).toBeCalledTimes( 1 );
+					const indexRequestObject = fetchTransport.get.mock.calls[0][0];
+					expect( indexRequestObject.toString() ).toBe( 'http://mozarts.house/?rest_route=%2F' );
+					return SUCCESS;
+				} );
+			return expect( prom ).resolves.toBe( SUCCESS );
+		} );
+
+		it( 'throws an error if no API endpoint can be discovered', () => {
+			const url = 'http://we.made.it/to/mozarts/house';
+			fetchTransport.get.mockImplementationOnce( () => Promise.reject( 'Some error' ) );
+			const prom = WPAPI.discover( url )
+				.catch( ( err ) => {
+					expect( err ).toBe( 'Some error' );
+					return SUCCESS;
+				} );
+			return expect( prom ).resolves.toBe( SUCCESS );
+		} );
+
+	} );
+
+} );
diff --git a/lib/autodiscovery.js b/lib/autodiscovery.js
deleted file mode 100644
index 67c68624..00000000
--- a/lib/autodiscovery.js
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- * Utility methods used when querying a site in order to discover its available
- * API endpoints
- *
- * @module autodiscovery
- */
-'use strict';
-
-const parseLinkHeader = require( 'li' ).parse;
-
-/**
- * Attempt to locate a `rel="https://api.w.org"` link relation header
- *
- * @method locateAPIRootHeader
- * @param {Object} response A response object with a link or headers property
- * @returns {String} The URL of the located API root
- */
-function locateAPIRootHeader( response ) {
-	// See https://developer.wordpress.org/rest-api/using-the-rest-api/discovery/
-	const rel = 'https://api.w.org/';
-
-	// Extract & parse the response link headers
-	const link = response.link || ( response.headers && response.headers.link );
-	const headers = parseLinkHeader( link );
-
-	const apiHeader = headers && headers[ rel ];
-
-	if ( apiHeader ) {
-		return apiHeader;
-	}
-
-	throw new Error( `No header link found with rel="${ rel }"` );
-}
-
-module.exports = {
-	locateAPIRootHeader: locateAPIRootHeader,
-};
diff --git a/lib/bind-transport.js b/lib/bind-transport.js
new file mode 100644
index 00000000..0fbfd86a
--- /dev/null
+++ b/lib/bind-transport.js
@@ -0,0 +1,58 @@
+/**
+ * Return a new constructor combining the path-building logic of WPAPI with
+ * a specified HTTP transport layer
+ *
+ * This new constructor receives the .discover() static method, and the base
+ * constructor's .site() static method is overridden to return instances of
+ * the new transport-specific constructor
+ *
+ * See /fetch and /superagent directories
+ *
+ * @param {Function} QueryBuilder  The base WPAPI query builder constructor
+ * @param {Object}   httpTransport The HTTP transport object
+ * @returns {Function} A WPAPI constructor with an associated HTTP transport
+ */
+module.exports = function( QueryBuilder, httpTransport ) {
+
+	// Create a new constructor which inherits from WPAPI, but uses this transport
+	class WPAPI extends QueryBuilder {}
+
+	WPAPI.transport = Object.create( httpTransport );
+	Object.freeze( WPAPI.transport );
+
+	// Add a version of the base WPAPI.site() static method specific to this new constructor
+	WPAPI.site = ( endpoint, routes ) => {
+		return new WPAPI( {
+			endpoint: endpoint,
+			routes: routes,
+		} );
+	};
+
+	/**
+	 * Take an arbitrary WordPress site, deduce the WP REST API root endpoint, query
+	 * that endpoint, and parse the response JSON. Use the returned JSON response
+	 * to instantiate a WPAPI instance bound to the provided site.
+	 *
+	 * @memberof! WPAPI
+	 * @static
+	 * @param {string} url A URL within a REST API-enabled WordPress website
+	 * @returns {Promise} A promise that resolves to a configured WPAPI instance bound
+	 * to the deduced endpoint, or rejected if an endpoint is not found or the
+	 * library is unable to parse the provided endpoint.
+	 */
+	WPAPI.discover = ( url ) => {
+		// Use WPAPI.site to make a request using the defined transport
+		const req = WPAPI.site( url ).root().param( 'rest_route', '/' );
+		return req.get().then( ( apiRootJSON ) => {
+			const routes = apiRootJSON.routes;
+			return new WPAPI( {
+				// Derive the endpoint from the self link for the / root
+				endpoint: routes['/']._links.self,
+				// Bootstrap returned WPAPI instance with the discovered routes
+				routes: routes,
+			} );
+		} );
+	};
+
+	return WPAPI;
+};
diff --git a/lib/constructors/wp-request.js b/lib/constructors/wp-request.js
index d5d9cd0b..3fd9ed5e 100644
--- a/lib/constructors/wp-request.js
+++ b/lib/constructors/wp-request.js
@@ -633,6 +633,11 @@ WPRequest.prototype.auth = function( credentials ) {
  *       .file( '/path/to/file.jpg' )
  *       .create({})...
  *
+ *     wp.media()
+ *       // Pass .file() an image as a Buffer object, and a filename string
+ *       .file( imgBuffer, 'desired-title.jpg' )
+ *       .create({})...
+ *
  * @example <caption>within a browser context</caption>
  *
  *     wp.media()
@@ -644,10 +649,14 @@ WPRequest.prototype.auth = function( credentials ) {
  * @chainable
  * @param {string|object} file   A path to a file (in Node) or an file object
  *                               (Node or Browser) to attach to the request
- * @param {string}        [name] An (optional) filename to use for the file
+ * @param {string}        [name] A filename to use for the file, required when
+ *                               providing file data as a Buffer object
  * @returns {WPRequest} The WPRequest instance (for chaining)
  */
 WPRequest.prototype.file = function( file, name ) {
+	if ( global.Buffer && file instanceof global.Buffer && ! name ) {
+		throw new Error( '.file(): File name is a required argument when uploading a Buffer' );
+	}
 	this._attachment = file;
 	// Explicitly set to undefined if not provided, to override any previously-
 	// set attachment name property that might exist from a prior `.file()` call
@@ -700,11 +709,10 @@ WPRequest.prototype.setHeaders = function( headers, value ) {
  *
  * @method
  * @async
- * @param {Function} [callback] A callback to invoke with the results of the GET request
  * @returns {Promise} A promise to the results of the HTTP request
  */
-WPRequest.prototype.get = function( callback ) {
-	return this.transport.get( this, callback );
+WPRequest.prototype.get = function() {
+	return this.transport.get( this );
 };
 
 /**
@@ -712,11 +720,10 @@ WPRequest.prototype.get = function( callback ) {
  *
  * @method
  * @async
- * @param {Function} [callback] A callback to invoke with the results of the HEAD request
  * @returns {Promise} A promise to the header results of the HTTP request
  */
-WPRequest.prototype.headers = function( callback ) {
-	return this.transport.head( this, callback );
+WPRequest.prototype.headers = function() {
+	return this.transport.head( this );
 };
 
 /**
@@ -727,11 +734,10 @@ WPRequest.prototype.headers = function( callback ) {
  * @method
  * @async
  * @param {Object} data The data for the POST request
- * @param {Function} [callback] A callback to invoke with the results of the POST request
  * @returns {Promise} A promise to the results of the HTTP request
  */
-WPRequest.prototype.create = function( data, callback ) {
-	return this.transport.post( this, data, callback );
+WPRequest.prototype.create = function( data ) {
+	return this.transport.post( this, data );
 };
 
 /**
@@ -743,11 +749,10 @@ WPRequest.prototype.create = function( data, callback ) {
  * @async
  * @private
  * @param {Object} data The data for the PUT request
- * @param {Function} [callback] A callback to invoke with the results of the PUT request
  * @returns {Promise} A promise to the results of the HTTP request
  */
-WPRequest.prototype.update = function( data, callback ) {
-	return this.transport.put( this, data, callback );
+WPRequest.prototype.update = function( data ) {
+	return this.transport.put( this, data );
 };
 
 /**
@@ -756,11 +761,10 @@ WPRequest.prototype.update = function( data, callback ) {
  * @method
  * @async
  * @param {Object} [data] Data to send along with the DELETE request
- * @param {Function} [callback] A callback to invoke with the results of the DELETE request
  * @returns {Promise} A promise to the results of the HTTP request
  */
-WPRequest.prototype.delete = function( data, callback ) {
-	return this.transport.delete( this, data, callback );
+WPRequest.prototype.delete = function( data ) {
+	return this.transport.delete( this, data );
 };
 
 /**
diff --git a/lib/pagination.js b/lib/pagination.js
new file mode 100644
index 00000000..6d1a5db1
--- /dev/null
+++ b/lib/pagination.js
@@ -0,0 +1,87 @@
+const parseLinkHeader = require( 'li' ).parse;
+
+const WPRequest = require( '../lib/constructors/wp-request' );
+
+/**
+ * If the response is not paged, return the body as-is. If pagination
+ * information is present in the response headers, parse those headers into
+ * a custom `_paging` property on the response body. `_paging` contains links
+ * to the previous and next pages in the collection, as well as metadata
+ * about the size and number of pages in the collection.
+ *
+ * The structure of the `_paging` property is as follows:
+ *
+ * - `total` {Integer} The total number of records in the collection
+ * - `totalPages` {Integer} The number of pages available
+ * - `links` {Object} The parsed "links" headers, separated into individual URI strings
+ * - `next` {WPRequest} A WPRequest object bound to the "next" page (if page exists)
+ * - `prev` {WPRequest} A WPRequest object bound to the "previous" page (if page exists)
+ *
+ * @private
+ * @param {Object} result           The response object from the HTTP request
+ * @param {Object} options          The options hash from the original request
+ * @param {String} options.endpoint The base URL of the requested API endpoint
+ * @param {Object} httpTransport    The HTTP transport object used by the original request
+ * @returns {Object} The pagination metadata object for this HTTP request, or else null
+ */
+function createPaginationObject( result, options, httpTransport ) {
+	let _paging = null;
+
+	if ( ! result.headers ) {
+		// No headers: return as-is
+		return _paging;
+	}
+
+	// Guard against capitalization inconsistencies in returned headers
+	Object.keys( result.headers ).forEach( ( header ) => {
+		result.headers[ header.toLowerCase() ] = result.headers[ header ];
+	} );
+
+	if ( ! result.headers[ 'x-wp-totalpages' ] ) {
+		// No paging: return as-is
+		return _paging;
+	}
+
+	const totalPages = +result.headers[ 'x-wp-totalpages' ];
+
+	if ( ! totalPages || totalPages === 0 ) {
+		// No paging: return as-is
+		return _paging;
+	}
+
+	// Decode the link header object
+	const links = result.headers.link ?
+		parseLinkHeader( result.headers.link ) :
+		{};
+
+	// Store pagination data from response headers on the response collection
+	_paging = {
+		total: +result.headers[ 'x-wp-total' ],
+		totalPages: totalPages,
+		links: links,
+	};
+
+	// Create a WPRequest instance pre-bound to the "next" page, if available
+	if ( links.next ) {
+		_paging.next = new WPRequest( {
+			...options,
+			transport: httpTransport,
+			endpoint: links.next,
+		} );
+	}
+
+	// Create a WPRequest instance pre-bound to the "prev" page, if available
+	if ( links.prev ) {
+		_paging.prev = new WPRequest( {
+			...options,
+			transport: httpTransport,
+			endpoint: links.prev,
+		} );
+	}
+
+	return _paging;
+}
+
+module.exports = {
+	createPaginationObject,
+};
diff --git a/lib/util/named-group-regexp.js b/lib/util/named-group-regexp.js
index 0a927dd8..3eaeb787 100644
--- a/lib/util/named-group-regexp.js
+++ b/lib/util/named-group-regexp.js
@@ -14,7 +14,7 @@ const pattern = [
 	'[>\']',
 	// Get everything up to the end of the capture group: this is the RegExp used
 	// when matching URLs to this route, which we can use for validation purposes.
-	'([^\\)]*)',
+	'([^\\)]*(\\))?)\\??',
 	// Capture group end
 	'\\)',
 ].join( '' );
diff --git a/lib/util/object-reduce.js b/lib/util/object-reduce.js
index 83e13aee..a6f7a0d7 100644
--- a/lib/util/object-reduce.js
+++ b/lib/util/object-reduce.js
@@ -8,7 +8,7 @@
  * minification and ~12kb of savings with minification.
  *
  * Unlike lodash.reduce(), the iterator and initial value properties are NOT
- * optional: this is done to simplify the code, this module is not intended to
+ * optional: this is done to simplify the code. This module is not intended to
  * be a full replacement for lodash.reduce and instead prioritizes simplicity
  * for a specific common case.
  *
diff --git a/node-wpapi.php b/node-wpapi.php
new file mode 100644
index 00000000..24eb81a2
--- /dev/null
+++ b/node-wpapi.php
@@ -0,0 +1,61 @@
+<?php
+/**
+ * Plugin Name: node-wpapi
+ * Plugin URI:  https://github.com/wp-api/node-wpapi
+ * Description: Register the wpapi npm package as a WordPress script.
+ */
+
+namespace WPAPI;
+
+add_action( 'wp enqueue scripts', __NAMESPACE__ . '\\enqueue_scripts' );
+
+/**
+ * Enqueue the wpapi script package.
+ *
+ * @return void
+ */
+function enqueue_scripts() {
+  $uri = plugin_dir_url( __FILE__ ) . 'browser/wpapi.min.js';
+  if ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) {
+    $uri = plugin_dir_url( __FILE__ ) . 'browser/wpapi.js';
+  }
+
+  // Read the package.json to derive the version number.
+  $package = read_json( plugin_dir_path( __FILE ) . '/package.json' );
+
+  // Enqueue the script itself.
+  wp_enqueue_script(
+    'wpapi',
+    $uri,
+    [],
+    $package['version'] ?? null,
+    true
+  );
+
+  // Inject a JS object into the page to expose the API root URI & nonce.
+  wp_localize_script(
+    'wpapi',
+    'WPAPI_Settings',
+    [
+      'root'  => esc_url_raw( rest_url() ),
+      'nonce' => wp_create_nonce( 'wp_rest' ),
+    ]
+  );
+}
+
+/**
+ * Read & parse a JSON file.
+ *
+ * @param string $path The path to the JSON file to load.
+ * @return array The parsed JSON data object.
+ */
+function read_json( string $path ) : array {
+	if ( ! file_exists( $path ) ) {
+		return [];
+	}
+	$contents = file_get_contents( $path );
+	if ( empty( $contents ) ) {
+		return [];
+	}
+	return json_decode( $contents, true );
+}
diff --git a/package.json b/package.json
index f386de0d..4df37586 100644
--- a/package.json
+++ b/package.json
@@ -4,7 +4,7 @@
     "url": "http://www.kadamwhite.com"
   },
   "name": "wpapi",
-  "version": "1.1.2",
+  "version": "2.0.0-alpha.1",
   "description": "An isomorphic JavaScript client for interacting with the WordPress REST API",
   "main": "wpapi.js",
   "repository": {
@@ -30,6 +30,7 @@
       "**/tests/**/*.js"
     ],
     "testPathIgnorePatterns": [
+      "test.js",
       ".eslintrc.js",
       "/tests/helpers/"
     ],
@@ -52,41 +53,43 @@
     "lint": "npm run eslint",
     "watch": "jest --watch",
     "test:all": "jest",
-    "test:unit": "jest tests/unit",
+    "test:unit": "jest tests/unit superagent/tests/unit fetch/tests/unit",
     "test:integration": "jest tests/integration",
     "test:ci": "npm run eslint && jest tests/unit --coverage",
     "pretest": "npm run lint || true",
     "test": "jest --coverage"
   },
   "dependencies": {
+    "li": "^1.3.0",
     "parse-link-header": "^1.0.1",
-    "qs": "^6.6.0",
-    "superagent": "^4.0.0"
+    "qs": "^6.7.0"
+  },
+  "optionalDependencies": {
+    "form-data": "^2.5.0",
+    "node-fetch": "^2.6.0",
+    "superagent": "^4.1.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.2.2",
+    "@babel/core": "^7.5.0",
     "@babel/plugin-proposal-object-rest-spread": "^7.2.0",
-    "@babel/preset-env": "^7.2.3",
-    "babel-loader": "^8.0.4",
+    "@babel/preset-env": "^7.5.0",
+    "babel-loader": "^8.0.6",
     "combyne": "^2.0.0",
     "eslint": "^4.19.1",
-    "grunt": "^1.0.1",
+    "grunt": "^1.0.4",
     "grunt-cli": "^1.2.0",
     "grunt-contrib-clean": "^1.0.0",
     "grunt-zip": "^0.17.1",
-    "istanbul": "^0.4.4",
-    "jest": "^23.6.0",
-    "jsdoc": "^3.4.3",
+    "jest": "^24.8.0",
+    "jsdoc": "^3.6.2",
     "kramed": "^0.5.6",
-    "li": "^1.3.0",
     "load-grunt-tasks": "^3.5.0",
-    "lodash.reduce": "^4.6.0",
     "minami": "^1.2.3",
     "minimist": "^1.2.0",
     "prompt": "^1.0.0",
-    "rimraf": "^2.6.1",
-    "webpack": "^4.28.1",
-    "webpack-bundle-analyzer": "^3.0.3",
-    "webpack-cli": "^3.1.2"
+    "rimraf": "^2.6.3",
+    "webpack": "^4.35.0",
+    "webpack-bundle-analyzer": "^3.3.2",
+    "webpack-cli": "^3.3.5"
   }
 }
diff --git a/superagent/README.md b/superagent/README.md
new file mode 100644
index 00000000..532f647a
--- /dev/null
+++ b/superagent/README.md
@@ -0,0 +1,14 @@
+# `wpapi/superagent`
+
+This endpoint returns a version of the WPAPI library configured to use Superagent for HTTP requests.
+
+## Installation & Usage
+
+Install both `wpapi` and `superagent` using the command `npm install --save wpapi superagent`.
+
+```js
+import WPAPI from 'wpapi/superagent';
+
+// Configure and use WPAPI as normal
+const site = new WPAPI( { /* ... */ } );
+```
diff --git a/superagent/index.js b/superagent/index.js
new file mode 100644
index 00000000..1e105cb3
--- /dev/null
+++ b/superagent/index.js
@@ -0,0 +1,6 @@
+const WPAPI = require( '../wpapi' );
+const superagentTransport = require( './superagent-transport' );
+const bindTransport = require( '../lib/bind-transport' );
+
+// Bind the superagent-based HTTP transport to the WPAPI constructor
+module.exports = bindTransport( WPAPI, superagentTransport );
diff --git a/lib/http-transport.js b/superagent/superagent-transport.js
similarity index 59%
rename from lib/http-transport.js
rename to superagent/superagent-transport.js
index f9ad9dc9..36057d02 100644
--- a/lib/http-transport.js
+++ b/superagent/superagent-transport.js
@@ -4,12 +4,11 @@
 'use strict';
 
 const agent = require( 'superagent' );
-const parseLinkHeader = require( 'li' ).parse;
 
-const WPRequest = require( './constructors/wp-request' );
-const checkMethodSupport = require( './util/check-method-support' );
-const objectReduce = require( './util/object-reduce' );
-const isEmptyObject = require( './util/is-empty-object' );
+const checkMethodSupport = require( '../lib/util/check-method-support' );
+const objectReduce = require( '../lib/util/object-reduce' );
+const isEmptyObject = require( '../lib/util/is-empty-object' );
+const { createPaginationObject } = require( '../lib/pagination' );
 
 /**
  * Set any provided headers on the outgoing request object. Runs after _auth.
@@ -95,100 +94,19 @@ function extractResponseBody( response ) {
 	return responseBody;
 }
 
-/**
- * If the response is not paged, return the body as-is. If pagination
- * information is present in the response headers, parse those headers into
- * a custom `_paging` property on the response body. `_paging` contains links
- * to the previous and next pages in the collection, as well as metadata
- * about the size and number of pages in the collection.
- *
- * The structure of the `_paging` property is as follows:
- *
- * - `total` {Integer} The total number of records in the collection
- * - `totalPages` {Integer} The number of pages available
- * - `links` {Object} The parsed "links" headers, separated into individual URI strings
- * - `next` {WPRequest} A WPRequest object bound to the "next" page (if page exists)
- * - `prev` {WPRequest} A WPRequest object bound to the "previous" page (if page exists)
- *
- * @private
- * @param {Object} result           The response object from the HTTP request
- * @param {Object} options          The options hash from the original request
- * @param {String} options.endpoint The base URL of the requested API endpoint
- * @param {Object} httpTransport    The HTTP transport object used by the original request
- * @returns {Object} The pagination metadata object for this HTTP request, or else null
- */
-function createPaginationObject( result, options, httpTransport ) {
-	let _paging = null;
-
-	if ( ! result.headers ) {
-		// No headers: return as-is
-		return _paging;
-	}
-
-	// Guard against capitalization inconsistencies in returned headers
-	Object.keys( result.headers ).forEach( ( header ) => {
-		result.headers[ header.toLowerCase() ] = result.headers[ header ];
-	} );
-
-	if ( ! result.headers[ 'x-wp-totalpages' ] ) {
-		// No paging: return as-is
-		return _paging;
-	}
-
-	const totalPages = +result.headers[ 'x-wp-totalpages' ];
-
-	if ( ! totalPages || totalPages === 0 ) {
-		// No paging: return as-is
-		return _paging;
-	}
-
-	// Decode the link header object
-	const links = result.headers.link ?
-		parseLinkHeader( result.headers.link ) :
-		{};
-
-	// Store pagination data from response headers on the response collection
-	_paging = {
-		total: +result.headers[ 'x-wp-total' ],
-		totalPages: totalPages,
-		links: links,
-	};
-
-	// Create a WPRequest instance pre-bound to the "next" page, if available
-	if ( links.next ) {
-		_paging.next = new WPRequest( {
-			...options,
-			transport: httpTransport,
-			endpoint: links.next,
-		} );
-	}
-
-	// Create a WPRequest instance pre-bound to the "prev" page, if available
-	if ( links.prev ) {
-		_paging.prev = new WPRequest( {
-			...options,
-			transport: httpTransport,
-			endpoint: links.prev,
-		} );
-	}
-
-	return _paging;
-}
-
 // HTTP-Related Helpers
 // ====================
 
 /**
- * Submit the provided superagent request object, invoke a callback (if it was
- * provided), and return a promise to the response from the HTTP request.
+ * Submit the provided superagent request object and return a promise which
+ * resolves to the response from the HTTP request.
  *
  * @private
  * @param {Object} request A superagent request object
- * @param {Function} callback A callback function (optional)
  * @param {Function} transform A function to transform the result data
  * @returns {Promise} A promise to the superagent request
  */
-function invokeAndPromisify( request, callback, transform ) {
+function invokeAndPromisify( request, transform ) {
 	return new Promise( ( resolve, reject ) => {
 		// Fire off the result
 		request.end( ( err, result ) => {
@@ -200,14 +118,7 @@ function invokeAndPromisify( request, callback, transform ) {
 				resolve( result );
 			}
 		} );
-	} ).then( transform ).then( ( result ) => {
-		// If a node-style callback was provided, call it, but also return the
-		// result value for use via the returned Promise
-		if ( callback && typeof callback === 'function' ) {
-			callback( null, result );
-		}
-		return result;
-	}, ( err ) => {
+	} ).then( transform ).catch( ( err ) => {
 		// If the API provided an error object, it will be available within the
 		// superagent response object as response.body (containing the response
 		// JSON). If that object exists, it will have a .code property if it is
@@ -217,13 +128,8 @@ function invokeAndPromisify( request, callback, transform ) {
 			// all transport-specific (superagent-specific) properties
 			err = err.response.body;
 		}
-		// If a callback was provided, ensure it is called with the error; otherwise
-		// re-throw the error so that it can be handled by a Promise .catch or .then
-		if ( callback && typeof callback === 'function' ) {
-			callback( err );
-		} else {
-			throw err;
-		}
+		// Re-throw the error so that it can be handled by a Promise .catch or .then
+		throw err;
 	} );
 }
 
@@ -264,17 +170,16 @@ function returnHeaders( result ) {
  * @method get
  * @async
  * @param {WPRequest} wpreq A WPRequest query object
- * @param {Function} [callback] A callback to invoke with the results of the GET request
  * @returns {Promise} A promise to the results of the HTTP request
  */
-function _httpGet( wpreq, callback ) {
+function _httpGet( wpreq ) {
 	checkMethodSupport( 'get', wpreq );
 	const url = wpreq.toString();
 
 	let request = _auth( agent.get( url ), wpreq._options );
 	request = _setHeaders( request, wpreq._options );
 
-	return invokeAndPromisify( request, callback, returnBody.bind( null, wpreq ) );
+	return invokeAndPromisify( request, returnBody.bind( null, wpreq ) );
 }
 
 /**
@@ -283,10 +188,9 @@ function _httpGet( wpreq, callback ) {
  * @async
  * @param {WPRequest} wpreq A WPRequest query object
  * @param {Object} data The data for the POST request
- * @param {Function} [callback] A callback to invoke with the results of the POST request
  * @returns {Promise} A promise to the results of the HTTP request
  */
-function _httpPost( wpreq, data, callback ) {
+function _httpPost( wpreq, data ) {
 	checkMethodSupport( 'post', wpreq );
 	const url = wpreq.toString();
 	data = data || {};
@@ -304,7 +208,7 @@ function _httpPost( wpreq, data, callback ) {
 		request = request.send( data );
 	}
 
-	return invokeAndPromisify( request, callback, returnBody.bind( null, wpreq ) );
+	return invokeAndPromisify( request, returnBody.bind( null, wpreq ) );
 }
 
 /**
@@ -312,10 +216,9 @@ function _httpPost( wpreq, data, callback ) {
  * @async
  * @param {WPRequest} wpreq A WPRequest query object
  * @param {Object} data The data for the PUT request
- * @param {Function} [callback] A callback to invoke with the results of the PUT request
  * @returns {Promise} A promise to the results of the HTTP request
  */
-function _httpPut( wpreq, data, callback ) {
+function _httpPut( wpreq, data ) {
 	checkMethodSupport( 'put', wpreq );
 	const url = wpreq.toString();
 	data = data || {};
@@ -323,7 +226,7 @@ function _httpPut( wpreq, data, callback ) {
 	let request = _auth( agent.put( url ), wpreq._options, true ).send( data );
 	request = _setHeaders( request, wpreq._options );
 
-	return invokeAndPromisify( request, callback, returnBody.bind( null, wpreq ) );
+	return invokeAndPromisify( request, returnBody.bind( null, wpreq ) );
 }
 
 /**
@@ -331,36 +234,30 @@ function _httpPut( wpreq, data, callback ) {
  * @async
  * @param {WPRequest} wpreq A WPRequest query object
  * @param {Object} [data] Data to send along with the DELETE request
- * @param {Function} [callback] A callback to invoke with the results of the DELETE request
  * @returns {Promise} A promise to the results of the HTTP request
  */
-function _httpDelete( wpreq, data, callback ) {
-	if ( ! callback && typeof data === 'function' ) {
-		callback = data;
-		data = null;
-	}
+function _httpDelete( wpreq, data ) {
 	checkMethodSupport( 'delete', wpreq );
 	const url = wpreq.toString();
 	let request = _auth( agent.del( url ), wpreq._options, true ).send( data );
 	request = _setHeaders( request, wpreq._options );
 
-	return invokeAndPromisify( request, callback, returnBody.bind( null, wpreq ) );
+	return invokeAndPromisify( request, returnBody.bind( null, wpreq ) );
 }
 
 /**
  * @method head
  * @async
  * @param {WPRequest} wpreq A WPRequest query object
- * @param {Function} [callback] A callback to invoke with the results of the HEAD request
  * @returns {Promise} A promise to the header results of the HTTP request
  */
-function _httpHead( wpreq, callback ) {
+function _httpHead( wpreq ) {
 	checkMethodSupport( 'head', wpreq );
 	const url = wpreq.toString();
 	let request = _auth( agent.head( url ), wpreq._options );
 	request = _setHeaders( request, wpreq._options );
 
-	return invokeAndPromisify( request, callback, returnHeaders );
+	return invokeAndPromisify( request, returnHeaders );
 }
 
 module.exports = {
diff --git a/superagent/tests/.eslintrc.js b/superagent/tests/.eslintrc.js
new file mode 100644
index 00000000..bd527d76
--- /dev/null
+++ b/superagent/tests/.eslintrc.js
@@ -0,0 +1,5 @@
+module.exports = {
+	'env': {
+		jest: true,
+	},
+};
diff --git a/superagent/tests/unit/superagent.js b/superagent/tests/unit/superagent.js
new file mode 100644
index 00000000..c7703ef3
--- /dev/null
+++ b/superagent/tests/unit/superagent.js
@@ -0,0 +1,164 @@
+'use strict';
+
+const WPAPI = require( '../../' );
+
+// HTTP transport, for stubbing
+const superagentTransport = require( '../../superagent-transport' );
+
+// Variable to use as our "success token" in promise assertions
+const SUCCESS = 'success';
+
+describe( 'WPAPI', () => {
+
+	describe( 'constructor', () => {
+
+		describe( 'assigns default HTTP transport', () => {
+
+			it( 'for GET requests', () => {
+				jest.spyOn( superagentTransport, 'get' ).mockImplementation( () => {} );
+				const site = new WPAPI( {
+					endpoint: 'http://some.url.com/wp-json',
+				} );
+				const query = site.root( '' );
+				query.get();
+				expect( superagentTransport.get ).toHaveBeenCalledWith( query );
+				superagentTransport.get.mockRestore();
+			} );
+
+			it( 'for POST requests', () => {
+				jest.spyOn( superagentTransport, 'post' ).mockImplementation( () => {} );
+				const site = new WPAPI( {
+					endpoint: 'http://some.url.com/wp-json',
+				} );
+				const query = site.root( '' );
+				const data = {};
+				query.create( data );
+				expect( superagentTransport.post ).toHaveBeenCalledWith( query, data );
+				superagentTransport.post.mockRestore();
+			} );
+
+			it( 'for POST requests', () => {
+				jest.spyOn( superagentTransport, 'post' ).mockImplementation( () => {} );
+				const site = new WPAPI( {
+					endpoint: 'http://some.url.com/wp-json',
+				} );
+				const query = site.root( '' );
+				const data = {};
+				query.create( data );
+				expect( superagentTransport.post ).toHaveBeenCalledWith( query, data );
+				superagentTransport.post.mockRestore();
+			} );
+
+			it( 'for PUT requests', () => {
+				jest.spyOn( superagentTransport, 'put' ).mockImplementation( () => {} );
+				const site = new WPAPI( {
+					endpoint: 'http://some.url.com/wp-json',
+				} );
+				const query = site.root( 'a-resource' );
+				const data = {};
+				query.update( data );
+				expect( superagentTransport.put ).toHaveBeenCalledWith( query, data );
+				superagentTransport.put.mockRestore();
+			} );
+
+			it( 'for DELETE requests', () => {
+				jest.spyOn( superagentTransport, 'delete' ).mockImplementation( () => {} );
+				const site = new WPAPI( {
+					endpoint: 'http://some.url.com/wp-json',
+				} );
+				const query = site.root( 'a-resource' );
+				const data = {
+					force: true,
+				};
+				query.delete( data );
+				expect( superagentTransport.delete ).toHaveBeenCalledWith( query, data );
+				superagentTransport.delete.mockRestore();
+			} );
+
+		} );
+
+	} );
+
+	describe( '.transport constructor property', () => {
+
+		it( 'is defined', () => {
+			expect( WPAPI ).toHaveProperty( 'transport' );
+		} );
+
+		it( 'is an object', () => {
+			expect( typeof WPAPI.transport ).toBe( 'object' );
+		} );
+
+		it( 'has methods for each http transport action', () => {
+			expect( typeof WPAPI.transport.delete ).toBe( 'function' );
+			expect( typeof WPAPI.transport.get ).toBe( 'function' );
+			expect( typeof WPAPI.transport.head ).toBe( 'function' );
+			expect( typeof WPAPI.transport.post ).toBe( 'function' );
+			expect( typeof WPAPI.transport.put ).toBe( 'function' );
+		} );
+
+		it( 'is frozen (properties cannot be modified directly)', () => {
+			expect( () => {
+				WPAPI.transport.get = () => {};
+			} ).toThrow();
+		} );
+
+	} );
+
+	describe( '.discover() constructor method', () => {
+
+		beforeEach( () => {
+			jest.spyOn( superagentTransport, 'get' ).mockImplementation( () => {} );
+		} );
+
+		afterEach( () => {
+			superagentTransport.get.mockRestore();
+		} );
+
+		it( 'is a function', () => {
+			expect( WPAPI ).toHaveProperty( 'discover' );
+			expect( typeof WPAPI.discover ).toBe( 'function' );
+		} );
+
+		it( 'discovers the API root with a GET request', () => {
+			const url = 'http://mozarts.house';
+			superagentTransport.get.mockImplementation( () => Promise.resolve( {
+				name: 'Skip Beats',
+				descrition: 'Just another WordPress weblog',
+				routes: {
+					'/': {
+						_links: {
+							self: 'http://mozarts.house/wp-json/',
+						},
+					},
+					'list': {},
+					'of': {},
+					'routes': {},
+				},
+			} ) );
+			const prom = WPAPI.discover( url )
+				.then( ( result ) => {
+					expect( result ).toBeInstanceOf( WPAPI );
+					expect( result.root().toString() ).toBe( 'http://mozarts.house/wp-json/' );
+					expect( superagentTransport.get ).toBeCalledTimes( 1 );
+					const indexRequestObject = superagentTransport.get.mock.calls[0][0];
+					expect( indexRequestObject.toString() ).toBe( 'http://mozarts.house/?rest_route=%2F' );
+					return SUCCESS;
+				} );
+			return expect( prom ).resolves.toBe( SUCCESS );
+		} );
+
+		it( 'throws an error if no API endpoint can be discovered', () => {
+			const url = 'http://we.made.it/to/mozarts/house';
+			superagentTransport.get.mockImplementationOnce( () => Promise.reject( 'Some error' ) );
+			const prom = WPAPI.discover( url )
+				.catch( ( err ) => {
+					expect( err ).toBe( 'Some error' );
+					return SUCCESS;
+				} );
+			return expect( prom ).resolves.toBe( SUCCESS );
+		} );
+
+	} );
+
+} );
diff --git a/tests/integration/autodiscovery.js b/tests/integration/autodiscovery.js
index ff77726c..5af4a961 100644
--- a/tests/integration/autodiscovery.js
+++ b/tests/integration/autodiscovery.js
@@ -1,6 +1,5 @@
 'use strict';
 
-const WPAPI = require( '../../' );
 const WPRequest = require( '../../lib/constructors/wp-request.js' );
 
 // Inspecting the titles of the returned posts arrays is an easy way to
@@ -17,7 +16,10 @@ const expectedResults = {
 	firstPostTitle: 'Markup: HTML Tags and Formatting',
 };
 
-describe( 'integration: discover()', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: discover', ( transportName, WPAPI ) => {
 	let apiPromise;
 
 	beforeAll( () => {
@@ -52,6 +54,24 @@ describe( 'integration: discover()', () => {
 		return expect( prom ).resolves.toBe( SUCCESS );
 	} );
 
+	it( 'resolves to correct endpoint if discovery targets /wp-json', () => {
+		const prom = WPAPI.discover( 'http://wpapi.local/wp-json' )
+			.then( ( site ) => {
+				expect( site.posts().toString() ).toBe( 'http://wpapi.local/wp-json/wp/v2/posts' );
+				return SUCCESS;
+			} );
+		return expect( prom ).resolves.toBe( SUCCESS );
+	} );
+
+	it( 'resolves to correct endpoint if discovery targets ?rest_route=/', () => {
+		const prom = WPAPI.discover( 'http://wpapi.local/?rest_route=/' )
+			.then( ( site ) => {
+				expect( site.posts().toString() ).toBe( 'http://wpapi.local/wp-json/wp/v2/posts' );
+				return SUCCESS;
+			} );
+		return expect( prom ).resolves.toBe( SUCCESS );
+	} );
+
 	it( 'can correctly instantiate requests against the detected and bound site', () => {
 		const prom = apiPromise
 			.then( site => site.posts() )
diff --git a/tests/integration/categories.js b/tests/integration/categories.js
index 4a8e9eac..12a005fc 100644
--- a/tests/integration/categories.js
+++ b/tests/integration/categories.js
@@ -1,6 +1,5 @@
 'use strict';
 
-const WPAPI = require( '../../' );
 const WPRequest = require( '../../lib/constructors/wp-request.js' );
 
 // Inspecting the names of the returned categories is an easy way to validate
@@ -48,7 +47,10 @@ const expectedResults = {
 	},
 };
 
-describe( 'integration: categories()', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: categories()', ( transportName, WPAPI ) => {
 	let wp;
 
 	beforeEach( () => {
diff --git a/tests/integration/comments.js b/tests/integration/comments.js
index d9f401f0..9e7451b2 100644
--- a/tests/integration/comments.js
+++ b/tests/integration/comments.js
@@ -1,6 +1,5 @@
 'use strict';
 
-const WPAPI = require( '../../' );
 const WPRequest = require( '../../lib/constructors/wp-request.js' );
 
 // Variable to use as our 'success token' in promise assertions
@@ -62,7 +61,10 @@ const expectedResults = {
 const getPostsAndAuthors = comments => comments
 	.map( comment => comment.post + comment.author_name );
 
-describe( 'integration: comments()', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: comments()', ( transportName, WPAPI ) => {
 	let wp;
 
 	beforeEach( () => {
diff --git a/tests/integration/custom-http-headers.js b/tests/integration/custom-http-headers.js
index 92bc0e39..8ed132ea 100644
--- a/tests/integration/custom-http-headers.js
+++ b/tests/integration/custom-http-headers.js
@@ -1,7 +1,5 @@
 'use strict';
 
-const WPAPI = require( '../../' );
-
 // Inspecting the titles of the returned posts arrays is an easy way to
 // validate that the right page of results was returned
 const getTitles = require( '../helpers/get-rendered-prop' ).bind( null, 'title' );
@@ -11,7 +9,10 @@ const base64credentials = Buffer.from( `${ credentials.username }:${ credentials
 // Variable to use as our "success token" in promise assertions
 const SUCCESS = 'success';
 
-describe( 'integration: custom HTTP Headers', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: custom HTTP Headers', ( transportName, WPAPI ) => {
 	let wp;
 
 	beforeEach( () => {
diff --git a/tests/integration/custom-http-transport.js b/tests/integration/custom-http-transport.js
index aa482d86..876c248f 100644
--- a/tests/integration/custom-http-transport.js
+++ b/tests/integration/custom-http-transport.js
@@ -1,15 +1,14 @@
 'use strict';
 
-const WPAPI = require( '../../' );
-
-const httpTransport = require( '../../lib/http-transport' );
-
 const credentials = require( '../helpers/constants' ).credentials;
 
 // Variable to use as our "success token" in promise assertions
 const SUCCESS = 'success';
 
-describe( 'integration: custom HTTP transport methods', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ), require( '../../superagent/superagent-transport' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ), require( '../../fetch/fetch-transport' ) ],
+] )( '%s: custom HTTP transport methods', ( transportName, WPAPI, httpTransport ) => {
 	let wp;
 	let id;
 	let cache;
@@ -17,19 +16,16 @@ describe( 'integration: custom HTTP transport methods', () => {
 
 	beforeEach( () => {
 		cache = {};
-		cachingGet = jest.fn( ( wpreq, cb ) => {
+		cachingGet = jest.fn( ( wpreq ) => {
 			const result = cache[ wpreq ];
-			// If a cache hit is found, return it via the same callback/promise
-			// signature as the default transport method
+			// If a cache hit is found, return it via the same promise
+			// signature as that of the default transport method
 			if ( result ) {
-				if ( cb && typeof cb === 'function' ) {
-					cb( null, result );
-				}
 				return Promise.resolve( result );
 			}
 
 			// Delegate to default transport if no cached data was found
-			return WPAPI.transport.get( wpreq, cb ).then( ( result ) => {
+			return WPAPI.transport.get( wpreq ).then( ( result ) => {
 				cache[ wpreq ] = result;
 				return result;
 			} );
@@ -67,7 +63,7 @@ describe( 'integration: custom HTTP transport methods', () => {
 				expect( result.id ).toBe( id );
 				expect( cachingGet ).toBeCalledTimes( 1 );
 				expect( httpTransport.get ).toHaveBeenCalledTimes( 1 );
-				expect( httpTransport.get ).toHaveBeenCalledWith( query1, undefined );
+				expect( httpTransport.get ).toHaveBeenCalledWith( query1 );
 				expect( result ).toBe( cache[ 'http://wpapi.local/wp-json/wp/v2/posts/' + id ] );
 			} )
 			.then( () => {
@@ -77,7 +73,7 @@ describe( 'integration: custom HTTP transport methods', () => {
 			.then( ( result ) => {
 				expect( cachingGet ).toBeCalledTimes( 2 );
 				expect( httpTransport.get ).toHaveBeenCalledTimes( 1 );
-				expect( httpTransport.get ).toHaveBeenLastCalledWith( query1, undefined );
+				expect( httpTransport.get ).toHaveBeenLastCalledWith( query1 );
 				expect( httpTransport.get.mock.calls[0][0] ).not.toBe( query2 );
 				expect( result ).toBe( cache[ 'http://wpapi.local/wp-json/wp/v2/posts/' + id ] );
 				return SUCCESS;
@@ -100,16 +96,12 @@ describe( 'integration: custom HTTP transport methods', () => {
 			endpoint: 'http://wpapi.local/wp-json',
 			transport: {
 				// If .slug is used, auto-unwrap the returned array
-				get( wpreq, cb ) {
+				get( wpreq ) {
 					if ( ! wpreq._params.slug ) {
-						return WPAPI.transport.get.call( this, wpreq, cb );
+						return WPAPI.transport.get.call( this, wpreq );
 					}
 					return WPAPI.transport.get( wpreq ).then( ( results ) => {
-						const result = extractSlug( results );
-						if ( cb && typeof cb === 'function' ) {
-							cb( null, result );
-						}
-						return result;
+						return extractSlug( results );
 					} );
 				},
 			},
diff --git a/tests/integration/error-states.js b/tests/integration/error-states.js
index d55494af..31b7abf7 100644
--- a/tests/integration/error-states.js
+++ b/tests/integration/error-states.js
@@ -1,18 +1,19 @@
 'use strict';
 
-const WPAPI = require( '../../' );
-
 // Variable to use as our "success token" in promise assertions
 const SUCCESS = 'success';
 
-describe( 'error states:', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: error states:', ( transportName, WPAPI ) => {
 
-	it( 'invalid root endpoint causes a transport-level (superagent) 404 error', () => {
+	it( 'invalid root endpoint causes a transport-level 404 error', () => {
 		const wp = WPAPI.site( 'http://wpapi.local/wrong-root-endpoint' );
 		const prom = wp.posts()
 			.get()
 			.catch( ( err ) => {
-				expect( err ).toBeInstanceOf( Error );
+				// expect( err ).toBeInstanceOf( Error );
 				expect( err ).toHaveProperty( 'status' );
 				expect( err.status ).toBe( 404 );
 				return SUCCESS;
diff --git a/tests/integration/media.js b/tests/integration/media.js
index e1900052..c0432113 100644
--- a/tests/integration/media.js
+++ b/tests/integration/media.js
@@ -5,7 +5,6 @@ const objectReduce = require( '../../lib/util/object-reduce' );
 const httpTestUtils = require( '../helpers/http-test-utils' );
 const unique = require( '../../lib/util/unique' );
 
-const WPAPI = require( '../../' );
 const WPRequest = require( '../../lib/constructors/wp-request.js' );
 
 // Inspecting the titles of the returned posts arrays is an easy way to
@@ -57,7 +56,10 @@ const expectedResults = {
 	},
 };
 
-describe( 'integration: media()', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: media()', ( transportName, WPAPI ) => {
 	let wp;
 	let authenticated;
 
diff --git a/tests/integration/pages.js b/tests/integration/pages.js
index bcf84d7d..9554dc73 100644
--- a/tests/integration/pages.js
+++ b/tests/integration/pages.js
@@ -1,6 +1,5 @@
 'use strict';
 
-const WPAPI = require( '../../' );
 const WPRequest = require( '../../lib/constructors/wp-request.js' );
 
 // Inspecting the titles of the returned posts arrays is an easy way to
@@ -39,7 +38,10 @@ const expectedResults = {
 	},
 };
 
-describe( 'integration: pages()', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: pages()', ( transportName, WPAPI ) => {
 	let wp;
 
 	beforeEach( () => {
diff --git a/tests/integration/posts.js b/tests/integration/posts.js
index f01afd70..42a91784 100644
--- a/tests/integration/posts.js
+++ b/tests/integration/posts.js
@@ -2,7 +2,6 @@
 
 const path = require( 'path' );
 
-const WPAPI = require( '../../' );
 const WPRequest = require( '../../lib/constructors/wp-request.js' );
 
 // Inspecting the titles of the returned posts arrays is an easy way to
@@ -54,7 +53,10 @@ const expectedResults = {
 	},
 };
 
-describe( 'integration: posts()', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: posts()', ( transportName, WPAPI ) => {
 	let wp;
 	let authenticated;
 
@@ -175,9 +177,8 @@ describe( 'integration: posts()', () => {
 
 				.then( ( posts ) => {
 					expect( Array.isArray( posts ) ).toBe( true );
-					// @TODO: re-enable once PPP support is merged
-					// expect( posts.length ).toBe( 10 );
-					// expect( getTitles( posts ) ).toEqual( expectedResults.titles.page2 );
+					expect( posts.length ).toBe( 10 );
+					expect( getTitles( posts ) ).toEqual( expectedResults.titles.page2 );
 					return SUCCESS;
 				} );
 			return expect( prom ).resolves.toBe( SUCCESS );
@@ -219,8 +220,7 @@ describe( 'integration: posts()', () => {
 				.page( 2 )
 				.get()
 				.then( ( posts ) => {
-					// @TODO: re-enable once PPP support is merged
-					// expect( getTitles( posts ) ).toEqual( expectedResults.titles.page2 );
+					expect( getTitles( posts ) ).toEqual( expectedResults.titles.page2 );
 					return posts._paging.prev
 						.get()
 						.then( ( posts ) => {
@@ -537,22 +537,19 @@ describe( 'integration: posts()', () => {
 			return expect( prom ).resolves.toBe( SUCCESS );
 		} );
 
-		it( 'cannot create (POST) without authentication (also tests callback-mode errors)', () => {
-			const prom = new Promise( ( resolve, reject ) => {
-				wp.posts().create( {
+		it( 'cannot create (POST) without authentication', () => {
+			const prom = wp.posts()
+				.create( {
 					title: 'New Post 2501',
 					content: 'Some Content',
-				}, ( err ) => {
-					if ( ! err ) {
-						reject();
-					}
+				} )
+				.catch( ( err ) => {
 					expect( err.code ).toBe( 'rest_cannot_create' );
 					expect( err.data ).toEqual( {
 						status: 401,
 					} );
-					resolve( SUCCESS );
+					return SUCCESS;
 				} );
-			} );
 			return expect( prom ).resolves.toBe( SUCCESS );
 		} );
 
@@ -630,15 +627,7 @@ describe( 'integration: posts()', () => {
 				expect( post.title ).toHaveProperty( 'rendered' );
 				expect( post.title.rendered ).toBe( 'Updated Title' );
 				// Re-authenticate & delete (trash) this post
-				// Use a callback to exercise that part of the functionality
-				return new Promise( ( resolve, reject ) => {
-					authenticated.posts().id( id ).delete( ( err, data ) => {
-						if ( err ) {
-							return reject( err );
-						}
-						resolve( data );
-					} );
-				} );
+				return authenticated.posts().id( id ).delete();
 			} )
 			.then( ( response ) => {
 				expect( typeof response ).toBe( 'object' );
@@ -807,35 +796,4 @@ describe( 'integration: posts()', () => {
 		return expect( prom ).resolves.toBe( SUCCESS );
 	}, 10000 );
 
-	// Callback context
-
-	it( 'can GET posts with a context-bound callback', ( done ) => {
-		class Ctor {
-			setState( state ) {
-				this.state = state;
-			}
-
-			request( cb ) {
-				const self = this;
-				wp.posts().get( ( err, data ) => {
-					expect( err ).toBeNull();
-
-					// Context is maintained
-					expect( this ).toBe( self );
-					this.setState( {
-						data: data,
-					} );
-
-					expect( this ).toHaveProperty( 'state' );
-					expect( typeof this.state ).toBe( 'object' );
-					expect( this.state ).toHaveProperty( 'data' );
-					expect( Array.isArray( this.state.data ) ).toBe( true );
-					expect( this.state.data.length ).toBe( 10 );
-					cb();
-				} );
-			}
-		}
-		( new Ctor() ).request( done );
-	} );
-
 } );
diff --git a/tests/integration/settings.js b/tests/integration/settings.js
index 8ee90ae3..b3bbc171 100644
--- a/tests/integration/settings.js
+++ b/tests/integration/settings.js
@@ -1,13 +1,14 @@
 'use strict';
 
-const WPAPI = require( '../../' );
-
 const credentials = require( '../helpers/constants' ).credentials;
 
 // Variable to use as our "success token" in promise assertions
 const SUCCESS = 'success';
 
-describe( 'integration: settings()', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: settings()', ( transportName, WPAPI ) => {
 	let wp;
 	let authenticated;
 
diff --git a/tests/integration/tags.js b/tests/integration/tags.js
index 6e179f57..d6cc1dbe 100644
--- a/tests/integration/tags.js
+++ b/tests/integration/tags.js
@@ -1,6 +1,5 @@
 'use strict';
 
-const WPAPI = require( '../../' );
 const WPRequest = require( '../../lib/constructors/wp-request.js' );
 
 // Inspecting the names of the returned terms is an easy way to validate
@@ -53,7 +52,10 @@ const expectedResults = {
 	},
 };
 
-describe( 'integration: tags()', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: tags()', ( transportName, WPAPI ) => {
 	let wp;
 
 	beforeEach( () => {
diff --git a/tests/integration/taxonomies.js b/tests/integration/taxonomies.js
index 9b2b7cea..f3c04ca4 100644
--- a/tests/integration/taxonomies.js
+++ b/tests/integration/taxonomies.js
@@ -1,11 +1,12 @@
 'use strict';
 
-const WPAPI = require( '../../' );
-
 // Variable to use as our "success token" in promise assertions
 const SUCCESS = 'success';
 
-describe( 'integration: taxonomies()', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: taxonomies()', ( transportName, WPAPI ) => {
 	let wp;
 
 	beforeEach( () => {
diff --git a/tests/integration/types.js b/tests/integration/types.js
index 1a05cdb5..a98fd166 100644
--- a/tests/integration/types.js
+++ b/tests/integration/types.js
@@ -1,11 +1,12 @@
 'use strict';
 
-const WPAPI = require( '../../' );
-
 // Variable to use as our "success token" in promise assertions
 const SUCCESS = 'success';
 
-describe( 'integration: types()', () => {
+describe.each( [
+	[ 'wpapi/superagent', require( '../../superagent' ) ],
+	[ 'wpapi/fetch', require( '../../fetch' ) ],
+] )( '%s: types()', ( transportName, WPAPI ) => {
 	let wp;
 
 	beforeEach( () => {
diff --git a/tests/unit/lib/autodiscovery.js b/tests/unit/lib/autodiscovery.js
deleted file mode 100644
index 9bbcf896..00000000
--- a/tests/unit/lib/autodiscovery.js
+++ /dev/null
@@ -1,37 +0,0 @@
-'use strict';
-
-const autodiscovery = require( '../../../lib/autodiscovery' );
-
-describe( 'autodiscovery helper methods', () => {
-
-	describe( '.locateAPIRootHeader()', () => {
-		let locateAPIRootHeader;
-
-		beforeEach( () => {
-			locateAPIRootHeader = autodiscovery.locateAPIRootHeader;
-		} );
-
-		it( 'is a function', () => {
-			expect( typeof locateAPIRootHeader ).toBe( 'function' );
-		} );
-
-		it( 'throws an error if no link header is found', () => {
-			expect( () => {
-				locateAPIRootHeader( {
-					headers: {},
-				} );
-			} ).toThrow( 'No header link found with rel="https://api.w.org/"' );
-		} );
-
-		it( 'parsed and returns the header with the rel for the REST API endpoint', () => {
-			const result = locateAPIRootHeader( {
-				headers: {
-					link: '<http://wpapi.local/wp-json/>; rel="https://api.w.org/"',
-				},
-			} );
-			expect( result ).toBe( 'http://wpapi.local/wp-json/' );
-		} );
-
-	} );
-
-} );
diff --git a/tests/unit/lib/bind-transport.js b/tests/unit/lib/bind-transport.js
new file mode 100644
index 00000000..6dc32b89
--- /dev/null
+++ b/tests/unit/lib/bind-transport.js
@@ -0,0 +1,35 @@
+'use strict';
+
+const bindTransport = require( '../../../lib/bind-transport' );
+
+describe( 'bindTransport()', () => {
+	it( 'is a function', () => {
+		expect( bindTransport ).toBeInstanceOf( Function );
+	} );
+} );
+
+describe( 'Transport-bound WPAPI constructor', () => {
+	let transport;
+	let WPAPI;
+
+	beforeEach( () => {
+		transport = {
+			get: jest.fn(),
+		};
+		WPAPI = bindTransport( require( '../../../wpapi' ), transport );
+	} );
+
+	it( 'has a .site() static method', () => {
+		expect( WPAPI ).toHaveProperty( 'site' );
+		expect( typeof WPAPI.site ).toBe( 'function' );
+	} );
+
+	it( 'returns instances of the expected constructor from WPAPI.site', () => {
+		const site = WPAPI.site( 'endpoint/url' );
+		expect( site instanceof WPAPI ).toBe( true );
+		expect( site._options.endpoint ).toBe( 'endpoint/url/' );
+		expect( site._options.transport ).toBeDefined();
+		expect( site._options.transport.get ).toBe( transport.get );
+	} );
+
+} );
diff --git a/tests/unit/lib/util/object-reduce.js b/tests/unit/lib/util/object-reduce.js
index 0d26a555..0cde240a 100644
--- a/tests/unit/lib/util/object-reduce.js
+++ b/tests/unit/lib/util/object-reduce.js
@@ -1,43 +1,28 @@
 'use strict';
 
-describe( 'Object reduction tools:', () => {
-	// Ensure parity with the relevant signature & functionality of lodash.reduce
-	[
-		{
-			name: 'lodash.reduce (for API parity verification)',
-			fn: require( 'lodash.reduce' ),
-		}, {
-			name: 'objectReduce utility',
-			fn: require( '../../../../lib/util/object-reduce' ),
-		},
-	].forEach( ( test ) => {
+const objectReduce = require( '../../../../lib/util/object-reduce' );
 
-		describe( test.name, () => {
-			const objectReduce = test.fn;
+describe( 'objectReduce utility', () => {
 
-			it( 'is defined', () => {
-				expect( objectReduce ).toBeDefined();
-			} );
-
-			it( 'is a function', () => {
-				expect( typeof objectReduce ).toBe( 'function' );
-			} );
-
-			it( 'resolves to the provided initial value if called on an empty object', () => {
-				expect( objectReduce( {}, () => {}, 'Sasquatch' ) ).toBe( 'Sasquatch' );
-			} );
+	it( 'is defined', () => {
+		expect( objectReduce ).toBeDefined();
+	} );
 
-			it( 'can be used to reduce over an object', () => {
-				const result = objectReduce( {
-					key1: 'val1',
-					key2: 'val2',
-					key3: 'val3',
-				}, ( memo, val, key ) => memo + val + key, 'result:' );
-				expect( result ).toBe( 'result:val1key1val2key2val3key3' );
-			} );
+	it( 'is a function', () => {
+		expect( typeof objectReduce ).toBe( 'function' );
+	} );
 
-		} );
+	it( 'resolves to the provided initial value if called on an empty object', () => {
+		expect( objectReduce( {}, () => {}, 'Sasquatch' ) ).toBe( 'Sasquatch' );
+	} );
 
+	it( 'can be used to reduce over an object', () => {
+		const result = objectReduce( {
+			key1: 'val1',
+			key2: 'val2',
+			key3: 'val3',
+		}, ( memo, val, key ) => memo + val + key, 'result:' );
+		expect( result ).toBe( 'result:val1key1val2key2val3key3' );
 	} );
 
 } );
diff --git a/tests/unit/wpapi.js b/tests/unit/wpapi.js
index 5b2d888d..8f3a5691 100644
--- a/tests/unit/wpapi.js
+++ b/tests/unit/wpapi.js
@@ -5,12 +5,6 @@ const WPAPI = require( '../../' );
 // Constructors, for use with instanceof checks
 const WPRequest = require( '../../lib/constructors/wp-request' );
 
-// HTTP transport, for stubbing
-const httpTransport = require( '../../lib/http-transport' );
-
-// Variable to use as our "success token" in promise assertions
-const SUCCESS = 'success';
-
 describe( 'WPAPI', () => {
 
 	let site;
@@ -71,75 +65,17 @@ describe( 'WPAPI', () => {
 			expect( site._options.auth ).toBe( true );
 		} );
 
-		describe( 'assigns default HTTP transport', () => {
-
-			it( 'for GET requests', () => {
-				jest.spyOn( httpTransport, 'get' ).mockImplementation( () => {} );
-				const site = new WPAPI( {
-					endpoint: 'http://some.url.com/wp-json',
-				} );
-				const query = site.root( '' );
-				query.get();
-				expect( httpTransport.get ).toHaveBeenCalledWith( query, undefined );
-				httpTransport.get.mockRestore();
-			} );
-
-			it( 'for POST requests', () => {
-				jest.spyOn( httpTransport, 'post' ).mockImplementation( () => {} );
-				const site = new WPAPI( {
-					endpoint: 'http://some.url.com/wp-json',
-				} );
-				const query = site.root( '' );
-				const data = {};
-				query.create( data );
-				expect( httpTransport.post ).toHaveBeenCalledWith( query, data, undefined );
-				httpTransport.post.mockRestore();
-			} );
-
-			it( 'for POST requests', () => {
-				jest.spyOn( httpTransport, 'post' ).mockImplementation( () => {} );
-				const site = new WPAPI( {
-					endpoint: 'http://some.url.com/wp-json',
-				} );
-				const query = site.root( '' );
-				const data = {};
-				query.create( data );
-				expect( httpTransport.post ).toHaveBeenCalledWith( query, data, undefined );
-				httpTransport.post.mockRestore();
-			} );
-
-			it( 'for PUT requests', () => {
-				jest.spyOn( httpTransport, 'put' ).mockImplementation( () => {} );
-				const site = new WPAPI( {
-					endpoint: 'http://some.url.com/wp-json',
-				} );
-				const query = site.root( 'a-resource' );
-				const data = {};
-				query.update( data );
-				expect( httpTransport.put ).toHaveBeenCalledWith( query, data, undefined );
-				httpTransport.put.mockRestore();
-			} );
+		describe( 'custom HTTP transport methods', () => {
 
-			it( 'for DELETE requests', () => {
-				jest.spyOn( httpTransport, 'delete' ).mockImplementation( () => {} );
-				const site = new WPAPI( {
-					endpoint: 'http://some.url.com/wp-json',
-				} );
-				const query = site.root( 'a-resource' );
-				const data = {
-					force: true,
+			beforeEach( () => {
+				WPAPI.transport = {
+					get: jest.fn().mockImplementation( () => {} ),
+					post: jest.fn().mockImplementation( () => {} ),
+					put: jest.fn().mockImplementation( () => {} ),
 				};
-				query.delete( data );
-				expect( httpTransport.delete ).toHaveBeenCalledWith( query, data, undefined );
-				httpTransport.delete.mockRestore();
 			} );
 
-		} );
-
-		describe( 'custom HTTP transport methods', () => {
-
 			it( 'can be set for an individual HTTP action', () => {
-				jest.spyOn( httpTransport, 'get' ).mockImplementation( () => {} );
 				const customGet = jest.fn();
 				const site = new WPAPI( {
 					endpoint: 'http://some.url.com/wp-json',
@@ -149,13 +85,12 @@ describe( 'WPAPI', () => {
 				} );
 				const query = site.root( '' );
 				query.get();
-				expect( customGet ).toHaveBeenCalledWith( query, undefined );
-				expect( httpTransport.get ).not.toHaveBeenCalled();
-				httpTransport.get.mockRestore();
+				expect( customGet ).toHaveBeenCalledWith( query );
+				expect( WPAPI.transport.get ).not.toHaveBeenCalled();
+				WPAPI.transport.get.mockRestore();
 			} );
 
 			it( 'can extend the default HTTP transport methods', () => {
-				jest.spyOn( httpTransport, 'get' ).mockImplementation( () => {} );
 				const customGet = jest.fn( ( ...args ) => {
 					WPAPI.transport.get.apply( null, args );
 				} );
@@ -167,14 +102,12 @@ describe( 'WPAPI', () => {
 				} );
 				const query = site.root( '' );
 				query.get();
-				expect( customGet ).toHaveBeenCalledWith( query, undefined );
-				expect( httpTransport.get ).toHaveBeenCalledWith( query, undefined );
-				httpTransport.get.mockRestore();
+				expect( customGet ).toHaveBeenCalledWith( query );
+				expect( WPAPI.transport.get ).toHaveBeenCalledWith( query );
+				WPAPI.transport.get.mockRestore();
 			} );
 
 			it( 'can be set for multiple HTTP actions', () => {
-				jest.spyOn( httpTransport, 'post' ).mockImplementation( () => {} );
-				jest.spyOn( httpTransport, 'put' ).mockImplementation( () => {} );
 				const customPost = jest.fn();
 				const customPut = jest.fn();
 				const site = new WPAPI( {
@@ -187,17 +120,16 @@ describe( 'WPAPI', () => {
 				const query = site.root( 'a-resource' );
 				const data = {};
 				query.create( data );
-				expect( customPost ).toHaveBeenCalledWith( query, data, undefined );
-				expect( httpTransport.post ).not.toHaveBeenCalled();
+				expect( customPost ).toHaveBeenCalledWith( query, data );
+				expect( WPAPI.transport.post ).not.toHaveBeenCalled();
 				query.update( data );
-				expect( customPut ).toHaveBeenCalledWith( query, data, undefined );
-				expect( httpTransport.put ).not.toHaveBeenCalled();
-				httpTransport.post.mockRestore();
-				httpTransport.put.mockRestore();
+				expect( customPut ).toHaveBeenCalledWith( query, data );
+				expect( WPAPI.transport.put ).not.toHaveBeenCalled();
+				WPAPI.transport.post.mockRestore();
+				WPAPI.transport.put.mockRestore();
 			} );
 
 			it( 'only apply to a specific WPAPI instance', () => {
-				jest.spyOn( httpTransport, 'get' ).mockImplementation( () => {} );
 				const customGet = jest.fn();
 				const site = new WPAPI( {
 					endpoint: 'http://some.url.com/wp-json',
@@ -211,41 +143,15 @@ describe( 'WPAPI', () => {
 				expect( site ).not.toBe( site2 );
 				const query = site2.root( '' );
 				query.get();
-				expect( httpTransport.get ).toHaveBeenCalledWith( query, undefined );
+				expect( WPAPI.transport.get ).toHaveBeenCalledWith( query );
 				expect( customGet ).not.toHaveBeenCalled();
-				httpTransport.get.mockRestore();
+				WPAPI.transport.get.mockRestore();
 			} );
 
 		} );
 
 	} );
 
-	describe( '.transport constructor property', () => {
-
-		it( 'is defined', () => {
-			expect( WPAPI ).toHaveProperty( 'transport' );
-		} );
-
-		it( 'is an object', () => {
-			expect( typeof WPAPI.transport ).toBe( 'object' );
-		} );
-
-		it( 'has methods for each http transport action', () => {
-			expect( typeof WPAPI.transport.delete ).toBe( 'function' );
-			expect( typeof WPAPI.transport.get ).toBe( 'function' );
-			expect( typeof WPAPI.transport.head ).toBe( 'function' );
-			expect( typeof WPAPI.transport.post ).toBe( 'function' );
-			expect( typeof WPAPI.transport.put ).toBe( 'function' );
-		} );
-
-		it( 'is frozen (properties cannot be modified directly)', () => {
-			expect( () => {
-				WPAPI.transport.get = () => {};
-			} ).toThrow();
-		} );
-
-	} );
-
 	describe( '.site() constructor method', () => {
 
 		it( 'is a function', () => {
@@ -282,154 +188,6 @@ describe( 'WPAPI', () => {
 
 	} );
 
-	describe( '.discover() constructor method', () => {
-		let responses;
-
-		beforeEach( () => {
-			responses = {
-				head: {},
-				get: {},
-			};
-			responses.head.withLink = {
-				'content-type': 'text/html; charset=UTF-8',
-				link: '<http://mozarts.house/wp-json/>; rel="https://api.w.org/"',
-			};
-			responses.head.withoutLink = {
-				'content-type': 'text/html; charset=utf-8',
-			};
-			responses.get.withLink = {
-				headers: {
-					'content-type': 'text/html; charset=UTF-8',
-					link: '<http://mozarts.house/wp-json/>; rel="https://api.w.org/"',
-				},
-			};
-			responses.get.withoutLink = {
-				headers: {
-					'content-type': 'text/html; charset=UTF-8',
-				},
-			};
-			responses.apiRoot = {
-				name: 'Skip Beats',
-				descrition: 'Just another WordPress weblog',
-				routes: {
-					'list': {},
-					'of': {},
-					'routes': {},
-				},
-			};
-			// Stub HTTP methods
-			jest.spyOn( httpTransport, 'head' ).mockImplementation( () => {} );
-			jest.spyOn( httpTransport, 'get' ).mockImplementation( () => {} );
-			// Stub warn and error
-			jest.spyOn( global.console, 'warn' ).mockImplementation( () => {} );
-			jest.spyOn( global.console, 'error' ).mockImplementation( () => {} );
-		} );
-
-		afterEach( () => {
-			// Restore HTTP methods
-			httpTransport.head.mockRestore();
-			httpTransport.get.mockRestore();
-		} );
-
-		it( 'is a function', () => {
-			expect( WPAPI ).toHaveProperty( 'discover' );
-			expect( typeof WPAPI.discover ).toBe( 'function' );
-		} );
-
-		it( 'throws an error if no API endpoint can be discovered', () => {
-			const url = 'http://we.made.it/to/mozarts/house';
-			httpTransport.head.mockImplementationOnce( () => Promise.reject() );
-			httpTransport.get.mockImplementationOnce( () => Promise.reject( 'Some error' ) );
-			const prom = WPAPI.discover( url )
-				.catch( ( err ) => {
-					expect( global.console.error ).toHaveBeenCalledWith( 'Some error' );
-					expect( err.message ).toBe( 'Autodiscovery failed' );
-					return SUCCESS;
-				} );
-			return expect( prom ).resolves.toBe( SUCCESS );
-		} );
-
-		it( 'discovers the API root with a HEAD request', () => {
-			const url = 'http://mozarts.house';
-			httpTransport.head.mockImplementation( () => Promise.resolve( responses.head.withLink ) );
-			httpTransport.get.mockImplementation( () => Promise.resolve( responses.apiRoot ) );
-			const prom = WPAPI.discover( url )
-				.then( ( result ) => {
-					expect( result ).toBeInstanceOf( WPAPI );
-					expect( httpTransport.head ).toBeCalledTimes( 1 );
-					expect( httpTransport.get ).toBeCalledTimes( 1 );
-					expect( result.root().toString() ).toBe( 'http://mozarts.house/wp-json/' );
-					return SUCCESS;
-				} );
-			return expect( prom ).resolves.toBe( SUCCESS );
-		} );
-
-		it( 'throws an error if HEAD succeeds but no link is present', () => {
-			const url = 'http://we.made.it/to/mozarts/house';
-			httpTransport.head.mockImplementationOnce( () => Promise.resolve( responses.head.withoutLink ) );
-			const prom = WPAPI.discover( url )
-				.catch( ( err ) => {
-					expect( global.console.error ).toHaveBeenCalledWith(
-						new Error( 'No header link found with rel="https://api.w.org/"' )
-					);
-					expect( err.message ).toBe( 'Autodiscovery failed' );
-					return SUCCESS;
-				} );
-			return expect( prom ).resolves.toBe( SUCCESS );
-		} );
-
-		it( 'retries the initial site request as a GET if HEAD fails', () => {
-			const url = 'http://mozarts.house';
-			httpTransport.head.mockImplementation( () => Promise.reject() );
-			httpTransport.get.mockImplementationOnce( () => Promise.resolve( responses.get.withLink ) );
-			httpTransport.get.mockImplementationOnce( () => Promise.resolve( responses.apiRoot ) );
-			const prom = WPAPI.discover( url )
-				.then( ( result ) => {
-					expect( result ).toBeInstanceOf( WPAPI );
-					expect( httpTransport.head ).toBeCalledTimes( 1 );
-					expect( httpTransport.get ).toBeCalledTimes( 2 );
-					expect( result.root().toString() ).toBe( 'http://mozarts.house/wp-json/' );
-					return SUCCESS;
-				} );
-			return expect( prom ).resolves.toBe( SUCCESS );
-		} );
-
-		it( 'throws an error if GET retry succeeds but no link is present', () => {
-			const url = 'http://we.made.it/to/mozarts/house';
-			httpTransport.head.mockImplementation( () => Promise.reject() );
-			httpTransport.get.mockImplementationOnce( () => Promise.resolve( responses.get.withoutLink ) );
-			const prom = WPAPI.discover( url )
-				.catch( ( err ) => {
-					expect( global.console.error ).toHaveBeenCalledWith(
-						new Error( 'No header link found with rel="https://api.w.org/"' )
-					);
-					expect( err.message ).toBe( 'Autodiscovery failed' );
-					return SUCCESS;
-				} );
-			return expect( prom ).resolves.toBe( SUCCESS );
-		} );
-
-		it( 'returns WPAPI instance bound to discovered root even when route request errors', () => {
-			const url = 'http://mozarts.house';
-			httpTransport.head.mockImplementation( () => Promise.reject() );
-			httpTransport.get
-				.mockImplementationOnce( () => Promise.resolve( responses.get.withLink ) )
-				.mockImplementationOnce( () => Promise.reject( 'Some error' ) );
-			const prom = WPAPI.discover( url )
-				.then( ( result ) => {
-					expect( result ).toBeInstanceOf( WPAPI );
-					expect( httpTransport.head ).toBeCalledTimes( 1 );
-					expect( httpTransport.get ).toBeCalledTimes( 2 );
-					expect( global.console.error ).toHaveBeenCalledWith( 'Some error' );
-					expect( global.console.warn ).toHaveBeenCalledWith( 'Endpoint detected, proceeding despite error...' );
-					expect( result.root().toString() ).toBe( 'http://mozarts.house/wp-json/' );
-					return SUCCESS;
-				} );
-			return expect( prom ).resolves.toBe( SUCCESS );
-		} );
-
-	} );
-
 	describe( '.prototype', () => {
 
 		describe( '.namespace()', () => {
@@ -574,17 +332,13 @@ describe( 'WPAPI', () => {
 			} );
 
 			it( 'sets transport methods on the instance', () => {
-				jest.spyOn( httpTransport, 'get' );
 				const customGet = jest.fn();
 				site.transport( {
 					get: customGet,
 				} );
-				const cb = () => {};
 				const query = site.root( '' );
-				query.get( cb );
-				expect( customGet ).toHaveBeenCalledWith( query, cb );
-				expect( httpTransport.get ).not.toHaveBeenCalled();
-				httpTransport.get.mockRestore();
+				query.get();
+				expect( customGet ).toHaveBeenCalledWith( query );
 			} );
 
 			it( 'does not impact or overwrite unspecified transport methods', () => {
diff --git a/webpack.config.js b/webpack.config.js
index 63bd472d..77f38fe3 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -3,7 +3,20 @@
 const { join } = require( 'path' );
 
 module.exports = {
-	entry: './wpapi.js',
+	entry: {
+		wpapi: './fetch',
+		'wpapi-superagent': './superagent',
+	},
+
+	// Use browser builtins instead of Node packages where appropriate.
+	externals: {
+		'node-fetch': 'fetch',
+		'form-data': 'FormData',
+	},
+
+	node: {
+		fs: 'empty',
+	},
 
 	mode: 'development',
 
@@ -21,7 +34,7 @@ module.exports = {
 
 	output: {
 		path: join( process.cwd(), 'browser' ),
-		filename: 'wpapi.js',
+		filename: '[name].js',
 		library: 'WPAPI',
 		libraryTarget: 'umd',
 	},
@@ -30,7 +43,7 @@ module.exports = {
 		rules: [
 			{
 				test: /\.js$/,
-				exclude: /(node_modules|bower_components)/,
+				exclude: /(node_modules)/,
 				loader: require.resolve( 'babel-loader' ),
 				options: {
 					presets: [ '@babel/preset-env' ],
diff --git a/webpack.config.minified.js b/webpack.config.minified.js
index 62ce81db..28c3ed3e 100644
--- a/webpack.config.minified.js
+++ b/webpack.config.minified.js
@@ -14,7 +14,7 @@ module.exports = {
 
 	output: {
 		...config.output,
-		filename: 'wpapi.min.js',
+		filename: '[name].min.js',
 	},
 
 	optimization: {
diff --git a/wpapi.js b/wpapi.js
index 602f17e5..c3e52325 100644
--- a/wpapi.js
+++ b/wpapi.js
@@ -30,15 +30,9 @@ let defaultEndpointFactories;
 // Constant used to detect first-party WordPress REST API routes
 const apiDefaultNamespace = 'wp/v2';
 
-// Pull in autodiscovery methods
-const autodiscovery = require( './lib/autodiscovery' );
-
 // Pull in base module constructors
 const WPRequest = require( './lib/constructors/wp-request' );
 
-// Pull in default HTTP transport
-const httpTransport = require( './lib/http-transport' );
-
 /**
  * Construct a REST API client instance object to create
  *
@@ -108,19 +102,16 @@ function WPAPI( options ) {
  *
  *     // Overwrite the GET behavior to inject a caching layer
  *     site.transport({
- *       get: function( wpreq, cb ) {
+ *       get: function( wpreq ) {
  *         var result = cache[ wpreq ];
- *         // If a cache hit is found, return it via the same callback/promise
- *         // signature as the default transport method
+ *         // If a cache hit is found, return it via the same promise
+ *         // signature as that of the default transport method
  *         if ( result ) {
- *           if ( cb && typeof cb === 'function' ) {
- *             cb( null, result );
- *           }
  *           return Promise.resolve( result );
  *         }
  *
  *         // Delegate to default transport if no cached data was found
- *         return WPAPI.transport.get( wpreq, cb ).then(function( result ) {
+ *         return this.constructor.transport.get( wpreq ).then(function( result ) {
  *           cache[ wpreq ] = result;
  *           return result;
  *         });
@@ -147,9 +138,11 @@ WPAPI.prototype.transport = function( transport ) {
 	// Local reference to avoid need to reference via `this` inside forEach
 	const _options = this._options;
 
-	// Create the default transport if it does not exist
+	// Attempt to use the default transport if no override was provided
 	if ( ! _options.transport ) {
-		_options.transport = Object.create( WPAPI.transport );
+		_options.transport = this.constructor.transport ?
+			Object.create( this.constructor.transport ) :
+			{};
 	}
 
 	// Whitelist the methods that may be applied
@@ -162,60 +155,6 @@ WPAPI.prototype.transport = function( transport ) {
 	return this;
 };
 
-/**
- * Default HTTP transport methods object for all WPAPI instances
- *
- * These methods may be extended or replaced on an instance-by-instance basis
- *
- * @memberof! WPAPI
- * @static
- * @property transport
- * @type {Object}
- */
-WPAPI.transport = Object.create( httpTransport );
-Object.freeze( WPAPI.transport );
-
-/**
- * Convenience method for making a new WPAPI instance
- *
- * @example
- * These are equivalent:
- *
- *     var wp = new WPAPI({ endpoint: 'http://my.blog.url/wp-json' });
- *     var wp = WPAPI.site( 'http://my.blog.url/wp-json' );
- *
- * `WPAPI.site` can take an optional API root response JSON object to use when
- * bootstrapping the client's endpoint handler methods: if no second parameter
- * is provided, the client instance is assumed to be using the default API
- * with no additional plugins and is initialized with handlers for only those
- * default API routes.
- *
- * @example
- * These are equivalent:
- *
- *     // {...} means the JSON output of http://my.blog.url/wp-json
- *     var wp = new WPAPI({
- *       endpoint: 'http://my.blog.url/wp-json',
- *       json: {...}
- *     });
- *     var wp = WPAPI.site( 'http://my.blog.url/wp-json', {...} );
- *
- * @memberof! WPAPI
- * @static
- * @param {String} endpoint The URI for a WP-API endpoint
- * @param {Object} routes   The "routes" object from the JSON object returned
- *                          from the root API endpoint of a WP site, which should
- *                          be a dictionary of route definition objects keyed by
- *                          the route's regex pattern
- * @returns {WPAPI} A new WPAPI instance, bound to the provided endpoint
- */
-WPAPI.site = function( endpoint, routes ) {
-	return new WPAPI( {
-		endpoint: endpoint,
-		routes: routes,
-	} );
-};
-
 /**
  * Generate a request against a completely arbitrary endpoint, with no assumptions about
  * or mutation of path, filtering, or query parameters. This request is not restricted to
@@ -412,58 +351,44 @@ WPAPI.prototype.namespace = function( namespace ) {
 };
 
 /**
- * Take an arbitrary WordPress site, deduce the WP REST API root endpoint, query
- * that endpoint, and parse the response JSON. Use the returned JSON response
- * to instantiate a WPAPI instance bound to the provided site.
+ * Convenience method for making a new WPAPI instance for a given API root
+ *
+ * @example
+ * These are equivalent:
+ *
+ *     var wp = new WPAPI({ endpoint: 'http://my.blog.url/wp-json' });
+ *     var wp = WPAPI.site( 'http://my.blog.url/wp-json' );
+ *
+ * `WPAPI.site` can take an optional API root response JSON object to use when
+ * bootstrapping the client's endpoint handler methods: if no second parameter
+ * is provided, the client instance is assumed to be using the default API
+ * with no additional plugins and is initialized with handlers for only those
+ * default API routes.
+ *
+ * @example
+ * These are equivalent:
+ *
+ *     // {...} means the JSON output of http://my.blog.url/wp-json
+ *     var wp = new WPAPI({
+ *       endpoint: 'http://my.blog.url/wp-json',
+ *       json: {...}
+ *     });
+ *     var wp = WPAPI.site( 'http://my.blog.url/wp-json', {...} );
  *
  * @memberof! WPAPI
  * @static
- * @param {string} url A URL within a REST API-enabled WordPress website
- * @returns {Promise} A promise that resolves to a configured WPAPI instance bound
- * to the deduced endpoint, or rejected if an endpoint is not found or the
- * library is unable to parse the provided endpoint.
+ * @param {String} endpoint The URI for a WP-API endpoint
+ * @param {Object} routes   The "routes" object from the JSON object returned
+ *                          from the root API endpoint of a WP site, which should
+ *                          be a dictionary of route definition objects keyed by
+ *                          the route's regex pattern
+ * @returns {WPAPI} A new WPAPI instance, bound to the provided endpoint
  */
-WPAPI.discover = ( url ) => {
-	// local placeholder for API root URL
-	let endpoint;
-
-	// Try HEAD request first, for smaller payload: use WPAPI.site to produce
-	// a request that utilizes the defined HTTP transports
-	const req = WPAPI.site( url ).root();
-	return req.headers()
-		.catch( () => {
-			// On the hypothesis that any error here is related to the HEAD request
-			// failing, provisionally try again using GET because that method is
-			// more widely supported
-			return req.get();
-		} )
-		// Inspect response to find API location header
-		.then( autodiscovery.locateAPIRootHeader )
-		.then( ( apiRootURL ) => {
-			// Set the function-scope variable that will be used to instantiate
-			// the bound WPAPI instance,
-			endpoint = apiRootURL;
-
-			// then GET the API root JSON object
-			return WPAPI.site( apiRootURL ).root().get();
-		} )
-		.then( ( apiRootJSON ) => {
-			// Instantiate & bootstrap with the discovered methods
-			return new WPAPI( {
-				endpoint: endpoint,
-				routes: apiRootJSON.routes,
-			} );
-		} )
-		.catch( ( err ) => {
-			/* eslint-disable no-console */
-			console.error( err );
-			if ( endpoint ) {
-				console.warn( 'Endpoint detected, proceeding despite error...' );
-				console.warn( 'Binding to ' + endpoint + ' and assuming default routes' );
-				return new WPAPI.site( endpoint );
-			}
-			throw new Error( 'Autodiscovery failed' );
-		} );
+WPAPI.site = ( endpoint, routes ) => {
+	return new WPAPI( {
+		endpoint: endpoint,
+		routes: routes,
+	} );
 };
 
 module.exports = WPAPI;