diff --git a/.travis.yml b/.travis.yml
index cdcdfc9..0c81086 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,3 +1,3 @@
 language: node_js
 node_js:
-  - "12"
+  - "16"
diff --git a/LICENSE b/LICENSE
index 52b3e98..aed4e0d 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019 Polybit Inc.
+Copyright (c) 2021 Polybit Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
diff --git a/README.md b/README.md
index d219ac4..a0f3a84 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 ![travis-ci build](https://travis-ci.org/FunctionScript/FunctionScript.svg?branch=master)
 ![npm version](https://badge.fury.io/js/functionscript.svg)
 
-## Turn JavaScript Functions into Typed HTTP APIs
+## An API gateway and framework for turning functions into web services
 
 FunctionScript is a language and specification for turning JavaScript
 functions into typed HTTP APIs. It allows JavaScript (Node.js) functions to be
@@ -19,16 +19,8 @@ interfaces. For this reason, the goals of the language are significantly differe
 [TypeScript](https://github.com/microsoft/TypeScript).
 **FunctionScript is intended to provide an easy introduction to API development for those of any skill level, while maintaining professional power and flexibility.**
 
-FunctionScript is the primary specification underpinning the [Standard Library](https://stdlib.com)
-API development and integration platform. You can start building with FunctionScript **immediately** using
-[Code on Standard Library](https://code.stdlib.com/?sample=t&filename=functions/__main__.js), right in
-your web browser. An animated example has been provided below.
-
-**Note:** *In order to use Code on Standard Library you must have a registered account on [stdlib.com](https://stdlib.com), available for free.*
-
-https://code.stdlib.com/?sample=t&filename=functions/__main__.js
-
-[![Demo](/images/demo-api.gif)](https://code.stdlib.com/?sample=t&filename=functions/__main__.js)
+FunctionScript is the primary specification underpinning the [Autocode](https://autocode.com)
+platform and its standard library of APIs.
 
 ### Quick Example of a FunctionScript API
 
@@ -89,7 +81,7 @@ It will return an `object`:
 ## Background
 
 The impetus for creating FunctionScript is simple: it stems from the initial
-vision of [Standard Library](https://stdlib.com). We believe the modern web is
+vision of [Autocode](https://autocode.com). We believe the modern web is
 missing a base primitive - the API. Daily, computer systems and developers around
 the planet make trillions of requests to perform specific tasks: process
 credit card payments with [Stripe](https://stripe.com), send team messages via
@@ -107,11 +99,6 @@ software development instead of an afterthought. This allows teams to be able to
 deliver high-quality APIs with the same fidelity as organizations like
 Stripe in a fraction of the time without requiring any additional tooling.
 
-FunctionScript has been developed by the team at Polybit Inc., responsible for
-[Standard Library](https://stdlib.com).
-Ongoing development is, in part, funded by both [Stripe](https://stripe.com) and
-[Slack](https://slack.com) as venture investments in the parent organization.
-
 # Table of Contents
 
 1. [Introduction](#introduction)
@@ -144,7 +131,7 @@ Ongoing development is, in part, funded by both [Stripe](https://stripe.com) and
 To put it simply, FunctionScript defines semantics and rules for turning exported
 JavaScript (Node.js) functions into strongly-typed, HTTP-accessible web APIs.
 In order to use FunctionScript, you'd set up your own [FunctionScript Gateway](#functionscript-server-and-gateway-implementation) or you would use an existing FunctionScript-compliant service
-like [Standard Library](https://stdlib.com/).
+like [Autocode](https://autocode.com/).
 
 FunctionScript allows you to turn something like this...
 
@@ -195,7 +182,7 @@ Or, when a type mismatch occurs (like `{"name":10}`):
 ## Why FunctionScript?
 
 FunctionScript is intended primarily to provide a scaffold to build and deliver
-APIs easily. It works best in conjunction with the [Standard Library](https://stdlib.com/)
+APIs easily. It works best as a part of the [Autocode](https://autocode.com/)
 platform which consumes the FunctionScript API definitions, hosts the code,
 generates documentation from the definitions, and automatically handles versioning and
 environment management. The reason we've open sourced the language specification
@@ -689,53 +676,26 @@ is available with this package, simply clone it and run `npm test` or look
 at the `/tests` folder for more information.
 
 The FunctionScript specification is used as the platform specification
-for [Standard Library](https://stdlib.com), and is available for local use with the
-[Standard Library CLI Package](https://github.com/stdlib/lib) which relies on this
+for [Autocode](https://autocode.com), and is available for local use with the
+[Autocode CLI](https://github.com/acode/cli) which relies on this
 repository as a dependency.
 
 # Acknowledgements
 
 FunctionScript is the result of years of concerted effort working to make API
 development easier. It would not be possible without the personal and financial
-commitments of some very amazing people and companies.
-
-## Corporate Interests
-
-Via investments in Polybit Inc., parent of [Standard Library](https://stdlib.com),
-the following companies have invested countless hours in and provided financial
-support for our team, which has made this project possible.
-
-[Stripe](https://stripe.com), the global leader in online payments
-
-[![Stripe Logo](/images/stripe-logo-300.png)](https://stripe.com)
-
-[Slack](https://slack.com), the online platform for work and communication
-
-[![Slack Logo](/images/slack-logo-300.png)](https://slack.com)
-
-## Special Thanks
-
-There have been a number of helpful supporters and contributors along the way,
-and FunctionScript would not be possible without any of them.
+commitments of some very amazing people and companies. We'd like to thank our
+customers, investors, supporters, friends and family.
 
 ### Core Contributors
 
 - [**Keith Horwood**](https://twitter.com/keithwhor)
 - [**Jacob Lee**](https://twitter.com/hacubu)
 - [**Steve Meyer**](https://twitter.com/notoriaga)
-
-### Friends and Supporters
-
-- [**Chad Fowler**](https://twitter.com/chadfowler)
-- [**Bear Douglas**](https://twitter.com/beardigsit)
-- [**Romain Huet**](https://twitter.com/romainhuet)
-- [**Will Gaybrick**](https://twitter.com/gaybrick)
-- [**Patrick Collison**](https://twitter.com/patrickc)
-- [**Patrick McKenzie**](https://twitter.com/patio11)
-- [**David Singleton**](https://twitter.com/dps)
+- [**Yusuf Musleh**](https://twitter.com/yusuf-musleh)
 
 # Notes
 
 The software contained within this repository has been developed and is
-copyrighted by the [Standard Library](https://stdlib.com) Team at Polybit Inc.
+copyrighted by the [Autocode](https://autocode.com) team (Polybit Inc.)
 and is MIT licensed.
diff --git a/images/demo-api.gif b/images/demo-api.gif
deleted file mode 100644
index 49f69fc..0000000
Binary files a/images/demo-api.gif and /dev/null differ
diff --git a/lib/background.js b/lib/background_validator.js
similarity index 64%
rename from lib/background.js
rename to lib/background_validator.js
index 2e05f19..ce632d2 100644
--- a/lib/background.js
+++ b/lib/background_validator.js
@@ -1,9 +1,9 @@
 module.exports = {
   modes: {
-    'info': (definition, params) => Buffer.from(`Initiated ${definition.name}...`),
+    'info': (definition, params) => Buffer.from(`initiated "${definition.name}"...`),
     'empty': (definition, params) => Buffer.from([]),
     'params': (definition, params) => {
-      let specifiedBgParams = definition.bg.value
+      let specifiedBgParams = definition.background.value
         .split(/\s+/)
         .filter(param => !!param);
       return !specifiedBgParams.length
@@ -16,11 +16,5 @@ module.exports = {
           }, {});
     }
   },
-  defaultMode: 'info',
-  generateDefaultValue: function () {
-    return {
-      mode: this.defaultMode,
-      value: ''
-    };
-  }
+  defaultMode: 'info'
 };
diff --git a/lib/daemon.js b/lib/daemon.js
index 347bfbd..996269c 100644
--- a/lib/daemon.js
+++ b/lib/daemon.js
@@ -2,6 +2,7 @@ const cluster = require('cluster');
 const os = require('os');
 const http = require('http');
 const fs = require('fs');
+const path = require('path');
 
 const Gateway = require('./gateway.js');
 
@@ -21,6 +22,8 @@ class Daemon {
     this._server = null;
     this._port = null;
 
+    this._paused = false;
+
     this.cpus = parseInt(cpus) || os.cpus().length;
     this.children = [];
 
@@ -46,15 +49,12 @@ class Daemon {
     if ((process.env.NODE_ENV || 'development') === 'development') {
 
       this.watch('', (changes) => {
-
         changes.forEach(change => {
           console.log(`[${this.name}.Daemon] ${change.event[0].toUpperCase()}${change.event.substr(1)}: ${change.path}`);
         });
-
         this.children.forEach(child => child.send({invalidate: true}));
         this.children = [];
         !this.children.length && this.unwatch() && this.start();
-
       });
 
     }
@@ -103,7 +103,9 @@ class Daemon {
 
   message(data) {
 
-    data.error && this.logError(data.error);
+    if (data.error) {
+      this.logError(data.error);
+    }
 
   }
 
@@ -161,12 +163,14 @@ class Daemon {
 
   /**
   * Watches a directory tree for changes
-  * @param {string} path Directory tree to watch
+  * @param {string} root Directory tree to watch
   * @param {function} onChange Method to be executed when a change is detected
   */
-  watch(path, onChange) {
+  watch (root, onChange) {
+
+    let cwd = process.cwd();
 
-    function watchDir(cwd, dirname, watchers) {
+    function watchDir (dirname, watchers) {
 
       if (!watchers) {
 
@@ -176,28 +180,28 @@ class Daemon {
 
       }
 
-      let path = [cwd, dirname].join('');
-      let files = fs.readdirSync(path);
+      let pathname = path.join(cwd, dirname);
+      let files = fs.readdirSync(pathname);
 
-      watchers.directories[path] = Object.create(null);
+      watchers.directories[dirname] = Object.create(null);
 
-      files.forEach(function(v) {
+      files.forEach(function (name) {
 
-        if (v === 'node_modules' || v.indexOf('.') === 0) {
+        if (name === 'node_modules' || name.indexOf('.') === 0) {
           return;
         }
 
-        let filename = [dirname, v].join('/');
-        let fullPath = [cwd, filename].join('/');
+        let filename = path.join(dirname, name);
+        let fullPath = path.join(cwd, filename);
 
         let stat = fs.statSync(fullPath);
 
         if (stat.isDirectory()) {
-          watchDir(cwd, filename, watchers);
+          watchDir(filename, watchers);
           return;
         }
 
-        watchers.directories[path][v] = stat;
+        watchers.directories[dirname][name] = stat;
 
       });
 
@@ -205,71 +209,93 @@ class Daemon {
 
     }
 
-    let watchers = watchDir(process.cwd(), path || '');
+    let watchers = watchDir(root || '');
     let self = this;
 
-    watchers.iterate = function(changes) {
-
-      if (changes.length) {
-        onChange.call(self, changes);
+    watchers.iterate = function (changes) {
+      if (!fs.existsSync(path.join(process.cwd(), '.daemon.pause'))) {
+        // Skip a cycle if just unpaused...
+        if (!this._paused) {
+          if (changes.length) {
+            onChange.call(self, changes);
+          }
+        } else {
+          this._paused = false;
+        }
+      } else {
+        this._paused = true;
       }
-
     };
 
     watchers.interval = setInterval(function() {
 
       let changes = [];
 
-      Object.keys(watchers.directories).forEach(function(dirPath) {
+      Object.keys(watchers.directories).forEach(function (dirname) {
 
-        let dir = watchers.directories[dirPath];
-        let files = fs.readdirSync(dirPath);
-        let added = [];
+        let dir = watchers.directories[dirname];
+        let dirPath = path.join(cwd, dirname);
 
-        let contents = Object.create(null);
+        if (!fs.existsSync(dirPath)) {
 
-        files.forEach(function(v) {
+          delete watchers.directories[dirname];
+          changes.push({event: 'removed', path: dirPath});
 
-          if (v === 'node_modules' || v.indexOf('.') === 0) {
-            return;
-          }
+        } else {
 
-          let fullPath = [dirPath, v].join('/');
-          let stat = fs.statSync(fullPath);
+          let files = fs.readdirSync(dirPath);
+          let added = [];
 
-          if (stat.isDirectory()) {
-            return;
-          }
+          let contents = Object.create(null);
 
-          if (!dir[v]) {
-            added.push([v, stat]);
-            changes.push({event: 'added', path: fullPath});
-            return;
-          }
+          files.forEach(function (filename) {
 
-          if (stat.mtime.toString() !== dir[v].mtime.toString()) {
-            dir[v] = stat;
-            changes.push({event: 'modified', path: fullPath});
-          }
+            if (filename === 'node_modules' || filename.indexOf('.') === 0) {
+              return;
+            }
 
-          contents[v] = true;
+            let fullPath = path.join(dirPath, filename);
+            let stat = fs.statSync(fullPath);
 
-        });
+            if (stat.isDirectory()) {
+              let checkPath = path.join(dirname, filename);
+              if (!watchers.directories[checkPath]) {
+                watchDir(checkPath, watchers);
+              }
+            } else {
+              if (!dir[filename]) {
+                added.push([filename, stat]);
+                changes.push({event: 'added', path: fullPath});
+                return;
+              }
 
-        Object.keys(dir).forEach(function(v) {
+              if (stat.mtime.toString() !== dir[filename].mtime.toString()) {
+                dir[filename] = stat;
+                changes.push({event: 'modified', path: fullPath});
+              }
 
-          let fullPath = [dirPath, v].join('/');
+              contents[filename] = true;
+            }
 
-          if (!contents[v]) {
-            delete dir[v];
-            changes.push({event: 'removed', path: fullPath});
-          }
+          });
 
-        });
+          Object.keys(dir).forEach(function (filename) {
 
-        added.forEach(function(v) {
-          dir[v[0]] = v[1];
-        });
+            let fullPath = path.join(cwd, dirname, filename);
+
+            if (!contents[filename]) {
+              delete dir[filename];
+              changes.push({event: 'removed', path: fullPath});
+            }
+
+          });
+
+          added.forEach(function (change) {
+            let [filename, stat] = change;
+            dir[filename] = stat;
+          });
+
+        }
 
       });
 
diff --git a/lib/gateway.js b/lib/gateway.js
index 5878efa..7b229ae 100644
--- a/lib/gateway.js
+++ b/lib/gateway.js
@@ -1,18 +1,33 @@
+const fs = require('fs');
 const http = require('http');
 const path = require('path');
 const url = require('url');
 const querystring = require('querystring');
 const zlib = require('zlib');
 const EventEmitter = require('events');
+const xmlParser = require('fast-xml-parser');
 
 const uuid = require('uuid');
 
+const backgroundValidator = require('./background_validator.js');
 const types = require('./types.js');
-const background = require('./background.js');
+const wellKnowns = require('./well-knowns.js');
+
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+
+const relrequire = function (pathname, name) {
+  let relpath = pathname.split('/').slice(0, -1).join('/');
+  let relname = name;
+  if (!name.startsWith('@') && name.indexOf('/') > 0) {
+    relname = path.join(process.cwd(), relpath, name);
+  }
+  return require(relname);
+};
 
 const DEFAULT_PORT = 8170;
 const DEFAULT_NAME = 'FunctionScript.Gateway';
 const DEFAULT_MAX_REQUEST_SIZE_MB = 128;
+const FUNCTION_EXECUTION_TIMEOUT = 30000;
 
 class Gateway extends EventEmitter {
 
@@ -24,20 +39,26 @@ class Gateway extends EventEmitter {
     this.port = cfg.port || DEFAULT_PORT;
     this.name = cfg.name || DEFAULT_NAME;
     this.maxRequestSizeMB = cfg.maxRequestSizeMB || DEFAULT_MAX_REQUEST_SIZE_MB;
+    this.defaultTimeout = cfg.defaultTimeout || FUNCTION_EXECUTION_TIMEOUT;
     this.supportedMethods = {'GET': true, 'POST': true, 'OPTIONS': true, 'HEAD': true};
     this.trailingSlashRedirectMethods = {'GET': true};
     this.supportedLogTypes = {'global': '***', 'info': ':::', 'error': '<!>', 'result': '>>>'};
     this.defaultLogType = 'info';
-    this.supportedBgModes = background.modes;
-    this.defaultBgMode = background.defaultMode;
+    this.supportedBackgroundModes = backgroundValidator.modes;
+    this.defaultBackgroundMode = backgroundValidator.defaultMode;
     this.server = null;
     this.definitions = {};
+    this.preloadFiles = {};
     this.contextHeaders = {
       'x-authorization-keys': 'keys',
       'x-authorization-providers': 'providers'
     };
+    this._inlineCache = [];
     this._requests = {};
     this._requestCount = 0;
+    this._staticCache = {};
+    this._serverSentEvents = {};
+    this._serverSentEventInterval = 100;
   }
 
   routename (req) {
@@ -67,10 +88,14 @@ class Gateway extends EventEmitter {
     this.debug && console.log(this.formatName(this.name), this.formatRequest(req), this.formatMessage(message + '', logType));
   }
 
-  define (definitions) {
+  define (definitions, preloadFiles = {}) {
     if (!definitions || typeof definitions !== 'object') {
-      throw new Error(`Definitions must be a valid object`);
+      throw new Error(`definitions must be a valid object`);
+    }
+    if (!preloadFiles || typeof preloadFiles !== 'object') {
+      throw new Error(`preloadFiles must be a valid object`);
     }
+    this.preloadFiles = preloadFiles;
     return this.definitions = definitions;
   }
 
@@ -129,25 +154,99 @@ class Gateway extends EventEmitter {
     }, {});
     headers['access-control-allow-origin'] = headers['access-control-allow-origin'] || '*';
     headers['access-control-allow-headers'] = headers['access-control-allow-headers'] || req.headers['access-control-request-headers'] || '';
-    headers['access-control-expose-headers'] = Object.keys(headers).join(', ');
     headers['x-functionscript'] = 'true';
+    headers['access-control-expose-headers'] = Object.keys(headers).concat('x-execution-uuid').join(', ');
     return headers;
   }
 
-  __background__ (req, res, definition, params) {
-    let bgResponse = this.supportedBgModes[definition.bg && definition.bg.mode] ||
-      this.supportedBgModes[this.defaultBgMode];
-    let value = bgResponse(definition, params);
+  __beginEmptyExecution__ (req, res) {
     let headers = this.__createHeaders__(req);
-    headers['content-type'] = headers['content-type'] ||
-      (value instanceof Buffer ? 'application/octet-stream' : 'application/json');
+    headers['content-type'] = 'text/plain';
+    let value = Buffer.from('202 accepted');
+    res.headersSent || res.writeHead(202, this.__formatHeaders__(headers));
+    res.finished || res.end(value);
+  }
+
+  __beginBackgroundExecution__ (req, res, definition, params, headers) {
+    let bgResponse = this.supportedBackgroundModes[definition.background && definition.background.mode] ||
+      this.supportedBackgroundModes[this.defaultBackgroundMode];
+    let value = bgResponse(definition, params);
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = value instanceof Buffer
+      ? 'text/plain'
+      : 'application/json';
     value = value instanceof Buffer ? value : JSON.stringify(value);
-    res.finished || res.writeHead(202, this.__formatHeaders__(headers));
+    res.headersSent || res.writeHead(202, this.__formatHeaders__(headers));
     res.finished || res.end(value);
   }
 
-  __clientError__ (req, res, message, status) {
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
+  __beginServerSentEvent__ (req, res, definition, params, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'text/event-stream';
+    res.headersSent || res.writeHead(200, this.__formatHeaders__(headers));
+    // Create SSE Instance
+    let sseInstance = {
+      ids: {},
+      sent: Buffer.from([]),
+      buffer: Buffer.from([]),
+    };
+    sseInstance.emptyQueue = function () {
+      let buffer = sseInstance.buffer;
+      if (buffer.byteLength) {
+        if (res && res.headersSent && !res.finished) {
+          res.write(buffer);
+        }
+        sseInstance.sent = Buffer.concat([sseInstance.sent, buffer]);
+        sseInstance.buffer = Buffer.from([]);
+      }
+    };
+    sseInstance.interval = setInterval(() => {
+      sseInstance.emptyQueue();
+    }, this._serverSentEventInterval);
+    sseInstance.end = function () {
+      clearInterval(sseInstance.interval);
+      sseInstance.interval = null;
+      sseInstance.emptyQueue();
+    };
+    this._serverSentEvents[req._uuid] = sseInstance;
+  }
+
+  __wellKnownResponse__ (req, res, body, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    return this.__endRequest__(
+      200,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      body
+    );
+  }
+
+  __wellKnownError__ (req, res, message, status, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      status || 403,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'WellKnownError',
+          message: message
+        }
+      })
+    );
+  }
+
+  __clientError__ (req, res, message, status, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
     return this.__endRequest__(
       status || 500,
       this.__formatHeaders__(headers),
@@ -162,8 +261,10 @@ class Gateway extends EventEmitter {
     );
   }
 
-  __parameterError__ (req, res, details) {
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
+  __parameterError__ (req, res, details, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
     return this.__endRequest__(
       400,
       this.__formatHeaders__(headers),
@@ -172,15 +273,109 @@ class Gateway extends EventEmitter {
       JSON.stringify({
         error: {
           type: 'ParameterError',
-          message: 'One or more parameters provided did not match the function signature',
+          message: 'One or more parameters were invalid or missing from your request.',
+          details: details
+        }
+      })
+    );
+  }
+
+  __parameterParseError__ (req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      400,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'ParameterParseError',
+          message: msg
+        }
+      })
+    );
+  }
+
+  __originError__ (req, res, origin, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      403,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'OriginError',
+          message: `Provided origin "${origin}" can not access this resource`,
+        }
+      })
+    );
+  }
+
+  __debugError__ (req, res, message, headers) {
+    headers = headers || {};
+    message = message || `You do not have permission to debug this endpoint`;
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      403,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'DebugError',
+          message: message,
+        }
+      })
+    );
+  }
+
+  __executionModeError__ (req, res, mode, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      403,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'ExecutionModeError',
+          message: `Execution mode "${mode}" not available for this endpoint`,
+        }
+      })
+    );
+  }
+
+  __streamListenerError__ (req, res, details, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      400,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'StreamListenerError',
+          message: 'One or more streams you specified to listen to do not exist.',
           details: details
         }
       })
     );
   }
 
-  __accessSourceError__ (req, res, msg) {
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
+  __accessSourceError__ (req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
     return this.__endRequest__(
       401,
       this.__formatHeaders__(headers),
@@ -195,8 +390,10 @@ class Gateway extends EventEmitter {
     );
   }
 
-  __accessPermissionError__ (req, res, msg) {
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
+  __accessPermissionError__ (req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
     return this.__endRequest__(
       401,
       this.__formatHeaders__(headers),
@@ -211,8 +408,10 @@ class Gateway extends EventEmitter {
     );
   }
 
-  __accessAuthError__ (req, res, msg) {
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
+  __accessAuthError__ (req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
     return this.__endRequest__(
       401,
       this.__formatHeaders__(headers),
@@ -227,8 +426,10 @@ class Gateway extends EventEmitter {
     );
   }
 
-  __accessSuspendedError__ (req, res, msg) {
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
+  __accessSuspendedError__ (req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
     return this.__endRequest__(
       401,
       this.__formatHeaders__(headers),
@@ -243,8 +444,46 @@ class Gateway extends EventEmitter {
     );
   }
 
-  __paymentRequiredError__ (req, res, msg) {
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
+  __ownerSuspendedError__ (req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      401,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'OwnerSuspendedError',
+          message: msg
+        }
+      })
+    );
+  }
+
+  __ownerPaymentRequiredError__ (req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      401,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'OwnerPaymentRequiredError',
+          message: msg
+        }
+      })
+    );
+  }
+
+  __paymentRequiredError__ (req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
     return this.__endRequest__(
       402,
       this.__formatHeaders__(headers),
@@ -259,8 +498,10 @@ class Gateway extends EventEmitter {
     );
   }
 
-  __rateLimitError__ (req, res, count, period) {
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
+  __rateLimitError__ (req, res, message, count, period, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
     return this.__endRequest__(
       429,
       this.__formatHeaders__(headers),
@@ -269,7 +510,7 @@ class Gateway extends EventEmitter {
       JSON.stringify({
         error: {
           type: 'RateLimitError',
-          message: `Too many requests. The rate limit for this endpoint is ${count} requests in ${period} seconds.`,
+          message: message,
           details: {
             rate: {count, period}
           }
@@ -278,7 +519,125 @@ class Gateway extends EventEmitter {
     );
   }
 
-  __fatalError__ (req, res, msg, stack) {
+  __authRateLimitError__ (req, res, message, count, period, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      429,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'AuthRateLimitError',
+          message: message,
+          details: {
+            rate: {count, period}
+          }
+        }
+      })
+    );
+  }
+
+  __unauthRateLimitError__ (req, res, message, count, period, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      429,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'UnauthRateLimitError',
+          message: message,
+          details: {
+            rate: {count, period}
+          }
+        }
+      })
+    );
+  }
+
+  __saveError__(req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      503,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'SaveError',
+          message: msg
+        }
+      })
+    );
+  }
+
+  __maintenanceError__(req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      403,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'MaintenanceError',
+          message: msg
+        }
+      })
+    );
+  }
+
+  __updateError__(req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      409,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: {
+          type: 'UpdateError',
+          message: msg
+        }
+      })
+    );
+  }
+
+  __timeoutError__(req, res, msg, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    let error = {
+      type: 'TimeoutError',
+      message: msg || 'Function Timeout Error'
+    };
+    return this.__endRequest__(
+      504,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({
+        error: error
+      })
+    );
+  }
+
+  __fatalError__ (req, res, msg, stack, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
     let error = {
       type: 'FatalError',
       message: msg || 'Fatal Error'
@@ -292,7 +651,6 @@ class Gateway extends EventEmitter {
       );
       error.stack = stackLines.join('\n');
     }
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
     return this.__endRequest__(
       500,
       this.__formatHeaders__(headers),
@@ -304,25 +662,49 @@ class Gateway extends EventEmitter {
     );
   }
 
-  __runtimeError__ (req, res, msg, stack) {
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
+  __runtimeError__ (req, res, msg, details, stack, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    let error = {};
+    error.type = 'RuntimeError';
+    error.message = msg || 'Runtime Error';
+    if (details) {
+      error.details = details;
+    }
+    error.stack = stack;
     return this.__endRequest__(
       403,
       this.__formatHeaders__(headers),
       req,
       res,
+      JSON.stringify({error: error})
+    );
+  }
+
+  __invalidResponseHeaderError__ (req, res, details, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    return this.__endRequest__(
+      502,
+      this.__formatHeaders__(headers),
+      req,
+      res,
       JSON.stringify({
         error: {
-          type: 'RuntimeError',
-          message: msg || 'Runtime Error',
-          stack: stack
+          type: 'InvalidResponseHeaderError',
+          message: 'Your service returned invalid response headers',
+          details: details
         }
       })
     );
   }
 
-  __valueError__ (req, res, details) {
-    let headers = this.__createHeaders__(req, {'content-type': 'application/json'});
+  __valueError__ (req, res, details, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
     return this.__endRequest__(
       502,
       this.__formatHeaders__(headers),
@@ -338,6 +720,26 @@ class Gateway extends EventEmitter {
     );
   }
 
+  __autoformatError__ (req, res, msg, details, stack, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'application/json';
+    let error = {};
+    error.type = 'AutoformatError';
+    error.message = msg || 'Autoformat Error';
+    error.details = {
+      retry: 'You can try this request again with ?raw=t set in the HTTP query parameters to see the raw file contents'
+    };
+    error.stack = stack;
+    return this.__endRequest__(
+      415,
+      this.__formatHeaders__(headers),
+      req,
+      res,
+      JSON.stringify({error: error})
+    );
+  }
+
   __complete__ (req, res, body, headers, statusCode) {
     headers = this.__createHeaders__(req, headers);
     headers['content-type'] = headers['content-type'] ||
@@ -384,19 +786,19 @@ class Gateway extends EventEmitter {
     let params;
 
     if (!contentType) {
-      throw new Error('Must Supply Content-Type');
+      throw new Error('Must supply "Content-Type" header');
     } else if (!buffer.length) {
       params = query;
       convert = true;
     } else if (buffer.length && Object.keys(query).length) {
-      throw new Error('Can not specify query parameters and POST data');
+      throw new Error('Can not specify both query parameters and POST data');
     } else if (contentType === 'application/x-www-form-urlencoded') {
       try {
         params = this.__parseParamsFromEncodedURL__(buffer.toString());
         buffer = Buffer.from([]);
         convert = true;
       } catch (e) {
-        throw new Error('Invalid URL Encoded Data');
+        throw e;
       }
     } else if (contentType === 'application/json') {
       try {
@@ -406,13 +808,43 @@ class Gateway extends EventEmitter {
         throw new Error('Invalid JSON');
       }
     } else if (contentType === 'multipart/form-data') {
-      params = this.__parseParamsFromMultipartForm__(buffer, contentType, contentTypeParameters)
+      params = this.__parseParamsFromMultipartForm__(buffer, contentType, contentTypeParameters);
+    } else if (contentType === 'application/xml' || contentType === 'application/atom+xml') {
+      try {
+        params = this.__parseParamsFromXML__(buffer.toString());
+        buffer = Buffer.from([]);
+      } catch (e) {
+        throw new Error('Invalid XML');
+      }
+    } else if (contentType === 'text/plain') {
+      // Check to see if text/plain provides valid JSON
+      // This fallback is meant to handle webhooks that don't send the right
+      // content-type headers -- eg vimeo
+      try {
+        params = JSON.parse(buffer.toString());
+        if (typeof params === 'string') {
+          // vimeo webhook hack
+          params = JSON.parse(params);
+        }
+        if (params && typeof params === 'object' && !Array.isArray(params)) {
+          buffer = Buffer.from([]);
+          contentType = 'application/json';
+        } else {
+          throw new Error('Aborting "text/plain" conversion to JSON');
+        }
+      } catch (e) {
+        // do nothing
+      }
     }
 
     let type = types.check(params);
 
     if (type !== 'object') {
-      throw new Error('Invalid JSON: Must be Object');
+      if (contentType === 'application/json') {
+        params = {};
+      } else {
+        throw new Error('Invalid JSON: Must be an Object');
+      }
     }
 
     if (proxyParameters) {
@@ -455,7 +887,7 @@ class Gateway extends EventEmitter {
     let nameRegex = /name="([^"]*)"/;
     let contentTypeRegex = /Content-Type: ([^\s]+)*/
 
-    let formString = '\r\n' + formBuffer.toString()
+    let formString = '\r\n' + formBuffer.toString('latin1')
     let params = formString
       .split(this.__getMultipartFormBoundary__([contentType, ...contentTypeParameters].join(';')))
       .slice(1, -1)
@@ -477,7 +909,7 @@ class Gateway extends EventEmitter {
             }
             break;
           default:
-            params[key] = Buffer.from(value);
+            params[key] = Buffer.from(value, 'latin1');
             break;
         }
 
@@ -490,10 +922,117 @@ class Gateway extends EventEmitter {
 
   __parseParamsFromEncodedURL__ (str) {
     let rawParams = querystring.parse(str);
-    return Object.keys(rawParams).reduce((params, paramName) => {
-      params[paramName] = rawParams[paramName];
+    // We need to grab keys like key1[0][].key2.key3[]=5
+    // Which would populate {key1:[[{key2:{key3:[5]}}]]}
+    // parseKeys is to make sure bracket balancing works as expected
+    let parseKeys = paramName => {
+      let keys = [];
+      let balancing = [];
+      let curKey = '';
+      for (let c = 0; c < paramName.length; c++) {
+        if (paramName[c] === '[') {
+          balancing.push('[');
+          curKey += paramName[c];
+        } else if (paramName[c] === ']') {
+          balancing.pop();
+          curKey += paramName[c];
+        } else if (paramName[c] === '.' && !balancing.length) {
+          keys.push(curKey);
+          curKey = '';
+        } else {
+          curKey += paramName[c];
+        }
+      }
+      keys.push(curKey);
+      return keys;
+    };
+    let params = Object.keys(rawParams).reduce((params, paramName) => {
+      let value = rawParams[paramName];
+      let keys = parseKeys(paramName);
+      let objectScope = params;
+      for (let i = 0; i < keys.length; i++) {
+        let objName = keys[i];
+        let arrayMatches = objName.match(/^(.*?)((\[([^\]]*)\])+?)$/);
+        if (arrayMatches) {
+          let name = arrayMatches[1];
+          let curObj = objectScope[name] = objectScope[name] || {
+            '.type': 'Array',
+            indexed: [],
+            pushed: []
+          };
+          let indices = arrayMatches[2].slice(1, -1).split('][');
+          indices.forEach((index, j) => {
+            let descriptiveName = keys.slice(0, i + 1).join('.') + '[' + indices.slice(0, j + 1).join('][') + ']';
+            if (curObj['.type'] !== 'Array') {
+              throw new Error(`${descriptiveName}: already set, can not set as Array`);
+            }
+            let item = (j === indices.length - 1 && i === keys.length - 1)
+              ? value
+              : j === indices.length - 1
+                ? {}
+                : {
+                    '.type': 'Array',
+                    indexed: [],
+                    pushed: []
+                  };
+            if (index) {
+              let n = parseInt(index);
+              if (isNaN(n) || n !== parseFloat(index)) {
+                throw new Error(`${descriptiveName}: Array indices in URL encoded values must be integer values`);
+              } else if (n < 0) {
+                throw new Error(`${descriptiveName}: Array indices in URL encoded values must be > 0`);
+              } else if (n > 65535) {
+                throw new Error(`${descriptiveName}: Array indices in URL encoded values limited to 65535`);
+              }
+              curObj.indexed = curObj.indexed.concat(
+                Array(Math.max(0, n - curObj.indexed.length)).fill(null)
+              );
+              curObj.indexed[n] = item;
+              curObj = item;
+            } else {
+              curObj.pushed = curObj.pushed.concat(item);
+              curObj = item;
+            }
+          });
+          objectScope = curObj;
+        } else if (i < keys.length - 1) {
+          let curObj = objectScope[objName] = objectScope[objName] || {};
+          if (typeof curObj !== 'object') {
+            throw new Error(`${keys.slice(0, i + 1).join('.')}: can not set subfield "${keys[i + 1]}" on value "${curObj}"`);
+          }
+          if (curObj['.type'] === 'Array') {
+            throw new Error(`${keys.slice(0, i + 1).join('.')}: already set as Array, can not set as Object`);
+          }
+          objectScope = curObj;
+        } else if (objName in objectScope) {
+          throw new Error(`${keys.slice(0, i + 1).join('.')}: already set`);
+        } else {
+          objectScope[objName] = value;
+        }
+      }
       return params;
     }, {});
+    let convertArrays = (obj) => {
+      if (Array.isArray(obj)) {
+        return obj.map(convertArrays);
+      } else if (obj && typeof obj === 'object' && obj['.type'] === 'Array') {
+        return convertArrays([].concat(obj.indexed, obj.pushed));
+      } else if (obj && typeof obj === 'object') {
+        return Object.keys(obj).reduce((newObj, key) => {
+          newObj[key] = convertArrays(obj[key]);
+          return newObj;
+        }, {});
+      } else {
+        return obj;
+      }
+    };
+    return convertArrays(params);
+  }
+
+  __parseParamsFromXML__ (str) {
+    let validate = true;
+    let parsedData = xmlParser.parse(str, {arrayMode: false, parseNodeValue: false, ignoreAttributes : false}, validate);
+    return parsedData;
   }
 
   __validateParameters__ (parsed, definition) {
@@ -502,12 +1041,26 @@ class Gateway extends EventEmitter {
     let convert = parsed.convert;
     let errors = {};
 
+    // Handle special parameters
+    let specialParams = ['_background', '_stream', '_debug'];
+    specialParams.forEach(key => {
+      if (params[key]) {
+        try {
+          params[key] = types.parse('object', null, params[key], convert);
+        } catch (e) {
+          params[key] = params[key];
+        }
+      }
+    });
+
     let paramsList = definition.params.map(param => {
+      // Catch where there is a mismatch
+      let paramMismatch = {};
       let nullable = param.defaultValue === null;
       let value = params[param.name];
       value = (value === undefined || value === null) ? param.defaultValue : value;
       try {
-        value = types.parse(param.type, value, convert);
+        value = types.parse(param.type, param.schema, value, convert);
       } catch (e) {
         value = value;
       }
@@ -521,13 +1074,17 @@ class Gateway extends EventEmitter {
           param.type, value, nullable,
           param.members ||
             (param.alternateSchemas || []).concat(param.schema ? [param.schema] : []),
-          param.options && param.options.values
+          param.options && param.options.values,
+          param.range,
+          [param.name],
+          paramMismatch
         )
       ) {
         let type = types.check(value);
         errors[param.name] = {
           message: `invalid value: ${Buffer.isBuffer(value) ? `Buffer[${value.length}]` : JSON.stringify(value, null, 2)} (${type}), expected (${param.type})`,
           invalid: true,
+          mismatch: paramMismatch.stack && paramMismatch.stack.join('.'),
           expected: {
             type: param.type
           },
@@ -536,6 +1093,9 @@ class Gateway extends EventEmitter {
             type: type
           }
         };
+        if (!errors[param.name].mismatch) {
+          delete errors[param.name].mismatch;
+        }
         if (param.schema) {
           errors[param.name].expected.schema = param.schema;
           if (param.alternateSchemas) {
@@ -543,17 +1103,19 @@ class Gateway extends EventEmitter {
           }
         } else if (param.members) {
           errors[param.name].expected.members = param.members
+        } else if (param.options && param.options.values) {
+          errors[param.name].message = `${errors[param.name].message} matching one of ${JSON.stringify(param.options.values)}`;
+          errors[param.name].expected.values = param.options.values;
         }
       } else {
         try {
-          value = types.sanitize(param.type, value);
+          value = types.sanitize(param.type, value, param.range);
         } catch (e) {
           errors[param.name] = {
             message: e.message,
             invalid: true
           };
         }
-
         if (param.type === 'enum') {
           let member = param.members.find(m => m[0] === value);
           value = member ? member[1] : param.defaultValue;
@@ -571,6 +1133,101 @@ class Gateway extends EventEmitter {
 
   }
 
+  __validateDebug__ (debugObject, streams) {
+    streams = streams || [];
+    debugObject = typeof debugObject === 'object'
+      ? Array.isArray(debugObject) || Buffer.isBuffer(debugObject)
+        ? {}
+        : debugObject || {}
+      : {};
+    let streamObject = {};
+    Object.keys(debugObject).forEach(key => {
+      if (
+        key === '*' ||
+        key === '@begin' ||
+        key === '@stdout' ||
+        key === '@stderr' ||
+        key === '@error'
+      ) {
+        return;
+      } else {
+        let stream = streams.find(stream => stream.name === key);
+        if (!stream) {
+          throw new Error(`Invalid debug listener: "${key}"`);
+        } else {
+          return;
+        }
+      }
+    });
+    return true;
+  }
+
+  __validateStreams__ (streamObject, streams) {
+    streams = streams || [];
+    streamObject = typeof streamObject === 'object'
+      ? Array.isArray(streamObject) || Buffer.isBuffer(streamObject)
+        ? {}
+        : streamObject || {}
+      : {};
+    let errors = {};
+    Object.keys(streamObject).forEach(key => {
+      if (key === '*') {
+        return;
+      } else {
+        let stream = streams.find(stream => stream.name === key);
+        if (!stream) {
+          errors[key] = {
+            message: `No such stream for this function: "${key}"`,
+            invalid: true
+          }
+        }
+      }
+    });
+    if (Object.keys(errors).length) {
+      return {valid: false, errors: errors};
+    } else {
+      return {valid: true};
+    }
+  }
+
+  __validateResponseHeaders__ (responseHeaders) {
+    let errors = {};
+    let validatedHeaders = Object.keys(responseHeaders).reduce((validatedHeaders, headerName) => {
+      if (typeof headerName !== 'string') {
+        errors[headerName] = {
+          message: `Invalid response header name "${headerName}"`,
+          invalid: true
+        }
+      } else if (headerName.match(/\s/)) {
+        errors[headerName] = {
+          message: `Response header name "${headerName}" may not contain space characters`,
+          invalid: true
+        };
+      } else if (headerName.match(/[^A-Za-z0-9\-_]/gi)) {
+        errors[headerName] = {
+          message: `Response header name "${headerName}" must only contain alphanumeric values, - and _`,
+          invalid: true
+        };
+      } else if (
+        typeof responseHeaders[headerName] !== 'string' &&
+        typeof responseHeaders[headerName] !== 'boolean' &&
+        typeof responseHeaders[headerName] !== 'number'
+      ) {
+        errors[headerName] = {
+          message: `The value of your "${headerName}" response header is missing or invalid`,
+          invalid: true
+        };
+      } else {
+        validatedHeaders[headerName] = responseHeaders[headerName];
+      }
+      return validatedHeaders;
+    }, {});
+    return {
+      headers: validatedHeaders,
+      errors: Object.keys(errors).length ? errors: null
+    };
+  }
+
   __httpHandler__ (req, res) {
 
     req._uuid = uuid.v4();
@@ -580,12 +1237,14 @@ class Gateway extends EventEmitter {
     let urlinfo = url.parse(req.url);
     let pathinfo = urlinfo.pathname.split(':');
     let pathname = pathinfo[0];
-    let pathquery = this.__parseParamsFromEncodedURL__(pathinfo[1] || '');
     req.url = [pathname, urlinfo.search].join('');
 
-    if ('bg' in pathquery) {
-      req._background = true;
-      this.log(req, `Background Function Initiated`);
+    // Legacy, will deprecate
+    let pathquery;
+    try {
+      pathquery = this.__parseParamsFromEncodedURL__(pathinfo[1] || '');
+    } catch (e) {
+      return this.__parameterParseError__(req, res, e.message, 400);
     }
 
     if (
@@ -611,6 +1270,11 @@ class Gateway extends EventEmitter {
       return this.__options__(req, res);
     }
 
+    if ('bg' in pathquery) {
+      this.log(req, `Empty Execution Initiated`);
+      this.__beginEmptyExecution__(req, res);
+    }
+
     let buffers = [];
     let size = 0;
     req.on('data', chunk => {
@@ -642,28 +1306,90 @@ class Gateway extends EventEmitter {
             return this.__accessAuthError__(req, res, err.message);
           } else if (err.accessSuspendedError) {
             return this.__accessSuspendedError__(req, res, err.message);
+          } else if (err.ownerSuspendedError) {
+            return this.__ownerSuspendedError__(req, res, err.message);
+          } else if (err.ownerPaymentRequiredError) {
+            return this.__ownerPaymentRequiredError__(req, res, err.message);
           } else if (err.paymentRequiredError) {
             return this.__paymentRequiredError__(req, res, err.message);
           } else if (err.rateLimitError) {
-            return this.__rateLimitError__(req, res, err.rate && err.rate.count, err.rate && err.rate.period);
+            return this.__rateLimitError__(req, res, err.message, err.rate && err.rate.count, err.rate && err.rate.period);
+          } else if (err.authRateLimitError) {
+            return this.__authRateLimitError__(req, res, err.message, err.rate && err.rate.count, err.rate && err.rate.period);
+          } else if (err.unauthRateLimitError) {
+            return this.__unauthRateLimitError__(req, res, err.message, err.rate && err.rate.count, err.rate && err.rate.period);
+          } else if (err.saveError) {
+            return this.__saveError__(req, res, err.message);
+          } else if (err.maintenanceError) {
+            return this.__maintenanceError__(req, res, err.message);
+          } else if (err.updateError) {
+            return this.__updateError__(req, res, err.message);
           }
           this.log(req, `ClientError: ${err.message}`, 'error');
           return this.__clientError__(req, res, err.message, err.statusCode || 400);
         }
 
+        if (definition.hasOwnProperty('wellKnown')) {
+          const wellKnown = definition.wellKnown;
+          const definitions = definition.definitions;
+          const pluginSupported = !!data.pluginSupported;
+          const pluginAuthorized = !!data.pluginAuthorized;
+          if (!pluginSupported) {
+            return this.__wellKnownError__(req, res, `Plugin not supported for this service`, 404);
+          } else if (!pluginAuthorized) {
+            return this.__wellKnownError__(req, res, `Plugin access not authorized`, 403);
+          }
+          let plugin;
+          try {
+            plugin = wellKnowns.validatePlugin(data.plugin, data.origin);
+          } catch (e) {
+            return this.__wellKnownError__(req, res, `Failed to validate plugin: ${e.message}`, 502);
+          }
+          const server = data.server;
+          const origin = data.origin;
+          const identifier = data.identifier;
+          let httpResponse;
+          try {
+            httpResponse = wellKnowns.handlers[wellKnown](definitions, plugin, server, origin, identifier);
+          } catch (e) {
+            return this.__fatalError__(req, res, `Error running .well-known handler for "${wellKnown}"`, e.stack);
+          }
+          return this.__wellKnownResponse__(req, res, httpResponse.body, httpResponse.headers);
+        }
+
+        let headers = {};
+        headers['x-execution-uuid'] = req._uuid;
+        if (definition.origins) {
+          if (
+            req.headers['origin'] &&
+            definition.origins.indexOf(req.headers['origin']) !== -1
+          ) {
+            headers['access-control-allow-origin'] = req.headers['origin'];
+          } else {
+            headers['access-control-allow-origin'] = '!';
+            return this.__originError__(req, res, req.headers['origin'], headers);
+          }
+        }
+
         let [contentType, ...contentTypeParameters] = (req.method === 'GET' || req.method === 'DELETE')
           ? ['application/x-www-form-urlencoded']
           : (req.headers['content-type'] || '').split(';');
 
         let convert = 'x-convert-strings' in req.headers;
-        let query = this.__parseParamsFromEncodedURL__(urlinfo.query);
+
+        let query;
         let parsed;
+        try {
+          query = this.__parseParamsFromEncodedURL__(urlinfo.query);
+        } catch (e) {
+          return this.__parameterParseError__(req, res, e.message);
+        }
 
         try {
           parsed = this.__parseParameters__(contentType, contentTypeParameters, convert, query, buffer, definition, proxyParameters);
         } catch (e) {
           this.log(req, `Bad Request: ${e.message}`, 'error');
-          return this.__clientError__(req, res, `Bad Request: ${e.message}`, 400);
+          return this.__parameterParseError__(req, res, e.message);
         }
 
         let validated = this.__validateParameters__(parsed, definition);
@@ -672,22 +1398,78 @@ class Gateway extends EventEmitter {
           return this.__parameterError__(req, res, validated.errors);
         }
 
-        if (req._background) {
-          this.log(req, `Background Function Responded to Client`);
-          this.__background__(req, res, definition, validated.params);
+        if (
+          validated.params._debug === '' ||
+          validated.params._debug
+        ) {
+          headers['x-debug'] = true;
+          if (!data.canDebug) {
+            this.log(req, `Debug Error`, 'error');
+            return this.__debugError__(req, res, null, headers);
+          } else if (
+            validated.params._background === '' ||
+            validated.params._background
+          ) {
+            this.log(req, `Debug Error`, 'error');
+            return this.__debugError__(req, res, 'Can not debug with "background" mode set', headers);
+          } else {
+            try {
+              this.__validateDebug__(validated.params._debug, definition.streams);
+            } catch (e) {
+              this.log(req, `Debug Error`, 'error');
+              return this.__debugError__(req, res, e.message, headers);
+            }
+            // Set data.debug to true
+            data.debug = true;
+          }
+        }
+
+        if (
+          validated.params._background === '' ||
+          validated.params._background
+        ) {
+          if (!definition.background) {
+            return this.__executionModeError__(req, res, 'background', headers);
+          } else {
+            this.log(req, `Background Function Responded to Client`);
+            this.__beginBackgroundExecution__(req, res, definition, validated.params, headers);
+          }
+        } else if (
+          validated.params._stream === '' ||
+          validated.params._stream
+        ) {
+          if (!definition.streams || !definition.streams.length) {
+            return this.__executionModeError__(req, res, 'stream', headers);
+          } else {
+            let streamValidated = this.__validateStreams__(validated.params._stream, definition.streams);
+            if (streamValidated.errors) {
+              this.log(req, `Stream Listener Error`, 'error');
+              return this.__streamListenerError__(req, res, streamValidated.errors, headers);
+            }
+            this.log(req, `Begin Server-Sent Event`);
+            this.__beginServerSentEvent__(req, res, definition, validated.params, headers);
+          }
+        } else if (data.debug) {
+          // Always debug in stream mode
+          this.__beginServerSentEvent__(req, res, definition, validated.params, headers);
         }
 
+        let context = this.createContext(req, definition, validated.params, data, buffer);
+
         let functionArgs = definition.context ?
-          validated.paramsList.concat(this.createContext(req, definition, validated.params, data, buffer)) :
+          validated.paramsList.concat(context) :
           validated.paramsList.slice();
 
+        data.context = context;
+
         setImmediate(() => {
           this.__requestHandler__(
             req,
             res,
             definition,
             data,
-            functionArgs
+            functionArgs,
+            headers
           );
         });
 
@@ -699,53 +1481,84 @@ class Gateway extends EventEmitter {
 
   __endRequest__ (status, headers, req, res, value) {
     if (!res.finished) {
-      let bytes = null;
-      if (value) {
-        bytes = value;
-        let contentType = headers['Content-Type'].split(';')[0];
-        let acceptEncoding = req.headers['accept-encoding'];
-        let canCompress = !!{
-          'text/plain': 1,
-          'text/html': 1,
-          'text/xml': 1,
-          'text/json': 1,
-          'text/javascript': 1,
-          'application/json': 1,
-          'application/xml': 1,
-          'application/javascript': 1,
-          'application/octet-stream': 1
-        }[contentType];
-        if (canCompress) {
-          try {
-            if (acceptEncoding.match(/\bgzip\b/gi)) {
-              bytes = zlib.gzipSync(bytes);
-              headers['Content-Encoding'] = 'gzip';
-            } else if (acceptEncoding.match(/\bdeflate\b/gi)) {
-              bytes = zlib.deflateSync(bytes);
-              headers['Content-Encoding'] = 'deflate';
+      if (!res.headersSent) {
+        // If we haven't sent headers it's a normal request
+        let bytes = null;
+        if (value) {
+          bytes = value;
+          let contentType = headers['Content-Type'].split(';')[0];
+          let acceptEncoding = req.headers['accept-encoding'];
+          let canCompress = !!{
+            'text/plain': 1,
+            'text/html': 1,
+            'text/xml': 1,
+            'text/json': 1,
+            'text/javascript': 1,
+            'application/json': 1,
+            'application/xml': 1,
+            'application/atom+xml': 1,
+            'application/javascript': 1,
+            'application/octet-stream': 1
+          }[contentType];
+          if (canCompress) {
+            try {
+              if (acceptEncoding.match(/\bgzip\b/gi)) {
+                bytes = zlib.gzipSync(bytes);
+                headers['Content-Encoding'] = 'gzip';
+              } else if (acceptEncoding.match(/\bdeflate\b/gi)) {
+                bytes = zlib.deflateSync(bytes);
+                headers['Content-Encoding'] = 'deflate';
+              }
+            } catch (e) {
+              bytes = value;
             }
-          } catch (e) {
-            bytes = value;
           }
+          headers['Content-Length'] = Buffer.byteLength(bytes);
+        }
+        res.writeHead(status, headers);
+        res.end(bytes);
+      } else {
+        // If we have sent headers, it's a Server-Sent Event
+        this.createServerSentEvent(
+          req._uuid,
+          -1,
+          '@response',
+          JSON.stringify({
+            statusCode: status,
+            headers: headers,
+            body: Buffer.isBuffer(value)
+              ? JSON.stringify({_base64: value.toString('base64')})
+              : value
+          })
+        );
+        let sseInstance = this._serverSentEvents[req._uuid];
+        if (sseInstance) {
+          sseInstance.end();
         }
-        headers['Content-Length'] = Buffer.byteLength(bytes);
+        res.end();
       }
-      res.writeHead(status, headers);
-      res.end(bytes);
     }
     this.end(req, value);
     delete this._requests[req._uuid];
+    delete this._serverSentEvents[req._uuid];
     this._requestCount -= 1;
     !this._requestCount && this.emit('empty');
   }
 
-  __requestHandler__ (req, res, definition, data, functionArgs) {
-    let nullable = definition.returns.defaultValue === null;
+  __requestHandler__ (req, res, definition, data, functionArgs, headers) {
+    let nullable = (definition.returns || {}).defaultValue === null;
     this.log(req, `Execution Start`);
     let t = new Date().valueOf();
-    this.execute(definition, functionArgs, data, (err, value, headers) => {
+    let isStatic = (
+      definition.format &&
+      definition.format.language &&
+      definition.format.language === 'static'
+    );
+    this.execute(definition, functionArgs, data, headers, (err, value, headers, executionUuid) => {
       let dt = new Date().valueOf() - t;
       err = err === undefined ? null : err;
+      // Catch where there is a mismatch
+      let returnsMismatch = {};
       if (err !== null) {
         if (!(err instanceof Error)) {
           let jsonErr;
@@ -760,7 +1573,7 @@ class Gateway extends EventEmitter {
             `Use callback(new Error('description')) to pass an error, or callback(null, 'result') ` +
             `to pass a result without an error.`;
           this.log(req, `Runtime Error (${dt}ms): ${msg}`, 'error');
-          return this.__runtimeError__(req, res, msg);
+          return this.__runtimeError__(req, res, msg, null, null, headers);
         } else if (err.thrown) {
           let message = err.message;
           if (err.hasOwnProperty('value')) {
@@ -771,20 +1584,26 @@ class Gateway extends EventEmitter {
             }
           }
           this.log(req, `Runtime Error Thrown (${dt}ms): ${message}`, 'error');
-          return this.__runtimeError__(req, res, message, err.stack);
+          return this.__runtimeError__(req, res, message, err.details, err.stack, headers);
+        } else if (err.timeoutError) {
+          this.log(req, `Timeout Error (${dt}ms): ${err.message}`, 'error');
+          return this.__timeoutError__(req, res, err.message, headers);
         } else if (err.fatal) {
           this.log(req, `Fatal Error (${dt}ms): ${err.message}`, 'error');
-          return this.__fatalError__(req, res, err.message, err.stack);
+          return this.__fatalError__(req, res, err.message, err.stack, headers);
         } else {
           this.log(req, `Runtime Error (${dt}ms): ${err.message}`, 'error');
-          return this.__runtimeError__(req, res, err.message, err.stack);
+          return this.__runtimeError__(req, res, err.message, err.details, err.stack, headers);
         }
       } else if (
         !types.validate(
           definition.returns.type, value, nullable,
           definition.returns.members ||
             (definition.returns.alternateSchemas || []).concat(definition.returns.schema ? [definition.returns.schema] : []),
-          definition.returns.options && definition.returns.options.values
+          definition.returns.options && definition.returns.options.values,
+          definition.returns.range,
+          [definition.returns.name || '$'],
+          returnsMismatch
         )
       ) {
         let returnType = definition.returns.type;
@@ -793,6 +1612,7 @@ class Gateway extends EventEmitter {
           returns: {
             message: `invalid return value: ${Buffer.isBuffer(value) ? `Buffer[${value.length}]` :JSON.stringify(value, null, 2)} (${type}), expected (${returnType})`,
             invalid: true,
+            mismatch: returnsMismatch.stack && returnsMismatch.stack.join('.'),
             expected: {
               type: returnType
             },
@@ -802,6 +1622,9 @@ class Gateway extends EventEmitter {
             }
           }
         };
+        if (!details.returns.mismatch) {
+          delete details.returns.mismatch;
+        }
         if (definition.returns.schema) {
           details.returns.expected.schema = definition.returns.schema;
           if (definition.returns.alternateSchemas) {
@@ -811,10 +1634,10 @@ class Gateway extends EventEmitter {
           details.returns.expected.members = definition.returns.members;
         }
         this.log(req, `Value Error (${dt}ms): ${details.returns.message}`, 'error');
-        return this.__valueError__(req, res, details);
+        return this.__valueError__(req, res, details, headers);
       } else {
         try {
-          value = types.sanitize(definition.returns.type, value);
+          value = types.sanitize(definition.returns.type, value, definition.returns.range);
         } catch (e) {
           let details = {
             returns: {
@@ -823,29 +1646,65 @@ class Gateway extends EventEmitter {
             }
           };
           this.log(req, `Value Error (${dt}ms): ${details.returns.message}`, 'error');
-          return this.__valueError__(req, res, details);
+          return this.__valueError__(req, res, details, headers);
         }
         if (definition.returns.type === 'enum') {
           let member = definition.returns.members.find(m => m[0] === value);
           value = member[1];
         }
+        let httpResponse;
+        try {
+          httpResponse = types.httpResponse(definition.returns.type, value, headers);
+        } catch (e) {
+          let details = {
+            returns: {
+              message: e.message,
+              invalid: true
+            }
+          };
+          this.log(req, `Value Error (${dt}ms): ${details.returns.message}`, 'error');
+          return this.__valueError__(req, res, details, headers);
+        }
+        if (isStatic && !functionArgs.slice().pop().params.raw) {
+          try {
+            httpResponse = this.__autoformat__(httpResponse);
+          } catch (err) {
+            this.log(req, `Autoformat Error (${dt}ms): ${err.message}`, 'error');
+            return this.__autoformatError__(req, res, err.message, err.details, err.stack, httpResponse.headers);
+          }
+        }
+        let validated = this.__validateResponseHeaders__(httpResponse.headers);
+        if (validated.errors) {
+          this.log(req, `Invalid Response Header Error (${dt}ms)`, 'error');
+          return this.__invalidResponseHeaderError__(req, res, validated.errors, validated.headers);
+        }
         this.log(req, `Execution Complete (${dt}ms)`);
-        let httpResponse = types.httpResponse(definition.returns.type, value, headers);
         return this.__complete__(req, res, httpResponse.body, httpResponse.headers, httpResponse.statusCode);
       }
     });
 
   }
 
+  __autoformat__ (httpResponse) {
+    return httpResponse;
+  }
+
   findDefinition (definitions, name) {
     name = name.replace(/^\/?(.*?)\/?$/gi, '$1');
     let definition = definitions[name];
     if (!definition) {
-      let subname = name;
-      definition = definitions[`${subname}:notfound`];
-      while (subname && !definition) {
-        subname = subname.substr(0, subname.lastIndexOf('/'));
+      if (wellKnowns.handlers[name]) {
+        return {
+          wellKnown: name,
+          definitions: definitions
+        };
+      } else {
+        let subname = name;
         definition = definitions[`${subname}:notfound`];
+        while (subname && !definition) {
+          subname = subname.substr(0, subname.lastIndexOf('/'));
+          definition = definitions[`${subname}:notfound`];
+        }
       }
     }
     if (!definition) {
@@ -865,7 +1724,15 @@ class Gateway extends EventEmitter {
       e.statusCode = 404;
       return callback(e);
     }
-    return callback(null, definition, {}, buffer);
+    let data = {};
+    data.canDebug = true;
+    data.pluginSupported = true;
+    data.pluginAuthorized = true;
+    data.plugin = {};
+    data.server = 'FunctionScript Gateway';
+    data.origin = urlinfo.origin || 'localhost';
+    data.identifier = 'service.localhost';
+    return callback(null, definition, data, buffer);
   }
 
   createContext (req, definition, params, data, buffer) {
@@ -875,11 +1742,17 @@ class Gateway extends EventEmitter {
     context.path = context.alias.split('/');
     context.params = params;
     context.remoteAddress = req.connection.remoteAddress;
+    context.uuid = req._uuid;
     context.http = {};
     context.http.url = req.url;
     context.http.method = req.method;
     context.http.headers = req.headers;
     context.http.body = buffer.toString('utf8');
+    try {
+      context.http.json = JSON.parse(buffer.toString('utf8'));
+    } catch (e) {
+      context.http.json = null;
+    }
     context.user = null;
     context.service = null;
     context.function = {
@@ -909,52 +1782,426 @@ class Gateway extends EventEmitter {
       keys[key] = context.keys[key] || null;
       return keys;
     }, {});
+    context.stream = this.__stream__.bind(this, definition.streams, context.uuid, null);
     return context;
   }
 
-  execute (definition, functionArgs, data, callback) {
-    let fn;
-    try {
-      let rpath = require.resolve(path.join(process.cwd(), this.root, definition.pathname));
-      delete require[rpath];
-      fn = require(rpath);
-    } catch (e) {
-      if (!(e instanceof Error)) {
-        let value = e;
-        e = new Error(e || '');
-        e.value = value;
+  __streamError__ (executionUuid, logId, eventName) {
+    let req = this._requests[executionUuid];
+    this.createServerSentEvent(
+      executionUuid,
+      logId,
+      '@error',
+      JSON.stringify({
+        type: 'StreamError',
+        message: [
+          `No such stream "${eventName}" in function definition.`,
+          ` Please use the syntax "@stream {string} name description"`,
+          ` after @params to define a stream.`,
+        ].join('')
+      })
+    );
+  }
+
+  __streamParameterError__ (executionUuid, logId, eventName, details) {
+    let req = this._requests[executionUuid];
+    this.log(req, `Stream Parameter Error: ${details[eventName].message}`, 'error');
+    this.createServerSentEvent(
+      executionUuid,
+      logId,
+      '@error',
+      JSON.stringify({
+        type: 'StreamError',
+        message: [
+          `Stream Parameter Error: "${eventName}".`,
+          ` Please make sure the data type you are sending to the stream matches`,
+          ` the definition for the stream in the function.`
+        ].join(''),
+        details: details
+      })
+    );
+  }
+
+  __stream__ (streams, executionUuid, logId, eventName, value) {
+    value = value === void 0
+      ? null
+      : value;
+    let stream = (streams || []).find(param => param.name === eventName);
+    if (!stream) {
+      if (
+        eventName === '@begin' ||
+        eventName === '@stdout' ||
+        eventName === '@stderr' ||
+        eventName === '@error'
+      ) {
+        this.createServerSentEvent(
+          executionUuid,
+          logId,
+          eventName,
+          JSON.stringify(value)
+        );
+      } else {
+        this.__streamError__(executionUuid, logId, eventName);
+      }
+    } else {
+      let nullable = stream.defaultValue === null;
+      let details = {};
+      let streamMismatch = {};
+      if (
+        !types.validate(
+          stream.type, value, nullable,
+          stream.members ||
+            (stream.alternateSchemas || []).concat(stream.schema ? [stream.schema] : []),
+          stream.options && stream.options.values,
+          stream.range,
+          [stream.name || '$'],
+          streamMismatch
+        )
+      ) {
+        let returnType = stream.type;
+        let type = types.check(value);
+        let details = {};
+        details[eventName] = {
+          message: `invalid value: ${Buffer.isBuffer(value) ? `Buffer[${value.length}]` :JSON.stringify(value, null, 2)} (${type}), expected (${returnType})`,
+          invalid: true,
+          mismatch: streamMismatch.stack && streamMismatch.stack.join('.'),
+          expected: {
+            type: returnType
+          },
+          actual: {
+            value: value,
+            type: type
+          }
+        };
+        if (!details[eventName].mismatch) {
+          delete details[eventName].mismatch;
+        }
+        if (stream.schema) {
+          details[eventName].expected.schema = stream.schema;
+          if (stream.alternateSchemas) {
+            details[eventName].expected.alternateSchemas = stream.alternateSchemas;
+          }
+        } else if (stream.members) {
+          details[eventName].expected.members = stream.members;
+        }
+        this.__streamParameterError__(executionUuid, logId, eventName, details);
+      } else {
+        try {
+          value = types.sanitize(stream.type, value, stream.range);
+        } catch (e) {
+          let details = {};
+          details[eventName] = {
+            message: e.message,
+            invalid: true
+          };
+          this.__streamParameterError__(executionUuid, logId, eventName, details);
+          return;
+        }
+        if (stream.type === 'enum') {
+          let member = stream.members.find(m => m[0] === value);
+          value = member[1];
+        }
+        this.createServerSentEvent(
+          executionUuid,
+          logId,
+          eventName,
+          JSON.stringify(types.serialize(stream.type, value))
+        );
       }
-      e.fatal = true;
-      return callback(e);
     }
-    // Catch unhandled promise rejections once, starting now.
-    //   This applies to local testing only.
-    process.removeAllListeners('unhandledRejection');
-    process.once('unhandledRejection', (err, p) => callback(err));
-    if (definition.format.async) {
-      fn.apply(null, functionArgs)
-        .then(result => callback(null, result))
-        .catch(e => {
+  }
+
+  createServerSentEvent (executionUuid, logId, eventName, value, silent = false, greaterThanTimestamp = null) {
+    let sseInstance = this._serverSentEvents[executionUuid];
+    let timestamp = new Date().toISOString();
+    // Incremenet this counter so IDs don't overlap
+    let i = 0;
+    if (greaterThanTimestamp && timestamp <= greaterThanTimestamp) {
+      let unixTimestamp = new Date(greaterThanTimestamp).valueOf();
+      timestamp = new Date(unixTimestamp + 1).toISOString();
+    }
+    if (silent || sseInstance) {
+      let printId = true;
+      if (logId === -1) {
+        printId = false;
+        logId = null;
+      }
+      if (!logId) {
+        let lpad = (i, len) => {
+          let s = i.toString();
+          return '0'.repeat(Math.max(0, len - s.length)) + s;
+        };
+        let endChar = timestamp[timestamp.length - 1];
+        let time = timestamp.slice(0, -1);
+        logId = [time, lpad(i++, 6), endChar, '/', executionUuid].join('');
+        while (!silent && sseInstance.ids[logId]) {
+          logId = [time, lpad(i++, 6), endChar, '/', executionUuid].join('');
+        }
+      }
+      if (silent || !sseInstance.ids[logId]) {
+        if (!silent) {
+          sseInstance.ids[logId] = true;
+          sseInstance.buffer = Buffer.concat([
+            sseInstance.buffer,
+            Buffer.from([
+              printId ? `id: ${logId}\n` : '',
+              eventName ? `event: ${eventName}\n` : '',
+              `data: ${value}\n\n`,
+            ].join(''))
+          ]);
+        }
+        return {
+          id: logId,
+          timestamp: timestamp,
+          name: eventName,
+          payload: value
+        };
+      } else {
+        return null
+      }
+    }
+  }
+
+  jsonify (obj) {
+    if (
+      obj !== null &&
+      typeof obj === 'object' &&
+      !Buffer.isBuffer(obj)
+    ) {
+      if (typeof obj.toJSON === 'function') {
+        obj = obj.toJSON();
+      }
+      if (Array.isArray(obj)) {
+        obj = obj.map(item => this.jsonify(item));
+      } else if (
+        obj !== null &&
+        typeof obj === 'object' &&
+        !Buffer.isBuffer(obj)
+      ) {
+        Object.keys(obj).forEach(key => obj[key] = this.jsonify(obj[key]));
+      }
+    }
+    return obj;
+  }
+
+  execute (definition, functionArgs, data, headers, callback) {
+    headers = headers || {};
+    let fn;
+    let complete = false;
+    let callbackWrapper = (err, result, headers, executionUuid) => {
+      if (!complete) {
+        complete = true;
+        result = this.jsonify(result);
+        callback(err, result, headers, executionUuid);
+      }
+    };
+    setTimeout(() => {
+      let error = new Error(`Timeout of ${this.defaultTimeout}ms exceeded.`);
+      error.timeoutError = true;
+      error.fatal = true;
+      return callbackWrapper(error, null, headers, executionUuid);
+    }, this.defaultTimeout);
+    let executionUuid = data.context.uuid || uuid.v4();
+    if (definition.format.language === 'static') {
+      let buffer = this._staticCache[definition.pathname] = (
+        this._staticCache[definition.pathname] ||
+        this.preloadFiles[definition.pathname] ||
+        fs.readFileSync(path.join(process.cwd(), this.root, definition.pathname))
+      );
+      let statusCode = definition.name.endsWith(':notfound')
+        ? 404
+        : 200;
+      let contentType = definition.metadata.contentType || 'application/octet-stream';
+      if (contentType.split(';')[0].split('/')[0] === 'video') {
+        let range = data.context.http.headers.range;
+        let len = buffer.byteLength;
+        if (range) {
+          range = range
+            .replace('bytes=', '')
+            .split('-')
+            .map(r => r.trim());
+          if (!range.length) {
+            range = [0, len - 1];
+          } else if (range.length === 1) {
+            range.push(len - 1);
+          } else if (range[1] === '') {
+            range[1] = len - 1;
+          }
+          if (range[0] === '' && !isNaN(parseInt(range[1]))) {
+            range = [len - parseInt(range[1]), len - 1];
+          } else {
+            range = [parseInt(range[0]) || 0, parseInt(range[1]) || 0];
+          }
+          buffer = buffer.slice(range[0], range[1] + 1);
+        } else {
+          range = [0, len - 1];
+        }
+        if (range[0] !== 0 || range[1] !== len - 1) {
+          statusCode = 206;
+        }
+        headers['Content-Range'] = `bytes ${range[0]}-${range[1]}/${len}`;
+        headers['Accept-Ranges'] = 'bytes';
+      } else if (contentType.split(';')[0].split('/')[0] === 'text') {
+        contentType = contentType.split(';')[0] + '; charset=utf-8';
+      }
+      headers['Content-Type'] = contentType;
+      headers['Content-Length'] = buffer.byteLength;
+      return callbackWrapper(
+        null,
+        {statusCode: statusCode, headers: headers, body: buffer},
+        headers,
+        executionUuid
+      );
+    } else if (definition.format.language === 'nodejs') {
+      if (definition.format.inline) {
+        fn = this._inlineCache[definition.pathname];
+        if (!fn) {
+          try {
+            let fnString;
+            if (this.preloadFiles[definition.pathname]) {
+              fnString = this.preloadFiles[definition.pathname].toString();
+            } else {
+              fnString = fs.readFileSync(path.join(process.cwd(), this.root, definition.pathname)).toString();
+            }
+            fn = new AsyncFunction('require', 'context', fnString).bind(null, relrequire.bind(null, definition.pathname));
+            this._inlineCache[definition.pathname] = fn;
+          } catch (e) {
+            e.fatal = true;
+            return callbackWrapper(e, null, headers, executionUuid);
+          }
+        }
+      } else {
+        try {
+          let pathname = definition.pathname;
+          let rpath;
+          if (this.preloadFiles[pathname]) {
+            let filename = path.join(process.cwd(), pathname);
+            if (fs.existsSync(filename)) {
+              throw new Error(`Preloaded file "${pathname}" conflicts with existing file`);
+            }
+            let pathList = filename.split(path.sep);
+            let addedDirs = [];
+            for (let i = 1; i < pathList.length - 1; i++) {
+              let checkPath = pathList.slice(0, i + 1).join(path.sep);
+              if (fs.existsSync(checkPath)) {
+                let stat = fs.statSync(checkPath);
+                if (!stat.isDirectory()) {
+                  throw new Error(`Preloaded file "${pathname}" can not be created, "${checkPath}" is not a directory`);
+                }
+              } else {
+                addedDirs.push(checkPath);
+                try {
+                  fs.mkdirSync(checkPath);
+                } catch (e) {
+                  throw new Error(`Preloaded file "${pathname}" can not be created, "${checkPath}" could not be written`);
+                }
+              }
+            }
+            fs.writeFileSync(filename, this.preloadFiles[pathname]);
+            rpath = require.resolve(filename);
+            delete require[rpath];
+            fn = require(rpath);
+            fs.unlinkSync(filename);
+            while (addedDirs.length) {
+              fs.rmdirSync(addedDirs.pop());
+            }
+          } else {
+            rpath = require.resolve(path.join(process.cwd(), this.root, definition.pathname));
+            delete require[rpath];
+            fn = require(rpath);
+          }
+        } catch (e) {
           if (!(e instanceof Error)) {
             let value = e;
             e = new Error(e || '');
             e.value = value;
           }
-          e.thrown = true;
-          callback(e);
+          e.fatal = true;
+          return callbackWrapper(e, null, headers, executionUuid);
+        }
+      }
+      // Overwrite internal console to stream output
+      const stringifyArgs = args => {
+        return args.map(arg => {
+          return (typeof arg === 'string')
+            ? arg
+            : JSON.stringify(arg)
+        }).join(' ');
+      };
+      let console = global.console;
+      if (data.debug) {
+        let gConsole = {};
+        Object.keys(console).forEach(key => {
+          let fn = console[key];
+          if (typeof fn === 'function') {
+            gConsole[key] = console[key].bind(console);
+          } else {
+            gConsole[key] = console[key];
+          }
         });
-    } else {
-      try {
-        fn.apply(null, functionArgs.concat(callback));
-      } catch (e) {
-        if (!(e instanceof Error)) {
-          let value = e;
-          e = new Error(e || '');
-          e.value = value;
+        gConsole.log = function () {
+          let args = [].slice.call(arguments);
+          console.log(...args);
+          data.context.stream('@stdout', stringifyArgs(args));
+        };
+        gConsole.error = function () {
+          let args = [].slice.call(arguments);
+          console.error(...args);
+          data.context.stream('@stderr', stringifyArgs(args));
+        };
+        global.console = gConsole;
+      }
+      // Catch unhandled promise rejections once, starting now.
+      //   This applies to local testing only.
+      process.removeAllListeners('unhandledRejection');
+      process.once('unhandledRejection', (err, p) => {
+        global.console = console;
+        callbackWrapper(err, null, headers, executionUuid);
+      });
+      data.context.stream('@begin', new Date().toISOString());
+      if (definition.format.async) {
+        fn.apply(null, functionArgs)
+          .then(result => {
+            global.console = console;
+            callbackWrapper(null, result, headers, executionUuid);
+          })
+          .catch(e => {
+            if (!(e instanceof Error)) {
+              let value = e;
+              e = new Error(e || '');
+              e.value = value;
+            }
+            e.thrown = true;
+            global.console = console;
+            callbackWrapper(e, null, headers, executionUuid);
+          });
+      } else {
+        try {
+          fn.apply(null, functionArgs.concat((err, result, responseHeaders) => {
+            Object.keys(responseHeaders || {}).forEach(key => {
+              headers[key.toLowerCase()] = responseHeaders[key];
+            });
+            global.console = console;
+            return callbackWrapper(err, result, headers, executionUuid);
+          }));
+        } catch (e) {
+          if (!(e instanceof Error)) {
+            let value = e;
+            e = new Error(e || '');
+            e.value = value;
+          }
+          e.thrown = true;
+          global.console = console;
+          return callbackWrapper(e, null, headers, executionUuid);
         }
-        e.thrown = true;
-        return callback(e);
       }
+    } else {
+      return callbackWrapper(
+        new Error(`Gateway does not support language "${definition.format.language}"`),
+        null,
+        headers,
+        executionUuid
+      );
     }
   }
 
diff --git a/lib/parser/function_parser.js b/lib/parser/function_parser.js
index ad0b1b9..144d82c 100644
--- a/lib/parser/function_parser.js
+++ b/lib/parser/function_parser.js
@@ -2,8 +2,9 @@ const fs = require('fs');
 const path = require('path');
 
 const minimatch = require('minimatch');
+const mime = require('mime');
 
-const background = require('../background.js');
+const backgroundValidator = require('../background_validator.js');
 const types = require('../types.js');
 
 const DEFAULT_IGNORE = [
@@ -41,8 +42,9 @@ class FunctionParser {
     return this._parsers[lang];
   }
 
-  parseDefinition(pathname, buffer, functionsPath) {
+  parseDefinition (pathname, buffer, functionsPath, isStatic, isPreload) {
 
+    isStatic = !!isStatic;
     functionsPath = functionsPath || '';
     functionsPath = (functionsPath && !functionsPath.endsWith('/')) ? `${functionsPath}/` : functionsPath;
     if (!pathname.startsWith(functionsPath)) {
@@ -50,127 +52,236 @@ class FunctionParser {
     }
     let names = pathname.split('/');
     let filename = names.pop();
-    let name;
     let ext = filename.split('.').pop();
-    let parser = this.getParser(`.${ext}`);
-    let suffix;
-    name = filename.substr(0, filename.length - ext.length - 1);
-    if (name === '__main__') {
-      name = names.join('/');
-    } else if (name === '__notfound__') {
-      name = names.join('/');
-      suffix = 'notfound';
+    let name = filename.substr(0, filename.length - ext.length - 1);
+    let definitionList = [];
+
+    if (isStatic) {
+      // Convert index.html -> mydomain.com/
+      // But also preserve mydomain.com/index.html
+      // Special rules for html files named "index" or "404"
+      // Which will create default routes
+      let parser = this.getParser('');
+      let definition;
+      let shouldCreateFileEntry = true;
+      if (
+        (name === 'index' || name === '404') &&
+        (ext === 'htm' || ext === 'html')
+      ) {
+        if (name === 'index') {
+          name = names.join('/').substr(functionsPath.length);
+        } else if (name === '404') {
+          name = `${names.join('/').substr(functionsPath.length)}:notfound`;
+          shouldCreateFileEntry = false; // 404 will trigger 404 anyway
+        }
+        try {
+          definition = parser.parse(
+            name,
+            buffer.toString(),
+            pathname,
+            buffer
+          );
+          definition.pathname = pathname;
+        } catch (e) {
+          throw new Error(`Static file error (${pathname})\n${e.message}`);
+        }
+        definitionList.push(definition);
+      }
+      if (shouldCreateFileEntry) {
+        try {
+          definition = parser.parse(
+            names.concat(filename).join('/').substr(functionsPath.length),
+            buffer.toString(),
+            pathname,
+            buffer
+          );
+          definition.pathname = pathname;
+        } catch (e) {
+          throw new Error(`Static file error (${pathname})\n${e.message}`);
+        }
+        definitionList.push(definition);
+      }
     } else {
-      name = names.concat(name).join('/');
-    }
-    name = name.substr(functionsPath.length);
-    if (name && !name.match(/^([A-Z][A-Z0-9\_\-]*\/)*[A-Z][A-Z0-9\_\-]*$/i)) {
-      throw new Error(
-        `Invalid function name: ${name} (${filename})\n` +
-        `All path segments must be alphanumeric (or -, _) and start with a letter`
-      );
-    }
+      let parser = this.getParser(`.${ext}`);
+      let suffix;
+      if (name === '__main__') {
+        name = names.join('/');
+      } else if (name === '__notfound__') {
+        name = names.join('/');
+        suffix = 'notfound';
+      } else {
+        name = names.concat(name).join('/');
+      }
+      name = name.substr(functionsPath.length);
+      if (name && !name.match(/^([A-Z][A-Z0-9\_\-]*\/)*[A-Z][A-Z0-9\_\-]*$/i)) {
+        throw new Error(
+          `Invalid function name: ${name} (${filename})\n` +
+          `All path segments must be alphanumeric (or -, _) and start with a letter`
+        );
+      }
 
-    name = name + (suffix ? `:${suffix}` : '');
-    let definition;
+      name = name + (suffix ? `:${suffix}` : '');
+      let definition;
 
-    try {
-      definition = parser.parse(name, buffer.toString());
-      definition.pathname = pathname;
-    } catch (e) {
-      e.message = `Function definition error (${pathname})\n${e.message}`;
-      throw e;
-    }
+      try {
+        definition = parser.parse(name, buffer.toString(), pathname, buffer);
+        definition.pathname = pathname;
+      } catch (e) {
+        e.message = `Function definition error (${pathname})\n${e.message}`;
+        throw e;
+      }
 
-    let validations = this.constructor.definitionFields;
-    Object.keys(validations).forEach(field => {
-      let validate = validations[field];
-      let value = definition[field];
-      if (!validate(value)) {
-        throw new Error(
-          `Function definition error (${pathname})\n`+
-          `Invalid field "${field}", unexpected value: ${JSON.stringify(value)}`
-        );
+      if (isPreload) {
+        definition.preload = true;
       }
+
+      definitionList.push(definition);
+
+    }
+
+    definitionList.forEach(definition => {
+      let validations = this.constructor.definitionFields;
+      Object.keys(validations).forEach(field => {
+        let validate = validations[field];
+        let value = definition[field];
+        if (!validate(value)) {
+          throw new Error(
+            `FunctionScript endpoint definition error (${pathname})\n`+
+            `Invalid field "${field}", unexpected value: ${JSON.stringify(value)}\n` +
+            `\nThis is likely caused by a FunctionScript misconfiguration.`
+          );
+        }
+      });
     });
 
-    return definition;
+    return definitionList;
 
   }
 
-  readDefinitions(files, functionsPath) {
+  readDefinitions (files, functionsPath, definitions, isStatic, isPreload) {
     functionsPath = (functionsPath && !functionsPath.endsWith('/')) ? `${functionsPath}/` : (functionsPath || '');
     return Object.keys(files).reduce((definitions, pathname) => {
       if (functionsPath && !pathname.startsWith(functionsPath)) {
         return definitions;
       }
-      let definition = this.parseDefinition(pathname, files[pathname], functionsPath);
-      if (definitions[definition.name]) {
-        throw new Error(
-          `Function ${definition.name} already exists\n` +
-          `If declaring with [dir]/__main__.js, make sure [dir].js isn't a file in the parent directory.`
-        );
-      }
-      definitions[definition.name] = definition;
+      let definitionList = this.parseDefinition(pathname, files[pathname], functionsPath, isStatic, isPreload);
+      definitionList.forEach(definition => {
+        if (definitions[definition.name]) {
+          let existingDefinition = definitions[definition.name];
+          throw new Error(
+            `Endpoint ${definition.name} (${definition.pathname}) was already defined in ${existingDefinition.pathname}\n` +
+            (
+              existingDefinition.preload
+                ? `This file was preloaded as part of a compilation step, it can not be overwritten.\n`
+                : ''
+            ) +
+            (
+              isStatic
+                ? (!existingDefinition.static && definition.static)
+                  ? [
+                      `Endpoint functions and static files can not have the same name.`,
+                      `This can often be caused when a function is named "__main__" and a static file is name "index",`,
+                      `or when a function is named "__notfound__" and a static file is named "404".`
+                    ].join('\n')
+                  : `Only one static file per directory can have the name "index" or "404".`
+                : `If declaring with [dir]/__main__.js, make sure [dir].js isn't a file in the parent directory.`
+            )
+          );
+        }
+        definitions[definition.name] = definition;
+      });
       return definitions;
-    }, {});
+    }, definitions || {});
   }
 
-  readFiles(rootPath, functionsPath, dirPath, files, ignore) {
+  readFiles (rootPath, functionsPath, dirPath, files, ignore) {
+    if (ignore && !Array.isArray(ignore)) {
+      throw new Error(`Invalid ignore file, received ${typeof ignore} instead of Array`);
+    }
     let ignoreList = (ignore || []).concat(DEFAULT_IGNORE);
     functionsPath = functionsPath || '.';
     dirPath = dirPath || '.';
     files = files || {};
-    return fs.readdirSync(path.join(rootPath, functionsPath, dirPath)).reduce((files, filename) => {
-      let pathname = path.join(rootPath, functionsPath, dirPath, filename);
-      let fullPath = path.join(functionsPath, dirPath, filename);
-      let filePath = path.join(dirPath, filename);
-      let fullPathNormalized = fullPath.split(path.sep).join('/');
-      let isDirectory = fs.statSync(pathname).isDirectory();
-      for (let i = 0; i < ignoreList.length; i++) {
-        if (minimatch(fullPathNormalized, ignoreList[i], {matchBase: true})) {
-          return files;
-        }
-      }
-      if (isDirectory) {
-        files = this.readFiles(rootPath, functionsPath, filePath, files, ignore);
-      } else {
-        files[fullPathNormalized] = fs.readFileSync(pathname);
-      }
+    if (!fs.existsSync(path.join(rootPath, functionsPath, dirPath))) {
       return files;
-    }, files);
+    } else {
+      return fs.readdirSync(path.join(rootPath, functionsPath, dirPath)).reduce((files, filename) => {
+        let pathname = path.join(rootPath, functionsPath, dirPath, filename);
+        let fullPath = path.join(functionsPath, dirPath, filename);
+        let filePath = path.join(dirPath, filename);
+        let fullPathNormalized = fullPath.split(path.sep).join('/');
+        let isDirectory = fs.statSync(pathname).isDirectory();
+        for (let i = 0; i < ignoreList.length; i++) {
+          if (minimatch(fullPathNormalized, ignoreList[i], {matchBase: true})) {
+            return files;
+          }
+        }
+        if (isDirectory) {
+          files = this.readFiles(rootPath, functionsPath, filePath, files, ignore);
+        } else {
+          files[fullPathNormalized] = fs.readFileSync(pathname);
+        }
+        return files;
+      }, files);
+    }
   }
 
-  load(rootPath, functionsPath, ignore) {
-    let files = this.readFiles(rootPath, functionsPath, null, null, ignore);
-    return this.readDefinitions(files, functionsPath);
+  load (rootPath, functionsPath, staticPath, ignore, preloadFiles) {
+    let definitions = {};
+    if (preloadFiles && typeof preloadFiles === 'object') {
+      definitions = this.readDefinitions(preloadFiles, functionsPath, definitions, false, true);
+      definitions = this.readDefinitions(preloadFiles, staticPath, definitions, true, true);
+    }
+    let functionFiles = this.readFiles(rootPath, functionsPath, null, null, ignore);
+    definitions = this.readDefinitions(functionFiles, functionsPath, definitions);
+    if (staticPath) {
+      let staticFiles = this.readFiles(rootPath, staticPath, null, null, ignore);
+      definitions = this.readDefinitions(staticFiles, staticPath, definitions, true);
+    }
+    return definitions;
   }
 
 }
 
 FunctionParser.parsers = {
+  'static' : require('./static/static_parser.js'),
   'nodejs': require('./nodejs/exported_function_parser.js')
 };
 
+FunctionParser.commentParsers = {
+  'nodejs': require('./nodejs/comment_definition_parser.js')
+};
+
 FunctionParser.extensions = {
+  '': 'static',
   '.js': 'nodejs'
 };
 
 FunctionParser.definitionFields = {
   'name': name => typeof name === 'string',
+  'pathname': pathname => typeof pathname === 'string',
   'format': format => {
     return format &&
       typeof format === 'object' &&
-      typeof format.language === 'string';
+      typeof format.language === 'string' &&
+      typeof format.inline === 'boolean'
   },
   'description': description => typeof description === 'string',
-  'bg': bg => {
-    return bg &&
-    typeof bg === 'object' &&
-    'mode' in bg &&
-    'value' in bg &&
-    typeof bg.value === 'string' &&
-    bg.mode in background.modes;
+  'metadata': metadata => typeof metadata === 'object' && metadata !== null,
+  'origins': origins => {
+    return origins === null || origins === void 0 || Array.isArray(origins);
+  },
+  'background': background => {
+    if (background) {
+      return background &&
+        typeof background === 'object' &&
+        'mode' in background &&
+        'value' in background &&
+        typeof background.value === 'string' &&
+        background.mode in backgroundValidator.modes;
+    } else {
+      return background === null || background === void 0;
+    }
   },
   'keys': keys => {
     return Array.isArray(keys);
@@ -178,12 +289,17 @@ FunctionParser.definitionFields = {
   'charge': charge => {
     return charge >= 0 && charge <= 100 && parseInt(charge) === charge;
   },
+  'streams': streams => {
+    return streams === null ||
+    FunctionParser.definitionFields['params'](streams);
+  },
   'context': context => typeof context === 'object',
   'params': params => {
     return Array.isArray(params) && params.filter(param => {
       return param &&
         typeof param == 'object' &&
         'name' in param &&
+        param.name
         'description' in param &&
         'type' in param &&
         (
@@ -221,7 +337,9 @@ FunctionParser.definitionFields = {
   'returns': returns => {
     return returns &&
       typeof returns === 'object' &&
-      'description' in returns && 'type' in returns;
+      'name' in returns &&
+      'description' in returns &&
+      'type' in returns;
   }
 };
 
diff --git a/lib/parser/nodejs/comment_definition_parser.js b/lib/parser/nodejs/comment_definition_parser.js
index f63adce..0987efd 100644
--- a/lib/parser/nodejs/comment_definition_parser.js
+++ b/lib/parser/nodejs/comment_definition_parser.js
@@ -1,12 +1,16 @@
+const backgroundValidator = require('../../background_validator.js');
 const types = require('../../types.js');
+const validateParameterName = require('./validate_parameter_name.js');
 
 const DEFAULT_DEFINITION_FIELD = 'description';
 const DEFINITION_FIELDS = [
-  'bg',
+  'origin',
+  'background',
   'keys',
   'charge',
   'acl',
   'param',
+  'stream',
   'returns'
 ];
 
@@ -29,7 +33,15 @@ class CommentDefinitionParser {
       let splitLine = line.split(' ');
       let field = splitLine.shift();
       line = splitLine.join(' ');
-      if (!field && previous && (previous.field === 'param' || previous.field === 'returns')) {
+      if (
+        !field &&
+        previous &&
+        (
+          previous.field === 'param' ||
+          previous.field === 'stream' ||
+          previous.field === 'returns'
+        )
+      ) {
         previous.textSchema = (previous.textSchema || []).concat([[line]]);
         return semanticsList;
       } else if (DEFINITION_FIELDS.indexOf(field) === -1) {
@@ -110,11 +122,42 @@ class CommentDefinitionParser {
     }, acl);
   }
 
-  getBg (values) {
+  getOrigin (values) {
+    let value = values.join(' ').trim();
+    let origins = [];
+    if (!value.match(/^(https?:\/\/)?([a-z0-9\-]{0,255}\.)*?([a-z0-9\-]{1,255})(:[0-9]{1,5})?$/gi)) {
+      throw new Error([
+        `Invalid origin: "${value}".`,
+        ` Must be a valid hostname consisting of alphanumeric characters or "-"`,
+        ` separated by ".".`,
+        ` Supported protocols are "http://" and "https://", if left absent both`,
+        ` will be enabled.`
+      ].join(''));
+    }
+    if (!value.match(/^https?:\/\//gi)) {
+      origins.push(`https://${value}`);
+      origins.push(`http://${value}`);
+    } else {
+      origins.push(value);
+    }
+    return origins;
+  }
+
+  getBackground (values) {
     values = values.join(' ').split(' ');
+    let mode = values[0].trim() || backgroundValidator.defaultMode;
+    let value = values.slice(1).join(' ').trim();
+    let modes = Object.keys(backgroundValidator.modes);
+    if (modes.indexOf(mode) === -1) {
+      throw new Error([
+        `Invalid Background mode: "${mode}". Please specify \`@background MODE\``,
+        ` where MODE is one of: "${modes.join('", "')}" (without quotes).`,
+        ` If no mode is provided, the default "${backgroundValidator.defaultMode}" will be used.`
+      ].join(''));
+    }
     return {
-      mode: values[0],
-      value: values.slice(1).join(' ').trim()
+      mode: mode,
+      value: value
     };
   }
 
@@ -131,19 +174,41 @@ class CommentDefinitionParser {
     let value = values.join(' ');
     let defaultMetafield = '';
     let options = '';
+    let range = '';
 
     if (value.indexOf('{?}') !== -1 && value.indexOf('{!}') > value.indexOf('{?}')) {
       throw new Error('defaultMetafield {!} must come before options {?}');
     }
 
+    if (value.indexOf('{:}') !== -1) {
+      if (value.indexOf('{!}') > value.indexOf('{:}')) {
+        throw new Error(`defaultMetafield {!} must come before range {:}`)
+      }
+      if (value.indexOf('{?}') > value.indexOf('{:}')) {
+        throw new Error(`options {?} must come before range {:}`);
+      }
+    }
+
     if (value.indexOf('{!}') !== -1) {
       defaultMetafield = (value.split('{!}')[1] || '').trim();
       value = value.split('{!}')[0].trim();
-      options = (defaultMetafield.split('{?}')[1] || '').trim();
-      defaultMetafield = defaultMetafield.split('{?}')[0].trim();
-    } else {
+      if (defaultMetafield.indexOf('{?}') !== -1) {
+        options = (defaultMetafield.split('{?}')[1] || '').trim();
+        defaultMetafield = defaultMetafield.split('{?}')[0].trim();
+        range = (options.split('{:}')[1] || '').trim();
+        options = options.split('{:}')[0].trim();
+      } else {
+        range = (defaultMetafield.split('{:}')[1] || '').trim();
+        defaultMetafield = defaultMetafield.split('{:}')[0].trim();
+      }
+    } else if (value.indexOf('{?}') !== -1) {
       options = (value.split('{?}')[1] || '').trim();
       value = value.split('{?}')[0].trim();
+      range = (options.split('{:}')[1] || '').trim();
+      options = options.split('{:}')[0].trim();
+    } else {
+      range = (value.split('{:}')[1] || '').trim();
+      value = value.split('{:}')[0].trim();
     }
 
     let param = {};
@@ -215,7 +280,7 @@ class CommentDefinitionParser {
           : param.type;
         values.forEach(v => {
           if (!types.validate(paramType, v)) {
-            throw new Error(`Options {?}: "${param.name}", type mismatch for type ${paramType} ("${options}")`);
+            throw new Error(`Options {?}: "${param.name}", type mismatch for type ${param.type} ("${options}")`);
           }
         });
         param.options.values = values;
@@ -246,7 +311,42 @@ class CommentDefinitionParser {
       }
     }
 
+    if (range) {
+      if (types.rangeAllowed.indexOf(param.type) === -1) {
+        throw new Error(`Range {:}: Not allowed for type "${param.type}" for parameter "${param.name}"`);
+      }
+      let span;
+      try {
+        span = JSON.parse(range);
+      } catch (e) {
+        span = null;
+      }
+      if (!Array.isArray(span)) {
+        throw new Error(`Range {:}: "${param.name}" invalid, expecting array [min, max] ("${range}")`);
+      }
+      let paramType = (param.type === 'object.keyql.limit')
+        ? 'integer'
+        : param.type;
+      span.forEach(s => {
+        if (!types.validate(paramType, s)) {
+          throw new Error(`Range {:}: "${param.name}", type mismatch for type ${param.type} ("${range}")`);
+        }
+      });
+      if (span.length !== 2) {
+        throw new Error(`Range {:}: "${param.name}" invalid length, expecting array [min, max] ("${range}")`);
+      } else if (span[0] > span[1]) {
+        throw new Error(`Range {:}: "${param.name}" invalid, max must be greater than min in [min, max] ("${range}")`);
+      }
+      if (param.type === 'object.keyql.limit') {
+        if (span[0] < 0 || span[1] < 0) {
+          throw new Error(`Range {:}: "${param.name}" invalid value, [min, max] must both be greater than or equal to 0 ("${range}")`);
+        }
+      }
+      param.range = {min: span[0], max: span[1]};
+    }
+
     return param;
+
   }
 
   getCharge (values) {
@@ -272,10 +372,29 @@ class CommentDefinitionParser {
       } else if (field === 'param') {
         definition.params = definition.params || [];
         definition.params.push(this.getParameter(values, textSchema));
+        definition.params.forEach(param => {
+          if (!validateParameterName(param.name)) {
+            throw new Error(`Invalid parameter name "${param.name}"`);
+          }
+        });
+      } else if (field === 'stream') {
+        definition.streams = definition.streams || [];
+        definition.streams.push(this.getParameter(values, textSchema));
+        definition.streams.forEach(stream => {
+          if (!validateParameterName(stream.name)) {
+            throw new Error(`Invalid stream name "${stream.name}"`);
+          }
+        });
       } else if (field === 'returns') {
         definition.returns = this.getParameter(values, textSchema);
-      } else if (field === 'bg') {
-        definition.bg = this.getBg(values);
+      } else if (field === 'origin') {
+        definition.origins = definition.origins || [];
+        definition.origins = [].concat(
+          definition.origins,
+          this.getOrigin(values)
+        );
+      } else if (field === 'background') {
+        definition.background = this.getBackground(values);
       } else if (field === 'acl') {
         definition.acl = this.getAcl(values);
       } else if (field === 'charge') {
@@ -297,6 +416,7 @@ class CommentDefinitionParser {
 
   parse (name, commentString) {
 
+    commentString = commentString || '';
     return this.getLines(commentString)
       .map(line => this.stripComments(line))
       .reduce((semanticsList, line) => this.reduceLines(semanticsList, line), [])
@@ -305,12 +425,15 @@ class CommentDefinitionParser {
         {
           name: name,
           description: '',
+          origins: null,
           acl: null,
-          bg: null,
+          background: null,
           keys: [],
+          streams: null,
           context: null,
           params: [],
           returns: {
+            name: '',
             type: 'any',
             description: ''
           }
diff --git a/lib/parser/nodejs/exported_function_parser.js b/lib/parser/nodejs/exported_function_parser.js
index 74765c3..760bc0b 100644
--- a/lib/parser/nodejs/exported_function_parser.js
+++ b/lib/parser/nodejs/exported_function_parser.js
@@ -1,7 +1,14 @@
-const babylon = require('babylon');
+const babelParser = require('@babel/parser');
 
 const types = require('../../types.js');
-const background = require('../../background.js');
+const validateParameterName = require('./validate_parameter_name.js');
+
+const RESERVED_NAMES = [
+  '_stream',
+  '_background',
+  '_debug',
+  'context'
+];
 
 const CommentDefinitionParser = require('./comment_definition_parser.js');
 
@@ -16,7 +23,8 @@ class ExportedFunctionParser {
       BooleanLiteral: 'boolean',
       NullLiteral: 'any',
       ObjectExpression: 'object',
-      ArrayExpression: 'array'
+      ArrayExpression: 'array',
+      UnaryExpression: 'number'
     };
     this.validateExpressions = {
       ObjectExpression: (node, stack) => {
@@ -34,6 +42,19 @@ class ExportedFunctionParser {
       },
       ArrayExpression: (node, stack) => {
         return node.elements.map((el, i) => this.validateDefaultParameterExpression(i, el, stack));
+      },
+      UnaryExpression: (node, stack) => {
+        if (node.argument.type === 'NumericLiteral') {
+          if (node.operator === '-') {
+            return -node.argument.value;
+          } else if (node.operator === '+') {
+            return node.argument.value;
+          } else {
+            throw new Error(`Invalid UnaryExpression`);
+          }
+        } else {
+          throw new Error(`Invalid UnaryExpression`);
+        }
       }
     };
   }
@@ -43,9 +64,11 @@ class ExportedFunctionParser {
     stack = (stack || []).slice(0);
     stack.push(name);
 
-    if (!this.literals[node.type]) {
+    let type = node.type;
+
+    if (!this.literals[type]) {
       console.log(node);
-      throw new Error(`(${stack.join('.')}) Expected ${Object.keys(this.literals).join(', ')} in Right-Hand of AssignmentPattern`);
+      throw new Error(`(${stack.join('.')}) Expected ${Object.keys(this.literals).join(', ')} in Right-Hand of AssignmentPattern, got ${type}.`);
     }
 
     if (this.validateExpressions[node.type]) {
@@ -58,11 +81,13 @@ class ExportedFunctionParser {
 
   parseModuleExportsStatement(fileString) {
 
-    let AST = babylon.parse(fileString, {
-      plugins: [
-        'objectRestSpread'
-      ]
-    });
+    let AST = babelParser.parse(
+      fileString,
+      {
+        allowReturnOutsideFunction: true,
+        allowAwaitOutsideFunction: true
+      }
+    );
 
     let body = AST.program.body;
 
@@ -80,15 +105,11 @@ class ExportedFunctionParser {
       )
     });
 
-    if (!statements.length) {
-      throw new Error(`Nothing exported from file via "module.exports"`);
-    }
-
     if (statements.length > 1) {
       throw new Error(`Too many exports from file via "module.exports"`);
     }
 
-    return statements[0];
+    return statements[0] || null;
 
   }
 
@@ -103,84 +124,94 @@ class ExportedFunctionParser {
     return expression.right;
   }
 
-  parseParamsFromFunctionExpression(functionExpression) {
+  parseParamsFromFunctionExpression(functionExpression, fileString) {
 
-    let params = functionExpression.params;
+    if (!functionExpression) {
+      return {
+        async: true,
+        inline: true,
+        context: {},
+        params: []
+      };
+    } else {
+      let params = functionExpression.params;
 
-    if (!functionExpression.async) {
-      let lastParam = params.pop();
-      if (!lastParam || lastParam.type !== 'Identifier' || lastParam.name !== 'callback') {
-        throw new Error(`Non-async functions must have parameter named "callback" as the last argument`);
+      if (!functionExpression.async) {
+        let lastParam = params.pop();
+        if (!lastParam || lastParam.type !== 'Identifier' || lastParam.name !== 'callback') {
+          throw new Error(`Non-async functions must have parameter named "callback" as the last argument`);
+        }
       }
-    }
 
-    let paramsObject = {};
+      let paramsObject = {};
 
-    if (params.length) {
-      let lastParam = params.pop();
-      if (lastParam.type === 'Identifier' && lastParam.name === 'context') {
-        paramsObject.context = {};
-      } else {
-        params.push(lastParam);
+      if (params.length) {
+        let lastParam = params.pop();
+        if (lastParam.type === 'Identifier' && lastParam.name === 'context') {
+          paramsObject.context = {};
+        } else {
+          params.push(lastParam);
+        }
       }
-    }
 
-    return {
-      async: functionExpression.async,
-      context: paramsObject.context || null,
-      params: params.slice()
-        .reverse()
-        .map((param, i) => {
-          let formattedParam;
-          if (param.type === 'Identifier') {
-            if (param.name === 'context') {
-              throw new Error(`When specified, "context" must be the last provided (non-callback) argument`);
+      return {
+        async: functionExpression.async,
+        inline: false,
+        context: paramsObject.context || null,
+        params: params.slice()
+          .reverse()
+          .map((param, i) => {
+            let formattedParam;
+            if (param.type === 'Identifier') {
+              if (param.name === 'context') {
+                throw new Error(`When specified, "context" must be the last provided (non-callback) argument`);
+              }
+              if (functionExpression.async && param.name === 'callback') {
+                throw new Error(`Async functions can not have a parameter named "callback"`);
+              }
+              if (!this.validateFunctionParamName(param.name)) {
+                throw new Error(`Invalid parameter name "${param.name}"`);
+              }
+              formattedParam = {name: param.name};
+            } else if (param.type === 'AssignmentPattern') {
+              if (param.left.type !== 'Identifier') {
+                throw new Error('Expected Identifier in Left-Hand of AssignmentPattern');
+              }
+              if (param.left.name === 'context') {
+                throw new Error(`When specified, "context" can not be assigned a default value`);
+              }
+              if (functionExpression.async && param.left.name === 'callback') {
+                throw new Error(`Async functions can not have a parameter named "callback"`);
+              }
+              if (!this.validateFunctionParamName(param.left.name)) {
+                throw new Error(`Invalid parameter name "${param.left.name}"`);
+              }
+              let defaultValue;
+              try {
+                defaultValue = this.validateDefaultParameterExpression(param.left.name, param.right);
+              } catch (e) {
+                throw new Error([
+                  `Invalid default parameter: ${param.left.name} = ${fileString.slice(param.right.start, param.right.end)}`,
+                  `(${e.message})`
+                ].join(' '));
+              }
+              formattedParam = {
+                name: param.left.name,
+                type: this.literals[param.right.type],
+                defaultValue: defaultValue
+              };
             }
-            if (functionExpression.async && param.name === 'callback') {
-              throw new Error(`Async functions can not have a parameter named "callback"`);
-            }
-            if (!this.validateFunctionParamName(param.name)) {
-              throw new Error(`Invalid parameter name "${param.name}"`);
-            }
-            formattedParam = {name: param.name};
-          } else if (param.type === 'AssignmentPattern') {
-            if (param.left.type !== 'Identifier') {
-              throw new Error('Expected Identifier in Left-Hand of AssignmentPattern');
-            }
-            if (param.left.name === 'context') {
-              throw new Error(`When specified, "context" can not be assigned a default value`);
-            }
-            if (functionExpression.async && param.left.name === 'callback') {
-              throw new Error(`Async functions can not have a parameter named "callback"`);
-            }
-            if (!this.validateFunctionParamName(param.left.name)) {
-              throw new Error(`Invalid parameter name "${param.left.name}"`);
-            }
-            let defaultValue = this.validateDefaultParameterExpression(param.left.name, param.right);
-            formattedParam = {
-              name: param.left.name,
-              type: this.literals[param.right.type],
-              defaultValue: defaultValue
-            };
-          }
-          paramsObject[formattedParam.name] = formattedParam;
-          return formattedParam;
-        })
-        .reverse()
-    };
+            paramsObject[formattedParam.name] = formattedParam;
+            return formattedParam;
+          })
+          .reverse()
+      };
+    }
 
   }
 
   validateFunctionParamName(param) {
-    try {
-      let token = babylon.parseExpression(param);
-      if (!token || token.type !== 'Identifier') {
-        return false;
-      }
-      return true;
-    } catch (e) {
-      return false;
-    }
+    return validateParameterName(param);
   }
 
   parseCommentFromModuleExportsStatement(moduleStatement) {
@@ -248,12 +279,19 @@ class ExportedFunctionParser {
             } else {
               throw new Error(`Parameter "${defParam.name}" type "${defParam.type}" does not match the default value ${JSON.stringify(param.defaultValue)} ("${param.type}")`);
             }
+          } else {
+            try {
+              types.sanitize(defParam.type, param.defaultValue, defParam.range);
+            } catch (e) {
+              throw new Error(`Parameter "${defParam.name}" defaultValue invalid: ${e.message}`);
+            }
           }
         }
         param.type = defParam.type || types.defaultType;
         param.description = defParam.description;
         defParam.defaultMetafield && (param.defaultMetafield = defParam.defaultMetafield);
         defParam.options && (param.options = defParam.options);
+        defParam.range && (param.range = defParam.range);
         defParam.schema && (param.schema = defParam.schema);
         defParam.alternateSchemas && (param.alternateSchemas = defParam.alternateSchemas);
         defParam.members && (param.members = defParam.members);
@@ -262,35 +300,49 @@ class ExportedFunctionParser {
     });
   }
 
-  parse(name, fileString) {
+  parse (name, fileString, pathname, buffer) {
 
     let moduleStatement = this.parseModuleExportsStatement(fileString);
-    let functionExpression = this.parseFunctionExpressionFromModuleExportsStatement(moduleStatement);
-    let comment = this.parseCommentFromModuleExportsStatement(moduleStatement);
+    let comment = null;
+    let functionExpression = null;
+
+    if (moduleStatement) {
+      comment = this.parseCommentFromModuleExportsStatement(moduleStatement);
+      functionExpression = this.parseFunctionExpressionFromModuleExportsStatement(moduleStatement);
+    }
+
     let commentDefinition = this.commentDefinitionParser.parse(name, comment);
-    let functionDefinition = this.parseParamsFromFunctionExpression(functionExpression);
+    let functionDefinition = this.parseParamsFromFunctionExpression(functionExpression, fileString);
 
     let description = commentDefinition.description || '';
-    let bg = commentDefinition.bg || background.generateDefaultValue();
+    let origins = commentDefinition.origins || null;
+    let background = commentDefinition.background || null;
     let charge = isNaN(commentDefinition.charge) ? 1 : commentDefinition.charge;
+    let streams = commentDefinition.streams || null;
     let context = commentDefinition.context || functionDefinition.context;
     let acl = commentDefinition.acl;
     let keys = commentDefinition.keys;
     let isAsync = functionDefinition.async;
+    let isInline = functionDefinition.inline;
     let params = this.compareParameters(functionDefinition.params, commentDefinition.params);
     let returns = commentDefinition.returns;
 
     return {
       name: name,
+      pathname: pathname,
       format: {
         language: this.language,
-        async: isAsync
+        async: isAsync,
+        inline: isInline
       },
       description: description,
-      bg: bg,
+      metadata: {},
+      origins: origins,
+      background: background,
       acl: acl,
       keys: keys,
       charge: charge,
+      streams: streams,
       context: context,
       params: params,
       returns: returns
diff --git a/lib/parser/nodejs/validate_parameter_name.js b/lib/parser/nodejs/validate_parameter_name.js
new file mode 100644
index 0000000..30f99a7
--- /dev/null
+++ b/lib/parser/nodejs/validate_parameter_name.js
@@ -0,0 +1,25 @@
+const babelParser = require('@babel/parser');
+
+const RESERVED_NAMES = [
+  '_stream',
+  '_debug',
+  '_bg',
+  'context'
+];
+
+function validateParameterName(param) {
+  try {
+    let token = babelParser.parseExpression(param);
+    if (
+      !token || token.type !== 'Identifier' || token.name === 'let' ||
+      RESERVED_NAMES.indexOf(token.name) !== -1
+    ) {
+      return false;
+    }
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+module.exports = validateParameterName;
diff --git a/lib/parser/static/static_parser.js b/lib/parser/static/static_parser.js
new file mode 100644
index 0000000..4f2a958
--- /dev/null
+++ b/lib/parser/static/static_parser.js
@@ -0,0 +1,52 @@
+const mime = require('mime');
+
+class StaticParser {
+
+  constructor() {
+    this.language = 'static';
+  }
+
+  parse (name, fileString, pathname, buffer) {
+
+    let filename = pathname.split('/').pop();
+
+    return {
+      name: name,
+      pathname: pathname,
+      format: {
+        language: this.language,
+        async: false,
+        inline: false
+      },
+      description: filename,
+      metadata: {
+        filename: filename,
+        contentType: mime.getType(filename),
+        contentLength: buffer.byteLength,
+      },
+      origins: null,
+      background: null,
+      keys: [],
+      charge: 0,
+      streams: null,
+      context: {},
+      params: [
+        {
+          name: 'raw',
+          description: 'turn off auto-formatting and return the raw file contents where applicable',
+          type: 'boolean',
+          defaultValue: false
+        }
+      ],
+      returns: {
+        name: 'file',
+        description: 'Static File',
+        type: 'object.http'
+      }
+    };
+
+  }
+
+}
+
+module.exports = StaticParser;
diff --git a/lib/types.js b/lib/types.js
index ade9102..3f32bed 100644
--- a/lib/types.js
+++ b/lib/types.js
@@ -6,12 +6,22 @@ const OPTIONS_ALLOWED = [
   'float',
   'integer',
   'object.keyql.query',
-  'object.keyql.order'
+  'object.keyql.order',
 ];
 
-const validate = (type, v, nullable, schemas, options) => {
+const RANGE_ALLOWED = [
+  'number',
+  'float',
+  'integer',
+  'object.keyql.limit'
+];
+
+const validate = (type, v, nullable, schemas, options, range, stack = [], mismatch = {}) => {
+  if (schemas && !Array.isArray(schemas)) {
+    throw new Error(`Argument schemas must be an Array`)
+  }
   return (nullable && v === null) ||
-    _validations[type](v, schemas, options);
+    _validations[type](v, schemas, options, range, stack, mismatch);
 };
 
 const _validations = {
@@ -20,12 +30,13 @@ const _validations = {
   float: (v, schemas = [], options = []) => parseFloat(v) === v && (options.length ? options.indexOf(v) > -1 : true),
   integer: (v, schemas = [], options = []) => parseInt(v) === v && v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER && (options.length ? options.indexOf(v) > -1 : true),
   boolean: (v) => typeof v === 'boolean',
-  object: (v, schemas = []) => {
+  object: (v, schemas = [], options = [], range = {}, stack = [], mismatch = {}) => {
     if (!!v && typeof v === 'object' && !Array.isArray(v) && !Buffer.isBuffer(v)) {
       let matchedSchemas = schemas.filter(schema => {
         for (let i = 0; i < schema.length; i++) {
           let param = schema[i];
           if (!v.hasOwnProperty(param.name) && !param.hasOwnProperty('defaultValue')) {
+            mismatch.stack = mismatch.stack || stack.concat(param.name);
             return false;
           } else if (
             !validate(
@@ -39,9 +50,13 @@ const _validations = {
                   ? param.members
                   : (param.alternateSchemas || []).concat(param.schema ? [param.schema] : [])
               ),
-              param.options && param.options.values
+              param.options && param.options.values,
+              param.range,
+              stack.concat(param.name),
+              mismatch
             )
           ) {
+            mismatch.stack = mismatch.stack || stack.concat(param.name);
             return false;
           }
         }
@@ -51,10 +66,11 @@ const _validations = {
         ? matchedSchemas.length > 0
         : true;
     } else {
+      mismatch.stack = mismatch.stack || stack;
       return false;
     }
   },
-  array: (v, schemas = []) => {
+  array: (v, schemas = [], options = [], range = {}, stack = [], mismatch = {}) => {
     let schema = schemas[0];
     if (Array.isArray(v)) {
       let param = schema && schema[0];
@@ -69,15 +85,30 @@ const _validations = {
                 ? param.members
                 : (param.alternateSchemas || []).concat(param.schema ? [param.schema] : [])
             ),
-            param.options && param.options.values
+            param.options && param.options.values,
+            param.range,
+            stack.length
+              ? stack.slice(0, stack.length - 1).concat(`${stack[stack.length - 1]}[${i}]`)
+              : stack,
+            mismatch
           );
           if (invalidParam) {
+            mismatch.stack = mismatch.stack || (
+              stack.length
+                ? stack.slice(0, stack.length - 1).concat(`${stack[stack.length - 1]}[${i}]`)
+                : stack
+            );
             return false;
           }
         }
       }
       return true;
     } else {
+      mismatch.stack = mismatch.stack || (
+        stack.length
+          ? stack.slice(0, stack.length - 1).concat(`${stack[stack.length - 1]}[]`)
+          : stack
+      );
       return false;
     }
   },
@@ -86,7 +117,30 @@ const _validations = {
       ? members.some(member => member[0] === v)
       : false;
   },
-  'object.http': v => _validations.object(v),
+  'object.http': v => {
+    let isObject = _validations.object(v);
+    if (!isObject) {
+      return false;
+    } else {
+      return (
+        (
+          Object.keys(v).length === 1 &&
+          v.hasOwnProperty('body')
+        ) ||
+        (
+          Object.keys(v).length === 2 &&
+          v.hasOwnProperty('body') &&
+          v.hasOwnProperty('headers')
+        ) ||
+        (
+          Object.keys(v).length === 3 &&
+          v.hasOwnProperty('body') &&
+          v.hasOwnProperty('headers') &&
+          v.hasOwnProperty('statusCode')
+        )
+      );
+    }
+  },
   'object.keyql.query': (v, schemas = [], options = []) => {
     try {
       KeyQL.validateQueryObject(v, options);
@@ -95,7 +149,14 @@ const _validations = {
     }
     return true;
   },
-  'object.keyql.limit': v => _validations.object(v),
+  'object.keyql.limit': (v, schemas = [], options = []) => {
+    try {
+      KeyQL.validateLimit(v);
+    } catch (e) {
+      return false;
+    }
+    return true;
+  },
   'object.keyql.order': (v, schemas = [], options = []) => {
     try {
       KeyQL.validateOrderObject(v, options);
@@ -110,6 +171,36 @@ const _validations = {
 
 // Unlike validations, sanitizations will throw errors if failed
 const _sanitizations = {
+  number: (v, range) => {
+    if (range) {
+      if (v < range.min) {
+        throw new Error(`must be greater than or equal to ${range.min}`);
+      } else if (v > range.max) {
+        throw new Error(`must less than or equal to ${range.max}`);
+      }
+    }
+    return v;
+  },
+  float: (v, range) => {
+    if (range) {
+      if (v < range.min) {
+        throw new Error(`must be greater than or equal to ${range.min}`);
+      } else if (v > range.max) {
+        throw new Error(`must less than or equal to ${range.max}`);
+      }
+    }
+    return v;
+  },
+  integer: (v, range) => {
+    if (range) {
+      if (v < range.min) {
+        throw new Error(`must be greater than or equal to ${range.mind}`);
+      } else if (v > range.max) {
+        throw new Error(`must less than or equal to ${range.max}`);
+      }
+    }
+    return v;
+  },
   'object.http': v => {
     if (!v || typeof v !== 'object') {
       return v;
@@ -140,8 +231,15 @@ const _sanitizations = {
     KeyQL.validateQueryObject(v);
     return v;
   },
-  'object.keyql.limit': v => {
-    KeyQL.validateLimit(v)
+  'object.keyql.limit': (v, range) => {
+    v = KeyQL.validateLimit(v);
+    if (range) {
+      if (v.count < range.min) {
+        throw new Error(`count must be greater than or equal to ${range[0]}`);
+      } else if (v.count > range.max) {
+        throw new Error(`count must less than or equal to ${range[1]}`);
+      }
+    }
     return v;
   },
   'object.keyql.order': v => {
@@ -167,12 +265,12 @@ const _format = {
   float: v => v,
   integer: v => v,
   boolean: v => v,
-  object: v => v,
+  object: v => _convertBuffers(v, true, true),
   'object.http': v => v,
   'object.keyql.query': v => v,
   'object.keyql.limit': v => v,
   'object.keyql.order': v => v,
-  array: v => v,
+  array: v => _convertBuffers(v, true, true),
   buffer: v => {
     if (!v || typeof v !== 'object' || Buffer.isBuffer(v)) {
       return v;
@@ -307,12 +405,42 @@ const _convert = {
     s = s.trim().toLowerCase();
     return s in convert ? !!convert[s] : s;
   },
-  object: s => JSON.parse(s),
+  object: (s, schema) => {
+    let obj = s;
+    if (typeof obj !== 'object') {
+      obj = JSON.parse(s);
+    }
+    if (schema && schema.length && obj && typeof obj === 'object') {
+      schema
+        .filter(param => param.name in obj)
+        .forEach(param => {
+          obj[param.name] = _convert[param.type](obj[param.name]);
+        });
+    }
+    return obj;
+  },
   'object.http': s => JSON.parse(s),
   'object.keyql.query': s => JSON.parse(s),
-  'object.keyql.limit': s => JSON.parse(s),
+  'object.keyql.limit': s => {
+    return _convert['object'](
+      s,
+      [
+        {name: 'count', type: 'integer'},
+        {name: 'offset', type: 'integer'}
+      ]
+    );
+  },
   'object.keyql.order': s => JSON.parse(s),
-  array: s => JSON.parse(s),
+  array: (s, schema) => {
+    let arr = s;
+    if (!Array.isArray(arr)) {
+      arr = JSON.parse(s);
+    }
+    if (schema && schema.length && Array.isArray(arr)) {
+      arr = arr.map(_convert[schema[0].type]);
+    }
+    return arr;
+  },
   buffer: s => {
     let o = JSON.parse(s);
     return _format.buffer(o);
@@ -320,15 +448,15 @@ const _convert = {
   any: s => s
 };
 
-const _convertBuffers = function (v, base) {
-  v = base ? _format.buffer(v) : v;
+const _convertBuffers = function (v, applyFormatting, formatRecursively) {
+  v = applyFormatting ? _format.buffer(v) : v;
   if (Buffer.isBuffer(v)) {
-    return base ? v : {_base64: v.toString('base64')};
+    return applyFormatting ? v : {_base64: v.toString('base64')};
   } else if (Array.isArray(v)) {
-    return v.map(v => _convertBuffers(v));
+    return v.map(v => _convertBuffers(v, formatRecursively ? applyFormatting : false, formatRecursively));
   } else if (v && typeof v === 'object') {
     return Object.keys(v).reduce(function (n, key) {
-      n[key] = _convertBuffers(v[key]);
+      n[key] = _convertBuffers(v[key], formatRecursively ? applyFormatting : false, formatRecursively);
       return n;
     }, {});
   } else {
@@ -347,6 +475,20 @@ const _httpResponse = {
       body: _convertBuffers(v, true)
     };
   },
+  'any': (v, headers) => {
+    if (_validations['object.http'](v)) {
+      return _sanitizations['object.http'](v);
+    } else {
+      headers = headers || {};
+      let statusCode = headers.status || 200; // legacy support
+      delete headers.status;
+      return {
+        statusCode: statusCode,
+        headers: headers,
+        body: _convertBuffers(v, true)
+      };
+    }
+  },
   'object.http': (v, headers) => {
     v.headers = Object.keys(v.headers || {}).reduce((headers, key) => {
       headers[key] = key.startsWith('x-')
@@ -358,20 +500,50 @@ const _httpResponse = {
   }
 };
 
+const _generateSchema = {
+  javascript: function (payload, defaultDepth = 0) {
+    let definition = _introspect(payload);
+    if (definition.type !== 'object') {
+      throw new Error('Can only generateSchema from an object');
+    }
+    let parseSchema = (schema, depth = 0) => {
+      return schema.map((field) => {
+        let prefix = !depth
+          ? ` * @param `
+          : ` * @ ${' '.repeat((depth - 1) * 2)}`;
+        let fieldContent = field.name ? ` ${field.name}` : '';
+        if (field.schema) {
+          return [
+            `${prefix}{${'defaultValue' in field ? '?' : ''}${field.type}}${fieldContent}`,
+            parseSchema(field.schema, depth + 1)
+          ].join('\n');
+        } else {
+          return `${prefix}{${'defaultValue' in field ? '?' : ''}${field.type}}${fieldContent}`;
+        }
+      }).join('\n');
+    };
+    let commentDefinition = parseSchema(definition.schema, defaultDepth);
+    return commentDefinition;
+  }
+};
+
 module.exports = {
   optionsAllowed: OPTIONS_ALLOWED,
+  rangeAllowed: RANGE_ALLOWED,
   defaultType: 'any',
   list: Object.keys(_validations),
   validate: validate,
+  serialize: (type, v) => _convertBuffers(v),
   convert: (type, s) => _convert[type](s),
   format: (type, v) => _format[type](v),
-  parse: (type, v, convert) => {
+  parse: (type, schema, v, convert) => {
     return convert
-      ? _format[type in _format ? type : ''](_convert[type](v))
+      ? _format[type in _format ? type : ''](_convert[type](v, schema))
       : _format[type](v);
   },
   check: (v) => _check(v),
   introspect: (v) => _introspect(v),
-  sanitize: (type, v) => type in _sanitizations ? _sanitizations[type](v) : v,
-  httpResponse: (type, v, headers) => type in _httpResponse ? _httpResponse[type](v, headers) : _httpResponse[''](v, headers)
+  generateSchema: _generateSchema,
+  sanitize: (type, v, range) => type in _sanitizations ? _sanitizations[type](v, range) : v,
+  httpResponse: (type, v, headers = {}) => type in _httpResponse ? _httpResponse[type](v, headers) : _httpResponse[''](v, headers)
 };
diff --git a/lib/well-knowns.js b/lib/well-knowns.js
new file mode 100644
index 0000000..c5a21b1
--- /dev/null
+++ b/lib/well-knowns.js
@@ -0,0 +1,453 @@
+const YAML = require('json-to-pretty-yaml');
+
+const FunctionScriptToJSONSchemaMapping = {
+  'boolean': (param) => {
+    let json = {};
+    json.type = 'boolean';
+    return json;
+  },
+  'string': (param) => {
+    let json = {};
+    json.type = 'string';
+    if (param.options && param.options.values) {
+      json.enum = param.options.values;
+    }
+    return json;
+  },
+  'number': (param) => {
+    let json = {};
+    json.type = 'number';
+    if (param.range) {
+      json.minimum = param.range[0];
+      json.maximum = param.range[1];
+    }
+    if (param.options && param.options.values) {
+      json.enum = param.options.values;
+    }
+    return json;
+  },
+  'float': (param) => {
+    let json = {};
+    json.type = 'number';
+    if (param.range) {
+      json.minimum = param.range[0];
+      json.maximum = param.range[1];
+    }
+    if (param.options && param.options.values) {
+      json.enum = param.options.values;
+    }
+    return json;
+  },
+  'integer': (param) => {
+    let json = {};
+    json.type = 'integer';
+    if (param.range) {
+      json.minimum = param.range[0];
+      json.maximum = param.range[1];
+    }
+    if (param.options) {
+      json.enum = param.options;
+    }
+    return json;
+  },
+  'array': (param) => {
+    let json = {};
+    json.type = 'array';
+    if (param.schema && param.schema.length) {
+      json.items = convertParamToJSONSchema(param.schema[0]);
+    }
+    return json;
+  },
+  'object': (param) => {
+    let schemas = [param.schema || []].concat(param.alternateSchemas || []);
+    schemas = schemas.filter(schema => schema.length > 0);
+    if (schemas.length > 1) {
+      return {
+        oneOf: schemas.map(schema => convertParametersArrayToJSONSchema(schema))
+      };
+    } else {
+      return convertParametersArrayToJSONSchema(schemas[0] || []);
+    }
+  },
+  'enum': (param) => {
+    let json = {};
+    json.enum = param.members.map(member => member[0]);
+    return json;
+  },
+  'buffer': (param) => {
+    let json = {};
+    json.type = 'object';
+    json.properties = {
+      '_base64': {type: 'string', contentEncoding: 'base64'},
+    };
+    return json;
+  },
+  'object.http': (param) => {
+    let json = {};
+    json.type = 'object';
+    json.properties = {
+      'statusCode': {type: 'integer'},
+      'headers': {type: 'object'},
+      'body': {type: 'string'}
+    };
+    return json;
+  },
+  'object.keyql.query': (param) => {
+    let json = {};
+    json.type = 'object';
+    return json;
+  },
+  'object.keyql.limit': (param) => {
+    let json = {};
+    json.type = 'object';
+    json.properties = {
+      'count': {type: 'integer', minimum: 0},
+      'offset': {type: 'integer', minimum: 0}
+    };
+    return json;
+  },
+  'object.keyql.order': (param) => {
+    let json = {};
+    json.type = 'array';
+    json.items = {
+      type: 'object',
+      properties: {
+        'field': {type: 'string'},
+        'sort': {enum: ['ASC', 'DESC']}
+      }
+    };
+    return json;
+  },
+  'any': (param) => {
+    let json = {};
+    return json;
+  }
+};
+
+const convertParamToJSONSchema = (param) => {
+  let convert = FunctionScriptToJSONSchemaMapping[param.type];
+  if (typeof convert === 'function') {
+    let json = convert(param);
+    if (param.description) {
+      json.description = param.description;
+    }
+    if (param.defaultValue !== null) {
+      json.default = param.defaultValue;
+    }
+    return json;
+  } else {
+    throw new Error(`Invalid param type for JSON Schema: "${param.type}"`);
+  }
+};
+
+const convertParametersArrayToJSONSchema = (params) => {
+  return params.reduce((obj, param) => {
+    obj.properties[param.name] = convertParamToJSONSchema(param);
+    if (!param.hasOwnProperty('defaultValue')) {
+      obj.required = obj.required || [];
+      obj.required.push(param.name);
+    }
+    return obj;
+  }, {
+    type: 'object',
+    properties: {}
+  });
+};
+
+const generateOpenAPISpec = (definitions, plugin, server, origin, identifier) => {
+
+  const paths = Object.keys(definitions)
+    .filter(key => {
+      let def = definitions[key];
+      return def.format.language !== 'static';
+    })
+    .reduce((paths, key) => {
+      let def = definitions[key];
+      let parts = key.split('/');
+      if (!parts[parts.length - 1]) {
+        parts.pop();
+      }
+      let name = parts.join('_').replace(/[^a-z0-9\-\_]+/gi, '-') || '_';
+      let route = `/${key}`;
+      if (route.match(/:notfound$/)) {
+        route = route.replace(/:notfound$/, '*/');
+      } else if (!route.endsWith('/')) {
+        route = route + '/';
+      }
+      let opIdentifier = identifier.replace(/\[(.*)\]/gi, '');
+      let operationId = `${opIdentifier}${parts.length ? ('.' + parts.join('.')) : ''}`;
+      operationId = operationId.replace(/[^A-Z0-9_]+/gi, '_');
+      operationId = operationId.replace(/^_+/gi, '');
+      operationId = operationId.replace(/_+$/gi, '');
+      let pathData = {
+        description: def.description,
+        operationId: operationId
+      };
+      // If we have at least one required parameter...
+      if (def.params.filter(param => !param.hasOwnProperty('defaultValue').length > 0)) {
+        pathData.requestBody = {
+          'content': {
+            'application/json': {
+              'schema': {
+                ...convertParametersArrayToJSONSchema(def.params)
+              }
+            }
+          }
+        }
+      };
+      if (def.returns && def.returns.type !== 'object.http') {
+        pathData.responses = {
+          '200': {
+            'content': {
+              'application/json': {
+                'schema': {
+                  ...convertParamToJSONSchema(def.returns)
+                }
+              }
+            }
+          }
+        };
+      }
+      paths[route] = {
+        post: pathData
+      };
+      return paths;
+    }, {});
+
+  const spec = {
+    openapi: '3.1.0',
+    info: {
+      version: plugin.version,
+      title: plugin.name,
+      description: plugin.description
+    },
+    servers: [
+      {
+        url: origin,
+        description: server
+      }
+    ],
+    paths: paths
+  };
+
+  if (plugin.termsOfService) {
+    spec.info.termsOfService = plugin.termsOfService;
+  }
+
+  if (plugin.contact) {
+    const {name, url, email} = plugin.contact;
+    if (name || url || email) {
+      spec.info.contact = {};
+    }
+    name && (spec.info.contact.name = name);
+    url && (spec.info.contact.url = url);
+    email && (spec.info.contact.email = email);
+  }
+
+  return spec;
+
+};
+
+const wellKnowns = {
+
+  validatePlugin: (rawPlugin, origin) => {
+
+    const plugin = {};
+
+    if (rawPlugin && typeof rawPlugin !== 'object' || Array.isArray(rawPlugin)) {
+      throw new Error(`"plugin" must be an object`);
+    }
+
+    plugin.name = rawPlugin.name || '(No name provided)';
+    plugin.description = rawPlugin.description || '(No description provided)';
+    plugin.version = rawPlugin.version || 'local';
+    plugin.image_url = rawPlugin.image_url || null;
+    if (
+      typeof plugin.image_url === 'string' &&
+      plugin.image_url.startsWith('/')
+    ) {
+      plugin.image_url = `${origin}${plugin.image_url}`;
+    }
+
+    plugin.forModel = rawPlugin.forModel || {};
+    plugin.forModel.name = plugin.forModel.name || plugin.name;
+    plugin.forModel.description = plugin.forModel.description || plugin.description;
+
+    plugin.termsOfService = rawPlugin.termsOfService || null;
+    if (
+      typeof plugin.termsOfService === 'string' &&
+      plugin.termsOfService.startsWith('/')
+    ) {
+      plugin.termsOfService = `${origin}${plugin.termsOfService}`;
+    }
+
+    plugin.contact = rawPlugin.contact || {};
+
+    const checkPluginValue = (name, isRequired = false) => {
+      let names = name.split('.');
+      let check = plugin;
+      for (let i = 0; i < names.length; i++) {
+        let n = names[i];
+        check = check[n];
+      }
+      if (typeof check !== 'string') {
+        if (check === null || check === void 0) {
+          if (isRequired) {
+            throw new Error(`plugin.${name} is required`);
+          }
+        } else {
+          throw new Error(`plugin.${name} must be a string`);
+        }
+      }
+    };
+
+    [
+      'name',
+      'description',
+      'version',
+      'forModel.name',
+      'forModel.description'
+    ].forEach(name => checkPluginValue(name, true));
+
+    [
+      'image_url',
+      'termsOfService',
+      'contact.name',
+      'contact.url',
+      'contact.email'
+    ].forEach(name => checkPluginValue(name));
+
+    return plugin;
+
+  },
+
+  handlers: {
+
+    '.well-known/plugin.json': (definitions, plugin, server, origin, identifier) => {
+
+      const body = Buffer.from(JSON.stringify(plugin, null, 2));
+      return {
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body
+      };
+
+    },
+
+    '.well-known/ai-plugin.json': (definitions, plugin, server, origin, identifier) => {
+
+      const AIPlugin = {};
+      AIPlugin.schema_version = 'v1';
+      AIPlugin.name_for_human = plugin.name.slice(0, 20);
+      AIPlugin.name_for_model = plugin.forModel.name.slice(0, 50);
+      AIPlugin.name_for_model = AIPlugin.name_for_model.replace(/[^A-Z0-9_]+/gi, '_');
+      AIPlugin.name_for_model = AIPlugin.name_for_model.replace(/^_+/gi, '');
+      AIPlugin.name_for_model = AIPlugin.name_for_model.replace(/_+$/gi, '');
+      AIPlugin.description_for_human = plugin.description.slice(0, 100);
+      AIPlugin.description_for_model = plugin.forModel.description.slice(0, 8000);
+      AIPlugin.auth = {
+        type: 'none'
+      };
+      AIPlugin.api = {
+        type: 'openapi',
+        url: `${origin}/.well-known/openapi.yaml`
+      };
+      AIPlugin.logo_url = `${origin}/logo.png`;
+      AIPlugin.contact_email = `noreply@${origin.replace(/^https?\:\/\/(.*)(:\d+)/gi, '$1')}`;
+      AIPlugin.legal_info_url = `${origin}/tos.txt`;
+      if (plugin.image_url) {
+        AIPlugin.logo_url = plugin.image_url;
+      }
+      if (plugin.contact && plugin.contact.email) {
+        AIPlugin.contact_email = plugin.contact.email;
+      }
+      if (plugin.termsOfService) {
+        AIPlugin.legal_info_url = plugin.termsOfService;
+      }
+
+      return {
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: Buffer.from(JSON.stringify(AIPlugin, null, 2))
+      };
+
+    },
+
+    '.well-known/openapi.json': (definitions, plugin, server, origin, identifier) => {
+
+      const spec = generateOpenAPISpec(definitions, plugin, server, origin, identifier);
+      const body = Buffer.from(JSON.stringify(spec, null, 2));
+      return {
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body
+      };
+
+    },
+
+    '.well-known/openapi.yaml': (definitions, plugin, server, origin, identifier) => {
+
+      const spec = generateOpenAPISpec(definitions, plugin, server, origin, identifier);
+      const body = Buffer.from(YAML.stringify(spec));
+      return {
+        headers: {
+          'Content-Type': 'application/yaml'
+        },
+        body
+      };
+
+    },
+
+    '.well-known/schema.json': (definitions, plugin, server, origin, identifier) => {
+
+      const schema = Object.keys(definitions)
+        .filter(key => {
+          let def = definitions[key];
+          return def.format.language !== 'static';
+        })
+        .map(key => {
+          let def = definitions[key];
+          let parts = key.split('/');
+          if (!parts[parts.length - 1]) {
+            parts.pop();
+          }
+          let name = parts.join('_').replace(/[^a-z0-9\-\_]+/gi, '-') || '_';
+          let route = `/${key}`;
+          if (route.match(/:notfound$/)) {
+            route = route.replace(/:notfound$/, '*/');
+          } else if (!route.endsWith('/')) {
+            route = route + '/';
+          }
+          return {
+            name: name,
+            description: def.description,
+            route: route,
+            url: `${origin}${route}`,
+            method: `POST`,
+            lib: `${identifier}${parts.length ? ('.' + parts.join('.')) : ''}`,
+            parameters: convertParametersArrayToJSONSchema(def.params)
+          };
+        });
+
+      const response = {
+        functions: schema
+      };
+
+      const body = Buffer.from(JSON.stringify(response, null, 2));
+
+      return {
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body
+      };
+
+    }
+  }
+
+};
+
+module.exports = wellKnowns;
diff --git a/package.json b/package.json
index 786382b..74e2a23 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "functionscript",
-  "version": "1.8.0",
-  "description": "A language and specification for turning JavaScript functions into typed HTTP APIs",
+  "version": "2.10.6",
+  "description": "An API gateway and framework for turning functions into web services",
   "author": "Keith Horwood <keithwhor@gmail.com>",
   "main": "index.js",
   "scripts": {
@@ -9,14 +9,17 @@
     "output": "node ./tests/output.js"
   },
   "dependencies": {
-    "babylon": "^6.16.1",
+    "@babel/parser": "^7.12.11",
+    "fast-xml-parser": "^3.19.0",
+    "json-to-pretty-yaml": "^1.2.2",
     "keyql": "^0.2.2",
+    "mime": "^2.5.2",
     "minimatch": "^3.0.4",
     "uuid": "^3.0.1"
   },
   "devDependencies": {
     "chai": "^3.5.0",
     "form-data": "^2.3.2",
-    "mocha": "^7.2.0"
+    "mocha": "^10.1.0"
   }
 }
diff --git a/tests/files/cases/function_invalid_background.js b/tests/files/cases/function_invalid_background.js
new file mode 100644
index 0000000..de01cd9
--- /dev/null
+++ b/tests/files/cases/function_invalid_background.js
@@ -0,0 +1,10 @@
+/**
+* Function with an invalid background
+* @background hello
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'invalid acl entry');
+
+};
diff --git a/tests/files/cases/function_invalid_definition_order_charge.js b/tests/files/cases/function_invalid_definition_order_charge.js
index 11091a9..95d876a 100644
--- a/tests/files/cases/function_invalid_definition_order_charge.js
+++ b/tests/files/cases/function_invalid_definition_order_charge.js
@@ -1,6 +1,6 @@
 /**
 * Function with invalid function definition order due to charge
-* @bg empty
+* @background empty
 * @acl *
 *   user_username faas_tester deny
 *   user_username faas_tester2 deny
diff --git a/tests/files/cases/function_invalid_keyql_limit_default.js b/tests/files/cases/function_invalid_keyql_limit_default.js
new file mode 100644
index 0000000..a65c4c0
--- /dev/null
+++ b/tests/files/cases/function_invalid_keyql_limit_default.js
@@ -0,0 +1,8 @@
+/**
+* Invalid KeyQL Limit
+* @param {object.keyql.limit} limit Some limit
+* @returns {string}
+*/
+module.exports = async (limit = {count: 0, fhg: 'wat'}) => {
+  return 'hello';
+};
diff --git a/tests/files/cases/function_invalid_keyql_limit_float.js b/tests/files/cases/function_invalid_keyql_limit_float.js
new file mode 100644
index 0000000..b8e1c37
--- /dev/null
+++ b/tests/files/cases/function_invalid_keyql_limit_float.js
@@ -0,0 +1,8 @@
+/**
+* Invalid KeyQL Limit
+* @param {object.keyql.limit} limit Some limit
+* @returns {string}
+*/
+module.exports = async (limit = {count: 0.354, offset: 0}) => {
+  return 'hello';
+};
diff --git a/tests/files/cases/function_invalid_keyql_limit_mismatch.js b/tests/files/cases/function_invalid_keyql_limit_mismatch.js
new file mode 100644
index 0000000..e27aced
--- /dev/null
+++ b/tests/files/cases/function_invalid_keyql_limit_mismatch.js
@@ -0,0 +1,8 @@
+/**
+* Invalid KeyQL Limit
+* @param {object.keyql.limit} limit Some limit {:} [5, 4]
+* @returns {string}
+*/
+module.exports = async (limit) => {
+  return 'hello';
+};
diff --git a/tests/files/cases/function_invalid_keyql_limit_oob.js b/tests/files/cases/function_invalid_keyql_limit_oob.js
new file mode 100644
index 0000000..9c21ac6
--- /dev/null
+++ b/tests/files/cases/function_invalid_keyql_limit_oob.js
@@ -0,0 +1,8 @@
+/**
+* Invalid KeyQL Limit
+* @param {object.keyql.limit} limit Some limit
+* @returns {string}
+*/
+module.exports = async (limit = {count: -1, offset: 0}) => {
+  return 'hello';
+};
diff --git a/tests/files/cases/function_invalid_keyql_limit_oob_offset.js b/tests/files/cases/function_invalid_keyql_limit_oob_offset.js
new file mode 100644
index 0000000..f45bcf0
--- /dev/null
+++ b/tests/files/cases/function_invalid_keyql_limit_oob_offset.js
@@ -0,0 +1,8 @@
+/**
+* Invalid KeyQL Limit
+* @param {object.keyql.limit} limit Some limit
+* @returns {string}
+*/
+module.exports = async (limit = {count: 0, offset: -1}) => {
+  return 'hello';
+};
diff --git a/tests/files/cases/function_invalid_keyql_limit_oob_user_lb.js b/tests/files/cases/function_invalid_keyql_limit_oob_user_lb.js
new file mode 100644
index 0000000..6173526
--- /dev/null
+++ b/tests/files/cases/function_invalid_keyql_limit_oob_user_lb.js
@@ -0,0 +1,8 @@
+/**
+* Invalid KeyQL Limit
+* @param {object.keyql.limit} limit Some limit {:} [2, 20]
+* @returns {string}
+*/
+module.exports = async (limit = {count: 1, offset: 0}) => {
+  return 'hello';
+};
diff --git a/tests/files/cases/function_invalid_keyql_limit_oob_user_ub.js b/tests/files/cases/function_invalid_keyql_limit_oob_user_ub.js
new file mode 100644
index 0000000..c43bd49
--- /dev/null
+++ b/tests/files/cases/function_invalid_keyql_limit_oob_user_ub.js
@@ -0,0 +1,8 @@
+/**
+* Invalid KeyQL Limit
+* @param {object.keyql.limit} limit Some limit {:} [2, 20]
+* @returns {string}
+*/
+module.exports = async (limit = {count: 21, offset: 0}) => {
+  return 'hello';
+};
diff --git a/tests/files/cases/function_invalid_origin.js b/tests/files/cases/function_invalid_origin.js
new file mode 100644
index 0000000..bc8812d
--- /dev/null
+++ b/tests/files/cases/function_invalid_origin.js
@@ -0,0 +1,10 @@
+/**
+* Function with an invalid origin
+* @origin *.autocode.com
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'origin');
+
+};
diff --git a/tests/files/cases/function_invalid_origin_asterisk.js b/tests/files/cases/function_invalid_origin_asterisk.js
new file mode 100644
index 0000000..ed024b8
--- /dev/null
+++ b/tests/files/cases/function_invalid_origin_asterisk.js
@@ -0,0 +1,10 @@
+/**
+* Function with an invalid origin
+* @origin *
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'origin');
+
+};
diff --git a/tests/files/cases/function_invalid_origin_bad_protocol.js b/tests/files/cases/function_invalid_origin_bad_protocol.js
new file mode 100644
index 0000000..acfc712
--- /dev/null
+++ b/tests/files/cases/function_invalid_origin_bad_protocol.js
@@ -0,0 +1,10 @@
+/**
+* Function with an invalid origin
+* @origin file://www.autocode.com
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'origin');
+
+};
diff --git a/tests/files/cases/function_invalid_parameter_not.js b/tests/files/cases/function_invalid_parameter_not.js
new file mode 100644
index 0000000..9cfab89
--- /dev/null
+++ b/tests/files/cases/function_invalid_parameter_not.js
@@ -0,0 +1,9 @@
+/**
+* My function
+* @param {string} a alpha
+* @param {number} b beta
+* @returns {string}
+*/
+module.exports = async (a = 'hi', b = !7, context) => {
+  // valid, negative number
+};
diff --git a/tests/files/cases/function_invalid_parameter_not_not.js b/tests/files/cases/function_invalid_parameter_not_not.js
new file mode 100644
index 0000000..2f3c645
--- /dev/null
+++ b/tests/files/cases/function_invalid_parameter_not_not.js
@@ -0,0 +1,9 @@
+/**
+* My function
+* @param {string} a alpha
+* @param {number} b beta
+* @returns {string}
+*/
+module.exports = async (a = 'hi', b = !!7, context) => {
+  // valid, negative number
+};
diff --git a/tests/files/cases/function_invalid_parameter_reserved_name.js b/tests/files/cases/function_invalid_parameter_reserved_name.js
new file mode 100644
index 0000000..e3e0016
--- /dev/null
+++ b/tests/files/cases/function_invalid_parameter_reserved_name.js
@@ -0,0 +1,8 @@
+/**
+* Invalid param - reserved name
+* @param {string} _stream
+* @returns {boolean}
+*/
+module.exports = async (_stream, context) => {
+  return true;
+};
diff --git a/tests/files/cases/function_invalid_stream_no_name.js b/tests/files/cases/function_invalid_stream_no_name.js
new file mode 100644
index 0000000..9306012
--- /dev/null
+++ b/tests/files/cases/function_invalid_stream_no_name.js
@@ -0,0 +1,8 @@
+/**
+* Invalid stream - no name
+* @stream {string}
+* @returns {boolean}
+*/
+module.exports = async (context) => {
+  return true;
+};
diff --git a/tests/files/cases/function_invalid_stream_nonfriendly_name.js b/tests/files/cases/function_invalid_stream_nonfriendly_name.js
new file mode 100644
index 0000000..b112fe8
--- /dev/null
+++ b/tests/files/cases/function_invalid_stream_nonfriendly_name.js
@@ -0,0 +1,8 @@
+/**
+* Invalid stream - nonfriendly name
+* @stream {string} ?stream
+* @returns {boolean}
+*/
+module.exports = async (context) => {
+  return true;
+};
diff --git a/tests/files/cases/function_valid_background.js b/tests/files/cases/function_valid_background.js
new file mode 100644
index 0000000..2b5b53b
--- /dev/null
+++ b/tests/files/cases/function_valid_background.js
@@ -0,0 +1,10 @@
+/**
+* Function with an valid background
+* @background
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'invalid acl entry');
+
+};
diff --git a/tests/files/cases/function_valid_background_mode.js b/tests/files/cases/function_valid_background_mode.js
new file mode 100644
index 0000000..1347667
--- /dev/null
+++ b/tests/files/cases/function_valid_background_mode.js
@@ -0,0 +1,10 @@
+/**
+* Function with an valid set background
+* @background params
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'invalid acl entry');
+
+};
diff --git a/tests/files/cases/function_valid_definition_order.js b/tests/files/cases/function_valid_definition_order.js
index 340fb4e..b9a07da 100644
--- a/tests/files/cases/function_valid_definition_order.js
+++ b/tests/files/cases/function_valid_definition_order.js
@@ -1,6 +1,6 @@
 /**
 * Function with valid function definition order
-* @bg empty
+* @background empty
 * @charge 10
 * @acl *
 *   user_username faas_tester deny
diff --git a/tests/files/cases/function_valid_inline.js b/tests/files/cases/function_valid_inline.js
new file mode 100644
index 0000000..8bfb529
--- /dev/null
+++ b/tests/files/cases/function_valid_inline.js
@@ -0,0 +1 @@
+return 'lol'; // valid
diff --git a/tests/files/cases/function_valid_inline_addition.js b/tests/files/cases/function_valid_inline_addition.js
new file mode 100644
index 0000000..cc20675
--- /dev/null
+++ b/tests/files/cases/function_valid_inline_addition.js
@@ -0,0 +1,5 @@
+// Valid inline function
+let a = 1;
+let b = 2;
+
+return a + b;
diff --git a/tests/files/cases/function_valid_inline_await.js b/tests/files/cases/function_valid_inline_await.js
new file mode 100644
index 0000000..f59a515
--- /dev/null
+++ b/tests/files/cases/function_valid_inline_await.js
@@ -0,0 +1,3 @@
+const sleep = t => new Promise(res => setTimeout(() => res(null), t))
+await sleep(100);
+return `hello world`;
diff --git a/tests/files/cases/function_valid_inline_context.js b/tests/files/cases/function_valid_inline_context.js
new file mode 100644
index 0000000..887f0bf
--- /dev/null
+++ b/tests/files/cases/function_valid_inline_context.js
@@ -0,0 +1,4 @@
+// Valid inline function
+console.log(context);
+
+return context.params;
diff --git a/tests/files/cases/function_valid_inline_empty.js b/tests/files/cases/function_valid_inline_empty.js
new file mode 100644
index 0000000..fce0b49
--- /dev/null
+++ b/tests/files/cases/function_valid_inline_empty.js
@@ -0,0 +1 @@
+console.log('wat'); // valid
diff --git a/tests/files/cases/function_valid_keyql_limit.js b/tests/files/cases/function_valid_keyql_limit.js
new file mode 100644
index 0000000..cf646c8
--- /dev/null
+++ b/tests/files/cases/function_valid_keyql_limit.js
@@ -0,0 +1,8 @@
+/**
+* Invalid KeyQL Limit
+* @param {object.keyql.limit} limit Some limit {:} [2, 20]
+* @returns {string}
+*/
+module.exports = async (limit = {count: 15, offset: 0}) => {
+  return 'hello';
+};
diff --git a/tests/files/cases/function_valid_multiline_param.js b/tests/files/cases/function_valid_multiline_param.js
new file mode 100644
index 0000000..9155fa7
--- /dev/null
+++ b/tests/files/cases/function_valid_multiline_param.js
@@ -0,0 +1,11 @@
+/**
+* Valid function with a multiline param definition
+* @param {string} alpha Not the omega,
+* but the ____...
+* @returns {boolean}
+*/
+module.exports = async (alpha) => {
+
+  return true;
+
+};
diff --git a/tests/files/cases/function_valid_origin.js b/tests/files/cases/function_valid_origin.js
new file mode 100644
index 0000000..c7907b7
--- /dev/null
+++ b/tests/files/cases/function_valid_origin.js
@@ -0,0 +1,10 @@
+/**
+* Function with an valid origin
+* @origin autocode.com
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'origin');
+
+};
diff --git a/tests/files/cases/function_valid_origin_http_port_subdomain.js b/tests/files/cases/function_valid_origin_http_port_subdomain.js
new file mode 100644
index 0000000..5083f4e
--- /dev/null
+++ b/tests/files/cases/function_valid_origin_http_port_subdomain.js
@@ -0,0 +1,10 @@
+/**
+* Function with an valid origin
+* @origin http://x.y.z.localhost:8000
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'origin');
+
+};
diff --git a/tests/files/cases/function_valid_origin_https_port_subdomain.js b/tests/files/cases/function_valid_origin_https_port_subdomain.js
new file mode 100644
index 0000000..4f277f1
--- /dev/null
+++ b/tests/files/cases/function_valid_origin_https_port_subdomain.js
@@ -0,0 +1,10 @@
+/**
+* Function with an valid origin
+* @origin https://x.y.z.localhost:8000
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'origin');
+
+};
diff --git a/tests/files/cases/function_valid_origin_localhost.js b/tests/files/cases/function_valid_origin_localhost.js
new file mode 100644
index 0000000..9de08ab
--- /dev/null
+++ b/tests/files/cases/function_valid_origin_localhost.js
@@ -0,0 +1,10 @@
+/**
+* Function with an valid origin
+* @origin localhost
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'origin');
+
+};
diff --git a/tests/files/cases/function_valid_origin_port.js b/tests/files/cases/function_valid_origin_port.js
new file mode 100644
index 0000000..da2625c
--- /dev/null
+++ b/tests/files/cases/function_valid_origin_port.js
@@ -0,0 +1,10 @@
+/**
+* Function with an valid origin
+* @origin localhost:8000
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'origin');
+
+};
diff --git a/tests/files/cases/function_valid_origin_port_subdomain.js b/tests/files/cases/function_valid_origin_port_subdomain.js
new file mode 100644
index 0000000..b5e7da4
--- /dev/null
+++ b/tests/files/cases/function_valid_origin_port_subdomain.js
@@ -0,0 +1,10 @@
+/**
+* Function with an valid origin
+* @origin x.y.z.localhost:8000
+* @returns {string}
+*/
+module.exports = (callback) => {
+
+  return callback(null, 'origin');
+
+};
diff --git a/tests/files/cases/function_valid_parameter_negative.js b/tests/files/cases/function_valid_parameter_negative.js
new file mode 100644
index 0000000..f87f645
--- /dev/null
+++ b/tests/files/cases/function_valid_parameter_negative.js
@@ -0,0 +1,9 @@
+/**
+* My function
+* @param {string} a alpha
+* @param {number} b beta
+* @returns {string}
+*/
+module.exports = async (a = 'hi', b = -7, context) => {
+  // valid, negative number
+};
diff --git a/tests/files/cases/function_valid_parameter_positive.js b/tests/files/cases/function_valid_parameter_positive.js
new file mode 100644
index 0000000..c864594
--- /dev/null
+++ b/tests/files/cases/function_valid_parameter_positive.js
@@ -0,0 +1,9 @@
+/**
+* My function
+* @param {string} a alpha
+* @param {number} b beta
+* @returns {string}
+*/
+module.exports = async (a = 'hi', b = +7, context) => {
+  // valid, negative number
+};
diff --git a/tests/files/cases/function_valid_parameter_reserved_name_nested.js b/tests/files/cases/function_valid_parameter_reserved_name_nested.js
new file mode 100644
index 0000000..b4183d5
--- /dev/null
+++ b/tests/files/cases/function_valid_parameter_reserved_name_nested.js
@@ -0,0 +1,9 @@
+/**
+* Valid param - reserved name in subset
+* @param {object} myObject
+* @ {string} _stream
+* @returns {boolean}
+*/
+module.exports = async (myObject, context) => {
+  return true;
+};
diff --git a/tests/files/cases/function_valid_stream.js b/tests/files/cases/function_valid_stream.js
new file mode 100644
index 0000000..2fd3163
--- /dev/null
+++ b/tests/files/cases/function_valid_stream.js
@@ -0,0 +1,8 @@
+/**
+* Valid stream - has name
+* @stream {string} message
+* @returns {boolean}
+*/
+module.exports = async (context) => {
+  return true;
+};
diff --git a/tests/files/cases/function_valid_stream_with_name.js b/tests/files/cases/function_valid_stream_with_name.js
new file mode 100644
index 0000000..93679d0
--- /dev/null
+++ b/tests/files/cases/function_valid_stream_with_name.js
@@ -0,0 +1,8 @@
+/**
+* Valid Streaming
+* @stream {string} hello Some description
+* @returns {boolean}
+*/
+module.exports = async (context) => {
+  return true;
+};
diff --git a/tests/files/cases/inline_valid_addition.js b/tests/files/cases/inline_valid_addition.js
new file mode 100644
index 0000000..cc20675
--- /dev/null
+++ b/tests/files/cases/inline_valid_addition.js
@@ -0,0 +1,5 @@
+// Valid inline function
+let a = 1;
+let b = 2;
+
+return a + b;
diff --git a/tests/files/cases/inline_valid_context.js b/tests/files/cases/inline_valid_context.js
new file mode 100644
index 0000000..887f0bf
--- /dev/null
+++ b/tests/files/cases/inline_valid_context.js
@@ -0,0 +1,4 @@
+// Valid inline function
+console.log(context);
+
+return context.params;
diff --git a/tests/files/comprehensive/inline.js b/tests/files/comprehensive/inline.js
new file mode 100644
index 0000000..eb9f5f8
--- /dev/null
+++ b/tests/files/comprehensive/inline.js
@@ -0,0 +1 @@
+return context.params;
diff --git a/tests/gateway/functions/a_standard_function.js b/tests/gateway/functions/a_standard_function.js
new file mode 100644
index 0000000..b95b146
--- /dev/null
+++ b/tests/gateway/functions/a_standard_function.js
@@ -0,0 +1,6 @@
+/**
+* Nothing special about this function
+*/
+module.exports = async () => {
+  return true;
+};
diff --git a/tests/gateway/functions/bg/__main__.js b/tests/gateway/functions/bg/__main__.js
index bfb069e..6f0397c 100644
--- a/tests/gateway/functions/bg/__main__.js
+++ b/tests/gateway/functions/bg/__main__.js
@@ -1,4 +1,5 @@
 /**
+* @background
 * @returns {string}
 */
 module.exports = (callback) => {
diff --git a/tests/gateway/functions/bg/empty.js b/tests/gateway/functions/bg/empty.js
index af3fdb8..f863d1d 100644
--- a/tests/gateway/functions/bg/empty.js
+++ b/tests/gateway/functions/bg/empty.js
@@ -1,5 +1,5 @@
 /**
-* @bg empty
+* @background empty
 * @returns {string}
 */
 module.exports = (callback) => {
diff --git a/tests/gateway/functions/bg/info.js b/tests/gateway/functions/bg/info.js
index fd21d58..ec68fe2 100644
--- a/tests/gateway/functions/bg/info.js
+++ b/tests/gateway/functions/bg/info.js
@@ -1,5 +1,5 @@
 /**
-* @bg info
+* @background info
 * @returns {string}
 */
 module.exports = (callback) => {
diff --git a/tests/gateway/functions/bg/params.js b/tests/gateway/functions/bg/params.js
index 21ff70e..d2820a9 100644
--- a/tests/gateway/functions/bg/params.js
+++ b/tests/gateway/functions/bg/params.js
@@ -1,5 +1,5 @@
 /**
-* @bg params
+* @background params
 * @returns {string}
 */
 module.exports = (callback) => {
diff --git a/tests/gateway/functions/bg/paramsSpecific1.js b/tests/gateway/functions/bg/paramsSpecific1.js
index 15a3b65..046839b 100644
--- a/tests/gateway/functions/bg/paramsSpecific1.js
+++ b/tests/gateway/functions/bg/paramsSpecific1.js
@@ -1,6 +1,6 @@
 /**
 * Comment for the function is here
-* @bg params 
+* @background params 
 * data 
 * @returns {string}
 */
diff --git a/tests/gateway/functions/bg/paramsSpecific2.js b/tests/gateway/functions/bg/paramsSpecific2.js
index 5c10849..1133f05 100644
--- a/tests/gateway/functions/bg/paramsSpecific2.js
+++ b/tests/gateway/functions/bg/paramsSpecific2.js
@@ -1,5 +1,5 @@
 /**
-* @bg params data otherdata
+* @background params data otherdata
 * @returns {string}
 */
 module.exports = (callback) => {
diff --git a/tests/gateway/functions/bg/paramsSpecific3.js b/tests/gateway/functions/bg/paramsSpecific3.js
index 6c6b786..e5ef6d6 100644
--- a/tests/gateway/functions/bg/paramsSpecific3.js
+++ b/tests/gateway/functions/bg/paramsSpecific3.js
@@ -1,5 +1,5 @@
 /**
-* @bg params data
+* @background params data
 * @returns {string}
 */
 module.exports = (callback) => {
diff --git a/tests/gateway/functions/buffer_reflect.js b/tests/gateway/functions/buffer_reflect.js
new file mode 100644
index 0000000..4cad328
--- /dev/null
+++ b/tests/gateway/functions/buffer_reflect.js
@@ -0,0 +1,7 @@
+/**
+* @param {buffer} bufferParam
+* @returns {buffer} mybuf
+*/
+module.exports = async (bufferParam) => {
+  return bufferParam;
+};
diff --git a/tests/gateway/functions/buffer_within_array_param.js b/tests/gateway/functions/buffer_within_array_param.js
new file mode 100644
index 0000000..93916d8
--- /dev/null
+++ b/tests/gateway/functions/buffer_within_array_param.js
@@ -0,0 +1,13 @@
+/**
+* @param {array} arrayParam
+* @ {buffer} bufferItem
+*/
+module.exports = async (arrayParam) => {
+  if (!arrayParam.length) {
+    throw new Error('No array items provided');
+  }
+  if (!Buffer.isBuffer(arrayParam[0])) {
+    throw new Error('The parsed value of the array parameter\'s item is not a buffer');
+  }
+  return 'ok';
+};
diff --git a/tests/gateway/functions/buffer_within_object_param.js b/tests/gateway/functions/buffer_within_object_param.js
new file mode 100644
index 0000000..0c9fc9a
--- /dev/null
+++ b/tests/gateway/functions/buffer_within_object_param.js
@@ -0,0 +1,10 @@
+/**
+* @param {object} objectParam
+* @ {buffer} bufferVal
+*/
+module.exports = async (objectParam) => {
+  if (!Buffer.isBuffer(objectParam.bufferVal)) {
+    throw new Error('The parsed value of the object parameter\'s "bufferVal" key is not a buffer');
+  }
+  return 'ok';
+};
diff --git a/tests/gateway/functions/empty/__main__.js b/tests/gateway/functions/empty/__main__.js
new file mode 100644
index 0000000..82db7cb
--- /dev/null
+++ b/tests/gateway/functions/empty/__main__.js
@@ -0,0 +1,9 @@
+/**
+* @param {integer} intValue
+* @returns {string}
+*/
+module.exports = (intValue, callback) => {
+
+  return callback(null, 'hello world');
+
+};
diff --git a/tests/gateway/functions/inline/await.js b/tests/gateway/functions/inline/await.js
new file mode 100644
index 0000000..e7a27ce
--- /dev/null
+++ b/tests/gateway/functions/inline/await.js
@@ -0,0 +1,3 @@
+const sleep = t => new Promise(res => setTimeout(() => res(null), t))
+await sleep(10);
+return `hello world`;
diff --git a/tests/gateway/functions/inline/buffer.js b/tests/gateway/functions/inline/buffer.js
new file mode 100644
index 0000000..71038f2
--- /dev/null
+++ b/tests/gateway/functions/inline/buffer.js
@@ -0,0 +1,3 @@
+let buffer = Buffer.from('lol');
+buffer.contentType = 'text/html';
+return buffer;
diff --git a/tests/gateway/functions/inline/buffer_mock.js b/tests/gateway/functions/inline/buffer_mock.js
new file mode 100644
index 0000000..b09395d
--- /dev/null
+++ b/tests/gateway/functions/inline/buffer_mock.js
@@ -0,0 +1 @@
+return {_base64: Buffer.from('lol').toString('base64')};
diff --git a/tests/gateway/functions/inline/context.js b/tests/gateway/functions/inline/context.js
new file mode 100644
index 0000000..9e1e721
--- /dev/null
+++ b/tests/gateway/functions/inline/context.js
@@ -0,0 +1 @@
+return context;
diff --git a/tests/gateway/functions/inline/extended_http_is_object.js b/tests/gateway/functions/inline/extended_http_is_object.js
new file mode 100644
index 0000000..cbdf15e
--- /dev/null
+++ b/tests/gateway/functions/inline/extended_http_is_object.js
@@ -0,0 +1,6 @@
+return {
+  statusCode: 429,
+  headers: {'Content-Type': 'text/html'},
+  body: 'lol',
+  extend: true
+};
diff --git a/tests/gateway/functions/inline/http.js b/tests/gateway/functions/inline/http.js
new file mode 100644
index 0000000..9383865
--- /dev/null
+++ b/tests/gateway/functions/inline/http.js
@@ -0,0 +1,5 @@
+return {
+  statusCode: 429,
+  headers: {'Content-Type': 'text/html'},
+  body: Buffer.from('lol')
+};
diff --git a/tests/gateway/functions/inline/http_no_status.js b/tests/gateway/functions/inline/http_no_status.js
new file mode 100644
index 0000000..f7f69b6
--- /dev/null
+++ b/tests/gateway/functions/inline/http_no_status.js
@@ -0,0 +1,4 @@
+return {
+  headers: {'Content-Type': 'text/html'},
+  body: Buffer.from('lol')
+};
diff --git a/tests/gateway/functions/inline/number.js b/tests/gateway/functions/inline/number.js
new file mode 100644
index 0000000..b3074e4
--- /dev/null
+++ b/tests/gateway/functions/inline/number.js
@@ -0,0 +1 @@
+return 1988;
diff --git a/tests/gateway/functions/inline/require.js b/tests/gateway/functions/inline/require.js
new file mode 100644
index 0000000..48d0999
--- /dev/null
+++ b/tests/gateway/functions/inline/require.js
@@ -0,0 +1,3 @@
+const fs = require('fs');
+
+return 'hello';
diff --git a/tests/gateway/functions/keyql_limit.js b/tests/gateway/functions/keyql_limit.js
new file mode 100644
index 0000000..b8c028b
--- /dev/null
+++ b/tests/gateway/functions/keyql_limit.js
@@ -0,0 +1,8 @@
+/**
+* Test Optional Params
+* @param {object.keyql.limit} limit
+* @returns {string}
+*/
+module.exports = async (limit) => {
+  return 'hello';
+};
diff --git a/tests/gateway/functions/keyql_limit_range.js b/tests/gateway/functions/keyql_limit_range.js
new file mode 100644
index 0000000..7f22fa3
--- /dev/null
+++ b/tests/gateway/functions/keyql_limit_range.js
@@ -0,0 +1,8 @@
+/**
+* Test Optional Params
+* @param {object.keyql.limit} limit {:} [2, 20]
+* @returns {string}
+*/
+module.exports = async (limit) => {
+  return 'hello';
+};
diff --git a/tests/gateway/functions/mismatch_params_deep.js b/tests/gateway/functions/mismatch_params_deep.js
new file mode 100644
index 0000000..6d5647d
--- /dev/null
+++ b/tests/gateway/functions/mismatch_params_deep.js
@@ -0,0 +1,13 @@
+/**
+ * Test param mismatch
+ * @param {object} userData
+ * @ {object} user
+ * @   {array} posts
+ * @     {object} post
+ * @       {string} title
+ * @       {array} messages
+ * @         {string}
+ */
+module.exports = async (userData) => {
+  return userData;
+};
diff --git a/tests/gateway/functions/mismatch_returns_anon.js b/tests/gateway/functions/mismatch_returns_anon.js
new file mode 100644
index 0000000..61deb2d
--- /dev/null
+++ b/tests/gateway/functions/mismatch_returns_anon.js
@@ -0,0 +1,13 @@
+/**
+ * Test mismatch
+ * @returns {object}
+ * @ {object} user
+ * @   {string} name
+ */
+module.exports = async () => {
+  return {
+    user: {
+      name: 5
+    }
+  };
+};
diff --git a/tests/gateway/functions/mismatch_returns_anon_array.js b/tests/gateway/functions/mismatch_returns_anon_array.js
new file mode 100644
index 0000000..2ee80a9
--- /dev/null
+++ b/tests/gateway/functions/mismatch_returns_anon_array.js
@@ -0,0 +1,14 @@
+/**
+ * Test mismatch
+ * @returns {object}
+ * @ {object} user
+ * @   {array} names
+ * @     {string} name
+ */
+module.exports = async () => {
+  return {
+    user: {
+      names: ['keith', 2]
+    }
+  };
+};
diff --git a/tests/gateway/functions/mismatch_returns_deep.js b/tests/gateway/functions/mismatch_returns_deep.js
new file mode 100644
index 0000000..2640541
--- /dev/null
+++ b/tests/gateway/functions/mismatch_returns_deep.js
@@ -0,0 +1,22 @@
+/**
+ * Test mismatch
+ * @returns {object}
+ * @ {object} user
+ * @   {array} posts
+ * @     {object} post
+ * @       {string} title
+ * @       {array} messages
+ * @         {string}
+ */
+module.exports = async () => {
+  return {
+    user: {
+      posts: [
+        {
+          title: 'sup',
+          messages: ['hey', 'there', 7]
+        }
+      ]
+    }
+  };
+};
diff --git a/tests/gateway/functions/mismatch_returns_named.js b/tests/gateway/functions/mismatch_returns_named.js
new file mode 100644
index 0000000..6b255c6
--- /dev/null
+++ b/tests/gateway/functions/mismatch_returns_named.js
@@ -0,0 +1,13 @@
+/**
+ * Test mismatch
+ * @returns {object} myObject
+ * @ {object} user
+ * @   {string} name
+ */
+module.exports = async () => {
+  return {
+    user: {
+      name: 5
+    }
+  };
+};
diff --git a/tests/gateway/functions/mismatch_returns_named_array.js b/tests/gateway/functions/mismatch_returns_named_array.js
new file mode 100644
index 0000000..e232fc3
--- /dev/null
+++ b/tests/gateway/functions/mismatch_returns_named_array.js
@@ -0,0 +1,14 @@
+/**
+ * Test mismatch
+ * @returns {object} myObject
+ * @ {object} user
+ * @   {array} names
+ * @     {string} name
+ */
+module.exports = async () => {
+  return {
+    user: {
+      names: ['keith', 2]
+    }
+  };
+};
diff --git a/tests/gateway/functions/my_function.js b/tests/gateway/functions/my_function.js
index 635ea42..88c432e 100644
--- a/tests/gateway/functions/my_function.js
+++ b/tests/gateway/functions/my_function.js
@@ -1,4 +1,5 @@
 /**
+* My function
 * @returns {number}
 */
 module.exports = (a = 1, b = 2, c = 3, callback) => {
diff --git a/tests/gateway/functions/my_function_test_parsing.js b/tests/gateway/functions/my_function_test_parsing.js
new file mode 100644
index 0000000..6e387e0
--- /dev/null
+++ b/tests/gateway/functions/my_function_test_parsing.js
@@ -0,0 +1,11 @@
+/**
+* @returns {object}
+*/
+module.exports = async (a = [], b = {}) => {
+
+  return {
+    a: a,
+    b: b
+  };
+
+};
diff --git a/tests/gateway/functions/my_function_test_parsing_convert.js b/tests/gateway/functions/my_function_test_parsing_convert.js
new file mode 100644
index 0000000..61ac3c4
--- /dev/null
+++ b/tests/gateway/functions/my_function_test_parsing_convert.js
@@ -0,0 +1,16 @@
+/**
+* @param {array} a
+* @ {?number} someNumber
+* @param {object} b
+* @ {?number} lol
+* @ {?string} wat
+* @returns {object}
+*/
+module.exports = async (a = [], b = {}) => {
+
+  return {
+    a: a,
+    b: b
+  };
+
+};
diff --git a/tests/gateway/functions/nonstandard/json.js b/tests/gateway/functions/nonstandard/json.js
new file mode 100644
index 0000000..e018b6d
--- /dev/null
+++ b/tests/gateway/functions/nonstandard/json.js
@@ -0,0 +1,9 @@
+/**
+* Test nonstandard JSON submissions
+* @returns {object}
+*/
+module.exports = async (a = 1, b = 2, c = 3, context) => {
+
+  return context;
+
+};
diff --git a/tests/gateway/functions/object_tojson.js b/tests/gateway/functions/object_tojson.js
new file mode 100644
index 0000000..291a116
--- /dev/null
+++ b/tests/gateway/functions/object_tojson.js
@@ -0,0 +1,25 @@
+class MyClass {
+
+  constructor (name = '?') {
+    this.name = name;
+  }
+
+  toJSON () {
+    return {
+      name: this.name,
+      description: this.constructor.name
+    };
+  }
+
+}
+
+/**
+* @returns {any}
+*/
+module.exports = async () => {
+
+  let obj = new MyClass('hello world');
+
+  return obj;
+
+};
diff --git a/tests/gateway/functions/origin/allow.js b/tests/gateway/functions/origin/allow.js
new file mode 100644
index 0000000..a2f3321
--- /dev/null
+++ b/tests/gateway/functions/origin/allow.js
@@ -0,0 +1,15 @@
+/**
+* Valid function for origins
+* @origin autocode.com
+* @origin localhost:8000
+* @origin test.some-url.com:9999
+* @origin https://hello.com
+* @background
+* @param {string} alpha Some value
+* @stream {boolean} hello Some value
+*/
+module.exports = async (alpha, context) => {
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/range_integer.js b/tests/gateway/functions/range_integer.js
new file mode 100644
index 0000000..7c5d715
--- /dev/null
+++ b/tests/gateway/functions/range_integer.js
@@ -0,0 +1,8 @@
+/**
+ * Test range
+ * @param {integer} ranged {:} [1, 200]
+ * @returns {any}
+ */
+module.exports = async (ranged) => {
+  return ranged;
+};
diff --git a/tests/gateway/functions/range_number.js b/tests/gateway/functions/range_number.js
new file mode 100644
index 0000000..345f5a9
--- /dev/null
+++ b/tests/gateway/functions/range_number.js
@@ -0,0 +1,8 @@
+/**
+ * Test range
+ * @param {number} ranged {:} [1.01, 199.9]
+ * @returns {any}
+ */
+module.exports = async (ranged) => {
+  return ranged;
+};
diff --git a/tests/gateway/functions/runtime/details.js b/tests/gateway/functions/runtime/details.js
new file mode 100644
index 0000000..a82c393
--- /dev/null
+++ b/tests/gateway/functions/runtime/details.js
@@ -0,0 +1,10 @@
+/**
+* @returns {any}
+*/
+module.exports = (callback) => {
+
+  let error = new Error('error');
+  error.details = {objects: 'supported'};
+  callback(error);
+
+};
diff --git a/tests/gateway/functions/runtime/timeout.js b/tests/gateway/functions/runtime/timeout.js
new file mode 100644
index 0000000..fd1880a
--- /dev/null
+++ b/tests/gateway/functions/runtime/timeout.js
@@ -0,0 +1,8 @@
+/**
+* @returns {any}
+*/
+module.exports = async () => {
+  return new Promise((resolve, reject) => {
+    // Empty promise that never resolves
+  });
+};
diff --git a/tests/gateway/functions/sanitize/http_object_invalid_header_names.js b/tests/gateway/functions/sanitize/http_object_invalid_header_names.js
new file mode 100644
index 0000000..6da6533
--- /dev/null
+++ b/tests/gateway/functions/sanitize/http_object_invalid_header_names.js
@@ -0,0 +1,20 @@
+/**
+* Test rejection of invalid header names
+* @param {string} contentType A content type
+* @returns {object.http}
+*/
+module.exports = (contentType = 'text/html', callback) => {
+
+  return callback(null, {
+    body: 'hello',
+    headers: {
+      'Content-Type ': contentType,
+      'X Authorization Key': 'somevalue',
+      ' AnotherHeader': 'somevalue',
+      'WeirdName!@#$%^&*()œ∑´®†¥¨ˆøπåß∂ƒ©˙∆˚¬≈ç√∫˜µ≤:|\{}🔥🔥🔥': 'test',
+      'MultilineName\n': 'test',
+      'Good-Header-Name': 'good value'
+    }
+  });
+
+};
diff --git a/tests/gateway/functions/sanitize/http_object_invalid_header_values.js b/tests/gateway/functions/sanitize/http_object_invalid_header_values.js
new file mode 100644
index 0000000..9f4fcf6
--- /dev/null
+++ b/tests/gateway/functions/sanitize/http_object_invalid_header_values.js
@@ -0,0 +1,22 @@
+/**
+* Test rejection of invalid header values
+* @param {string} contentType A content type
+* @returns {object.http}
+*/
+module.exports = (contentType = 'text/html', callback) => {
+
+  return callback(null, {
+    body: 'hello',
+    headers: {
+      'Null-Value': null,
+      'Undefined-Value': undefined,
+      'Object-Value': {
+        'a': 'b'
+      },
+      'Number-Value': 0xdeadbeef,
+      'Boolean-Value': false,
+      'Empty-String-Value': ''
+    }
+  });
+
+};
diff --git a/tests/gateway/functions/stream/basic.js b/tests/gateway/functions/stream/basic.js
new file mode 100644
index 0000000..458a3b6
--- /dev/null
+++ b/tests/gateway/functions/stream/basic.js
@@ -0,0 +1,12 @@
+/**
+* Valid function for streaming
+* @param {string} alpha Some value
+* @stream {boolean} hello Some value
+*/
+module.exports = async (alpha, context) => {
+
+  context.stream('hello', true);
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/stream/basic_buffer.js b/tests/gateway/functions/stream/basic_buffer.js
new file mode 100644
index 0000000..b71dd32
--- /dev/null
+++ b/tests/gateway/functions/stream/basic_buffer.js
@@ -0,0 +1,12 @@
+/**
+* Valid function for streaming
+* @param {string} alpha Some value
+* @stream {buffer} hello Some value
+*/
+module.exports = async (alpha, context) => {
+
+  context.stream('hello', Buffer.from('123'));
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/stream/basic_buffer_mocked.js b/tests/gateway/functions/stream/basic_buffer_mocked.js
new file mode 100644
index 0000000..fd980db
--- /dev/null
+++ b/tests/gateway/functions/stream/basic_buffer_mocked.js
@@ -0,0 +1,12 @@
+/**
+* Valid function for streaming
+* @param {string} alpha Some value
+* @stream {buffer} hello Some value
+*/
+module.exports = async (alpha, context) => {
+
+  context.stream('hello', {_base64: Buffer.from('123').toString('base64')});
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/stream/basic_buffer_nested.js b/tests/gateway/functions/stream/basic_buffer_nested.js
new file mode 100644
index 0000000..bad76ff
--- /dev/null
+++ b/tests/gateway/functions/stream/basic_buffer_nested.js
@@ -0,0 +1,12 @@
+/**
+* Valid function for streaming
+* @param {string} alpha Some value
+* @stream {any} hello
+*/
+module.exports = async (alpha, context) => {
+
+  context.stream('hello', {mybuff: Buffer.from('123')});
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/stream/basic_buffer_nested_mocked.js b/tests/gateway/functions/stream/basic_buffer_nested_mocked.js
new file mode 100644
index 0000000..b980ece
--- /dev/null
+++ b/tests/gateway/functions/stream/basic_buffer_nested_mocked.js
@@ -0,0 +1,13 @@
+/**
+* Valid function for streaming
+* @param {string} alpha Some value
+* @stream {object} hello
+* @ {buffer} mybuff
+*/
+module.exports = async (alpha, context) => {
+
+  context.stream('hello', {mybuff: {_base64: Buffer.from('123').toString('base64')}});
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/stream/debug.js b/tests/gateway/functions/stream/debug.js
new file mode 100644
index 0000000..b13102b
--- /dev/null
+++ b/tests/gateway/functions/stream/debug.js
@@ -0,0 +1,25 @@
+/**
+* Valid function for streaming
+* @param {string} alpha Some value
+* @stream {string} hello Hello message
+* @stream {string} goodbye Goodbye message
+*/
+module.exports = async (alpha, context) => {
+
+  context.stream('hello', 'Hello?');
+  context.stream('hello', 'How are you?');
+  console.log('what?', 'who?');
+
+  await new Promise(resolve => setTimeout(() => resolve(), 20));
+
+  context.stream('hello', 'Is it me you\'re looking for?');
+  console.error('oh no');
+
+  await new Promise(resolve => setTimeout(() => resolve(), 20));
+
+  context.stream('goodbye', 'Nice to see ya');
+  console.log('finally');
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/stream/debug_no_stream.js b/tests/gateway/functions/stream/debug_no_stream.js
new file mode 100644
index 0000000..e606ec3
--- /dev/null
+++ b/tests/gateway/functions/stream/debug_no_stream.js
@@ -0,0 +1,19 @@
+/**
+* Not a streaming function, can debug with streaming
+* @param {string} alpha Some value
+*/
+module.exports = async (alpha, context) => {
+
+  console.log('what?', 'who?');
+
+  await new Promise(resolve => setTimeout(() => resolve(), 20));
+
+  console.error('oh no');
+
+  await new Promise(resolve => setTimeout(() => resolve(), 20));
+
+  console.log('finally');
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/stream/invalid_stream_name.js b/tests/gateway/functions/stream/invalid_stream_name.js
new file mode 100644
index 0000000..c8dd30f
--- /dev/null
+++ b/tests/gateway/functions/stream/invalid_stream_name.js
@@ -0,0 +1,12 @@
+/**
+* Valid function for streaming
+* @param {string} alpha Some value
+* @stream {boolean} hello Some value
+*/
+module.exports = async (alpha, context) => {
+
+  context.stream('hello2', 'what');
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/stream/invalid_stream_param.js b/tests/gateway/functions/stream/invalid_stream_param.js
new file mode 100644
index 0000000..ae5a79a
--- /dev/null
+++ b/tests/gateway/functions/stream/invalid_stream_param.js
@@ -0,0 +1,12 @@
+/**
+* Valid function for streaming
+* @param {string} alpha Some value
+* @stream {boolean} hello Some value
+*/
+module.exports = async (alpha, context) => {
+
+  context.stream('hello', 'what');
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/stream/sleep.js b/tests/gateway/functions/stream/sleep.js
new file mode 100644
index 0000000..18eb3d7
--- /dev/null
+++ b/tests/gateway/functions/stream/sleep.js
@@ -0,0 +1,22 @@
+/**
+* Valid function for streaming
+* @param {string} alpha Some value
+* @stream {string} hello Hello message
+* @stream {string} goodbye Goodbye message
+*/
+module.exports = async (alpha, context) => {
+
+  context.stream('hello', 'Hello?');
+  context.stream('hello', 'How are you?');
+
+  await new Promise(resolve => setTimeout(() => resolve(), 20));
+
+  context.stream('hello', 'Is it me you\'re looking for?');
+
+  await new Promise(resolve => setTimeout(() => resolve(), 20));
+
+  context.stream('goodbye', 'Nice to see ya');
+
+  return true;
+
+};
diff --git a/tests/gateway/functions/string_options.js b/tests/gateway/functions/string_options.js
new file mode 100644
index 0000000..3ee9213
--- /dev/null
+++ b/tests/gateway/functions/string_options.js
@@ -0,0 +1,8 @@
+/**
+ * Test options with string
+ * @param {string} value {?} ["one", "two", "three"]
+ * @returns {any}
+ */
+module.exports = async (value) => {
+  return value;
+};
diff --git a/tests/gateway/tests.js b/tests/gateway/tests.js
index ab708f1..7571227 100644
--- a/tests/gateway/tests.js
+++ b/tests/gateway/tests.js
@@ -1,5 +1,6 @@
 const http = require('http');
 const zlib = require('zlib');
+const fs = require('fs')
 const FormData = require('form-data');
 const {Gateway, FunctionParser} = require('../../index.js');
 
@@ -7,10 +8,41 @@ const PORT = 7357;
 const HOST = 'localhost'
 const ROOT = './tests/gateway';
 
-const FaaSGateway = new Gateway({debug: false, root: ROOT});
+const FaaSGateway = new Gateway({debug: false, root: ROOT, defaultTimeout: 1000});
 const parser = new FunctionParser();
 
-function request(method, headers, path, data, callback) {
+function parseServerSentEvents (buffer) {
+  let events = {};
+  let entries = buffer.toString().split('\n\n');
+  entries
+    .filter(entry => !!entry)
+    .forEach(entry => {
+      let event = '';
+      let data = null;
+      let lines = entry.split('\n').map((line, i) => {
+        let lineData = line.split(':');
+        let type = lineData[0];
+        let contents = lineData.slice(1).join(':');
+        if (contents.startsWith(' ')) {
+          contents = contents.slice(1);
+        }
+        if (type === 'event' && data === null) {
+          event = contents;
+        } else if (type === 'data') {
+          data = data || '';
+          data = data + contents + '\n';
+        }
+      });
+      if (data && data.endsWith('\n')) {
+        data = data.slice(0, -1);
+      }
+      events[event] = events[event] || [];
+      events[event].push(data || '');
+    });
+  return events;
+}
+
+function request (method, headers, path, data, callback) {
   headers = headers || {};
   method = method || 'GET';
   path = path || '';
@@ -19,7 +51,10 @@ function request(method, headers, path, data, callback) {
     data = JSON.stringify(data);
     headers['Content-Type'] = 'application/json';
   } else if (typeof data === 'string') {
-    headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    let contentType = Object.keys(headers).find(k => k.toLowerCase() === 'content-type');
+    if (!contentType) {
+      headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    }
   }
   data = data || '';
   let req = http.request({
@@ -51,8 +86,14 @@ function request(method, headers, path, data, callback) {
 module.exports = (expect) => {
 
   before(() => {
+    const preloadFiles = {
+      'functions/sample_preload.js': Buffer.from(`module.exports = async () => { return true; };`)
+    };
     FaaSGateway.listen(PORT);
-    FaaSGateway.define(parser.load(ROOT, 'functions'));
+    FaaSGateway.define(
+      parser.load(ROOT, 'functions', 'www', null, preloadFiles),
+      preloadFiles
+    );
   });
 
   it('Should setup correctly', () => {
@@ -60,6 +101,52 @@ module.exports = (expect) => {
     expect(FaaSGateway.server).to.exist;
     expect(FaaSGateway.definitions).to.exist;
     expect(FaaSGateway.definitions).to.haveOwnProperty('my_function');
+    expect(FaaSGateway.definitions).to.haveOwnProperty('sample_preload');
+    expect(FaaSGateway.preloadFiles).to.haveOwnProperty('functions/sample_preload.js');
+
+  });
+
+  it('Should have the parser preload correctly', () => {
+
+    const preloadFiles = {
+      'functions/preload.js': Buffer.from(`
+        module.exports = async (a, context) => {
+          return true;
+        };
+      `),
+      'functions/preload2.js': Buffer.from(`
+        module.exports = async (b, c) => {
+          return true;
+        };
+      `)
+    };
+
+    let definitions = parser.load(ROOT, 'functions', 'www', null, preloadFiles);
+    expect(definitions).to.haveOwnProperty('preload');
+    expect(definitions['preload'].params.length).to.equal(1);
+    expect(definitions['preload'].context).to.deep.equal({});
+    expect(definitions['preload2'].params.length).to.equal(2);
+    expect(definitions['preload2'].context).to.equal(null);
+
+  });
+
+  it('Should parser error if trying to load a preloaded file name', () => {
+
+    const preloadFiles = {
+      'functions/my_function.js': Buffer.from(`
+        module.exports = async (a, context) => {
+          return true;
+        };
+      `)
+    };
+
+    let definitions;
+    try {
+      definitions = parser.load(ROOT, 'functions', 'www', null, preloadFiles);
+    } catch (e) {
+      expect(e).to.exist;
+      expect(e.message).to.contain('preload');
+    }
 
   });
 
@@ -102,6 +189,7 @@ module.exports = (expect) => {
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+
       done();
 
     });
@@ -160,7 +248,7 @@ module.exports = (expect) => {
     });
   });
 
-  it('Should return 400 Bad Request + ClientError when no Content-Type specified on POST', done => {
+  it('Should return 400 Bad Request + ParameterParseError when no Content-Type specified on POST', done => {
     request('POST', {}, '/my_function/', undefined, (err, res, result) => {
 
       expect(err).to.not.exist;
@@ -170,47 +258,49 @@ module.exports = (expect) => {
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       expect(result).to.exist;
       expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ClientError');
+      expect(result.error.type).to.equal('ParameterParseError');
       done();
 
     });
   });
 
-  it('Should return 200 OK + result when executed', done => {
-    request('GET', {}, '/my_function/', '', (err, res, result) => {
+  it('Should return 400 Bad Request + ParameterParseError when Content-Type: text/plain specified on POST with invalid JSON', done => {
+    request('POST', {'Content-Type': 'text/plain'}, '/my_function/', 'lol', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(400);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result).to.equal(6);
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterParseError');
       done();
 
     });
   });
 
-  it('Should return 200 OK + gzip result when executed with Accept-Encoding: gzip', done => {
-    request('GET', {'accept-encoding': 'gzip'}, '/my_function/', '', (err, res, result) => {
+  it('Should return 400 Bad Request + ParameterParseError when Content-Type: text/plain specified on POST with non-object JSON', done => {
+    request('POST', {'Content-Type': 'text/plain'}, '/my_function/', '[]', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(res.headers['content-encoding']).to.equal('gzip');
+      expect(res.statusCode).to.equal(400);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result).to.equal(6);
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterParseError');
       done();
 
     });
   });
 
-  it('Should return 200 OK + deflate result when executed with Accept-Encoding: deflate', done => {
-    request('GET', {'accept-encoding': 'deflate'}, '/my_function/', '', (err, res, result) => {
+  it('Should return 200 OK when Content-Type: text/plain specified on POST with valid JSON object', done => {
+    request('POST', {'Content-Type': 'text/plain'}, '/my_function/', '{}', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(res.headers['content-encoding']).to.equal('deflate');
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
@@ -220,12 +310,11 @@ module.exports = (expect) => {
     });
   });
 
-  it('Should return 200 OK + gzip result when executed with Accept-Encoding: gzip, deflate', done => {
-    request('GET', {'accept-encoding': 'gzip, deflate'}, '/my_function/', '', (err, res, result) => {
+  it('Should return 200 OK when Content-Type: text/plain specified on POST with valid doubly-stringified JSON object', done => {
+    request('POST', {'Content-Type': 'text/plain;charset=UTF-8'}, '/my_function/', '"{}"', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(res.headers['content-encoding']).to.equal('gzip');
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
@@ -235,1181 +324,2051 @@ module.exports = (expect) => {
     });
   });
 
-  it('Should parse arguments from URL', done => {
-    request('GET', {}, '/my_function/?a=10&b=20&c=30', '', (err, res, result) => {
+  it('Should return 200 OK + result when executed', done => {
+    request('GET', {}, '/my_function/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result).to.equal(60);
+      expect(result).to.equal(6);
       done();
 
     });
   });
 
-  it('Should parse arguments from POST (URL encoded)', done => {
-    request('POST', {}, '/my_function/', 'a=10&b=20&c=30', (err, res, result) => {
+  it('Should return 200 OK + result when preloadFile executed', done => {
+    request('GET', {}, '/sample_preload/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result).to.equal(60);
+      expect(result).to.equal(true);
       done();
 
     });
   });
 
-  it('Should not overwrite POST (URL encoded) data with query parameters', done => {
-    request('POST', {}, '/my_function/?c=300', 'a=10&b=20&c=30', (err, res, result) => {
+  it('Should return 200 OK + gzip result when executed with Accept-Encoding: gzip', done => {
+    request('GET', {'accept-encoding': 'gzip'}, '/my_function/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-encoding']).to.equal('gzip');
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ClientError');
+      expect(result).to.equal(6);
       done();
 
     });
   });
 
-  it('Should parse arguments from POST (JSON)', done => {
-    request('POST', {}, '/my_function/', {a: 10, b: 20, c: 30}, (err, res, result) => {
+  it('Should return 200 OK + deflate result when executed with Accept-Encoding: deflate', done => {
+    request('GET', {'accept-encoding': 'deflate'}, '/my_function/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-encoding']).to.equal('deflate');
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result).to.equal(60);
+      expect(result).to.equal(6);
       done();
 
     });
   });
 
-  it('Should not overwrite POST (JSON) data with query parameters', done => {
-    request('POST', {}, '/my_function/?c=300', {a: 10, b: 20, c: 30}, (err, res, result) => {
+  it('Should return 200 OK + gzip result when executed with Accept-Encoding: gzip, deflate', done => {
+    request('GET', {'accept-encoding': 'gzip, deflate'}, '/my_function/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-encoding']).to.equal('gzip');
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ClientError');
+      expect(result).to.equal(6);
       done();
 
     });
   });
 
-  it('Should not parse arguments from POST (JSON Array)', done => {
-    request('POST', {}, '/my_function/', [10, 20, 30], (err, res, result) => {
+  it('Should parse arguments from URL', done => {
+    request('GET', {}, '/my_function/?a=10&b=20&c=30', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ClientError');
-      expect(result.error.message).to.equal('Bad Request: Invalid JSON: Must be Object');
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.equal(60);
       done();
 
     });
   });
 
-  it('Should give ParameterError if parameter doesn\'t match (converted)', done => {
-    request('POST', {}, '/my_function/', 'a=10&b=20&c=hello%20world', (err, res, result) => {
+  it('Should parse arguments from URL into array, var[] format', done => {
+    request('GET', {}, '/my_function_test_parsing/?a[]=1&a[]=2&a[]=3', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(200);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ParameterError');
-      expect(result.error.details).to.exist;
-      expect(result.error.details.c).to.exist;
-      expect(result.error.details.c.expected).to.exist;
-      expect(result.error.details.c.expected.type).to.equal('number');
-      expect(result.error.details.c.actual).to.exist;
-      expect(result.error.details.c.actual.type).to.equal('string');
-      expect(result.error.details.c.actual.value).to.equal('hello world');
+      expect(result).to.deep.equal({a: ['1', '2', '3'], b: {}});
       done();
 
     });
   });
 
-  it('Should give ParameterError if parameter doesn\'t match (not converted)', done => {
-    request('POST', {}, '/my_function/', {a: 10, b: 20, c: '30'}, (err, res, result) => {
+  it('Should parse arguments from URL into array, var[0] format, with push', done => {
+    request('GET', {}, '/my_function_test_parsing/?a[1]=1&a[0]=2&a[]=100&a[5]=3&a[]=7', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(200);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ParameterError');
-      expect(result.error.details).to.exist;
-      expect(result.error.details.c).to.exist;
-      expect(result.error.details.c.expected).to.exist;
-      expect(result.error.details.c.expected.type).to.equal('number');
-      expect(result.error.details.c.actual).to.exist;
-      expect(result.error.details.c.actual.type).to.equal('string');
-      expect(result.error.details.c.actual.value).to.equal('30');
+      expect(result).to.deep.equal({a: ['2', '1', null, null, null, '3', '100', '7'], b: {}});
       done();
 
     });
   });
 
-  it('Should give 502 + ValueError if unexpected value', done => {
-    request('POST', {}, '/my_function/', {c: 100}, (err, res, result) => {
+  it('Should return bad request if array populated by pushing and set', done => {
+    request('GET', {}, '/my_function_test_parsing/?a[]=1&a[]=2&a=[1,2,3]', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(502);
+      expect(res.statusCode).to.equal(400);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ValueError');
-      expect(result.error.details).to.exist;
-      expect(result.error.details.returns).to.exist;
-      expect(result.error.details.returns.message).to.exist;
-      expect(result.error.details.returns.expected).to.exist;
-      expect(result.error.details.returns.expected.type).to.equal('number');
-      expect(result.error.details.returns.actual).to.exist;
-      expect(result.error.details.returns.actual.type).to.equal('string');
-      expect(result.error.details.returns.actual.value).to.equal('hello value');
       done();
 
     });
   });
 
-  it('Should give 200 OK for not found function', done => {
-    request('POST', {}, '/test/', {}, (err, res, result) => {
+  it('Should return bad request if non-integer value used as index in array', done => {
+    request('GET', {}, '/my_function_test_parsing/?a[1.5]=1', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(400);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result).to.equal('not found?');
       done();
 
     });
   });
 
-  it('Should allow status setting from third callback parameter', done => {
-    request('POST', {}, '/test/status/', {}, (err, res, result) => {
+  it('Should parse arguments from URL into array, var[0] format, with push and covert to type', done => {
+    request('GET', {}, '/my_function_test_parsing_convert/?a[1]=1&a[0]=2&a[]=100&a[5]=3&a[]=7', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(404);
+      expect(res.statusCode).to.equal(200);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result).to.be.instanceof(Buffer);
-      expect(result.toString()).to.equal('not found');
+      expect(result).to.deep.equal({a: [2, 1, null, null, null, 3, 100, 7], b: {}});
       done();
 
     });
   });
 
-  it('Should pass headers properly', done => {
-    request('POST', {}, '/headers/', {}, (err, res, result) => {
+  it('Should parse arguments from URL into array, obj.field format', done => {
+    request('GET', {}, '/my_function_test_parsing/?b.lol=1&b.wat=23', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(res.headers['content-type']).to.equal('text/html');
-      expect(result).to.be.instanceof(Buffer);
-      expect(result.toString()).to.equal('abcdef');
+      expect(result).to.deep.equal({a: [], b: {lol: '1', wat: '23'}});
       done();
 
     });
   });
 
-  it('Should parse object properly', done => {
-    request('POST', {}, '/object_parsing/', {}, (err, res, result) => {
+  it('Should parse arguments from URL into array, obj.field format, setting multiple field levels', done => {
+    request('GET', {}, '/my_function_test_parsing/?b.lol=1&b.wat=23&b.cool.beans=hi', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal(null);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal({a: [], b: {lol: '1', wat: '23', cool: {beans: 'hi'}}});
       done();
 
     });
   });
 
-  it('Should populate HTTP body', done => {
-    request('POST', {}, '/http_body/', {abc: 123}, (err, res, result) => {
+  it('Should parse arguments from URL into array, obj.field format, setting multiple field levels with array', done => {
+    request('GET', {}, '/my_function_test_parsing/?b.lol=1&b.wat=23&b.cool.beans[]=hi', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.be.a.string;
-      expect(result).to.equal('{"abc":123}');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal({a: [], b: {lol: '1', wat: '23', cool: {beans: ['hi']}}});
       done();
 
     });
   });
 
-  it('Should null number properly (POST)', done => {
-    request('POST', {}, '/number_nullable/', {}, (err, res, result) => {
+  it('Should parse arguments from URL into array, obj.field format, setting multiple field levels with array and sub object', done => {
+    request('GET', {}, '/my_function_test_parsing/?b.lol=1&b.wat=23&b.cool[].beans=hi', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.be.an.array;
-      expect(result[0]).to.equal(null);
-      expect(result[1]).to.equal(null);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal({a: [], b: {lol: '1', wat: '23', cool: [{beans: 'hi'}]}});
       done();
 
     });
   });
 
-  it('Should null number properly (GET)', done => {
-    request('GET', {}, '/number_nullable/', '', (err, res, result) => {
+  it('Should parse arguments from URL into array, obj.field format, setting multiple field levels with 2d array and sub object within an array', done => {
+    request('GET', {}, '/my_function_test_parsing/?b.lol=1&b.wat=23&b.cool[][].beans=hi', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.be.an.array;
-      expect(result[0]).to.equal(null);
-      expect(result[1]).to.equal(null);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal({a: [], b: {lol: '1', wat: '23', cool: [[{beans: 'hi'}]]}});
       done();
 
     });
   });
 
-  it('Should error object on string provided', done => {
-    request('POST', {}, '/object_parsing/', {obj: 'xxx'}, (err, res, result) => {
+  it('Should parse arguments from URL into array, obj.field format, setting multiple items in an array and sub object within an array', done => {
+    request('GET', {}, '/my_function_test_parsing/?b.lol=1&b.wat=23&b.cool[]=hi&b.cool[]=anotheritem', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ParameterError');
-      expect(result.error.details).to.exist;
-      expect(result.error.details.obj).to.exist;
-      expect(result.error.details.obj.message).to.exist;
-      expect(result.error.details.obj.expected).to.exist;
-      expect(result.error.details.obj.expected.type).to.equal('object');
-      expect(result.error.details.obj.actual).to.exist;
-      expect(result.error.details.obj.actual.type).to.equal('string');
-      expect(result.error.details.obj.actual.value).to.equal('xxx');
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal({a: [], b: {lol: '1', wat: '23', cool: ['hi', 'anotheritem']}});
       done();
 
     });
   });
 
-  it('Should reject integer type when provided float (GET)', done => {
-    request('GET', {}, '/type_rejection/?alpha=47.2', '', (err, res, result) => {
+  it('Should reject obj.field format for an argument in the URL that is already typed as a non-object with a ParameterParseError', done => {
+    request('GET', {}, '/my_function_test_parsing/?c=1&c.field=1', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ParameterError');
-      expect(result.error.details).to.exist;
-      expect(result.error.details.alpha).to.exist;
-      expect(result.error.details.alpha.message).to.exist;
-      expect(result.error.details.alpha.expected).to.exist;
-      expect(result.error.details.alpha.expected.type).to.equal('integer');
-      expect(result.error.details.alpha.actual).to.exist;
-      expect(result.error.details.alpha.actual.type).to.equal('number');
-      expect(result.error.details.alpha.actual.value).to.equal(47.2);
+      expect(result.error.type).to.equal('ParameterParseError');
       done();
 
     });
   });
 
-  it('Should reject integer type when provided float (POST)', done => {
-    request('POST', {}, '/type_rejection/', {alpha: 47.2}, (err, res, result) => {
+  it('Should reject obj.field format for a nested argument in the URL that is already typed as a non object with a ParameterParseError', done => {
+    request('GET', {}, '/my_function_test_parsing/?b.field=1&b.field.test=2', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ParameterError');
-      expect(result.error.details).to.exist;
-      expect(result.error.details.alpha).to.exist;
-      expect(result.error.details.alpha.message).to.exist;
-      expect(result.error.details.alpha.expected).to.exist;
-      expect(result.error.details.alpha.expected.type).to.equal('integer');
-      expect(result.error.details.alpha.actual).to.exist;
-      expect(result.error.details.alpha.actual.type).to.equal('number');
-      expect(result.error.details.alpha.actual.value).to.equal(47.2);
+      expect(result.error.type).to.equal('ParameterParseError');
       done();
 
     });
   });
 
-  it('Should accept integer type when provided integer (GET)', done => {
-    request('GET', {}, '/type_rejection/?alpha=47', '', (err, res, result) => {
+  it('Should reject obj.field format, setting multiple field levels with array', done => {
+    request('GET', {}, '/my_function_test_parsing/?b.lol=1&b.wat=23&b.cool[]=hi&b.cool=hi', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(result).to.equal(47);
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       done();
 
     });
   });
 
-  it('Should accept integer type when provided integer (POST)', done => {
-    request('POST', {}, '/type_rejection/', {alpha: 47}, (err, res, result) => {
+  it('Should reject obj.field format, overwriting child object', done => {
+    request('GET', {}, '/my_function_test_parsing/?b.lol=1&b.wat=23&b.cool.beans=hi&b.cool=beans', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(result).to.equal(47);
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       done();
 
     });
   });
 
-  it('Should not accept empty object.http', done => {
-    request('GET', {}, '/sanitize/http_object_empty/', '', (err, res, result) => {
+  it('Should return bad request if object populated by value and set', done => {
+    request('GET', {}, '/my_function_test_parsing/?b.lol=1&b={}', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(502);
-      expect(result.error).to.exist;
-      expect(result.error.details).to.exist;
-      expect(result.error.details.returns).to.exist
-      expect(result.error.details.returns.invalid).to.equal(true);
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       done();
 
     });
   });
 
-  it('Should sanitize a {_base64: ...} buffer input', done => {
-    request('GET', {}, '/sanitize/http_object_base64/', '', (err, res, result) => {
+  it('Should parse arguments from URL into object, obj.field format, and convert to type', done => {
+    request('GET', {}, '/my_function_test_parsing_convert/?b.lol=1&b.wat=23', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result.error).to.not.exist;
-      expect(result.toString()).to.equal('fix for steven');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal({a: [], b: {lol: 1, wat: '23'}});
       done();
 
     });
   });
 
-  it('Should accept uppercase Content-Type', done => {
-    request('GET', {}, '/sanitize/http_object_header_case/?contentType=image/png', '', (err, res, result) => {
+  it('Should parse arguments from POST (URL encoded)', done => {
+    request('POST', {}, '/my_function/', 'a=10&b=20&c=30', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(res.headers).to.exist;
-      expect(res.headers).to.haveOwnProperty('content-type');
-      expect(res.headers['content-type']).to.equal('image/png');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.equal(60);
       done();
 
     });
   });
 
-  it('Should not accept object.http with null body', done => {
-    request('GET', {}, '/sanitize/http_object/', '', (err, res, result) => {
+  it('Should not overwrite POST (URL encoded) data with query parameters', done => {
+    request('POST', {}, '/my_function/?c=300', 'a=10&b=20&c=30', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(502);
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       expect(result.error).to.exist;
-      expect(result.error.details).to.exist;
-      expect(result.error.details.returns).to.exist
-      expect(result.error.details.returns.invalid).to.equal(true);
+      expect(result.error.type).to.equal('ParameterParseError');
       done();
 
-
     });
   });
 
-  it('Should accept object.http with string body', done => {
-    request('GET', {}, '/sanitize/http_object/?body=hello', '', (err, res, result) => {
+  it('Should parse arguments from POST (JSON)', done => {
+    request('POST', {}, '/my_function/', {a: 10, b: 20, c: 30}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(res.headers['content-type']).to.equal('text/plain');
-      expect(result.toString()).to.equal('hello');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.equal(60);
       done();
 
     });
   });
 
-  it('Should not accept object.http with statusCode out of range', done => {
-    request('GET', {}, '/sanitize/http_object/?statusCode=600', '', (err, res, result) => {
+  it('Should not overwrite POST (JSON) data with query parameters', done => {
+    request('POST', {}, '/my_function/?c=300', {a: 10, b: 20, c: 30}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(502);
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       expect(result.error).to.exist;
-      expect(result.error.details).to.exist;
-      expect(result.error.details.returns).to.exist
-      expect(result.error.details.returns.invalid).to.equal(true);
+      expect(result.error.type).to.equal('ParameterParseError');
       done();
 
-
     });
   });
 
-  it('Should not accept object.http with invalid headers object', done => {
-    request('POST', {}, '/sanitize/http_object/', {headers: true}, (err, res, result) => {
+  it('Should successfully parse arguments from POST (JSON Array)', done => {
+    request('POST', {}, '/my_function/', [10, 20, 30], (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(502);
-      expect(result.error).to.exist;
-      expect(result.error.details).to.exist;
-      expect(result.error.details.returns).to.exist
-      expect(result.error.details.returns.invalid).to.equal(true);
+      expect(res.statusCode).to.equal(200);
+      expect(result.error).to.not.exist;
       done();
 
-
     });
   });
 
-  it('Should allow header setting', done => {
-    request('POST', {}, '/sanitize/http_object/', {body: '<b>hello</b>', headers: {'content-type': 'text/html'}}, (err, res, result) => {
+  it('Should give ParameterError if parameter doesn\'t match (converted)', done => {
+    request('POST', {}, '/my_function/', 'a=10&b=20&c=hello%20world', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(res.headers['content-type']).to.equal('text/html');
-      expect(result.toString()).to.equal('<b>hello</b>');
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.c).to.exist;
+      expect(result.error.details.c.expected).to.exist;
+      expect(result.error.details.c.expected.type).to.equal('number');
+      expect(result.error.details.c.actual).to.exist;
+      expect(result.error.details.c.actual.type).to.equal('string');
+      expect(result.error.details.c.actual.value).to.equal('hello world');
       done();
 
     });
   });
 
-  it('Should overwrite access-control-allow-origin', done => {
-    request('POST', {}, '/sanitize/http_object/', {body: '<b>hello</b>', headers: {'access-control-allow-origin': '$'}}, (err, res, result) => {
+  it('Should give ParameterError if parameter doesn\'t match (not converted)', done => {
+    request('POST', {}, '/my_function/', {a: 10, b: 20, c: '30'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(res.headers['access-control-allow-origin']).to.equal('$');
-      expect(result.toString()).to.equal('<b>hello</b>');
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.c).to.exist;
+      expect(result.error.details.c.expected).to.exist;
+      expect(result.error.details.c.expected.type).to.equal('number');
+      expect(result.error.details.c.actual).to.exist;
+      expect(result.error.details.c.actual.type).to.equal('string');
+      expect(result.error.details.c.actual.value).to.equal('30');
       done();
 
     });
   });
 
-  it('Should NOT overwrite x-functionscript', done => {
-    request('POST', {}, '/sanitize/http_object/', {body: '<b>hello</b>', headers: {'x-functionscript': '$'}}, (err, res, result) => {
+  it('Should give 502 + ValueError if unexpected value', done => {
+    request('POST', {}, '/my_function/', {c: 100}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(res.headers['x-functionscript']).to.not.equal('$');
-      expect(result.toString()).to.equal('<b>hello</b>');
+      expect(res.statusCode).to.equal(502);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ValueError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.returns).to.exist;
+      expect(result.error.details.returns.message).to.exist;
+      expect(result.error.details.returns.expected).to.exist;
+      expect(result.error.details.returns.expected.type).to.equal('number');
+      expect(result.error.details.returns.actual).to.exist;
+      expect(result.error.details.returns.actual.type).to.equal('string');
+      expect(result.error.details.returns.actual.value).to.equal('hello value');
       done();
 
     });
   });
 
-  it('Should run a background function', done => {
-    request('POST', {}, '/bg/:bg', {data: 'xxx'}, (err, res, result) => {
+  it('Should give 200 OK for not found function', done => {
+    request('POST', {}, '/test/', {}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(202);
-      expect(result).to.exist;
-      expect(result).to.be.instanceof(Buffer);
-      expect(result.length).to.be.greaterThan(0);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.equal('not found?');
       done();
 
     });
   });
 
-  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before :bg and at end of url', done => {
-    request('GET', {'user-agent': 'testing'}, '/bg:bg', '', (err, res, result) => {
+  it('Should allow status setting from third callback parameter', done => {
+    request('POST', {}, '/test/status/', {}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(302);
+      expect(res.statusCode).to.equal(404);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(res.headers).to.haveOwnProperty('location');
-      expect(res.headers.location).to.equal('/bg/:bg');
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.toString()).to.equal('not found');
       done();
 
     });
   });
 
-  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before :bg but with slash at end of url', done => {
-    request('GET', {'user-agent': 'testing'}, '/bg:bg/', '', (err, res, result) => {
+  it('Should pass headers properly', done => {
+    request('POST', {}, '/headers/', {}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(302);
+      expect(res.statusCode).to.equal(200);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(res.headers).to.haveOwnProperty('location');
-      expect(res.headers.location).to.equal('/bg/:bg');
+      expect(res.headers['content-type']).to.equal('text/html');
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.toString()).to.equal('abcdef');
       done();
 
     });
   });
 
-  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before :bg and at end of url with a query', done => {
-    request('GET', {'user-agent': 'testing'}, '/bg:bg?test=param', '', (err, res, result) => {
+  it('Should parse object properly', done => {
+    request('POST', {}, '/object_parsing/', {}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(302);
-      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
-      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
-      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(res.headers).to.haveOwnProperty('location');
-      expect(res.headers.location).to.equal('/bg/:bg?test=param');
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal(null);
       done();
 
     });
   });
 
-  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before :bg but with slash at end of url with a query', done => {
-    request('GET', {'user-agent': 'testing'}, '/bg:bg/?test=param', '', (err, res, result) => {
+  it('Should toJSON object properly', done => {
+    request('POST', {}, '/object_tojson/', {}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(302);
-      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
-      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
-      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(res.headers).to.haveOwnProperty('location');
-      expect(res.headers.location).to.equal('/bg/:bg?test=param');
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.deep.equal({name: 'hello world', description: 'MyClass'});
       done();
 
     });
   });
 
-  it('Should run a background function with bg mode "info"', done => {
-    request('POST', {}, '/bg/info/:bg', {data: 'xxx'}, (err, res, result) => {
+  it('Should populate HTTP body', done => {
+    request('POST', {}, '/http_body/', {abc: 123}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(202);
-      expect(result).to.exist;
-      expect(result).to.be.instanceof(Buffer);
-      expect(result.length).to.be.greaterThan(0);
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.be.a.string;
+      expect(result).to.equal('{"abc":123}');
       done();
 
     });
   });
 
-  it('Should run a background function with bg mode "empty"', done => {
-    request('POST', {}, '/bg/empty/:bg', {data: 'xxx'}, (err, res, result) => {
+  it('Should null number properly (POST)', done => {
+    request('POST', {}, '/number_nullable/', {}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(202);
-      expect(result).to.exist;
-      expect(result).to.be.instanceof(Buffer);
-      expect(result.length).to.equal(0);
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.be.an.array;
+      expect(result[0]).to.equal(null);
+      expect(result[1]).to.equal(null);
       done();
 
     });
   });
 
-  it('Should run a background function with bg mode "params"', done => {
-    request('POST', {}, '/bg/params/:bg', {data: 'xxx'}, (err, res, result) => {
+  it('Should null number properly (GET)', done => {
+    request('GET', {}, '/number_nullable/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(202);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
-      expect(result).to.haveOwnProperty('data');
-      expect(result.data).to.equal('xxx');
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.be.an.array;
+      expect(result[0]).to.equal(null);
+      expect(result[1]).to.equal(null);
       done();
 
     });
   });
 
-  it('Should run a background function with bg mode "params" looking for a specific parameter', done => {
-    request('POST', {}, '/bg/paramsSpecific1/:bg', {data: 'xxx', discarded: 'xxx'}, (err, res, result) => {
+  it('Should error object on string provided', done => {
+    request('POST', {}, '/object_parsing/', {obj: 'xxx'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(202);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
-      expect(result).to.haveOwnProperty('data');
-      expect(result).to.not.haveOwnProperty('discarded');
-      expect(result.data).to.equal('xxx');
+      expect(res.statusCode).to.equal(400);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.obj).to.exist;
+      expect(result.error.details.obj.message).to.exist;
+      expect(result.error.details.obj.expected).to.exist;
+      expect(result.error.details.obj.expected.type).to.equal('object');
+      expect(result.error.details.obj.actual).to.exist;
+      expect(result.error.details.obj.actual.type).to.equal('string');
+      expect(result.error.details.obj.actual.value).to.equal('xxx');
       done();
 
     });
   });
 
-  it('Should run a background function with bg mode "params" looking for two specific parameters', done => {
-    request('POST', {}, '/bg/paramsSpecific2/:bg', {data: 'xxx', otherdata: 'xxx', discarded: 'xxx'}, (err, res, result) => {
+  it('Should reject integer type when provided float (GET)', done => {
+    request('GET', {}, '/type_rejection/?alpha=47.2', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(202);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
-      expect(result).to.haveOwnProperty('data');
-      expect(result).to.haveOwnProperty('otherdata');
-      expect(result.data).to.equal('xxx');
-      expect(result.otherdata).to.equal('xxx');
+      expect(res.statusCode).to.equal(400);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.alpha).to.exist;
+      expect(result.error.details.alpha.message).to.exist;
+      expect(result.error.details.alpha.expected).to.exist;
+      expect(result.error.details.alpha.expected.type).to.equal('integer');
+      expect(result.error.details.alpha.actual).to.exist;
+      expect(result.error.details.alpha.actual.type).to.equal('number');
+      expect(result.error.details.alpha.actual.value).to.equal(47.2);
       done();
 
     });
   });
 
-  it('Should run a background function with bg mode "params" looking for specific param that is not there', done => {
-    request('POST', {}, '/bg/paramsSpecific3/:bg', {otherdata: 'xxx'}, (err, res, result) => {
+  it('Should reject integer type when provided float (POST)', done => {
+    request('POST', {}, '/type_rejection/', {alpha: 47.2}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(202);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
-      expect(result).to.not.haveOwnProperty('data');
+      expect(res.statusCode).to.equal(400);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.alpha).to.exist;
+      expect(result.error.details.alpha.message).to.exist;
+      expect(result.error.details.alpha.expected).to.exist;
+      expect(result.error.details.alpha.expected.type).to.equal('integer');
+      expect(result.error.details.alpha.actual).to.exist;
+      expect(result.error.details.alpha.actual.type).to.equal('number');
+      expect(result.error.details.alpha.actual.value).to.equal(47.2);
       done();
 
     });
   });
 
-  it('Should register an error in the resolve step with type AccessPermissionError', done => {
-
-    let originalResolveFn = FaaSGateway.resolve;
-    FaaSGateway.resolve = (req, res, buffer, callback) => {
-      let error = new Error('You are not allowed to access this API.');
-      error.accessPermissionError = true;
-      return callback(error);
-    };
-
-    request('POST', {}, '/my_function/', {}, (err, res, result) => {
-
-      FaaSGateway.resolve = originalResolveFn;
+  it('Should accept integer type when provided integer (GET)', done => {
+    request('GET', {}, '/type_rejection/?alpha=47', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(401);
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('AccessPermissionError');
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal(47);
       done();
 
     });
-
   });
 
-  it('Should register an error in the resolve step with type AccessSourceError', done => {
-
-    let originalResolveFn = FaaSGateway.resolve;
-    FaaSGateway.resolve = (req, res, buffer, callback) => {
-      let error = new Error('You are not allowed to access this API.');
-      error.accessSourceError = true;
-      return callback(error);
-    };
-
-    request('POST', {}, '/my_function/', {}, (err, res, result) => {
-
-      FaaSGateway.resolve = originalResolveFn;
+  it('Should accept integer type when provided integer (POST)', done => {
+    request('POST', {}, '/type_rejection/', {alpha: 47}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(401);
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('AccessSourceError');
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal(47);
       done();
 
     });
-
   });
 
-  it('Should register an error in the resolve step with type AccessAuthError', done => {
-
-    let originalResolveFn = FaaSGateway.resolve;
-    FaaSGateway.resolve = (req, res, buffer, callback) => {
-      let error = new Error('You are not allowed to access this API.');
-      error.accessAuthError = true;
-      return callback(error);
-    };
-
-    request('POST', {}, '/my_function/', {}, (err, res, result) => {
-
-      FaaSGateway.resolve = originalResolveFn;
+  it('Should not accept empty object.http', done => {
+    request('GET', {}, '/sanitize/http_object_empty/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(401);
+      expect(res.statusCode).to.equal(502);
       expect(result.error).to.exist;
-      expect(result.error.type).to.equal('AccessAuthError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.returns).to.exist
+      expect(result.error.details.returns.invalid).to.equal(true);
       done();
 
     });
-
   });
 
-  it('Should register an error in the resolve step with type AccessSuspendedError', done => {
-
-    let originalResolveFn = FaaSGateway.resolve;
-    FaaSGateway.resolve = (req, res, buffer, callback) => {
-      let error = new Error('You are not allowed to access this API.');
-      error.accessSuspendedError = true;
-      return callback(error);
-    };
-
-    request('POST', {}, '/my_function/', {}, (err, res, result) => {
-
-      FaaSGateway.resolve = originalResolveFn;
+  it('Should sanitize a {_base64: ...} buffer input', done => {
+    request('GET', {}, '/sanitize/http_object_base64/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(401);
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('AccessSuspendedError');
+      expect(res.statusCode).to.equal(200);
+      expect(result.error).to.not.exist;
+      expect(result.toString()).to.equal('fix for steven');
       done();
 
     });
-
   });
 
-  it('Should register an error in the resolve step with type PaymentRequiredError', done => {
-
-    let originalResolveFn = FaaSGateway.resolve;
-    FaaSGateway.resolve = (req, res, buffer, callback) => {
-      let error = new Error('You are not allowed to access this API.');
-      error.paymentRequiredError = true;
-      return callback(error);
-    };
-
-    request('POST', {}, '/my_function/', {}, (err, res, result) => {
-
-      FaaSGateway.resolve = originalResolveFn;
+  it('Should accept uppercase Content-Type', done => {
+    request('GET', {}, '/sanitize/http_object_header_case/?contentType=image/png', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(402);
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('PaymentRequiredError');
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.exist;
+      expect(res.headers).to.haveOwnProperty('content-type');
+      expect(res.headers['content-type']).to.equal('image/png');
       done();
 
     });
-
   });
 
-  it('Should register an error in the resolve step with type RateLimitError', done => {
-
-    let originalResolveFn = FaaSGateway.resolve;
-    FaaSGateway.resolve = (req, res, buffer, callback) => {
-      let error = new Error('You have called this API too many times.');
-      error.rateLimitError = true;
-      error.rate = {
-        count: 1,
-        period: 3600
-      };
-      return callback(error);
-    };
-
-    request('POST', {}, '/my_function/', {}, (err, res, result) => {
-
-      FaaSGateway.resolve = originalResolveFn;
+  it('Should return a proper error for invalid header names', done => {
+    request('GET', {}, '/sanitize/http_object_invalid_header_names/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(429);
+      expect(res.statusCode).to.equal(502);
       expect(result.error).to.exist;
-      expect(result.error.type).to.equal('RateLimitError');
-      expect(result.error.details).to.haveOwnProperty('rate');
-      expect(result.error.details.rate).to.haveOwnProperty('count');
-      expect(result.error.details.rate).to.haveOwnProperty('period');
-      expect(result.error.details.rate.count).to.equal(1);
-      expect(result.error.details.rate.period).to.equal(3600);
+      expect(result.error.details).to.exist;
+      expect(Object.keys(result.error.details).length).to.equal(5);
+      expect(result.error.details['content-type ']).to.exist;
+      expect(result.error.details['x authorization key']).to.exist;
+      expect(result.error.details[' anotherheader']).to.exist;
+      expect(result.error.details['multilinename\n']).to.exist;
+      expect(result.error.details['weirdname!@#$%^&*()œ∑´®†¥¨ˆøπåß∂ƒ©˙∆˚¬≈ç√∫˜µ≤:|{}🔥🔥🔥']).to.exist;
       done();
 
     });
-
   });
 
-  it('Should register a runtime error properly', done => {
-    request('POST', {}, '/runtime/', {}, (err, res, result) => {
+  it('Should return a proper error for invalid header values', done => {
+    request('GET', {}, '/sanitize/http_object_invalid_header_values/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(403);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
+      expect(res.statusCode).to.equal(502);
       expect(result.error).to.exist;
-      expect(result.error).to.be.an('object');
-      expect(result.error.type).to.equal('RuntimeError');
+      expect(result.error.details).to.exist;
+      expect(Object.keys(result.error.details).length).to.equal(3);
+      expect(result.error.details['object-value']).to.exist;
+      expect(result.error.details['undefined-value']).to.exist;
+      expect(result.error.details['null-value']).to.exist;
       done();
 
     });
   });
 
-  it('Should register a fatal error properly', done => {
-    request('POST', {}, '/runtime/fatal/', {}, (err, res, result) => {
+  it('Should not accept object.http with null body', done => {
+    request('GET', {}, '/sanitize/http_object/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(500);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
+      expect(res.statusCode).to.equal(502);
       expect(result.error).to.exist;
-      expect(result.error).to.be.an('object');
-      expect(result.error.type).to.equal('FatalError');
-      expect(result.error.stack).to.exist;
+      expect(result.error.details).to.exist;
+      expect(result.error.details.returns).to.exist
+      expect(result.error.details.returns.invalid).to.equal(true);
       done();
 
+
     });
   });
 
-  it('Should register a fatal error with no stack properly', done => {
-    request('POST', {}, '/runtime/fatal_no_stack/', {}, (err, res, result) => {
+  it('Should accept object.http with string body', done => {
+    request('GET', {}, '/sanitize/http_object/?body=hello', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(500);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
-      expect(result.error).to.exist;
-      expect(result.error).to.be.an('object');
-      expect(result.error.type).to.equal('FatalError');
-      expect(result.error.stack).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/plain');
+      expect(result.toString()).to.equal('hello');
       done();
 
     });
   });
 
-  it('Should register a thrown error properly', done => {
-    request('POST', {}, '/runtime/thrown/', {}, (err, res, result) => {
+  it('Should not accept object.http with statusCode out of range', done => {
+    request('GET', {}, '/sanitize/http_object/?statusCode=600', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(403);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
+      expect(res.statusCode).to.equal(502);
       expect(result.error).to.exist;
-      expect(result.error).to.be.an('object');
-      expect(result.error.type).to.equal('RuntimeError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.returns).to.exist
+      expect(result.error.details.returns.invalid).to.equal(true);
       done();
 
+
     });
   });
 
-  it('Should register an uncaught promise', done => {
-    request('POST', {}, '/runtime/promise_uncaught/', {}, (err, res, result) => {
+  it('Should not accept object.http with invalid headers object', done => {
+    request('POST', {}, '/sanitize/http_object/', {headers: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(403);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
+      expect(res.statusCode).to.equal(502);
       expect(result.error).to.exist;
-      expect(result.error).to.be.an('object');
-      expect(result.error.type).to.equal('RuntimeError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.returns).to.exist
+      expect(result.error.details.returns.invalid).to.equal(true);
       done();
 
+
     });
   });
 
-  it('Should respond to an array as an implementation error', done => {
-    request('POST', {}, '/runtime/array/', {}, (err, res, result) => {
+  it('Should allow header setting', done => {
+    request('POST', {}, '/sanitize/http_object/', {body: '<b>hello</b>', headers: {'content-type': 'text/html'}}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(403);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
-      expect(result.error).to.exist;
-      expect(result.error).to.be.an('object');
-      expect(result.error.type).to.equal('RuntimeError');
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/html');
+      expect(result.toString()).to.equal('<b>hello</b>');
       done();
 
     });
   });
 
-  it('Should respond to a boolean as an implementation error', done => {
-    request('POST', {}, '/runtime/boolean/', {}, (err, res, result) => {
+  it('Should overwrite access-control-allow-origin', done => {
+    request('POST', {}, '/sanitize/http_object/', {body: '<b>hello</b>', headers: {'access-control-allow-origin': '$'}}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(403);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
-      expect(result.error).to.exist;
-      expect(result.error).to.be.an('object');
-      expect(result.error.type).to.equal('RuntimeError');
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['access-control-allow-origin']).to.equal('$');
+      expect(result.toString()).to.equal('<b>hello</b>');
       done();
 
     });
   });
 
-  it('Should respond to a number as an implementation error', done => {
-    request('POST', {}, '/runtime/number/', {}, (err, res, result) => {
+  it('Should NOT overwrite x-functionscript', done => {
+    request('POST', {}, '/sanitize/http_object/', {body: '<b>hello</b>', headers: {'x-functionscript': '$'}}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(403);
-      expect(result).to.exist;
-      expect(result).to.be.an('object');
-      expect(result.error).to.exist;
-      expect(result.error).to.be.an('object');
-      expect(result.error.type).to.equal('RuntimeError');
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['x-functionscript']).to.not.equal('$');
+      expect(result.toString()).to.equal('<b>hello</b>');
       done();
 
     });
   });
 
-  it('Should respond to an object as an implementation error', done => {
-    request('POST', {}, '/runtime/object/', {}, (err, res, result) => {
+  it('Should run a function with an empty response', done => {
+    request('POST', {}, '/empty/:bg', {intValue: 1}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(403);
+      expect(res.statusCode).to.equal(202);
       expect(result).to.exist;
-      expect(result).to.be.an('object');
-      expect(result.error).to.exist;
-      expect(result.error).to.be.an('object');
-      expect(result.error.type).to.equal('RuntimeError');
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.length).to.be.greaterThan(0);
+      expect(result.toString()).to.equal('202 accepted');
       done();
 
     });
   });
 
-  it('Should respond to a string as an implementation error', done => {
-    request('POST', {}, '/runtime/string/', {}, (err, res, result) => {
+  it('Should run a function with an empty response even if it has an invalid parameter', done => {
+    request('POST', {}, '/empty/:bg', {intValue: 'what'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(403);
+      expect(res.statusCode).to.equal(202);
       expect(result).to.exist;
-      expect(result).to.be.an('object');
-      expect(result.error).to.exist;
-      expect(result.error).to.be.an('object');
-      expect(result.error.type).to.equal('RuntimeError');
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.length).to.be.greaterThan(0);
+      expect(result.toString()).to.equal('202 accepted');
       done();
 
     });
   });
 
-  it('Should handle multipart/form-data', done => {
-
-    let form = new FormData();
-    form.append('my_field', 'my value');
-    form.append('my_other_field', 'my other value');
-
-    form.submit(`http://${HOST}:${PORT}/reflect`, (err, response) => {
+  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before :bg and at end of url', done => {
+    request('GET', {'user-agent': 'testing'}, '/empty:bg', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(response.statusCode).to.equal(200);
-
-      let body = [];
-      response.on('readable', function() {
-          body.push(response.read());
-      });
-
-      response.on('end', function() {
-        let results = JSON.parse(body);
-        expect(results.my_field).to.equal('my value');
-        expect(results.my_other_field).to.equal('my other value');
-        done();
-      });
-
-      response.on('err', function(err) {
-        expect(err).to.not.exist;
-        done();
-      })
+      expect(res.statusCode).to.equal(302);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(res.headers).to.haveOwnProperty('location');
+      expect(res.headers.location).to.equal('/empty/:bg');
+      done();
 
-    })
+    });
   });
 
-  it('Should handle multipart/form-data with buffer', done => {
-    const fs = require('fs')
-    let pkgJson = fs.readFileSync(process.cwd() + '/package.json')
-
-    let form = new FormData();
-    form.append('my_field', 'my value');
-    form.append('my_string_buffer', Buffer.from('123'));
-    form.append('my_file_buffer', pkgJson);
-
-    form.submit(`http://${HOST}:${PORT}/reflect`, (err, response) => {
+  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before :bg but with slash at end of url', done => {
+    request('GET', {'user-agent': 'testing'}, '/empty:bg/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(response.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(302);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(res.headers).to.haveOwnProperty('location');
+      expect(res.headers.location).to.equal('/empty/:bg');
+      done();
 
-      let body = [];
-      response.on('readable', function() { body.push(response.read()); });
+    });
+  });
 
-      response.on('end', function() {
-        let results = JSON.parse(body);
-        let stringBuffer = Buffer.from(results.my_string_buffer._base64, 'base64');
-        let fileBuffer = Buffer.from(results.my_file_buffer._base64, 'base64');
-        expect(results.my_field).to.equal('my value');
-        expect(stringBuffer).to.be.deep.equal(Buffer.from('123'))
-        expect(fileBuffer).to.be.deep.equal(pkgJson)
-        done();
-      });
+  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before :bg and at end of url with a query', done => {
+    request('GET', {'user-agent': 'testing'}, '/empty:bg?test=param', '', (err, res, result) => {
 
-      response.on('err', function(err) {
-        expect(err).to.not.exist;
-        done();
-      })
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(302);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(res.headers).to.haveOwnProperty('location');
+      expect(res.headers.location).to.equal('/empty/:bg?test=param');
+      done();
 
-    })
+    });
   });
 
-  it('Should handle multipart/form-data with json', done => {
-
-    let form = new FormData();
-    form.append('my_field', 'my value');
-    form.append('my_json', JSON.stringify({
-      someJsonNums: 123,
-      someJson: 'hello'
-    }), 'my.json');
-
-    form.submit(`http://${HOST}:${PORT}/reflect`, (err, response) => {
+  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before :bg but with slash at end of url with a query', done => {
+    request('GET', {'user-agent': 'testing'}, '/empty:bg/?test=param', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(response.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(302);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(res.headers).to.haveOwnProperty('location');
+      expect(res.headers.location).to.equal('/empty/:bg?test=param');
+      done();
 
-      let body = [];
-      response.on('readable', function() {
-          body.push(response.read());
-      });
+    });
+  });
 
-      response.on('end', function() {
-        let results = JSON.parse(body);
-        expect(results.my_field).to.equal('my value');
-        expect(results.my_json).to.deep.equal({
-          someJsonNums: 123,
-          someJson: 'hello'
-        });
-        done();
-      });
+  it('Should fail to run a background function without @background specified', done => {
+    request('POST', {}, '/a_standard_function/', {_background: true}, (err, res, result) => {
 
-      response.on('err', function(err) {
-        expect(err).to.not.exist;
-        done();
-      })
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(result).to.exist;
+      expect(result).to.be.an.object;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ExecutionModeError');
+      expect(result.error.message).to.contain('"background"');
+      done();
 
-    })
+    });
   });
 
-  it('Should handle multipart/form-data with bad json', done => {
-
-    let form = new FormData();
-    form.append('my_field', 'my value');
-    form.append('my_json', 'totally not json', 'my.json');
-
-    form.submit(`http://${HOST}:${PORT}/reflect`, (err, response) => {
+  it('Should fail to run a background function without @stream specified', done => {
+    request('POST', {}, '/a_standard_function/', {_stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(response.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(403);
+      expect(result).to.exist;
+      expect(result).to.be.an.object;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ExecutionModeError');
+      expect(result.error.message).to.contain('"stream"');
+      done();
 
-      let body = [];
-      response.on('readable', function() {
-          body.push(response.read());
-      });
+    });
+  });
 
-      response.on('end', function() {
-        let results = JSON.parse(body);
-        expect(results.error).to.exist
-        expect(results.error.message).to.equal('Bad Request: Invalid multipart form-data with key: my_json')
-        done();
-      });
+  it('Should run a background function', done => {
+    request('POST', {}, '/bg/', {data: 'xxx', _background: true}, (err, res, result) => {
 
-      response.on('err', function(err) {
-        expect(err).to.not.exist;
-        done();
-      })
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(202);
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.length).to.be.greaterThan(0);
+      expect(result.toString()).to.equal(`initiated "bg"...`);
+      done();
 
-    })
+    });
   });
 
-  it('Should reject an object that doesn\'t map to Schema', done => {
-    request('POST', {}, '/schema_rejection/', {
-      obj: {
-        name: 'hello',
-        enabled: true,
-        data: 'xxx',
-        timestamp: 1337
-      }
-    },
-    (err, res, result) => {
+  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before ?_background and at end of url', done => {
+    request('GET', {'user-agent': 'testing'}, '/bg?_background', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(302);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ParameterError');
-      expect(result.error.details).to.exist;
-      expect(result.error.details.obj).to.exist;
-      expect(result.error.details.obj.expected).to.exist;
-      expect(result.error.details.obj.expected.type).to.equal('object');
-      expect(result.error.details.obj.expected.schema).to.exist;
-      expect(result.error.details.obj.expected.schema).to.have.length(4);
-      expect(result.error.details.obj.expected.schema[0].name).to.equal('name');
-      expect(result.error.details.obj.expected.schema[0].type).to.equal('string');
-      expect(result.error.details.obj.expected.schema[1].name).to.equal('enabled');
-      expect(result.error.details.obj.expected.schema[1].type).to.equal('boolean');
-      expect(result.error.details.obj.expected.schema[2].name).to.equal('data');
-      expect(result.error.details.obj.expected.schema[2].type).to.equal('object');
-      expect(result.error.details.obj.expected.schema[2].schema).to.exist;
-      expect(result.error.details.obj.expected.schema[2].schema).to.have.length(2);
-      expect(result.error.details.obj.expected.schema[2].schema[0].name).to.equal('a');
-      expect(result.error.details.obj.expected.schema[2].schema[0].type).to.equal('string');
-      expect(result.error.details.obj.expected.schema[2].schema[1].name).to.equal('b');
-      expect(result.error.details.obj.expected.schema[2].schema[1].type).to.equal('string');
-      expect(result.error.details.obj.expected.schema[3].name).to.equal('timestamp');
-      expect(result.error.details.obj.expected.schema[3].type).to.equal('number');
-      expect(result.error.details.obj.actual).to.exist;
-      expect(result.error.details.obj.actual.type).to.equal('object');
-      expect(result.error.details.obj.actual.value).to.deep.equal({
-        name: 'hello',
-        enabled: true,
-        data: 'xxx',
-        timestamp: 1337
-      });
+      expect(res.headers).to.haveOwnProperty('location');
+      expect(res.headers.location).to.equal('/bg/?_background');
       done();
 
     });
   });
 
-  it('Should accept an object that correctly maps to Schema', done => {
-    request('POST', {}, '/schema_rejection/', {
-      obj: {
-        name: 'hello',
-        enabled: true,
-        data: {a: 'alpha', b: 'beta'},
-        timestamp: 1337
-      }
-    },
-    (err, res, result) => {
+  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before ?_background but with slash at end of url', done => {
+    request('GET', {'user-agent': 'testing'}, '/bg?_background/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(302);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result).to.equal('hello');
+      expect(res.headers).to.haveOwnProperty('location');
+      expect(res.headers.location).to.equal('/bg/?_background/');
       done();
 
     });
   });
 
-  it('Should reject an array that doesn\'t map to Schema', done => {
-    request('POST', {}, '/schema_rejection_array/', {
-      users: ['alpha', 'beta']
-    },
-    (err, res, result) => {
+  it('Should return 302 redirect on a GET request with correct url when running a background function missing a slash before ?_background and at end of url with a query', done => {
+    request('GET', {'user-agent': 'testing'}, '/bg?_background&test=param', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(302);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ParameterError');
-      expect(result.error.details).to.exist;
-      expect(result.error.details.users).to.exist;
-      expect(result.error.details.users.expected).to.exist;
-      expect(result.error.details.users.expected.type).to.equal('array');
-      expect(result.error.details.users.expected.schema).to.exist;
-      expect(result.error.details.users.expected.schema).to.have.length(1);
-      expect(result.error.details.users.expected.schema[0].name).to.equal('user');
-      expect(result.error.details.users.expected.schema[0].type).to.equal('object');
-      expect(result.error.details.users.expected.schema[0].schema).to.exist;
-      expect(result.error.details.users.expected.schema[0].schema).to.have.length(2);
-      expect(result.error.details.users.expected.schema[0].schema[0].name).to.equal('username');
-      expect(result.error.details.users.expected.schema[0].schema[0].type).to.equal('string');
-      expect(result.error.details.users.expected.schema[0].schema[1].name).to.equal('age');
-      expect(result.error.details.users.expected.schema[0].schema[1].type).to.equal('number');
-      expect(result.error.details.users.actual).to.exist;
-      expect(result.error.details.users.actual.type).to.equal('array');
-      expect(result.error.details.users.actual.value).to.deep.equal(['alpha', 'beta']);
+      expect(res.headers).to.haveOwnProperty('location');
+      expect(res.headers.location).to.equal('/bg/?_background&test=param');
       done();
 
     });
   });
 
-  it('Should accept an array that correctly maps to Schema', done => {
-    request('POST', {}, '/schema_rejection_array/', {
-      users: [
-        {
-          username: 'alpha',
-          age: 1
-        },
-        {
-          username: 'beta',
-          age: 2
-        }
-      ]
-    },
-    (err, res, result) => {
+  it('Should run a background function with bg mode "info"', done => {
+    request('POST', {}, '/bg/info/', {data: 'xxx', _background: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(202);
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.length).to.be.greaterThan(0);
+      done();
+
+    });
+  });
+
+  it('Should run a background function with bg mode "empty"', done => {
+    request('POST', {}, '/bg/empty/', {data: 'xxx', _background: true}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(202);
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.length).to.equal(0);
+      done();
+
+    });
+  });
+
+  it('Should run a background function with bg mode "params"', done => {
+    request('POST', {}, '/bg/params/', {data: 'xxx', _background: true}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(202);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result).to.haveOwnProperty('data');
+      expect(result.data).to.equal('xxx');
+      done();
+
+    });
+  });
+
+  it('Should run a background function with bg mode "params" looking for a specific parameter', done => {
+    request('POST', {}, '/bg/paramsSpecific1/', {data: 'xxx', discarded: 'xxx', _background: true}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(202);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result).to.haveOwnProperty('data');
+      expect(result).to.not.haveOwnProperty('discarded');
+      expect(result.data).to.equal('xxx');
+      done();
+
+    });
+  });
+
+  it('Should run a background function with bg mode "params" looking for two specific parameters', done => {
+    request('POST', {}, '/bg/paramsSpecific2/', {data: 'xxx', otherdata: 'xxx', discarded: 'xxx', _background: true}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(202);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result).to.haveOwnProperty('data');
+      expect(result).to.haveOwnProperty('otherdata');
+      expect(result.data).to.equal('xxx');
+      expect(result.otherdata).to.equal('xxx');
+      done();
+
+    });
+  });
+
+  it('Should run a background function with bg mode "params" looking for specific param that is not there', done => {
+    request('POST', {}, '/bg/paramsSpecific3/', {otherdata: 'xxx', _background: true}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(202);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result).to.not.haveOwnProperty('data');
+      done();
+
+    });
+  });
+
+  it('Should register an error in the resolve step with type AccessPermissionError', done => {
+
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error('You are not allowed to access this API.');
+      error.accessPermissionError = true;
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(401);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('AccessPermissionError');
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type AccessSourceError', done => {
+
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error('You are not allowed to access this API.');
+      error.accessSourceError = true;
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(401);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('AccessSourceError');
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type AccessAuthError', done => {
+
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error('You are not allowed to access this API.');
+      error.accessAuthError = true;
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(401);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('AccessAuthError');
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type AccessSuspendedError', done => {
+
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error('You are not allowed to access this API.');
+      error.accessSuspendedError = true;
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(401);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('AccessSuspendedError');
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type OwnerSuspendedError', done => {
+
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error('You are not allowed to access this API.');
+      error.ownerSuspendedError = true;
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(401);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('OwnerSuspendedError');
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type OwnerPaymentRequiredError', done => {
+
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error('You are not allowed to access this API.');
+      error.ownerPaymentRequiredError = true;
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(401);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('OwnerPaymentRequiredError');
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type PaymentRequiredError', done => {
+
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error('You are not allowed to access this API.');
+      error.paymentRequiredError = true;
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(402);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('PaymentRequiredError');
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type RateLimitError', done => {
+
+    let errorMessage = 'You have called this API too many times.';
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error(errorMessage);
+      error.rateLimitError = true;
+      error.rate = {
+        count: 1,
+        period: 3600
+      };
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(429);
+      expect(result.error).to.exist;
+      expect(result.error.message).to.equal(errorMessage);
+      expect(result.error.type).to.equal('RateLimitError');
+      expect(result.error.details).to.haveOwnProperty('rate');
+      expect(result.error.details.rate).to.haveOwnProperty('count');
+      expect(result.error.details.rate).to.haveOwnProperty('period');
+      expect(result.error.details.rate.count).to.equal(1);
+      expect(result.error.details.rate.period).to.equal(3600);
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type AuthRateLimitError', done => {
+
+    let errorMessage = 'You have called this API authenticated too many times.';
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error(errorMessage);
+      error.authRateLimitError = true;
+      error.rate = {
+        count: 1,
+        period: 3600
+      };
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(429);
+      expect(result.error).to.exist;
+      expect(result.error.message).to.equal(errorMessage);
+      expect(result.error.type).to.equal('AuthRateLimitError');
+      expect(result.error.details).to.haveOwnProperty('rate');
+      expect(result.error.details.rate).to.haveOwnProperty('count');
+      expect(result.error.details.rate).to.haveOwnProperty('period');
+      expect(result.error.details.rate.count).to.equal(1);
+      expect(result.error.details.rate.period).to.equal(3600);
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type UnauthRateLimitError', done => {
+
+    let errorMessage = 'You have called this API unauthenticated too many times.';
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error(errorMessage);
+      error.unauthRateLimitError = true;
+      error.rate = {
+        count: 1,
+        period: 3600
+      };
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(429);
+      expect(result.error).to.exist;
+      expect(result.error.message).to.equal(errorMessage);
+      expect(result.error.type).to.equal('UnauthRateLimitError');
+      expect(result.error.details).to.haveOwnProperty('rate');
+      expect(result.error.details.rate).to.haveOwnProperty('count');
+      expect(result.error.details.rate).to.haveOwnProperty('period');
+      expect(result.error.details.rate.count).to.equal(1);
+      expect(result.error.details.rate.period).to.equal(3600);
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type SaveError', done => {
+
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error('There was a problem when saving your API.');
+      error.saveError = true;
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(503);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('SaveError');
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type MaintenanceError', done => {
+
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error('Your API is in maintenance mode.');
+      error.maintenanceError = true;
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('MaintenanceError');
+      done();
+
+    });
+
+  });
+
+  it('Should register an error in the resolve step with type UpdateError', done => {
+
+    let originalResolveFn = FaaSGateway.resolve;
+    FaaSGateway.resolve = (req, res, buffer, callback) => {
+      let error = new Error('Your API is currently updating.');
+      error.updateError = true;
+      return callback(error);
+    };
+
+    request('POST', {}, '/my_function/', {}, (err, res, result) => {
+
+      FaaSGateway.resolve = originalResolveFn;
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(409);
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('UpdateError');
+      done();
+
+    });
+
+  });
+
+  it('Should register a runtime error properly', done => {
+    request('POST', {}, '/runtime/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('RuntimeError');
+      expect(result.error).to.not.haveOwnProperty('details');
+      done();
+
+    });
+  });
+
+  it('Should register a runtime error properly with details', done => {
+    request('POST', {}, '/runtime/details/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('RuntimeError');
+      expect(result.error.details).to.deep.equal({objects: 'supported'});
+      done();
+
+    });
+  });
+
+  it('Should register a fatal error properly', done => {
+    request('POST', {}, '/runtime/fatal/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(500);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('FatalError');
+      expect(result.error.stack).to.exist;
+      done();
+
+    });
+  });
+
+  it('Should register a fatal error with no stack properly', done => {
+    request('POST', {}, '/runtime/fatal_no_stack/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(500);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('FatalError');
+      expect(result.error.stack).to.not.exist;
+      done();
+
+    });
+  });
+
+  it('Should register a timeout error properly', done => {
+    request('POST', {}, '/runtime/timeout/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(504);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('TimeoutError');
+      done();
+
+    });
+  });
+
+  it('Should register a thrown error properly', done => {
+    request('POST', {}, '/runtime/thrown/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('RuntimeError');
+      done();
+
+    });
+  });
+
+  it('Should register an uncaught promise', done => {
+    request('POST', {}, '/runtime/promise_uncaught/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('RuntimeError');
+      done();
+
+    });
+  });
+
+  it('Should respond to an array as an implementation error', done => {
+    request('POST', {}, '/runtime/array/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('RuntimeError');
+      done();
+
+    });
+  });
+
+  it('Should respond to a boolean as an implementation error', done => {
+    request('POST', {}, '/runtime/boolean/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('RuntimeError');
+      done();
+
+    });
+  });
+
+  it('Should respond to a number as an implementation error', done => {
+    request('POST', {}, '/runtime/number/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('RuntimeError');
+      done();
+
+    });
+  });
+
+  it('Should respond to an object as an implementation error', done => {
+    request('POST', {}, '/runtime/object/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('RuntimeError');
+      done();
+
+    });
+  });
+
+  it('Should respond to a string as an implementation error', done => {
+    request('POST', {}, '/runtime/string/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result).to.be.an('object');
+      expect(result.error).to.exist;
+      expect(result.error).to.be.an('object');
+      expect(result.error.type).to.equal('RuntimeError');
+      done();
+
+    });
+  });
+
+  it('Should handle multipart/form-data', done => {
+
+    let form = new FormData();
+    form.append('my_field', 'my value');
+    form.append('my_other_field', 'my other value');
+
+    form.submit(`http://${HOST}:${PORT}/reflect`, (err, response) => {
+
+      expect(err).to.not.exist;
+      expect(response.statusCode).to.equal(200);
+
+      let body = [];
+      response.on('readable', function() {
+          body.push(response.read());
+      });
+
+      response.on('end', function() {
+        let results = JSON.parse(body);
+        expect(results.my_field).to.equal('my value');
+        expect(results.my_other_field).to.equal('my other value');
+        done();
+      });
+
+      response.on('err', function(err) {
+        expect(err).to.not.exist;
+        done();
+      })
+
+    })
+  });
+
+  it('Should handle multipart/form-data with buffer', done => {
+
+    let pkgJson = fs.readFileSync(process.cwd() + '/package.json')
+
+    let form = new FormData();
+    form.append('my_field', 'my value');
+    form.append('my_string_buffer', Buffer.from('123'));
+    form.append('my_file_buffer', pkgJson);
+
+    form.submit(`http://${HOST}:${PORT}/reflect`, (err, response) => {
+
+      expect(err).to.not.exist;
+      expect(response.statusCode).to.equal(200);
+
+      let body = [];
+      response.on('readable', function() { body.push(response.read()); });
+
+      response.on('end', function() {
+        let results = JSON.parse(body);
+        let stringBuffer = Buffer.from(results.my_string_buffer._base64, 'base64');
+        let fileBuffer = Buffer.from(results.my_file_buffer._base64, 'base64');
+        expect(results.my_field).to.equal('my value');
+        expect(stringBuffer).to.be.deep.equal(Buffer.from('123'))
+        expect(fileBuffer).to.be.deep.equal(pkgJson)
+        done();
+      });
+
+      response.on('err', function(err) {
+        expect(err).to.not.exist;
+        done();
+      })
+
+    })
+  });
+
+  it('Should handle multipart/form-data with json', done => {
+
+    let form = new FormData();
+    form.append('my_field', 'my value');
+    form.append('my_json', JSON.stringify({
+      someJsonNums: 123,
+      someJson: 'hello'
+    }), 'my.json');
+
+    form.submit(`http://${HOST}:${PORT}/reflect`, (err, response) => {
+
+      expect(err).to.not.exist;
+      expect(response.statusCode).to.equal(200);
+
+      let body = [];
+      response.on('readable', function() {
+          body.push(response.read());
+      });
+
+      response.on('end', function() {
+        let results = JSON.parse(body);
+        expect(results.my_field).to.equal('my value');
+        expect(results.my_json).to.deep.equal({
+          someJsonNums: 123,
+          someJson: 'hello'
+        });
+        done();
+      });
+
+      response.on('err', function(err) {
+        expect(err).to.not.exist;
+        done();
+      })
+
+    })
+  });
+
+  it('Should handle multipart/form-data with bad json', done => {
+
+    let form = new FormData();
+    form.append('my_field', 'my value');
+    form.append('my_json', 'totally not json', 'my.json');
+
+    form.submit(`http://${HOST}:${PORT}/reflect`, (err, response) => {
+
+      expect(err).to.not.exist;
+      expect(response.statusCode).to.equal(400);
+
+      let body = [];
+      response.on('readable', function() {
+          body.push(response.read());
+      });
+
+      response.on('end', function() {
+        let results = JSON.parse(body);
+        expect(results.error).to.exist
+        expect(results.error.type).to.equal('ParameterParseError');
+        expect(results.error.message).to.equal('Invalid multipart form-data with key: my_json');
+        done();
+      });
+
+      response.on('err', function(err) {
+        expect(err).to.not.exist;
+        done();
+      })
+
+    })
+  });
+
+  it('Should handle multipart/form-data with a png', done => {
+
+    let image = fs.readFileSync(process.cwd() + '/tests/gateway/www/fs-wordmark.png');
+
+    let form = new FormData();
+    form.append('bufferParam', image);
+
+    form.submit(`http://${HOST}:${PORT}/buffer_reflect`, (err, response) => {
+
+      expect(err).to.not.exist;
+      expect(response.statusCode).to.equal(200);
+
+      let body = [];
+      response.on('readable', function() {
+          body.push(response.read());
+      });
+
+      response.on('end', function() {
+        let result = Buffer.concat(body);
+        expect(image.equals(result)).to.equal(true);
+        done();
+      });
+
+      response.on('err', function(err) {
+        expect(err).to.not.exist;
+        done();
+      })
+
+    })
+  });
+
+  it('Should reject an object that doesn\'t map to Schema', done => {
+    request('POST', {}, '/schema_rejection/', {
+      obj: {
+        name: 'hello',
+        enabled: true,
+        data: 'xxx',
+        timestamp: 1337
+      }
+    },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.obj).to.exist;
+      expect(result.error.details.obj.expected).to.exist;
+      expect(result.error.details.obj.expected.type).to.equal('object');
+      expect(result.error.details.obj.expected.schema).to.exist;
+      expect(result.error.details.obj.expected.schema).to.have.length(4);
+      expect(result.error.details.obj.expected.schema[0].name).to.equal('name');
+      expect(result.error.details.obj.expected.schema[0].type).to.equal('string');
+      expect(result.error.details.obj.expected.schema[1].name).to.equal('enabled');
+      expect(result.error.details.obj.expected.schema[1].type).to.equal('boolean');
+      expect(result.error.details.obj.expected.schema[2].name).to.equal('data');
+      expect(result.error.details.obj.expected.schema[2].type).to.equal('object');
+      expect(result.error.details.obj.expected.schema[2].schema).to.exist;
+      expect(result.error.details.obj.expected.schema[2].schema).to.have.length(2);
+      expect(result.error.details.obj.expected.schema[2].schema[0].name).to.equal('a');
+      expect(result.error.details.obj.expected.schema[2].schema[0].type).to.equal('string');
+      expect(result.error.details.obj.expected.schema[2].schema[1].name).to.equal('b');
+      expect(result.error.details.obj.expected.schema[2].schema[1].type).to.equal('string');
+      expect(result.error.details.obj.expected.schema[3].name).to.equal('timestamp');
+      expect(result.error.details.obj.expected.schema[3].type).to.equal('number');
+      expect(result.error.details.obj.actual).to.exist;
+      expect(result.error.details.obj.actual.type).to.equal('object');
+      expect(result.error.details.obj.actual.value).to.deep.equal({
+        name: 'hello',
+        enabled: true,
+        data: 'xxx',
+        timestamp: 1337
+      });
+      done();
+
+    });
+  });
+
+  it('Should accept an object that correctly maps to Schema', done => {
+    request('POST', {}, '/schema_rejection/', {
+      obj: {
+        name: 'hello',
+        enabled: true,
+        data: {a: 'alpha', b: 'beta'},
+        timestamp: 1337
+      }
+    },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should reject an array that doesn\'t map to Schema', done => {
+    request('POST', {}, '/schema_rejection_array/', {
+      users: ['alpha', 'beta']
+    },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.users).to.exist;
+      expect(result.error.details.users.expected).to.exist;
+      expect(result.error.details.users.expected.type).to.equal('array');
+      expect(result.error.details.users.expected.schema).to.exist;
+      expect(result.error.details.users.expected.schema).to.have.length(1);
+      expect(result.error.details.users.expected.schema[0].name).to.equal('user');
+      expect(result.error.details.users.expected.schema[0].type).to.equal('object');
+      expect(result.error.details.users.expected.schema[0].schema).to.exist;
+      expect(result.error.details.users.expected.schema[0].schema).to.have.length(2);
+      expect(result.error.details.users.expected.schema[0].schema[0].name).to.equal('username');
+      expect(result.error.details.users.expected.schema[0].schema[0].type).to.equal('string');
+      expect(result.error.details.users.expected.schema[0].schema[1].name).to.equal('age');
+      expect(result.error.details.users.expected.schema[0].schema[1].type).to.equal('number');
+      expect(result.error.details.users.actual).to.exist;
+      expect(result.error.details.users.actual.type).to.equal('array');
+      expect(result.error.details.users.actual.value).to.deep.equal(['alpha', 'beta']);
+      done();
+
+    });
+  });
+
+  it('Should accept an array that correctly maps to Schema', done => {
+    request('POST', {}, '/schema_rejection_array/', {
+      users: [
+        {
+          username: 'alpha',
+          age: 1
+        },
+        {
+          username: 'beta',
+          age: 2
+        }
+      ]
+    },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should reject an nested array that doesn\'t map to Schema', done => {
+    request('POST', {}, '/schema_rejection_nested_array/', {
+      users: [
+        { username: 'steve', posts: [{ title: 't', body: 'b' }] },
+        { posts: [{ title: 't', body: 'b' }] }
+      ]
+    },
+      (err, res, result) => {
+
+        expect(err).to.not.exist;
+        expect(res.statusCode).to.equal(400);
+        expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+        expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+        expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+        expect(result.error).to.exist;
+        expect(result.error.type).to.equal('ParameterError');
+        expect(result.error.details).to.exist;
+        expect(result.error.details.users).to.exist;
+        expect(result.error.details.users.expected).to.exist;
+        expect(result.error.details.users.expected.type).to.equal('array');
+        expect(result.error.details.users.expected.schema).to.deep.equal([
+          {
+            name: 'user',
+            type: 'object',
+            description: 'a user',
+            schema: [
+              {
+                name: 'username',
+                type: 'string',
+                description: ''
+              },
+              {
+                name: 'posts',
+                type: 'array',
+                description: '',
+                schema: [
+                  {
+                    name: 'post',
+                    type: 'object',
+                    description: '',
+                    schema: [
+                      {
+                        name: 'title',
+                        type: 'string',
+                        description: ''
+                      },
+                      {
+                        name: 'body',
+                        type: 'string',
+                        description: ''
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        ]);
+        expect(result.error.details.users.actual).to.deep.equal({
+          type: 'array',
+          value: [
+            {
+              posts: [
+                {
+                  body: 'b',
+                  title: 't'
+                }
+              ],
+              username: 'steve'
+            },
+            {
+              posts: [
+                {
+                  body: 'b',
+                  title: 't'
+                }
+              ]
+            }
+          ]
+        });
+        done();
+
+      });
+  });
+
+  it('Should accept a nested array that correctly maps to Schema', done => {
+    request('POST', {}, '/schema_rejection_nested_array/', {
+      users: [
+        { username: 'steve', posts: [{ title: 't', body: 'b' }] },
+        { username: 'steve2', posts: [{ title: 't', body: 'b' }] }
+      ]
+    },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal( [
+        { username: 'steve', posts: [{ title: 't', body: 'b' }] },
+        { username: 'steve2', posts: [{ title: 't', body: 'b' }] }
+      ]);
+      done();
+
+    });
+  });
+
+  it('Should reject an array that doesn\'t map to a Schema for an array of numbers', done => {
+    request('POST', {}, '/schema_rejection_number_array/', {
+      userIds: ['alpha', 'beta']
+    },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details.userIds).to.exist;
+      expect(result.error.details.userIds.expected).to.exist;
+      expect(result.error.details.userIds.expected.type).to.equal('array');
+      expect(result.error.details.userIds.expected.schema).to.exist;
+      expect(result.error.details.userIds.expected.schema).to.have.length(1);
+      expect(result.error.details.userIds.expected.schema[0].type).to.equal('number');
+      expect(result.error.details.userIds.actual).to.exist;
+      expect(result.error.details.userIds.actual.type).to.equal('array');
+      expect(result.error.details.userIds.actual.value).to.deep.equal(['alpha', 'beta']);
+      done();
+
+    });
+  });
+
+  it('Should accept an array that correctly maps to Schema', done => {
+    request('POST', {}, '/schema_rejection_number_array/', {
+      userIds: [1, 2, 3]
+    },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
       expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
       expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
       expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
@@ -1419,1272 +2378,3322 @@ module.exports = (expect) => {
     });
   });
 
-  it('Should reject an nested array that doesn\'t map to Schema', done => {
-    request('POST', {}, '/schema_rejection_nested_array/', {
-      users: [
-        { username: 'steve', posts: [{ title: 't', body: 'b' }] },
-        { posts: [{ title: 't', body: 'b' }] }
-      ]
-    },
-      (err, res, result) => {
+  it('Should handle large buffer parameters', done => {
+    request('POST', {'x-convert-strings': true}, '/runtime/largebuffer/', {
+      file: `{"_base64": "${'a'.repeat(50000000)}"}`
+    }, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result.error).to.not.exist;
+      done();
+
+    });
+  }).timeout(5000);
+
+  it('Should accept a request with the optional param', done => {
+    request('POST', {}, '/optional_params/', {name: 'steve'},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('steve');
+      done();
+
+    });
+  });
+
+  it('Should accept a request without the optional param', done => {
+    request('POST', {}, '/optional_params/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should accept a request without the optional param', done => {
+    request('POST', {}, '/schema_optional_params/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal(null);
+      done();
+
+    });
+  });
+
+  it('Should accept a request without the optional param field', done => {
+    request('POST', {}, '/schema_optional_params/', {obj: {name: 'steve'}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.deep.equal({name: 'steve'});
+      done();
+
+    });
+  });
+
+  it('Should accept a request with the optional param field set to null', done => {
+    request('POST', {}, '/schema_optional_params/', {obj: {name: 'steve', enabled: null}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.deep.equal({name: 'steve', enabled: null});
+      done();
+
+    });
+  });
+
+  it('Should accept a request with the optional param field', done => {
+    request('POST', {}, '/schema_optional_params/', {obj: {name: 'steve', enabled: true}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.deep.equal({name: 'steve', enabled: true});
+      done();
+
+    });
+  });
+
+  it('Should accept a request without the optional param (nested schema)', done => {
+    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve' }},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.deep.equal({name: 'steve'});
+      done();
+
+    });
+  });
+
+  it('Should reject a request without the required param within the optional object (nested schema)', done => {
+    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve', options: {}}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should accept a request with the optional object (nested schema)', done => {
+    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve', options: {istest: true}}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal({name: 'steve', options: { istest: true}});
+      done();
+
+    });
+  });
+
+  it('Should accept a request with the optional object and optional field (nested schema)', done => {
+    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve', options: {istest: true, threads: 4}}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal({name: 'steve', options: { istest: true, threads: 4}});
+      done();
+
+    });
+  });
+
+  it('Should successfully return a request without the optional value', done => {
+    request('POST', {}, '/optional_nested_schema_params/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal(null);
+      done();
+
+    });
+  });
+
+
+  it('Should successfully return a request without the optional values', done => {
+    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve'}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal({name: 'steve'});
+      done();
+
+    });
+  });
+
+  it('Should successfully return a request with the optional values', done => {
+    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve', options: {istest: true}}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal({name: 'steve', options: {istest: true}});
+      done();
+
+    });
+  });
+
+  it('Should successfully return a request with the optional values and fields', done => {
+    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve', options: {istest: true, threads: 4}}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal({name: 'steve', options: {istest: true, threads: 4}});
+      done();
+
+    });
+  });
+
+  it('Should accept a request that matches first of two schemas', done => {
+    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test', size: 100}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(result).to.exist;
+      expect(result.error).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      done();
+
+    });
+  });
+
+  it('Should accept a request that matches second of two schemas', done => {
+    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test', files: [], options: {type: 'test'}}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(result).to.exist;
+      expect(result.error).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      done();
+
+    });
+  });
+
+  it('Should accept a request that matches second subsection of two schemas', done => {
+    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test', files: [], options: {type: 100}}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(result).to.exist;
+      expect(result.error).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      done();
+
+    });
+  });
+
+  it('Should reject a request that matches no schema', done => {
+    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test'}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject a request that matches no schema based on subsection', done => {
+    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test', files: [], options: {}}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject a request that matches no schema based on subsection type mismatch', done => {
+    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test', files: [], options: {type: false}}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should successfully return a default value with an optional field', done => {
+    request('POST', {}, '/optional_param_not_null/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.equal('default');
+      done();
+
+    });
+  });
+
+  it('Should successfully return a schema with a default set to 0', done => {
+    request('POST', {}, '/stripe/', {id: '0'},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      done();
+
+    });
+  });
+
+  it('Should successfully return a schema with an array', done => {
+    request('POST', {}, '/giphy/', {query: 'q'},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      done();
+
+    });
+  });
+
+  it('Should reject a request without an proper enum member', done => {
+    request('POST', {}, '/enum/', { day: 'funday' }, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.exist;
+      expect(result.error.type).to.equal('ParameterError');
+      expect(result.error.details).to.exist;
+      expect(result.error.details).to.deep.equal({
+        day: {
+          message: 'invalid value: "funday" (string), expected (enum)',
+          invalid: true,
+          expected: {
+            type: 'enum',
+            members: [
+              ['sunday', 0],
+              ['monday', '0'],
+              ['tuesday', { a: 1, b: 2 }],
+              ['wednesday', 3],
+              ['thursday', [1, 2, 3]],
+              ['friday', 5.4321],
+              ['saturday', 6]
+            ]
+          },
+          actual: {
+            value: 'funday',
+            type: 'string'
+          }
+        }
+      });
+      done();
+
+    });
+  });
+
+  it('Should successfully return an enum variant (number)', done => {
+    request('POST', {}, '/enum/', { day: 'sunday' },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.equal(0);
+      done();
+
+    });
+  });
+
+  it('Should successfully return an enum variant (string)', done => {
+    request('POST', {}, '/enum/', { day: 'monday' },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.equal("0");
+      done();
+
+    });
+  });
+
+  it('Should successfully return an enum variant (object)', done => {
+    request('POST', {}, '/enum/', { day: 'tuesday' },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal({a: 1, b: 2});
+      done();
+
+    });
+  });
+
+
+  it('Should successfully return an enum variant (array)', done => {
+    request('POST', {}, '/enum/', { day: 'thursday' },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal([1, 2, 3]);
+      done();
+
+    });
+  });
+
+  it('Should successfully return an enum variant (float)', done => {
+    request('POST', {}, '/enum/', { day: 'friday' },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.equal(5.4321);
+      done();
+
+    });
+  });
+
+  it('Should return a default enum variant', done => {
+    request('POST', {}, '/enum_default/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.equal(0);
+      done();
+
+    });
+  });
+
+  it('Should return an enum using the context param', done => {
+    request('POST', {}, '/enum_context/', { thingA: 'a', thingB: 'c' },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal({
+        a: 0,
+        b: {
+          c: 1,
+          d: [1, 2, 3]
+        },
+        c: '4',
+        d: 5.4321
+      });
+      done();
+
+    });
+  });
+
+  it('Should return an enum variant when the return type is enum', done => {
+    request('POST', {}, '/enum_return/', { a: 'a' },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.equal(0);
+      done();
+
+    });
+  });
+
+  it('Should reject returning an invalid enum variant  when the return type is enum', done => {
+    request('POST', {}, '/enum_return/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(502);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      expect(result.error).to.deep.equal({
+        type: 'ValueError',
+        message: 'The value returned by the function did not match the specified type',
+        details: {
+          returns: {
+            message: 'invalid return value: "not correct" (string), expected (enum)',
+            invalid: true,
+            expected: {
+              type: 'enum',
+              members: [['a', 0], ['b', [1, 2, 3]]]
+            },
+            actual: {
+              value: 'not correct',
+              type: 'string'
+            }
+          }
+        }
+      });
+      done();
+
+    });
+  });
+
+  it('Should fail to return null from a function without a nullable return value', done => {
+    request('POST', {}, '/not_nullable_return/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(502);
+      expect(result.error).to.exist;
+      expect(result.error.details).to.exist;
+      expect(result.error.details.returns).to.exist
+      expect(result.error.details.returns.invalid).to.equal(true);
+      done();
+
+    });
+  });
+
+  it('Should return null from a function with a nullable return value', done => {
+    request('POST', {}, '/nullable_return/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal(null);;
+      done();
+
+    });
+  });
+
+  it('Should return a value from a function with a nullable return value', done => {
+    request('POST', {}, '/nullable_return/', {a: 'hello'},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('hello');;
+      done();
+
+    });
+  });
+
+  it('Should successfully return a default parameter after passing in null', done => {
+    request('POST', {}, '/null_default_param/', {name: null},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('default');
+      done();
+
+    });
+  });
+
+  it('Should successfully return a default parameter after passing in undefined', done => {
+    request('POST', {}, '/null_default_param/', {name: undefined},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('default');
+      done();
+
+    });
+  });
+
+  it('Should successfully return an object with a schema that has an enum variant', done => {
+    request(
+      'POST',
+      {},
+      '/enum_schema/',
+      {
+        before: 'before',
+        valueRange: {
+          range: 'a range',
+          majorDimension: 'ROWS',
+          values: []
+        },
+        after: 'after',
+      },
+      (err, res, result) => {
+
+        expect(err).to.not.exist;
+        expect(res.statusCode).to.equal(200);
+        expect(result).to.exist;
+        expect(result).to.deep.equal({
+          range: 'a range',
+          majorDimension: 'ROWS',
+          values: []
+        });
+        done();
+
+      }
+    );
+  });
+
+  it('Should return a default enum variant set to null', done => {
+    request('POST', {}, '/enum_null/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal(null);
+      done();
+
+    });
+  });
+
+  it('Should accept keyql params', done => {
+    request('POST', {}, '/keyql/', { query: { name: 'steve' }, limit: { count: 0, offset: 0 }, order: { field: 'name', sort: 'ASC' } },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should accept keyql params', done => {
+    let query = JSON.stringify({ name: 'steve' });
+    let limit = JSON.stringify({ count: 0, offset: 0 });
+    let order = JSON.stringify({field: 'name', sort: 'ASC'});
+
+    request('GET', {'x-convert-strings': true}, `/keyql/?query=${query}&limit=${limit}&order=${order}`, '', (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should reject invalid keyql limit', done => {
+    request('POST', {}, '/keyql/', { query: { name: 'steve' }, limit: { count: 0, wrong: 0 }, order: { field: 'name', sort: 'ASC' }},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(result.error).to.exist;
+      expect(result.error.details).to.exist;
+      expect(result.error.details.limit).to.exist;
+      done();
+
+    });
+  });
+
+  it('Should reject invalid keyql order (no field)', done => {
+    request('POST', {}, '/keyql/', { query: { name: 'steve' }, limit: { count: 0, offset: 0 }, order: { field: null, sort: 'ASC' }},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(result.error).to.exist;
+      expect(result.error.details).to.exist;
+      expect(result.error.details.order).to.exist;
+      done();
+
+    });
+  });
+
+  it('Should reject invalid keyql order (invalid sort)', done => {
+    request('POST', {}, '/keyql/', { query: { name: 'steve' }, limit: { count: 0, offset: 0 }, order: { field: 'name', sort: 'WRONG' }},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(result.error).to.exist;
+      expect(result.error.details).to.exist;
+      expect(result.error.details.order).to.exist;
+      done();
+
+    });
+  });
+
+  it('Should reject invalid keyql order (overloaded)', done => {
+    request('POST', {}, '/keyql/', { query: { name: 'steve' }, limit: { count: 0, offset: 0 }, order: { field: 'name', sort: 'ASC', wrong: 'WRONG' }},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(result.error).to.exist;
+      expect(result.error.details).to.exist;
+      expect(result.error.details.order).to.exist;
+      done();
+
+    });
+  });
+
+  it('Should accept keyql with correct options', done => {
+    request('POST', {}, '/keyql_options/', {query: {alpha: 'hello'}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should accept keyql with correct options and an operator', done => {
+    request('POST', {}, '/keyql_options/', {query: {alpha__is: 'hello'}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should reject keyql with correct options with an incorrect operator', done => {
+    request('POST', {}, '/keyql_options/', {query: {alpha__isnt: 'hello'}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject keyql with incorrect options', done => {
+    request('POST', {}, '/keyql_options/', {query: {gamma: 'hello'}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject keyql with incorrect options with an operator', done => {
+    request('POST', {}, '/keyql_options/', {query: {gamma__is: 'hello'}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should accept keyql array with correct options', done => {
+    request('POST', {}, '/keyql_options_array/', {query: [{alpha: 'hello'}]},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should accept keyql array with correct options and an operator', done => {
+    request('POST', {}, '/keyql_options_array/', {query: [{alpha__is: 'hello'}]},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should reject keyql array with correct options with an incorrect operator', done => {
+    request('POST', {}, '/keyql_options_array/', {query: [{alpha__isnt: 'hello'}]},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject keyql array with incorrect options', done => {
+    request('POST', {}, '/keyql_options_array/', {query: [{gamma: 'hello'}]},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject keyql array with incorrect options with an operator', done => {
+    request('POST', {}, '/keyql_options_array/', {query: [{gamma__is: 'hello'}]},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should accept keyql order with correct options', done => {
+    request('POST', {}, '/keyql_order_options/', {order: {field: 'alpha'}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should reject keyql order with incorrect options', done => {
+    request('POST', {}, '/keyql_order_options/', {order: {field: 'gamma'}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should accept keyql array with correct options', done => {
+    request('POST', {}, '/keyql_order_options_array/', {order: [{field: 'alpha'}]},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should reject keyql array with incorrect options', done => {
+    request('POST', {}, '/keyql_order_options_array/', {order: [{field: 'gamma'}]},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should accept keyql array with all correct options', done => {
+    request('POST', {}, '/keyql_order_options_array/', {order: [{field: 'alpha'}, {field: 'beta'}]},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      done();
+
+    });
+  });
+
+  it('Should reject keyql array with an incorrect option', done => {
+    request('POST', {}, '/keyql_order_options_array/', {order: [{field: 'alpha'}, {field: 'gamma'}]},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject keyql limit count out of range, hard limit', done => {
+    request('POST', {}, '/keyql_limit/', {limit: {count: -1, offset: 0}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject keyql limit offset out of range, hard limit', done => {
+    request('POST', {}, '/keyql_limit/', {limit: {count: 0, offset: -1}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject keyql limit count non-integer, hard limit', done => {
+    request('POST', {}, '/keyql_limit/', {limit: {count: 0.256, offset: 0}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject keyql limit count out of lowerbound range, user limit', done => {
+    request('POST', {}, '/keyql_limit_range/', {limit: {count: 1, offset: 0}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject keyql limit count out of upperbound range, user limit', done => {
+    request('POST', {}, '/keyql_limit_range/', {limit: {count: 30, offset: 0}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should accept keyql limit count in range', done => {
+    request('POST', {}, '/keyql_limit_range/', {limit: {count: 5}},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      done();
+
+    });
+  });
+
+  it('Should accept number inside integer range', done => {
+    request('POST', {}, '/range_integer/', {ranged: 1},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      done();
+
+    });
+  });
+
+  it('Should reject number outside integer range, lowerbound', done => {
+    request('POST', {}, '/range_integer/', {ranged: -1},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should reject number outside integer range, upperbound', done => {
+    request('POST', {}, '/range_integer/', {ranged: 201},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should accept number inside number range', done => {
+    request('POST', {}, '/range_number/', {ranged: 1.5},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      done();
+
+    });
+  });
+
+  it('Should reject number outside number range, lowerbound', done => {
+    request('POST', {}, '/range_number/', {ranged: 1},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(result.error).to.exist;
+      expect(result.error.details.ranged.message).to.equal('must be greater than or equal to 1.01');
+      done();
+
+    });
+  });
+
+  it('Should reject number outside number range, upperbound', done => {
+    request('POST', {}, '/range_number/', {ranged: 200},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      done();
+
+    });
+  });
+
+  it('Should accept string within provided options', done => {
+    request('POST', {}, '/string_options/', {value: 'one'},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.equal('one');
+      done();
+
+    });
+  });
+
+  it('Should reject string outside provided options', done => {
+    request('POST', {}, '/string_options/', {value: 'four'},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(result.error.details.value.message).to.contain('["one","two","three"]');
+      expect(result.error.details.value.expected.values).to.deep.equal(['one', 'two', 'three']);
+      done();
+
+    });
+  });
+
+  it('Should identify mismatch in a returns statement (unnamed, non-array)', done => {
+    request('POST', {}, '/mismatch_returns_anon/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(502);
+      expect(result.error.details.returns.mismatch).to.exist;
+      expect(result.error.details.returns.mismatch).to.equal('$.user.name');
+      done();
+
+    });
+  });
+
+  it('Should identify mismatch in a returns statement (unnamed, array)', done => {
+    request('POST', {}, '/mismatch_returns_anon_array/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(502);
+      expect(result.error.details.returns.mismatch).to.exist;
+      expect(result.error.details.returns.mismatch).to.equal('$.user.names[1]');
+      done();
+
+    });
+  });
+
+  it('Should identify mismatch in a returns statement (named, non-array)', done => {
+    request('POST', {}, '/mismatch_returns_named/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(502);
+      expect(result.error.details.returns.mismatch).to.exist;
+      expect(result.error.details.returns.mismatch).to.equal('myObject.user.name');
+      done();
+
+    });
+  });
+
+  it('Should identify mismatch in a returns statement (named, array)', done => {
+    request('POST', {}, '/mismatch_returns_named_array/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(502);
+      expect(result.error.details.returns.mismatch).to.exist;
+      expect(result.error.details.returns.mismatch).to.equal('myObject.user.names[1]');
+      done();
+
+    });
+  });
+
+  it('Should identify mismatch in a returns statement (deep)', done => {
+    request('POST', {}, '/mismatch_returns_deep/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(502);
+      expect(result.error.details.returns.mismatch).to.exist;
+      expect(result.error.details.returns.mismatch).to.equal('$.user.posts[0].messages[2]');
+      done();
+
+    });
+  });
+
+  it('Should identify mismatch in a param statement (deep)', done => {
+    request('POST', {}, '/mismatch_params_deep/',
+    {
+      userData: {
+        user: {
+          posts: [
+            {
+              title: 'sup',
+              messages: ['hey', 'there', 7]
+            }
+          ]
+        }
+      }
+    },
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(result.error.details.userData).to.exist;
+      expect(result.error.details.userData.mismatch).to.equal('userData.user.posts[0].messages[2]');
+      done();
+
+    });
+  });
+
+  it('Should return a buffer properly', done => {
+    request('POST', {}, '/buffer_return/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/octet-stream');
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.toString()).to.equal('lol');
+      done();
+
+    });
+  });
+
+  it('Should return a buffer properly with a .contentType set', done => {
+    request('POST', {}, '/buffer_return_content_type/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('image/png');
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.toString()).to.equal('lol');
+      done();
+
+    });
+  });
+
+  it('Should return a nested buffer properly', done => {
+    request('POST', {}, '/buffer_nested_return/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.haveOwnProperty('body');
+      expect(result.body).to.haveOwnProperty('_base64');
+      expect(Buffer.from(result.body._base64, 'base64').toString()).to.equal('lol');
+      expect(result.test).to.exist;
+      expect(result.test.deep).to.exist;
+      expect(result.test.deep).to.be.an('array');
+      expect(result.test.deep.length).to.equal(3);
+      expect(result.test.deep[1]).to.haveOwnProperty('_base64');
+      expect(Buffer.from(result.test.deep[1]._base64, 'base64').toString()).to.equal('wat');
+      done();
+
+    });
+  });
+
+  it('Should parse buffers within object params', done => {
+    request('POST', {}, '/buffer_within_object_param/', {
+      objectParam: {
+        bufferVal: {
+          _base64: 'abcde'
+        }
+      }
+    }, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result).to.exist;
+      expect(result).to.equal('ok');
+      done();
+
+    });
+  });
+
+  it('Should parse buffers within array params', done => {
+    request('POST', {}, '/buffer_within_array_param/', {
+      arrayParam: [{
+        _base64: 'abcde'
+      }]
+    }, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result).to.exist;
+      expect(result).to.equal('ok');
+      done();
+
+    });
+  });
+
+  it('Should return a mocked buffer as if it were a real one', done => {
+    request('POST', {}, '/buffer_mocked_return/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.toString()).to.equal('lol');
+      done();
+
+    });
+  });
+
+  it('Should return a nested mocked buffer as if it were a real one', done => {
+    request('POST', {}, '/buffer_nested_mocked_return/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.haveOwnProperty('body');
+      expect(result.body).to.haveOwnProperty('_base64');
+      expect(Buffer.from(result.body._base64, 'base64').toString()).to.equal('lol');
+      expect(result.test).to.exist;
+      expect(result.test.deep).to.exist;
+      expect(result.test.deep).to.be.an('array');
+      expect(result.test.deep.length).to.equal(3);
+      expect(result.test.deep[1]).to.haveOwnProperty('_base64');
+      expect(Buffer.from(result.test.deep[1]._base64, 'base64').toString()).to.equal('wat');
+      done();
+
+    });
+  });
+
+  it('Should return a mocked buffer as if it were a real one, if type "any"', done => {
+    request('POST', {}, '/buffer_any_return/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.toString()).to.equal('lol');
+      done();
+
+    });
+  });
+
+  it('Should return a nested mocked buffer as if it were a real one, if type "any"', done => {
+    request('POST', {}, '/buffer_nested_any_return/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.haveOwnProperty('body');
+      expect(result.body).to.haveOwnProperty('_base64');
+      expect(Buffer.from(result.body._base64, 'base64').toString()).to.equal('lol');
+      expect(result.test).to.exist;
+      expect(result.test.deep).to.exist;
+      expect(result.test.deep).to.be.an('array');
+      expect(result.test.deep.length).to.equal(3);
+      expect(result.test.deep[1]).to.haveOwnProperty('_base64');
+      expect(Buffer.from(result.test.deep[1]._base64, 'base64').toString()).to.equal('wat');
+      done();
+
+    });
+  });
+
+  it('Should throw an ValueError on an invalid Buffer type', done => {
+    request('POST', {}, '/value_error/buffer_invalid/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(502);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      done();
+
+    });
+  });
+
+  it('Should throw an ValueError on an invalid Number type', done => {
+    request('POST', {}, '/value_error/number_invalid/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(502);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      done();
+
+    });
+  });
+
+  it('Should throw an ValueError on an invalid Object type with alternate schema', done => {
+    request('POST', {}, '/value_error/object_alternate_schema_invalid/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(502);
+      expect(res.headers['x-execution-uuid'].length).to.be.greaterThan(1);
+      expect(result).to.exist;
+      done();
+
+    });
+  });
+
+  it('Should not populate "context.keys" with no authorization keys header provided', done => {
+    request('POST', {}, '/keys/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal({
+        TEST_KEY: null,
+        ANOTHER_KEY: null,
+        A_THIRD_KEY: null
+      });
+      done();
+
+    });
+  });
+
+  it('Should not populate "context.keys" if the authorization keys header is not a serialized object', done => {
+    request('POST', {
+      'X-Authorization-Keys': 'stringvalue'
+    }, '/keys/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal({
+        TEST_KEY: null,
+        ANOTHER_KEY: null,
+        A_THIRD_KEY: null
+      });
+      done();
+
+    });
+  });
+
+  it('Should populate "context.keys" with only the proper keys', done => {
+    request('POST', {
+      'X-Authorization-Keys': JSON.stringify({
+        TEST_KEY: '123',
+        ANOTHER_KEY: 'abc',
+        UNSPECIFIED_KEY: '987'
+      })
+    }, '/keys/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result).to.deep.equal({
+        TEST_KEY: '123',
+        ANOTHER_KEY: 'abc',
+        A_THIRD_KEY: null
+      });
+      done();
+
+    });
+  });
+
+  it('Should not populate "context.providers" with no authorization providers header provided', done => {
+    request('POST', {}, '/context/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result.providers).to.deep.equal({});
+      done();
+
+    });
+  });
+
+  it('Should not populate "context.providers" if the authorization providers header is not an serialized object', done => {
+    request('POST', {
+      'X-Authorization-Providers': 'stringvalue'
+    }, '/context/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result.providers).to.deep.equal({});
+      done();
+
+    });
+  });
+
+  it('Should populate "context.providers" as the value of the authorization providers header if it is a serialized object', done => {
+    let headerValue = {
+      test: {
+        item: 'value'
+      }
+    };
+    request('POST', {
+      'X-Authorization-Providers': JSON.stringify(headerValue)
+    }, '/context/', {},
+    (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(result).to.exist;
+      expect(result.providers).to.deep.equal(headerValue);
+      done();
+
+    });
+  });
+
+  it('Should populate context in "inline/context"', done => {
+    request('POST', {}, '/inline/context/', {a: 1, b: 2}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result).to.exist;
+      expect(result.http.method).to.equal('POST');
+      expect(result.params).to.deep.equal({a: 1, b: 2});
+      done();
+
+    });
+  });
+
+  it('Should output buffer from "inline/buffer"', done => {
+    request('POST', {}, '/inline/buffer/', {}, (err, res, result) => {
 
-        expect(err).to.not.exist;
-        expect(res.statusCode).to.equal(400);
-        expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
-        expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
-        expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-        expect(result.error).to.exist;
-        expect(result.error.type).to.equal('ParameterError');
-        expect(result.error.details).to.exist;
-        expect(result.error.details.users).to.exist;
-        expect(result.error.details.users.expected).to.exist;
-        expect(result.error.details.users.expected.type).to.equal('array');
-        expect(result.error.details.users.expected.schema).to.deep.equal([
-          {
-            name: 'user',
-            type: 'object',
-            description: 'a user',
-            schema: [
-              {
-                name: 'username',
-                type: 'string',
-                description: ''
-              },
-              {
-                name: 'posts',
-                type: 'array',
-                description: '',
-                schema: [
-                  {
-                    name: 'post',
-                    type: 'object',
-                    description: '',
-                    schema: [
-                      {
-                        name: 'title',
-                        type: 'string',
-                        description: ''
-                      },
-                      {
-                        name: 'body',
-                        type: 'string',
-                        description: ''
-                      }
-                    ]
-                  }
-                ]
-              }
-            ]
-          }
-        ]);
-        expect(result.error.details.users.actual).to.deep.equal({
-          type: 'array',
-          value: [
-            {
-              posts: [
-                {
-                  body: 'b',
-                  title: 't'
-                }
-              ],
-              username: 'steve'
-            },
-            {
-              posts: [
-                {
-                  body: 'b',
-                  title: 't'
-                }
-              ]
-            }
-          ]
-        });
-        done();
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/html');
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.toString()).to.equal('lol');
+      done();
+
+    });
+  });
+
+  it('Should output buffer from "inline/buffer_mock"', done => {
+    request('POST', {}, '/inline/buffer_mock/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/octet-stream');
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.toString()).to.equal('lol');
+      done();
+
+    });
+  });
+
+  it('Should output buffer from "inline/http"', done => {
+    request('POST', {}, '/inline/http/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(429);
+      expect(res.headers['content-type']).to.equal('text/html');
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.toString()).to.equal('lol');
+      done();
+
+    });
+  });
+
+  it('Should output buffer from "inline/http_no_status"', done => {
+    request('POST', {}, '/inline/http_no_status/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/html');
+      expect(result).to.exist;
+      expect(result).to.be.instanceof(Buffer);
+      expect(result.toString()).to.equal('lol');
+      done();
+
+    });
+  });
+
+  it('Should output object from "inline/extended_http_is_object"', done => {
+    request('POST', {}, '/inline/extended_http_is_object/', {}, (err, res, result) => {
 
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result).to.exist;
+      expect(result).to.deep.equal({
+        statusCode: 429,
+        headers: {'Content-Type': 'text/html'},
+        body: 'lol',
+        extend: true
       });
+      done();
+
+    });
   });
 
-  it('Should accept a nested array that correctly maps to Schema', done => {
-    request('POST', {}, '/schema_rejection_nested_array/', {
-      users: [
-        { username: 'steve', posts: [{ title: 't', body: 'b' }] },
-        { username: 'steve2', posts: [{ title: 't', body: 'b' }] }
-      ]
-    },
-    (err, res, result) => {
+  it('Should output object from "inline/number"', done => {
+    request('POST', {}, '/inline/number/', {}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
-      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
-      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result).to.deep.equal( [
-        { username: 'steve', posts: [{ title: 't', body: 'b' }] },
-        { username: 'steve2', posts: [{ title: 't', body: 'b' }] }
-      ]);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result).to.exist;
+      expect(result).to.equal(1988);
       done();
 
     });
   });
 
-  it('Should reject an array that doesn\'t map to a Schema for an array of numbers', done => {
-    request('POST', {}, '/schema_rejection_number_array/', {
-      userIds: ['alpha', 'beta']
-    },
-    (err, res, result) => {
+  it('Should allow you to use "require()"', done => {
+    request('POST', {}, '/inline/require/', {}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
-      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
-      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
-      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result.error).to.exist;
-      expect(result.error.type).to.equal('ParameterError');
-      expect(result.error.details).to.exist;
-      expect(result.error.details.userIds).to.exist;
-      expect(result.error.details.userIds.expected).to.exist;
-      expect(result.error.details.userIds.expected.type).to.equal('array');
-      expect(result.error.details.userIds.expected.schema).to.exist;
-      expect(result.error.details.userIds.expected.schema).to.have.length(1);
-      expect(result.error.details.userIds.expected.schema[0].type).to.equal('number');
-      expect(result.error.details.userIds.actual).to.exist;
-      expect(result.error.details.userIds.actual.type).to.equal('array');
-      expect(result.error.details.userIds.actual.value).to.deep.equal(['alpha', 'beta']);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result).to.exist;
+      expect(result).to.equal('hello');
+      done();
+
+    });
+  });
+
+  it('Should allow you to use "await"', done => {
+    request('POST', {}, '/inline/await/', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result).to.exist;
+      expect(result).to.equal('hello world');
+      done();
+
+    });
+  });
+
+  it('Should support static files in "www" directory properly', done => {
+    request('GET', {}, '/page.html', '', (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('this is an html file\n');
+      done();
+
+    });
+  });
+
+  it('Should support POST to static files in "www" directory properly (noop)', done => {
+    request('POST', {}, '/page.html', {}, (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('this is an html file\n');
+      done();
+
+    });
+  });
+
+  it('Should NOT support static files in "www" directory properly, without .html', done => {
+    request('GET', {}, '/page/', '', (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(404);
+      done();
+
+    });
+  });
+
+  it('Should NOT support static files in "www" directory properly, without .htm', done => {
+    request('GET', {}, '/page2/', '', (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(404);
+      done();
+
+    });
+  });
+
+  it('Should support 404 not found in "www" directory properly by direct accession', done => {
+    request('GET', {}, '/error/404.html', '', (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(404);
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('error 404\n');
+      done();
+
+    });
+  });
+
+  it('Should support 404 not found in "www" directory properly by dir accession', done => {
+    request('GET', {}, '/error/', '', (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(404);
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('error 404\n');
+      done();
+
+    });
+  });
+
+  it('Should support 404 not found in "www" directory properly by non-existent file accession', done => {
+    request('GET', {}, '/error/nope.txt', '', (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(404);
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('error 404\n');
+      done();
+
+    });
+  });
+
+  it('Should support 404 not found in "www" directory properly by nested non-existent file accession', done => {
+    request('GET', {}, '/error/path/to/nope.txt', '', (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(404);
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('error 404\n');
+      done();
+
+    });
+  });
+
+  it('Should support 404 not found in "www" directory properly by nested non-existent file accession', done => {
+    request('GET', {}, '/error/path/to/nope.txt', '', (err, res, result) => {
+
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(404);
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('error 404\n');
       done();
 
     });
   });
 
-  it('Should accept an array that correctly maps to Schema', done => {
-    request('POST', {}, '/schema_rejection_number_array/', {
-      userIds: [1, 2, 3]
-    },
-    (err, res, result) => {
+  it('Should support "index.html" mapping to root directory', done => {
+    request('GET', {}, '/static-test/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
-      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
-      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
-      expect(result).to.equal('hello');
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('this is an index.html file\n');
       done();
 
     });
   });
 
-  it('Should handle large buffer parameters', done => {
-    request('POST', {'x-convert-strings': true}, '/runtime/largebuffer/', {
-      file: `{"_base64": "${'a'.repeat(50000000)}"}`
-    }, (err, res, result) => {
+  it('Should support "index.html" also mapping to itself', done => {
+    request('GET', {}, '/static-test/index.html', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.exist;
-      expect(result.error).to.not.exist;
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('this is an index.html file\n');
       done();
 
     });
-  }).timeout(5000);
+  });
 
-  it('Should accept a request with the optional param', done => {
-    request('POST', {}, '/optional_params/', {name: 'steve'},
-    (err, res, result) => {
+  it('Should support "index.htm" mapping to root directory', done => {
+    request('GET', {}, '/static-test/htm/', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('steve');
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('this is an index.htm file\n');
       done();
 
     });
   });
 
-  it('Should accept a request without the optional param', done => {
-    request('POST', {}, '/optional_params/', {},
-    (err, res, result) => {
+  it('Should support "index.htm" also mapping to itself', done => {
+    request('GET', {}, '/static-test/htm/index.htm', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('hello');
+      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8');
+      expect(result.toString()).to.equal('this is an index.htm file\n');
       done();
 
     });
   });
 
-  it('Should accept a request without the optional param', done => {
-    request('POST', {}, '/schema_optional_params/', {},
-    (err, res, result) => {
+  it('Should support static (www) ".png" files properly', done => {
+    request('GET', {}, '/fs-wordmark.png', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal(null);
+      expect(res.headers['content-type']).to.equal('image/png');
+      expect(result.byteLength).to.equal(parseInt(res.headers['content-length']));
       done();
 
     });
   });
 
-  it('Should accept a request without the optional param field', done => {
-    request('POST', {}, '/schema_optional_params/', {obj: {name: 'steve'}},
-    (err, res, result) => {
+  it('Should support static (www) ".mp4" files properly', done => {
+    request('GET', {}, '/video.mp4', '', (err, res, result, headers) => {
 
+      let size = parseInt(res.headers['content-length']);
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.deep.equal({name: 'steve'});
+      expect(res.headers['content-type']).to.equal('video/mp4');
+      expect(res.headers['content-range']).to.equal('bytes 0-' + (size - 1) + '/' + size);
+      expect(res.headers['accept-ranges']).to.equal('bytes');
+      expect(result.byteLength).to.equal(size);
       done();
 
     });
   });
 
-  it('Should accept a request with the optional param field set to null', done => {
-    request('POST', {}, '/schema_optional_params/', {obj: {name: 'steve', enabled: null}},
-    (err, res, result) => {
+  it('Should support static (www) ".mp4" files properly with range header', done => {
+    request('GET', {range: '27-255'}, '/video.mp4', '', (err, res, result) => {
 
+      let size = parseInt(res.headers['content-length']);
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(result).to.deep.equal({name: 'steve', enabled: null});
+      expect(res.statusCode).to.equal(206);
+      expect(res.headers['content-type']).to.equal('video/mp4');
+      expect(res.headers['content-range']).to.equal('bytes 27-255/574823');
+      expect(res.headers['accept-ranges']).to.equal('bytes');
+      expect(size).to.equal(255 - 27 + 1);
+      expect(result.byteLength).to.equal(size);
       done();
 
     });
   });
 
-  it('Should accept a request with the optional param field', done => {
-    request('POST', {}, '/schema_optional_params/', {obj: {name: 'steve', enabled: true}},
-    (err, res, result) => {
+  it('Should support static (www) ".mp4" files properly with range header (prefix)', done => {
+    request('GET', {range: '0-'}, '/video.mp4', '', (err, res, result) => {
 
+      let size = parseInt(res.headers['content-length']);
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.deep.equal({name: 'steve', enabled: true});
+      expect(res.headers['content-type']).to.equal('video/mp4');
+      expect(res.headers['content-range']).to.equal('bytes 0-' + (size - 1) + '/' + size);
+      expect(res.headers['accept-ranges']).to.equal('bytes');
+      expect(result.byteLength).to.equal(size);
       done();
 
     });
   });
 
-  it('Should accept a request without the optional param (nested schema)', done => {
-    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve' }},
-    (err, res, result) => {
+  it('Should support static (www) ".mp4" files properly with range header (prefix + 1)', done => {
+    request('GET', {range: '1-'}, '/video.mp4', '', (err, res, result) => {
 
+      let size = parseInt(res.headers['content-length']);
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(result).to.deep.equal({name: 'steve'});
+      expect(res.statusCode).to.equal(206);
+      expect(res.headers['content-type']).to.equal('video/mp4');
+      expect(res.headers['content-range']).to.equal('bytes 1-574822/574823');
+      expect(res.headers['accept-ranges']).to.equal('bytes');
+      expect(result.byteLength).to.equal(size);
       done();
 
     });
   });
 
-  it('Should reject a request without the required param within the optional object (nested schema)', done => {
-    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve', options: {}}},
-    (err, res, result) => {
+  it('Should support static (www) ".mp4" files properly with range header (suffix)', done => {
+    request('GET', {range: '-500'}, '/video.mp4', '', (err, res, result) => {
 
+      let size = parseInt(res.headers['content-length']);
       expect(err).to.not.exist;
-      expect(result).to.exist;
-      expect(result.error).to.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(206);
+      expect(res.headers['content-type']).to.equal('video/mp4');
+      expect(res.headers['content-range']).to.equal('bytes 574323-574822/574823');
+      expect(res.headers['accept-ranges']).to.equal('bytes');
+      expect(size).to.equal(500);
+      expect(result.byteLength).to.equal(size);
       done();
 
     });
   });
 
-  it('Should accept a request with the optional object (nested schema)', done => {
-    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve', options: {istest: true}}},
-    (err, res, result) => {
+  it('Should support POST with nonstandard JSON (array)', done => {
+    request('POST', {}, '/nonstandard/json/', [1, 2, 3], (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.exist;
-      expect(result).to.deep.equal({name: 'steve', options: { istest: true}});
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result.http.json).to.exist;
+      expect(result.http.json).to.deep.equal([1, 2, 3]);
       done();
 
     });
   });
 
-  it('Should accept a request with the optional object and optional field (nested schema)', done => {
-    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve', options: {istest: true, threads: 4}}},
-    (err, res, result) => {
+  it('Should support POST with nonstandard JSON (string)', done => {
+    request('POST', {}, '/nonstandard/json/', '"hello"', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.exist;
-      expect(result).to.deep.equal({name: 'steve', options: { istest: true, threads: 4}});
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result.http.json).to.exist;
+      expect(result.http.json).to.equal('hello');
       done();
 
     });
   });
 
-  it('Should successfully return a request without the optional value', done => {
-    request('POST', {}, '/optional_nested_schema_params/', {},
-    (err, res, result) => {
+  it('Should support POST with nonstandard JSON (boolean)', done => {
+    request('POST', {}, '/nonstandard/json/', 'true', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal(null);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result.http.json).to.exist;
+      expect(result.http.json).to.equal(true);
       done();
 
     });
   });
 
-
-  it('Should successfully return a request without the optional values', done => {
-    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve'}},
-    (err, res, result) => {
+  it('Should support POST with nonstandard JSON (number)', done => {
+    request('POST', {}, '/nonstandard/json/', '1.2', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.exist;
-      expect(result).to.deep.equal({name: 'steve'});
-      done();
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result.http.json).to.exist;
+      expect(result.http.json).to.equal(1.2);
+      done();
+
+    });
+  });
+
+  it('Should support POST with XML', done => {
+
+    let xmlData = `
+      <Company>
+        <Employee>
+            <FirstName>John</FirstName>
+            <LastName>Doe</LastName>
+            <ContactNo>1234567890</ContactNo>
+            <Email>johndoe@example.com</Email>
+            <Address>
+                 <City>San Francisco</City>
+                 <State>California</State>
+                 <Zip>123456</Zip>
+            </Address>
+            <Fulltime>True</Fulltime>
+        </Employee>
+        <Employee>
+            <FirstName>Jane</FirstName>
+            <LastName>Smith</LastName>
+            <ContactNo>0987654321</ContactNo>
+            <Email>janesmith@example.com</Email>
+            <Address>
+                 <City>Los Angeles</City>
+                 <State>California</State>
+                 <Zip>654321</Zip>
+            </Address>
+            <Fulltime>False</Fulltime>
+        </Employee>
+      </Company>`;
+
+    let parsedData = {
+      Company: {
+        Employee: [
+          {
+            FirstName: 'John',
+            LastName: 'Doe',
+            ContactNo: "1234567890",
+            Email: 'johndoe@example.com',
+            Address: {
+              City: 'San Francisco',
+              State: 'California',
+              Zip: '123456'
+            },
+            Fulltime: 'True',
+          },
+          {
+            FirstName: 'Jane',
+            LastName: 'Smith',
+            ContactNo: '0987654321',
+            Email: 'janesmith@example.com',
+            Address: {
+              City: 'Los Angeles',
+              State: 'California',
+              Zip: '654321'
+            },
+            Fulltime: 'False',
+          }
+        ]
+      }
+    }
 
-    });
-  });
+    request('POST', {'Content-Type': 'application/xml'}, '/reflect/', xmlData, (err, res, result) => {
 
-  it('Should successfully return a request with the optional values', done => {
-    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve', options: {istest: true}}},
-    (err, res, result) => {
+      expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal(parsedData);
+      done();
+
+    });
+  });
+
+  it('Should support POST with XML (containing attributes)', done => {
+
+    let xmlData = `<feed xmlns:yt="http://www.youtube.com/xml/schemas/2015"
+         xmlns="http://www.w3.org/2005/Atom">
+      <link rel="hub" href="https://pubsubhubbub.appspot.com"/>
+      <link rel="self" href="https://www.youtube.com/xml/feeds/videos.xml?channel_id=CHANNEL_ID"/>
+      <title>YouTube video feed</title>
+      <updated>2015-04-01T19:05:24.552394234+00:00</updated>
+      <entry>
+        <id>yt:video:VIDEO_ID</id>
+        <yt:videoId>VIDEO_ID</yt:videoId>
+        <yt:channelId>CHANNEL_ID</yt:channelId>
+        <title>Video title</title>
+        <link rel="alternate" href="http://www.youtube.com/watch?v=VIDEO_ID"/>
+        <author>
+         <name>Channel title</name>
+         <uri>http://www.youtube.com/channel/CHANNEL_ID</uri>
+        </author>
+        <published>2015-03-06T21:40:57+00:00</published>
+        <updated>2015-03-09T19:05:24.552394234+00:00</updated>
+      </entry>
+    </feed>`;
+
+    let parsedData = {
+      "feed": {
+        "@_xmlns:yt": "http://www.youtube.com/xml/schemas/2015",
+        "@_xmlns": "http://www.w3.org/2005/Atom",
+        "link": [
+          {
+            "@_rel": "hub",
+            "@_href": "https://pubsubhubbub.appspot.com"
+          },
+          {
+            "@_rel": "self",
+            "@_href": "https://www.youtube.com/xml/feeds/videos.xml?channel_id=CHANNEL_ID"
+          }
+        ],
+        "title": "YouTube video feed",
+        "updated": "2015-04-01T19:05:24.552394234+00:00",
+        "entry": {
+          "id": "yt:video:VIDEO_ID",
+          "yt:videoId": "VIDEO_ID",
+          "yt:channelId": "CHANNEL_ID",
+          "title": "Video title",
+          "link": {
+            "@_rel": "alternate",
+            "@_href": "http://www.youtube.com/watch?v=VIDEO_ID"
+          },
+          "author": {
+            "name": "Channel title",
+            "uri": "http://www.youtube.com/channel/CHANNEL_ID"
+          },
+          "published": "2015-03-06T21:40:57+00:00",
+          "updated": "2015-03-09T19:05:24.552394234+00:00"
+        }
+      }
+    }
+
+    request('POST', {'Content-Type': 'application/xml'}, '/reflect/', xmlData, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.exist;
-      expect(result).to.deep.equal({name: 'steve', options: {istest: true}});
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal(parsedData);
       done();
 
     });
+
   });
 
-  it('Should successfully return a request with the optional values and fields', done => {
-    request('POST', {}, '/optional_nested_schema_params/', {obj: {name: 'steve', options: {istest: true, threads: 4}}},
-    (err, res, result) => {
+  it('Should reject invalid XML', done => {
+
+    let xmlData = `
+      <Company>
+        <Employee>
+            <FirstName>John</FirstName>
+            <LastName>Doe</LastName>
+            <ContactNo>1234567890</ContactNo>
+            <Email>johndoe@example.com</Email>
+            <Address>
+                 <City>San Francisco</City>
+                 <State>California</State>
+                 <Zip>123456</Zip>
+            </Address>
+            <Fulltime>True</Fulltime>
+        </Employee>
+        <Employee>
+            <FirstName>Jane</FirstName>
+            <LastName>Smith</LastName>
+            <ContactNo>0987654321</ContactNo>
+            <Email>janesmith@example.com</Email>
+            <Address>
+                 <City>Los Angeles</City>
+                 <State>California</State>
+                 <Zip>654321</Zip>
+            </Address>
+            <Fulltime>False</Fulltime>
+        </Employee>
+      </Companyyy>`;
+
+    request('POST', {'Content-Type': 'application/xml'}, '/reflect/', xmlData, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       expect(result).to.exist;
-      expect(result).to.deep.equal({name: 'steve', options: {istest: true, threads: 4}});
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ParameterParseError');
       done();
 
     });
   });
 
-  it('Should accept a request that matches first of two schemas', done => {
-    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test', size: 100}},
-    (err, res, result) => {
+  it('Should not reject nor parse XML if no Content-Type headers are passed in', done => {
+
+    let xmlData = `
+      <Company>
+        <Employee>
+            <FirstName>John</FirstName>
+            <LastName>Doe</LastName>
+            <ContactNo>1234567890</ContactNo>
+            <Email>johndoe@example.com</Email>
+            <Address>
+                 <City>San Francisco</City>
+                 <State>California</State>
+                 <Zip>123456</Zip>
+            </Address>
+            <Fulltime>True</Fulltime>
+        </Employee>
+        <Employee>
+            <FirstName>Jane</FirstName>
+            <LastName>Smith</LastName>
+            <ContactNo>0987654321</ContactNo>
+            <Email>janesmith@example.com</Email>
+            <Address>
+                 <City>Los Angeles</City>
+                 <State>California</State>
+                 <Zip>654321</Zip>
+            </Address>
+            <Fulltime>False</Fulltime>
+        </Employee>
+      </Company>`;
+
+    request('POST', {}, '/reflect/', xmlData, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(result).to.exist;
-      expect(result.error).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       done();
 
     });
   });
 
-  it('Should accept a request that matches second of two schemas', done => {
-    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test', files: [], options: {type: 'test'}}},
-    (err, res, result) => {
+  it('Should support POST with XML for content type "application/atom+xml"', done => {
+
+    let xmlData = `
+      <Company>
+        <Employee>
+            <FirstName>John</FirstName>
+            <LastName>Doe</LastName>
+            <ContactNo>1234567890</ContactNo>
+            <Email>johndoe@example.com</Email>
+            <Address>
+                 <City>San Francisco</City>
+                 <State>California</State>
+                 <Zip>123456</Zip>
+            </Address>
+            <Fulltime>True</Fulltime>
+        </Employee>
+        <Employee>
+            <FirstName>Jane</FirstName>
+            <LastName>Smith</LastName>
+            <ContactNo>0987654321</ContactNo>
+            <Email>janesmith@example.com</Email>
+            <Address>
+                 <City>Los Angeles</City>
+                 <State>California</State>
+                 <Zip>654321</Zip>
+            </Address>
+            <Fulltime>False</Fulltime>
+        </Employee>
+      </Company>`;
+
+    let parsedData = {
+      Company: {
+        Employee: [
+          {
+            FirstName: 'John',
+            LastName: 'Doe',
+            ContactNo: "1234567890",
+            Email: 'johndoe@example.com',
+            Address: {
+              City: 'San Francisco',
+              State: 'California',
+              Zip: '123456'
+            },
+            Fulltime: 'True',
+          },
+          {
+            FirstName: 'Jane',
+            LastName: 'Smith',
+            ContactNo: '0987654321',
+            Email: 'janesmith@example.com',
+            Address: {
+              City: 'Los Angeles',
+              State: 'California',
+              Zip: '654321'
+            },
+            Fulltime: 'False',
+          }
+        ]
+      }
+    }
+
+    request('POST', {'Content-Type': 'application/atom+xml'}, '/reflect/', xmlData, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(result).to.exist;
-      expect(result.error).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal(parsedData);
       done();
 
     });
   });
 
-  it('Should accept a request that matches second subsection of two schemas', done => {
-    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test', files: [], options: {type: 100}}},
-    (err, res, result) => {
+  it('Should support POST with XML for content type "application/atom+xml" (containing attributes)', done => {
+
+    let xmlData = `<entry>
+      <id>yt:video:abdefghijklmnop</id>
+      <yt:videoId>abdefghijklmnop</yt:videoId>
+      <yt:channelId>abcdefghijklmnop</yt:channelId>
+      <title>Some Video Title</title>
+      <link rel="alternate" href="https://www.youtube.com/watch?v=abcdefghijklmnop"/>
+      <author>
+        <name>Video Name</name>
+        <uri>https://www.youtube.com/channel/abcdefghijklmnop</uri>
+      </author>
+      <published>2021-06-24T23:37:28+00:00</published>
+      <updated>2021-06-24T23:37:58.731601431+00:00</updated>
+    </entry>`;
+
+    let parsedData = {
+      "entry": {
+        "author": {
+            "name": "Video Name",
+            "uri": "https://www.youtube.com/channel/abcdefghijklmnop"
+        },
+        "id": "yt:video:abdefghijklmnop",
+        "link": {
+          "@_href": "https://www.youtube.com/watch?v=abcdefghijklmnop",
+          "@_rel": "alternate",
+        },
+        "published": "2021-06-24T23:37:28+00:00",
+        "title": "Some Video Title",
+        "updated": "2021-06-24T23:37:58.731601431+00:00",
+        "yt:channelId": "abcdefghijklmnop",
+        "yt:videoId": "abdefghijklmnop"
+      }
+    };
+
+    request('POST', {'Content-Type': 'application/atom+xml'}, '/reflect/', xmlData, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(result).to.exist;
-      expect(result.error).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(result).to.deep.equal(parsedData);
       done();
 
     });
+
   });
 
-  it('Should reject a request that matches no schema', done => {
-    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test'}},
-    (err, res, result) => {
+  it('Should reject invalid XML for content type "application/atom+xml"', done => {
+
+    let xmlData = `
+      <Company>
+        <Employee>
+            <FirstName>John</FirstName>
+            <LastName>Doe</LastName>
+            <ContactNo>1234567890</ContactNo>
+            <Email>johndoe@example.com</Email>
+            <Address>
+                 <City>San Francisco</City>
+                 <State>California</State>
+                 <Zip>123456</Zip>
+            </Address>
+            <Fulltime>True</Fulltime>
+        </Employee>
+        <Employee>
+            <FirstName>Jane</FirstName>
+            <LastName>Smith</LastName>
+            <ContactNo>0987654321</ContactNo>
+            <Email>janesmith@example.com</Email>
+            <Address>
+                 <City>Los Angeles</City>
+                 <State>California</State>
+                 <Zip>654321</Zip>
+            </Address>
+            <Fulltime>False</Fulltime>
+        </Employee>
+      </Companyyy>`;
+
+    request('POST', {'Content-Type': 'application/atom+xml'}, '/reflect/', xmlData, (err, res, result) => {
 
       expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       expect(result).to.exist;
       expect(result.error).to.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(result.error.type).to.equal('ParameterParseError');
       done();
 
     });
   });
 
-  it('Should reject a request that matches no schema based on subsection', done => {
-    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test', files: [], options: {}}},
-    (err, res, result) => {
+  it('Streaming endpoints should default to normal request with no _stream sent', done => {
+    request('POST', {}, '/stream/basic/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
       expect(result).to.exist;
-      expect(result.error).to.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(result).to.equal(true);
+
       done();
 
     });
   });
 
-  it('Should reject a request that matches no schema based on subsection type mismatch', done => {
-    request('POST', {}, '/object_alternate_schema/', {fileOrFolder: {name: 'test', files: [], options: {type: false}}},
-    (err, res, result) => {
+  it('Streaming endpoints should default to normal request with _stream falsy', done => {
+    request('POST', {}, '/stream/basic/', {alpha: 'hello', _stream: false}, (err, res, result) => {
 
       expect(err).to.not.exist;
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
       expect(result).to.exist;
-      expect(result.error).to.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(result).to.equal(true);
+
       done();
 
     });
   });
 
-  it('Should successfully return a default value with an optional field', done => {
-    request('POST', {}, '/optional_param_not_null/', {},
-    (err, res, result) => {
+  it('Streaming endpoints should default to normal request with _stream falsy in query params', done => {
+    request('POST', {}, '/stream/basic/?alpha=hello&_stream=false', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
       expect(result).to.exist;
-      expect(result).to.equal('default');
+      expect(result).to.equal(true);
+
       done();
 
     });
   });
 
-  it('Should successfully return a schema with a default set to 0', done => {
-    request('POST', {}, '/stripe/', {id: '0'},
-    (err, res, result) => {
+  it('Streaming endpoints should fail with StreamError if contains an invalid stream', done => {
+    request('POST', {}, '/stream/basic/', {alpha: 'hello', _stream: {test: true}}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(400);
+      expect(res.headers['content-type']).to.equal('application/json');
       expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('StreamListenerError');
+      expect(result.error.details).to.haveOwnProperty('test');
+
       done();
 
     });
   });
 
-  it('Should successfully return a schema with an array', done => {
-    request('POST', {}, '/giphy/', {query: 'q'},
-    (err, res, result) => {
+  it('Should support POST with streaming with _stream in query params', done => {
+    request('POST', {}, '/stream/basic/?alpha=hello&_stream', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['hello'][0]).to.equal('true');
+      expect(events['@response']).to.exist;
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should reject a request without an proper enum member', done => {
-    request('POST', {}, '/enum/', { day: 'funday' }, (err, res, result) => {
+  it('Should support POST with streaming with _stream in query params with truthy value', done => {
+    request('POST', {}, '/stream/basic/?alpha=hello&_stream=lol', '', (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
-      expect(result.error).to.exist;
-      expect(result.error.type).to.exist;
-      expect(result.error.type).to.equal('ParameterError');
-      expect(result.error.details).to.exist;
-      expect(result.error.details).to.deep.equal({
-        day: {
-          message: 'invalid value: "funday" (string), expected (enum)',
-          invalid: true,
-          expected: {
-            type: 'enum',
-            members: [
-              ['sunday', 0],
-              ['monday', '0'],
-              ['tuesday', { a: 1, b: 2 }],
-              ['wednesday', 3],
-              ['thursday', [1, 2, 3]],
-              ['friday', 5.4321],
-              ['saturday', 6]
-            ]
-          },
-          actual: {
-            value: 'funday',
-            type: 'string'
-          }
-        }
-      });
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['hello'][0]).to.equal('true');
+      expect(events['@response']).to.exist;
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should successfully return an enum variant (number)', done => {
-    request('POST', {}, '/enum/', { day: 'sunday' },
-    (err, res, result) => {
+  it('Should support POST with streaming with _stream set to valid stream', done => {
+    request('POST', {}, '/stream/basic/', {alpha: 'hello', _stream: {'hello': true}}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
-      expect(result).to.equal(0);
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['hello'][0]).to.equal('true');
+      expect(events['@response']).to.exist;
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should successfully return an enum variant (string)', done => {
-    request('POST', {}, '/enum/', { day: 'monday' },
-    (err, res, result) => {
+  it('Should support POST with streaming with _stream set to *', done => {
+    request('POST', {}, '/stream/basic/', {alpha: 'hello', _stream: {'*': true}}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
-      expect(result).to.equal("0");
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['hello'][0]).to.equal('true');
+      expect(events['@response']).to.exist;
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should successfully return an enum variant (object)', done => {
-    request('POST', {}, '/enum/', { day: 'tuesday' },
-    (err, res, result) => {
+  it('Should support POST with streaming with _stream set to valid stream or *', done => {
+    request('POST', {}, '/stream/basic/', {alpha: 'hello', _stream: {'hello': true, '*': true}}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
-      expect(result).to.deep.equal({a: 1, b: 2});
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['hello'][0]).to.equal('true');
+      expect(events['@response']).to.exist;
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-
-  it('Should successfully return an enum variant (array)', done => {
-    request('POST', {}, '/enum/', { day: 'thursday' },
-    (err, res, result) => {
+  it('Should support POST with streaming with _stream set', done => {
+    request('POST', {}, '/stream/basic/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
-      expect(result).to.deep.equal([1, 2, 3]);
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['hello'][0]).to.equal('true');
+      expect(events['@response']).to.exist;
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should successfully return an enum variant (float)', done => {
-    request('POST', {}, '/enum/', { day: 'friday' },
-    (err, res, result) => {
+  it('Should support POST with streaming (buffer) with _stream set', done => {
+    request('POST', {}, '/stream/basic_buffer/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
-      expect(result).to.equal(5.4321);
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['@response']).to.exist;
+
+      let stream = JSON.parse(events['hello'][0]);
+      expect(stream).to.be.an.object;
+      expect(stream).to.haveOwnProperty('_base64');
+      expect(stream._base64).to.equal(Buffer.from('123').toString('base64'));
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should return a default enum variant', done => {
-    request('POST', {}, '/enum_default/', {},
-    (err, res, result) => {
+  it('Should support POST with streaming (mocked buffer) with _stream set', done => {
+    request('POST', {}, '/stream/basic_buffer_mocked/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
-      expect(result).to.equal(0);
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['@response']).to.exist;
+
+      let stream = JSON.parse(events['hello'][0]);
+      expect(stream).to.be.an.object;
+      expect(stream).to.haveOwnProperty('_base64');
+      expect(stream._base64).to.equal(Buffer.from('123').toString('base64'));
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should return an enum using the context param', done => {
-    request('POST', {}, '/enum_context/', { thingA: 'a', thingB: 'c' },
-    (err, res, result) => {
+  it('Should support POST with streaming (nested buffer) with _stream set', done => {
+    request('POST', {}, '/stream/basic_buffer_nested/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
-      expect(result).to.deep.equal({
-        a: 0,
-        b: {
-          c: 1,
-          d: [1, 2, 3]
-        },
-        c: '4',
-        d: 5.4321
-      });
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['@response']).to.exist;
+
+      let stream = JSON.parse(events['hello'][0]);
+      expect(stream).to.be.an.object;
+      expect(stream).to.haveOwnProperty('mybuff');
+      expect(stream.mybuff).to.haveOwnProperty('_base64');
+      expect(stream.mybuff._base64).to.equal(Buffer.from('123').toString('base64'));
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should return an enum variant when the return type is enum', done => {
-    request('POST', {}, '/enum_return/', { a: 'a' },
-    (err, res, result) => {
+  it('Should support POST with streaming (nested mocked buffer) with _stream set', done => {
+    request('POST', {}, '/stream/basic_buffer_nested_mocked/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
-      expect(result).to.equal(0);
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['@response']).to.exist;
+
+      let stream = JSON.parse(events['hello'][0]);
+      expect(stream).to.be.an.object;
+      expect(stream).to.haveOwnProperty('mybuff');
+      expect(stream.mybuff).to.haveOwnProperty('_base64');
+      expect(stream.mybuff._base64).to.equal(Buffer.from('123').toString('base64'));
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should reject returning an invalid enum variant  when the return type is enum', done => {
-    request('POST', {}, '/enum_return/', {},
-    (err, res, result) => {
+  it('Should error POST with invalid stream name in execution with _stream set', done => {
+    request('POST', {}, '/stream/invalid_stream_name/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(502);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
       expect(result).to.exist;
-      expect(result.error).to.deep.equal({
-        type: 'ValueError',
-        message: 'The value returned by the function did not match the specified type',
-        details: {
-          returns: {
-            message: 'invalid return value: "not correct" (string), expected (enum)',
-            invalid: true,
-            expected: {
-              type: 'enum',
-              members: [['a', 0], ['b', [1, 2, 3]]]
-            },
-            actual: {
-              value: 'not correct',
-              type: 'string'
-            }
-          }
-        }
-      });
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.not.exist;
+      expect(events['@error']).to.exist;
+      expect(events['@response']).to.exist;
+
+      let error = JSON.parse(events['@error'][0]);
+      expect(error.type).to.equal('StreamError');
+      expect(error.message).to.satisfy(msg => msg.startsWith(`No such stream "hello2" in function definition.`));
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.statusCode).to.equal(200);
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should fail to return null from a function without a nullable return value', done => {
-    request('POST', {}, '/not_nullable_return/', {},
-    (err, res, result) => {
+  it('Should quietly fail if invalid stream name in execution without _stream set', done => {
+    request('POST', {}, '/stream/invalid_stream_name/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(502);
-      expect(result.error).to.exist;
-      expect(result.error.details).to.exist;
-      expect(result.error.details.returns).to.exist
-      expect(result.error.details.returns.invalid).to.equal(true);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result).to.equal(true);
+
       done();
 
     });
   });
 
-  it('Should return null from a function with a nullable return value', done => {
-    request('POST', {}, '/nullable_return/', {},
-    (err, res, result) => {
+  it('Should stream error POST with invalid stream value in execution with _stream set', done => {
+    request('POST', {}, '/stream/invalid_stream_param/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal(null);;
+      expect(res.headers['content-type']).to.equal('text/event-stream');
+      expect(result).to.exist;
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.not.exist;
+      expect(events['@error']).to.exist;
+      expect(events['@response']).to.exist;
+
+      let error = JSON.parse(events['@error'][0]);
+      expect(error.type).to.equal('StreamError');
+      expect(error.message).to.satisfy(msg => msg.startsWith(`Stream Parameter Error: "hello".`));
+      expect(error.details).to.haveOwnProperty('hello');
+      expect(error.details['hello'].invalid).to.equal(true);
+      expect(error.details['hello'].expected.type).to.equal('boolean');
+      expect(error.details['hello'].actual.type).to.equal('string');
+      expect(error.details['hello'].actual.value).to.equal('what');
+
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.statusCode).to.equal(200);
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should return a value from a function with a nullable return value', done => {
-    request('POST', {}, '/nullable_return/', {a: 'hello'},
-    (err, res, result) => {
+  it('Should support POST with streaming and stream components between sleep() calls with _stream set', done => {
+    request('POST', {}, '/stream/sleep/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('hello');;
+      expect(res.headers['content-type']).to.equal('text/event-stream');
+      expect(result).to.exist;
+
+      let events = parseServerSentEvents(result);
+      expect(events['hello']).to.exist;
+      expect(events['hello'].length).to.equal(3);
+      expect(events['hello'][0]).to.equal('"Hello?"');
+      expect(events['hello'][1]).to.equal('"How are you?"');
+      expect(events['hello'][2]).to.equal('"Is it me you\'re looking for?"');
+
+      expect(events['goodbye']).to.exist;
+      expect(events['goodbye'].length).to.equal(1);
+      expect(events['goodbye'][0]).to.equal('"Nice to see ya"');
+
+      expect(events['@response']).to.exist;
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
+
       done();
 
     });
   });
 
-  it('Should successfully return a default parameter after passing in null', done => {
-    request('POST', {}, '/null_default_param/', {name: null},
-    (err, res, result) => {
+  it('Should POST normally with streaming and stream components between sleep() calls without _stream set', done => {
+    request('POST', {}, '/stream/sleep/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('default');
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result).to.equal(true);
+
       done();
 
     });
   });
 
-  it('Should successfully return a default parameter after passing in undefined', done => {
-    request('POST', {}, '/null_default_param/', {name: undefined},
-    (err, res, result) => {
+  it('Should support POST with streaming without _debug set', done => {
+    request('POST', {}, '/stream/debug/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('default');
-      done();
+      expect(res.headers['content-type']).to.equal('text/event-stream');
+      expect(result).to.exist;
 
-    });
-  });
+      let events = parseServerSentEvents(result);
+      expect(Object.keys(events).length).to.equal(4);
 
-  it('Should successfully return an object with a schema that has an enum variant', done => {
-    request(
-      'POST',
-      {},
-      '/enum_schema/',
-      {
-        before: 'before',
-        valueRange: {
-          range: 'a range',
-          majorDimension: 'ROWS',
-          values: []
-        },
-        after: 'after',
-      },
-      (err, res, result) => {
+      expect(events['hello']).to.exist;
+      expect(events['hello'].length).to.equal(3);
+      expect(events['hello'][0]).to.equal('"Hello?"');
+      expect(events['hello'][1]).to.equal('"How are you?"');
+      expect(events['hello'][2]).to.equal('"Is it me you\'re looking for?"');
 
-        expect(err).to.not.exist;
-        expect(res.statusCode).to.equal(200);
-        expect(result).to.exist;
-        expect(result).to.deep.equal({
-          range: 'a range',
-          majorDimension: 'ROWS',
-          values: []
-        });
-        done();
+      expect(events['goodbye']).to.exist;
+      expect(events['goodbye'].length).to.equal(1);
+      expect(events['goodbye'][0]).to.equal('"Nice to see ya"');
 
-      }
-    );
-  });
+      expect(events['@begin']).to.exist;
+      expect(events['@begin'].length).to.equal(1);
+      expect(events['@begin'][0]).to.be.a.string;
 
-  it('Should return a default enum variant set to null', done => {
-    request('POST', {}, '/enum_null/', {},
-    (err, res, result) => {
+      expect(events['@response']).to.exist;
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
 
-      expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(result).to.equal(null);
       done();
 
     });
   });
 
-  it('Should accept keyql params', done => {
-    request('POST', {}, '/keyql/', { query: { name: 'steve' }, limit: { count: 0, offset: 0 }, order: { field: 'name', sort: 'ASC' } },
-    (err, res, result) => {
+  it('Should support POST with streaming with _debug set without _stream set', done => {
+    request('POST', {}, '/stream/debug/', {alpha: 'hello', _debug: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('hello');
-      done();
+      expect(res.headers['content-type']).to.equal('text/event-stream');
+      expect(res.headers['x-debug']).to.equal('true');
+      expect(result).to.exist;
 
-    });
-  });
+      let events = parseServerSentEvents(result);
+      expect(Object.keys(events).length).to.equal(6);
 
-  it('Should accept keyql params', done => {
-    let query = JSON.stringify({ name: 'steve' });
-    let limit = JSON.stringify({ count: 0, offset: 0 });
-    let order = JSON.stringify({field: 'name', sort: 'ASC'});
+      expect(events['hello']).to.exist;
+      expect(events['hello'].length).to.equal(3);
+      expect(events['hello'][0]).to.equal('"Hello?"');
+      expect(events['hello'][1]).to.equal('"How are you?"');
+      expect(events['hello'][2]).to.equal('"Is it me you\'re looking for?"');
 
-    request('GET', {'x-convert-strings': true}, `/keyql/?query=${query}&limit=${limit}&order=${order}`, '', (err, res, result) => {
+      expect(events['goodbye']).to.exist;
+      expect(events['goodbye'].length).to.equal(1);
+      expect(events['goodbye'][0]).to.equal('"Nice to see ya"');
 
-      expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('hello');
-      done();
+      expect(events['@begin']).to.exist;
+      expect(events['@begin'].length).to.equal(1);
+      expect(events['@begin'][0]).to.be.a.string;
 
-    });
-  });
+      expect(events['@stdout']).to.exist;
+      expect(events['@stdout'].length).to.equal(2);
+      expect(events['@stdout'][0]).to.equal('"what? who?"');
+      expect(events['@stdout'][1]).to.equal('"finally"');
 
-  it('Should reject invalid keyql limit', done => {
-    request('POST', {}, '/keyql/', { query: { name: 'steve' }, limit: { count: 0, wrong: 0 }, order: { field: 'name', sort: 'ASC' }},
-    (err, res, result) => {
+      expect(events['@stderr']).to.exist;
+      expect(events['@stderr'].length).to.equal(1);
+      expect(events['@stderr'][0]).to.equal('"oh no"');
+
+      expect(events['@response']).to.exist;
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
 
-      expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
-      expect(result.error).to.exist;
-      expect(result.error.details).to.exist;
-      expect(result.error.details.limit).to.exist;
       done();
 
     });
   });
 
-  it('Should reject invalid keyql order (no field)', done => {
-    request('POST', {}, '/keyql/', { query: { name: 'steve' }, limit: { count: 0, offset: 0 }, order: { field: null, sort: 'ASC' }},
-    (err, res, result) => {
+  it('Should support POST with streaming with _debug set to valid channels without _stream set', done => {
+    request('POST', {}, '/stream/debug/', {alpha: 'hello', _debug: {'*': true, '@begin': true, '@stdout': true, '@stderr': true, '@error': true}}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
-      expect(result.error).to.exist;
-      expect(result.error.details).to.exist;
-      expect(result.error.details.order).to.exist;
-      done();
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
+      expect(res.headers['x-debug']).to.equal('true');
+      expect(result).to.exist;
 
-    });
-  });
+      let events = parseServerSentEvents(result);
+      expect(Object.keys(events).length).to.equal(6);
 
-  it('Should reject invalid keyql order (invalid sort)', done => {
-    request('POST', {}, '/keyql/', { query: { name: 'steve' }, limit: { count: 0, offset: 0 }, order: { field: 'name', sort: 'WRONG' }},
-    (err, res, result) => {
+      expect(events['hello']).to.exist;
+      expect(events['hello'].length).to.equal(3);
+      expect(events['hello'][0]).to.equal('"Hello?"');
+      expect(events['hello'][1]).to.equal('"How are you?"');
+      expect(events['hello'][2]).to.equal('"Is it me you\'re looking for?"');
 
-      expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
-      expect(result.error).to.exist;
-      expect(result.error.details).to.exist;
-      expect(result.error.details.order).to.exist;
-      done();
+      expect(events['goodbye']).to.exist;
+      expect(events['goodbye'].length).to.equal(1);
+      expect(events['goodbye'][0]).to.equal('"Nice to see ya"');
 
-    });
-  });
+      expect(events['@begin']).to.exist;
+      expect(events['@begin'].length).to.equal(1);
+      expect(events['@begin'][0]).to.be.a.string;
 
-  it('Should reject invalid keyql order (overloaded)', done => {
-    request('POST', {}, '/keyql/', { query: { name: 'steve' }, limit: { count: 0, offset: 0 }, order: { field: 'name', sort: 'ASC', wrong: 'WRONG' }},
-    (err, res, result) => {
+      expect(events['@stdout']).to.exist;
+      expect(events['@stdout'].length).to.equal(2);
+      expect(events['@stdout'][0]).to.equal('"what? who?"');
+      expect(events['@stdout'][1]).to.equal('"finally"');
+
+      expect(events['@stderr']).to.exist;
+      expect(events['@stderr'].length).to.equal(1);
+      expect(events['@stderr'][0]).to.equal('"oh no"');
+
+      expect(events['@response']).to.exist;
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
 
-      expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
-      expect(result.error).to.exist;
-      expect(result.error.details).to.exist;
-      expect(result.error.details.order).to.exist;
       done();
 
     });
   });
 
-  it('Should accept keyql with correct options', done => {
-    request('POST', {}, '/keyql_options/', {query: {alpha: 'hello'}},
-    (err, res, result) => {
+  it('Streaming endpoints should succeed if contains a valid stream in _debug', done => {
+    request('POST', {}, '/stream/basic/', {alpha: 'hello', _stream: {}, _debug: {hello: true}}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('hello');
-      done();
+      expect(res.headers['content-type']).to.equal('text/event-stream');
+      expect(res.headers['x-debug']).to.equal('true');
+      expect(result).to.exist;
 
-    });
-  });
+      let events = parseServerSentEvents(result);
+      expect(Object.keys(events).length).to.equal(3);
 
-  it('Should accept keyql with correct options and an operator', done => {
-    request('POST', {}, '/keyql_options/', {query: {alpha__is: 'hello'}},
-    (err, res, result) => {
+      expect(events['@begin']).to.exist;
+      expect(events['@begin'].length).to.equal(1);
+      expect(events['@begin'][0]).to.be.a.string;
+
+      expect(events['hello']).to.exist;
+      expect(events['hello'].length).to.equal(1);
+      expect(events['hello'][0]).to.equal('true');
+
+      expect(events['@response']).to.exist;
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
 
-      expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('hello');
       done();
 
     });
   });
 
-  it('Should reject keyql with correct options with an incorrect operator', done => {
-    request('POST', {}, '/keyql_options/', {query: {alpha__isnt: 'hello'}},
-    (err, res, result) => {
+  it('Streaming endpoints should fail if contains an invalid stream in _debug', done => {
+    request('POST', {}, '/stream/basic/', {alpha: 'hello', _stream: {}, _debug: {test: true}}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['x-debug']).to.equal('true');
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('DebugError');
+      expect(result.error.message).to.contain('"test"');
+
       done();
 
     });
   });
 
-  it('Should reject keyql with incorrect options', done => {
-    request('POST', {}, '/keyql_options/', {query: {gamma: 'hello'}},
-    (err, res, result) => {
+  it('Streaming endpoints should fail with StreamError if contains an invalid stream when _debug', done => {
+    request('POST', {}, '/stream/basic/', {alpha: 'hello', _stream: {test: true}, _debug: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(400);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['x-debug']).to.equal('true');
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('StreamListenerError');
+      expect(result.error.details).to.haveOwnProperty('test');
+
       done();
 
     });
   });
 
-  it('Should reject keyql with incorrect options with an operator', done => {
-    request('POST', {}, '/keyql_options/', {query: {gamma__is: 'hello'}},
-    (err, res, result) => {
+  it('Should support POST with streaming with _debug to a function with no stream', done => {
+    request('POST', {}, '/stream/debug_no_stream/', {alpha: 'hello', _debug: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
-      done();
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
+      expect(res.headers['x-debug']).to.equal('true');
+      expect(result).to.exist;
 
-    });
-  });
+      let events = parseServerSentEvents(result);
+      expect(Object.keys(events).length).to.equal(4);
 
-  it('Should accept keyql array with correct options', done => {
-    request('POST', {}, '/keyql_options_array/', {query: [{alpha: 'hello'}]},
-    (err, res, result) => {
+      expect(events['@begin']).to.exist;
+      expect(events['@begin'].length).to.equal(1);
+      expect(events['@begin'][0]).to.be.a.string;
+
+      expect(events['@stdout']).to.exist;
+      expect(events['@stdout'].length).to.equal(2);
+      expect(events['@stdout'][0]).to.equal('"what? who?"');
+      expect(events['@stdout'][1]).to.equal('"finally"');
+
+      expect(events['@stderr']).to.exist;
+      expect(events['@stderr'].length).to.equal(1);
+      expect(events['@stderr'][0]).to.equal('"oh no"');
+
+      expect(events['@response']).to.exist;
+      let response = JSON.parse(events['@response'][0]);
+      expect(response.headers['Content-Type']).to.equal('application/json');
+      expect(response.body).to.equal('true');
 
-      expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('hello');
       done();
 
     });
   });
 
-  it('Should accept keyql array with correct options and an operator', done => {
-    request('POST', {}, '/keyql_options_array/', {query: [{alpha__is: 'hello'}]},
-    (err, res, result) => {
+  it('Endpoint without stream should fail with ExecutionModeError if _debug set and _stream set', done => {
+    request('POST', {}, '/stream/debug_no_stream/', {alpha: 'hello', _stream: {test: true}, _debug: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('hello');
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['x-debug']).to.equal('true');
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ExecutionModeError');
+      expect(result.error.message).to.contain('"stream"');
+
       done();
 
     });
   });
 
-  it('Should reject keyql array with correct options with an incorrect operator', done => {
-    request('POST', {}, '/keyql_options_array/', {query: [{alpha__isnt: 'hello'}]},
-    (err, res, result) => {
+  it('Endpoint without stream should fail with ExecutionModeError if _debug not set and _stream set', done => {
+    request('POST', {}, '/stream/debug_no_stream/', {alpha: 'hello', _stream: {test: true}}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('ExecutionModeError');
+      expect(result.error.message).to.contain('"stream"');
+
       done();
 
     });
   });
 
-  it('Should reject keyql array with incorrect options', done => {
-    request('POST', {}, '/keyql_options_array/', {query: [{gamma: 'hello'}]},
-    (err, res, result) => {
+  it('Endpoint without stream should fail with DebugError if _debug set to an invalid listener', done => {
+    request('POST', {}, '/stream/debug_no_stream/', {alpha: 'hello', _debug: {test: true}}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['x-debug']).to.equal('true');
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('DebugError');
+      expect(result.error.message).to.contain('"test"');
+
       done();
 
     });
   });
 
-  it('Should reject keyql array with incorrect options with an operator', done => {
-    request('POST', {}, '/keyql_options_array/', {query: [{gamma__is: 'hello'}]},
-    (err, res, result) => {
+  it('Endpoint without stream should fail with DebugError if _debug set and _background set', done => {
+    request('POST', {}, '/stream/debug_no_stream/', {alpha: 'hello', _debug: true, _background: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['x-debug']).to.equal('true');
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('DebugError');
+      expect(result.error.message).to.equal('Can not debug with "background" mode set');
+
       done();
 
     });
   });
 
-  it('Should accept keyql order with correct options', done => {
-    request('POST', {}, '/keyql_order_options/', {order: {field: 'alpha'}},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "autocode.com" should not work', done => {
+    request('POST', {'origin': 'autocode.com'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('hello');
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('!');
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('OriginError');
+      expect(result.error.message).to.contain(`"autocode.com"`)
+
       done();
 
     });
   });
 
-  it('Should reject keyql order with incorrect options', done => {
-    request('POST', {}, '/keyql_order_options/', {order: {field: 'gamma'}},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "https://sub.autocode.com" should not work', done => {
+    request('POST', {'origin': 'https://sub.autocode.com'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('!');
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('OriginError');
+      expect(result.error.message).to.contain(`"https://sub.autocode.com"`)
+
       done();
 
     });
   });
 
-  it('Should accept keyql array with correct options', done => {
-    request('POST', {}, '/keyql_order_options_array/', {order: [{field: 'alpha'}]},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "http://autocode.com" should work', done => {
+    request('POST', {'origin': 'http://autocode.com'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.equal('hello');
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('http://autocode.com');
+      expect(result).to.exist;
+
       done();
 
     });
   });
 
-  it('Should reject keyql array with incorrect options', done => {
-    request('POST', {}, '/keyql_order_options_array/', {order: [{field: 'gamma'}]},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "https://autocode.com" should work', done => {
+    request('POST', {'origin': 'https://autocode.com'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('https://autocode.com');
+      expect(result).to.exist;
+
       done();
 
     });
   });
 
-  it('Should accept keyql array with all correct options', done => {
-    request('POST', {}, '/keyql_order_options_array/', {order: [{field: 'alpha'}, {field: 'beta'}]},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "localhost:8000" should not work', done => {
+    request('POST', {'origin': 'localhost:8000'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('!');
+      expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('OriginError');
+      expect(result.error.message).to.contain(`"localhost:8000"`)
+
       done();
 
     });
   });
 
-  it('Should reject keyql array with an incorrect option', done => {
-    request('POST', {}, '/keyql_order_options_array/', {order: [{field: 'alpha'}, {field: 'gamma'}]},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "http://localhost:8000" should work', done => {
+    request('POST', {'origin': 'http://localhost:8000'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(400);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('http://localhost:8000');
+      expect(result).to.exist;
+
       done();
 
     });
   });
 
-  it('Should return a buffer properly', done => {
-    request('POST', {}, '/buffer_return/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "https://localhost:8000" should work', done => {
+    request('POST', {'origin': 'https://localhost:8000'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(res.headers['content-type']).to.equal('application/octet-stream');
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('https://localhost:8000');
       expect(result).to.exist;
-      expect(result).to.be.instanceof(Buffer);
-      expect(result.toString()).to.equal('lol');
+
       done();
 
     });
   });
 
-  it('Should return a buffer properly with a .contentType set', done => {
-    request('POST', {}, '/buffer_return_content_type/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "test.some-url.com:9999" should not work', done => {
+    request('POST', {'origin': 'test.some-url.com:9999'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
-      expect(res.headers['content-type']).to.equal('image/png');
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('!');
       expect(result).to.exist;
-      expect(result).to.be.instanceof(Buffer);
-      expect(result.toString()).to.equal('lol');
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('OriginError');
+      expect(result.error.message).to.contain(`"test.some-url.com:9999"`)
+
       done();
 
     });
   });
 
-  it('Should return a nested buffer properly', done => {
-    request('POST', {}, '/buffer_nested_return/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "http://test.some-url.com:9999" should work', done => {
+    request('POST', {'origin': 'http://test.some-url.com:9999'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('http://test.some-url.com:9999');
       expect(result).to.exist;
-      expect(result).to.haveOwnProperty('body');
-      expect(result.body).to.haveOwnProperty('_base64');
-      expect(Buffer.from(result.body._base64, 'base64').toString()).to.equal('lol');
-      expect(result.test).to.exist;
-      expect(result.test.deep).to.exist;
-      expect(result.test.deep).to.be.an('array');
-      expect(result.test.deep.length).to.equal(3);
-      expect(result.test.deep[1]).to.haveOwnProperty('_base64');
-      expect(Buffer.from(result.test.deep[1]._base64, 'base64').toString()).to.equal('wat');
+
       done();
 
     });
   });
 
-  it('Should return a mocked buffer as if it were a real one', done => {
-    request('POST', {}, '/buffer_mocked_return/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "https://test.some-url.com:9999" should work', done => {
+    request('POST', {'origin': 'https://test.some-url.com:9999'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('https://test.some-url.com:9999');
       expect(result).to.exist;
-      expect(result).to.be.instanceof(Buffer);
-      expect(result.toString()).to.equal('lol');
+
       done();
 
     });
   });
 
-  it('Should return a nested mocked buffer as if it were a real one', done => {
-    request('POST', {}, '/buffer_nested_mocked_return/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "http://hello.com" should not work', done => {
+    request('POST', {'origin': 'http://hello.com'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('!');
       expect(result).to.exist;
-      expect(result).to.haveOwnProperty('body');
-      expect(result.body).to.haveOwnProperty('_base64');
-      expect(Buffer.from(result.body._base64, 'base64').toString()).to.equal('lol');
-      expect(result.test).to.exist;
-      expect(result.test.deep).to.exist;
-      expect(result.test.deep).to.be.an('array');
-      expect(result.test.deep.length).to.equal(3);
-      expect(result.test.deep[1]).to.haveOwnProperty('_base64');
-      expect(Buffer.from(result.test.deep[1]._base64, 'base64').toString()).to.equal('wat');
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('OriginError');
+      expect(result.error.message).to.contain(`"http://hello.com"`)
+
       done();
 
     });
   });
 
-  it('Should return a mocked buffer as if it were a real one, if type "any"', done => {
-    request('POST', {}, '/buffer_any_return/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "http://hello.com" should not work with _stream', done => {
+    request('POST', {'origin': 'http://hello.com'}, '/origin/allow/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('!');
       expect(result).to.exist;
-      expect(result).to.be.instanceof(Buffer);
-      expect(result.toString()).to.equal('lol');
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('OriginError');
+      expect(result.error.message).to.contain(`"http://hello.com"`)
+
       done();
 
     });
   });
 
-  it('Should return a nested mocked buffer as if it were a real one, if type "any"', done => {
-    request('POST', {}, '/buffer_nested_any_return/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "http://hello.com" should not work with _debug', done => {
+    request('POST', {'origin': 'http://hello.com'}, '/origin/allow/', {alpha: 'hello', _debug: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('!');
       expect(result).to.exist;
-      expect(result).to.haveOwnProperty('body');
-      expect(result.body).to.haveOwnProperty('_base64');
-      expect(Buffer.from(result.body._base64, 'base64').toString()).to.equal('lol');
-      expect(result.test).to.exist;
-      expect(result.test.deep).to.exist;
-      expect(result.test.deep).to.be.an('array');
-      expect(result.test.deep.length).to.equal(3);
-      expect(result.test.deep[1]).to.haveOwnProperty('_base64');
-      expect(Buffer.from(result.test.deep[1]._base64, 'base64').toString()).to.equal('wat');
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('OriginError');
+      expect(result.error.message).to.contain(`"http://hello.com"`)
+
       done();
 
     });
   });
 
-  it('Should throw an ValueError on an invalid Buffer type', done => {
-    request('POST', {}, '/value_error/buffer_invalid/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "http://hello.com" should not work with _background', done => {
+    request('POST', {'origin': 'http://hello.com'}, '/origin/allow/', {alpha: 'hello', _background: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(502);
+      expect(res.statusCode).to.equal(403);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('!');
       expect(result).to.exist;
+      expect(result.error).to.exist;
+      expect(result.error.type).to.equal('OriginError');
+      expect(result.error.message).to.contain(`"http://hello.com"`)
+
       done();
 
     });
   });
 
-  it('Should throw an ValueError on an invalid Number type', done => {
-    request('POST', {}, '/value_error/number_invalid/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "https://hello.com" should work', done => {
+    request('POST', {'origin': 'https://hello.com'}, '/origin/allow/', {alpha: 'hello'}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(502);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('application/json');
+      expect(res.headers['access-control-allow-origin']).to.equal('https://hello.com');
       expect(result).to.exist;
+
       done();
 
     });
   });
 
-  it('Should throw an ValueError on an invalid Object type with alternate schema', done => {
-    request('POST', {}, '/value_error/object_alternate_schema_invalid/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "https://hello.com" should work with _stream', done => {
+    request('POST', {'origin': 'https://hello.com'}, '/origin/allow/', {alpha: 'hello', _stream: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(502);
+      expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
+      expect(res.headers['access-control-allow-origin']).to.equal('https://hello.com');
       expect(result).to.exist;
+
       done();
 
     });
   });
 
-  it('Should not populate "context.keys" with no authorization keys header provided', done => {
-    request('POST', {}, '/keys/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "https://hello.com" should work with _debug', done => {
+    request('POST', {'origin': 'https://hello.com'}, '/origin/allow/', {alpha: 'hello', _debug: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers['content-type']).to.equal('text/event-stream');
+      expect(res.headers['access-control-allow-origin']).to.equal('https://hello.com');
       expect(result).to.exist;
-      expect(result).to.deep.equal({
-        TEST_KEY: null,
-        ANOTHER_KEY: null,
-        A_THIRD_KEY: null
-      });
+
       done();
 
     });
   });
 
-  it('Should not populate "context.keys" if the authorization keys header is not a serialized object', done => {
-    request('POST', {
-      'X-Authorization-Keys': 'stringvalue'
-    }, '/keys/', {},
-    (err, res, result) => {
+  it('Endpoint triggered with request origin "https://hello.com" should work with _background', done => {
+    request('POST', {'origin': 'https://hello.com'}, '/origin/allow/', {alpha: 'hello', _background: true}, (err, res, result) => {
 
       expect(err).to.not.exist;
-      expect(res.statusCode).to.equal(200);
+      expect(res.statusCode).to.equal(202);
+      expect(res.headers['content-type']).to.equal('text/plain');
+      expect(res.headers['access-control-allow-origin']).to.equal('https://hello.com');
       expect(result).to.exist;
-      expect(result).to.deep.equal({
-        TEST_KEY: null,
-        ANOTHER_KEY: null,
-        A_THIRD_KEY: null
-      });
+
       done();
 
     });
   });
 
-  it('Should populate "context.keys" with only the proper keys', done => {
-    request('POST', {
-      'X-Authorization-Keys': JSON.stringify({
-        TEST_KEY: '123',
-        ANOTHER_KEY: 'abc',
-        UNSPECIFIED_KEY: '987'
-      })
-    }, '/keys/', {},
-    (err, res, result) => {
+  it('Should return a valid /.well-known/ai-plugin.json', done => {
+    request('GET', {}, '/.well-known/ai-plugin.json', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       expect(result).to.exist;
-      expect(result).to.deep.equal({
-        TEST_KEY: '123',
-        ANOTHER_KEY: 'abc',
-        A_THIRD_KEY: null
-      });
+      expect(result.schema_version).to.equal('v1');
+      expect(result.name_for_human).to.equal('(No name provided)');
+      expect(result.name_for_model).to.equal('No_name_provided');
+      expect(result.description_for_human).to.equal('(No description provided)');
+      expect(result.description_for_model).to.equal('(No description provided)');
+      expect(result.api).to.exist;
+      expect(result.api.type).to.equal('openapi');
+      expect(result.api.url).to.equal('localhost/.well-known/openapi.yaml');
       done();
 
     });
   });
 
-  it('Should not populate "context.providers" with no authorization providers header provided', done => {
-    request('POST', {}, '/context/', {},
-    (err, res, result) => {
+  it('Should return a valid /.well-known/openapi.json', done => {
+    request('GET', {}, '/.well-known/openapi.json', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
       expect(result).to.exist;
-      expect(result.providers).to.deep.equal({});
+      expect(result.openapi).to.equal('3.1.0');
+      expect(result.info).to.exist;
+      expect(result.info.version).to.equal('local');
+      expect(result.info.title).to.equal('(No name provided)');
+      expect(result.info.description).to.equal('(No description provided)');
+      expect(result.servers).to.be.an('Array');
+      expect(result.servers[0]).to.exist;
+      expect(result.servers[0].url).to.equal('localhost');
+      expect(result.servers[0].description).to.equal('FunctionScript Gateway');
+      expect(result.paths).to.be.an('Object');
+      expect(result.paths['/my_function/']).to.exist;
+      expect(result.paths['/my_function/'].post).to.exist;
+      expect(result.paths['/my_function/'].post.description).to.equal('My function');
+      expect(result.paths['/my_function/'].post.operationId).to.equal('service_localhost_my_function');
+      expect(result.paths['/my_function/'].post.requestBody).to.exist;
+      expect(result.paths['/my_function/'].post.requestBody.content).to.exist;
+      expect(result.paths['/my_function/'].post.requestBody.content['application/json']).to.exist;
+      expect(result.paths['/my_function/'].post.requestBody.content['application/json']).to.deep.equal({
+        "schema": {
+          "type": "object",
+          "properties": {
+            "a": {
+              "type": "number",
+              "default": 1
+            },
+            "b": {
+              "type": "number",
+              "default": 2
+            },
+            "c": {
+              "type": "number",
+              "default": 3
+            }
+          }
+        }
+      });
+      expect(result.paths['/my_function/'].post.responses).to.exist;
+      expect(result.paths['/my_function/'].post.responses['200']).to.exist;
+      expect(result.paths['/my_function/'].post.responses['200'].content).to.exist;
+      expect(result.paths['/my_function/'].post.responses['200'].content['application/json']).to.exist;
+      expect(result.paths['/my_function/'].post.responses['200'].content['application/json']).to.deep.equal({
+        "schema": {
+          "type": "number"
+        }
+      });
+      expect(result.paths['/a_standard_function/']).to.exist;
+      expect(result.paths['/reflect/']).to.exist;
       done();
 
     });
   });
 
-  it('Should not populate "context.providers" if the authorization providers header is not an serialized object', done => {
-    request('POST', {
-      'X-Authorization-Providers': 'stringvalue'
-    }, '/context/', {},
-    (err, res, result) => {
+  it('Should return a valid /.well-known/openapi.yaml', done => {
+    request('GET', {}, '/.well-known/openapi.yaml', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
-      expect(result).to.exist;
-      expect(result.providers).to.deep.equal({});
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(res.headers['content-type']).to.equal('application/yaml');
+      let yaml = result.toString();
+      expect(yaml.startsWith('openapi: "3.1.0"')).to.equal(true);
       done();
 
     });
   });
 
-  it('Should populate "context.providers" as the value of the authorization providers header if it is a serialized object', done => {
-    let headerValue = {
-      test: {
-        item: 'value'
-      }
-    };
-    request('POST', {
-      'X-Authorization-Providers': JSON.stringify(headerValue)
-    }, '/context/', {},
-    (err, res, result) => {
+  it('Should return a valid /.well-known/schema.json', done => {
+    request('GET', {}, '/.well-known/schema.json', '', (err, res, result) => {
 
       expect(err).to.not.exist;
       expect(res.statusCode).to.equal(200);
+      expect(res.headers).to.haveOwnProperty('access-control-allow-origin');
+      expect(res.headers).to.haveOwnProperty('access-control-allow-headers');
+      expect(res.headers).to.haveOwnProperty('access-control-expose-headers');
+      expect(res.headers['content-type']).to.equal('application/json');
       expect(result).to.exist;
-      expect(result.providers).to.deep.equal(headerValue);
+      expect(result.functions).to.exist;
+      expect(result.functions.length).to.be.greaterThan(1);
       done();
 
     });
diff --git a/tests/gateway/www/compile/test-sass-error.scss b/tests/gateway/www/compile/test-sass-error.scss
new file mode 100644
index 0000000..ac62b3d
--- /dev/null
+++ b/tests/gateway/www/compile/test-sass-error.scss
@@ -0,0 +1,5 @@
+body {
+  div {
+    font-family:
+  }
+}
diff --git a/tests/gateway/www/compile/test-sass.scss b/tests/gateway/www/compile/test-sass.scss
new file mode 100644
index 0000000..dd4144f
--- /dev/null
+++ b/tests/gateway/www/compile/test-sass.scss
@@ -0,0 +1,5 @@
+body {
+  div {
+    font-family: Arial;
+  }
+}
diff --git a/tests/gateway/www/error/404.html b/tests/gateway/www/error/404.html
new file mode 100644
index 0000000..568430b
--- /dev/null
+++ b/tests/gateway/www/error/404.html
@@ -0,0 +1 @@
+error 404
diff --git a/tests/gateway/www/fs-wordmark.png b/tests/gateway/www/fs-wordmark.png
new file mode 100644
index 0000000..5d58a44
Binary files /dev/null and b/tests/gateway/www/fs-wordmark.png differ
diff --git a/tests/gateway/www/page.html b/tests/gateway/www/page.html
new file mode 100644
index 0000000..e2ad6e4
--- /dev/null
+++ b/tests/gateway/www/page.html
@@ -0,0 +1 @@
+this is an html file
diff --git a/tests/gateway/www/page2.htm b/tests/gateway/www/page2.htm
new file mode 100644
index 0000000..cafe103
--- /dev/null
+++ b/tests/gateway/www/page2.htm
@@ -0,0 +1 @@
+this is an htm file
diff --git a/tests/gateway/www/static-test/htm/index.htm b/tests/gateway/www/static-test/htm/index.htm
new file mode 100644
index 0000000..18ed0fd
--- /dev/null
+++ b/tests/gateway/www/static-test/htm/index.htm
@@ -0,0 +1 @@
+this is an index.htm file
diff --git a/tests/gateway/www/static-test/index.html b/tests/gateway/www/static-test/index.html
new file mode 100644
index 0000000..669ffa8
--- /dev/null
+++ b/tests/gateway/www/static-test/index.html
@@ -0,0 +1 @@
+this is an index.html file
diff --git a/tests/gateway/www/video.mp4 b/tests/gateway/www/video.mp4
new file mode 100644
index 0000000..5b621bd
Binary files /dev/null and b/tests/gateway/www/video.mp4 differ
diff --git a/tests/runner.js b/tests/runner.js
index eb7ebf2..d838b91 100644
--- a/tests/runner.js
+++ b/tests/runner.js
@@ -37,6 +37,7 @@ describe('LibDoc', () => {
         try {
           parser.parseDefinition(functionCase.pathname, functionCase.buffer);
         } catch (e) {
+          // console.log(e.message);
           err = e;
         }
 
@@ -53,11 +54,11 @@ describe('LibDoc', () => {
   describe('Comprehensive Test', () => {
 
     let definitions = parser.load('./tests/files/comprehensive');
-    let ignoredDefinitions = parser.load('./tests/files/ignore', null, ['ignoreme.js']);
+    let ignoredDefinitions = parser.load('./tests/files/ignore', null, null, ['ignoreme.js']);
 
     it('Should read all functions correctly', () => {
 
-      expect(Object.keys(definitions).length).to.equal(24);
+      expect(Object.keys(definitions).length).to.equal(25);
       expect(definitions).to.haveOwnProperty('');
       expect(definitions).to.haveOwnProperty('test');
       expect(definitions).to.haveOwnProperty('returns');
@@ -77,6 +78,7 @@ describe('LibDoc', () => {
       expect(definitions).to.haveOwnProperty('options');
       expect(definitions).to.haveOwnProperty('keyql_options');
       expect(definitions).to.haveOwnProperty('alternate_schemas');
+      expect(definitions).to.haveOwnProperty('inline');
 
     });
 
@@ -106,6 +108,7 @@ describe('LibDoc', () => {
       expect(definitions['enum_nested'].pathname).to.equal('enum_nested.js');
       expect(definitions['enum_nested_optional'].pathname).to.equal('enum_nested_optional.js');
       expect(definitions['options'].pathname).to.equal('options.js');
+      expect(definitions['inline'].pathname).to.equal('inline.js');
 
     });
 
@@ -128,6 +131,7 @@ describe('LibDoc', () => {
       expect(definitions['enum_nested'].description).to.equal('Test Nested Enum');
       expect(definitions['enum_nested_optional'].description).to.equal('Test Optional Nested Enum');
       expect(definitions['options'].description).to.equal('Populate options properly');
+      expect(definitions['inline'].description).to.equal('');
 
     });
 
@@ -150,6 +154,8 @@ describe('LibDoc', () => {
       expect(definitions['enum_nested'].context).to.exist;
       expect(definitions['enum_nested_optional'].context).to.exist;
       expect(definitions['options'].context).to.equal(null);
+      expect(definitions['inline'].context).to.exist;
+
 
     });
 
@@ -171,6 +177,7 @@ describe('LibDoc', () => {
       expect(definitions['enum_nested'].returns.description).to.equal('A boolean value');
       expect(definitions['enum_nested_optional'].returns.description).to.equal('A boolean value');
       expect(definitions['options'].returns.description).to.equal('a Boolean?');
+      expect(definitions['inline'].returns.description).to.equal('');
 
     });
 
@@ -192,6 +199,7 @@ describe('LibDoc', () => {
       expect(definitions['enum_nested'].returns.type).to.equal('boolean');
       expect(definitions['enum_nested'].returns.type).to.equal('boolean');
       expect(definitions['options'].returns.type).to.equal('boolean');
+      expect(definitions['inline'].returns.type).to.equal('any');
 
     });
 
@@ -214,6 +222,7 @@ describe('LibDoc', () => {
       expect(definitions['enum_nested'].charge).to.equal(1);
       expect(definitions['enum_nested_optional'].charge).to.equal(1);
       expect(definitions['options'].charge).to.equal(1);
+      expect(definitions['inline'].charge).to.equal(1);
 
     });
 
@@ -255,6 +264,7 @@ describe('LibDoc', () => {
       expect(definitions['enum_nested_optional'].keys).to.have.length(0);
       expect(definitions['options'].keys).to.be.an('Array');
       expect(definitions['options'].keys).to.have.length(0);
+      expect(definitions['inline'].keys).to.have.length(0);
 
     });
 
@@ -609,6 +619,13 @@ describe('LibDoc', () => {
 
     });
 
+    it('Should read "inline" parameters', () => {
+
+      let params = definitions['inline'].params;
+      expect(params.length).to.equal(0);
+
+    });
+
     it('Should have a named return value and description', () => {
 
       let definition = definitions['named_return'];
@@ -1401,6 +1418,13 @@ describe('LibDoc', () => {
 
     });
 
+    it('should throw on invalid schema type', () => {
+      const throws = () => {
+        types.validate('object', {}, false, {})
+      }
+      expect(throws).to.throw(/Array/)
+    })
+
     it('should validate "object" with schema', () => {
 
       expect(types.validate('object', {})).to.equal(true);
@@ -1505,7 +1529,7 @@ describe('LibDoc', () => {
       expect(
         types.validate('object.keyql.limit', {
           offset: 0,
-          limit: 0
+          count: 0
         })
       ).to.equal(true);
 
@@ -1815,6 +1839,113 @@ describe('LibDoc', () => {
 
     });
 
+    it('Should generateSchema for javascript', () => {
+
+      try {
+        types.generateSchema.javascript([1, 2, null, 4]);
+      } catch (e) {
+        expect(e).to.exist;
+        expect(e.message).to.contain('from an object');
+      }
+
+      let result;
+
+      result = types.generateSchema.javascript({list: [1, 2, 3, 4]});
+      expect(result).to.equal([
+        ` * @param {array} list`,
+        ` * @ {number}`
+      ].join('\n'));
+
+      result = types.generateSchema.javascript({list: [1, 2, null, 4]});
+      expect(result).to.equal([
+        ` * @param {array} list`,
+        ` * @ {?number}`
+      ].join('\n'));
+
+      result = types.generateSchema.javascript({list: [null, null, 1, null, 2, 3]});
+      expect(result).to.equal([
+        ` * @param {array} list`,
+        ` * @ {?number}`
+      ].join('\n'));
+
+      result = types.generateSchema.javascript({list: [null]});
+      expect(result).to.equal([
+        ` * @param {array} list`,
+        ` * @ {?any}`
+      ].join('\n'));
+
+      result = types.generateSchema.javascript({list: [1, 'two', null, 4]});
+      expect(result).to.equal([
+        ` * @param {array} list`,
+        ` * @ {?any}`
+      ].join('\n'));
+
+      result = types.generateSchema.javascript({
+        nested: ['one', 2, 3, null],
+        nestedObjects: [{
+          one: 'one',
+          two: 2,
+          three: 3,
+          four: 4,
+          five: 'five'
+        }, {
+          one: null,
+          two: null,
+          three: null,
+          four: 44,
+          five: '5ive'
+        }, {
+          one: 'uno',
+          two: 2,
+          three: 'three',
+          four: 444
+        }]
+      });
+      expect(result).to.deep.equal([
+        ` * @param {array} nested`,
+        ` * @ {?any}`,
+        ` * @param {array} nestedObjects`,
+        ` * @ {object}`,
+        ` * @   {?any} one`,
+        ` * @   {?any} two`,
+        ` * @   {?any} three`,
+        ` * @   {number} four`
+      ].join('\n'));
+
+      result = types.generateSchema.javascript({
+        nested: ['one', 2, 3, null],
+        nestedObjects: [{
+          one: 'one',
+          two: 2,
+          three: 3,
+          four: 4,
+          five: 'five'
+        }, {
+          one: null,
+          two: null,
+          three: null,
+          four: 44,
+          five: '5ive'
+        }, {
+          one: 'uno',
+          two: 2,
+          three: 'three',
+          four: 444
+        }]
+      }, 1);
+      expect(result).to.deep.equal([
+        ` * @ {array} nested`,
+        ` * @   {?any}`,
+        ` * @ {array} nestedObjects`,
+        ` * @   {object}`,
+        ` * @     {?any} one`,
+        ` * @     {?any} two`,
+        ` * @     {?any} three`,
+        ` * @     {number} four`
+      ].join('\n'));
+
+    });
+
     it('Should parse valid Node.js variable names', () => {
 
       expect(NodeJsFunctionParser.validateFunctionParamName('test')).to.equal(true);
