diff --git a/client.js b/client.js
index a08fbfa..df87cf1 100644
--- a/client.js
+++ b/client.js
@@ -34,7 +34,7 @@ var tunneler = net.connect({ port: 5443 , host: 'pokemap.hellabit.com' }, functi
   // a place to store data
   // file management
   // Synergy Teamwork Paradigm = Jabberwocky
-  var machine = require('./machine.js');
+  var machine = require('./machine.js').create();
   machine.onMessage = function (opts) {
     var id = opts.family + ',' + opts.address + ',' + opts.port;
     var service = 'https';
diff --git a/machine.js b/machine.js
index 9d8fb83..4436399 100644
--- a/machine.js
+++ b/machine.js
@@ -1,167 +1,166 @@
 'use strict';
 
-var machine = {};
-machine._version = 1;
-machine.state = 0;
-machine.states = { 0: 'version', 1: 'headerLength', 2: 'header', 3: 'data'/*, 4: 'error'*/ };
-machine.states_length = Object.keys(machine.states).length;
-machine.chunkIndex = 0;
-machine.fns = {};
+module.exports.create = function () {
 
-function debug(chunk, i, len) {
-  i = i || 0;
-  len = len || chunk.length - i;
-  console.log(chunk.slice(i, len)[0]);
-  console.log(chunk);
-  console.log('state:', machine.states[machine.state]);
-  console.log('statei:', machine.state);
-  console.log('index:', machine.chunkIndex);
-}
+  var machine = {};
+  machine._version = 1;
+  machine.state = 0;
+  machine.states = { 0: 'version', 1: 'headerLength', 2: 'header', 3: 'data'/*, 4: 'error'*/ };
+  machine.states_length = Object.keys(machine.states).length;
+  machine.chunkIndex = 0;
+  machine.fns = {};
 
-machine.fns.version = function (chunk) {
-  //console.log('');
-  //console.log('[version]');
-  if ((255 - machine._version) !== chunk[machine.chunkIndex]) {
-    console.error("not v" + machine._version + " (or data is corrupt)");
-    // no idea how to fix this yet
+  function debug(chunk, i, len) {
+    i = i || 0;
+    len = len || chunk.length - i;
+    console.log(chunk.slice(i, len)[0]);
+    console.log(chunk);
+    console.log('state:', machine.states[machine.state]);
+    console.log('statei:', machine.state);
+    console.log('index:', machine.chunkIndex);
   }
-  machine.chunkIndex += 1;
 
-  return true;
-};
-
-
-machine.headerLen = 0;
-machine.fns.headerLength = function (chunk) {
-  //console.log('');
-  //console.log('[headerLength]');
-  machine.headerLen = chunk[machine.chunkIndex];
-  machine.chunkIndex += 1;
-
-  return true;
-};
-
-
-machine.buf = null;
-machine.bufIndex = 0;
-//var buf = Buffer.alloc(4096);
-machine.fns.header = function (chunk) {
-  //console.log('');
-  //console.log('[header]');
-  var curSize = machine.bufIndex + (chunk.length - machine.chunkIndex);
-  var partLen = 0;
-  var str = '';
-  var part;
-
-  if (curSize < machine.headerLen) {
-    // I still don't have the whole header,
-    // so just create a large enough buffer,
-    // write these bits, and wait for the next chunk.
-    if (!machine.buf) {
-      machine.buf = Buffer.alloc(machine.headerLen);
-      //console.log('[1a] machine.headerLen:', machine.headerLen);
+  machine.fns.version = function (chunk) {
+    //console.log('');
+    //console.log('[version]');
+    if ((255 - machine._version) !== chunk[machine.chunkIndex]) {
+      console.error("not v" + machine._version + " (or data is corrupt)");
+      // no idea how to fix this yet
     }
-
-    // partLen should be no more than the available size
-    partLen = Math.min(machine.headerLen - machine.bufIndex, chunk.length - machine.chunkIndex);
-    part = chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen);
-    chunk.copy(machine.buf, machine.bufIndex, machine.chunkIndex, machine.chunkIndex + partLen);
-    machine.chunkIndex += partLen; // this MUST be chunk.length
-    machine.bufIndex += partLen;
-
-    return false;
-  }
-  else {
-    // it's now ready to discover the whole header
-    if (machine.buf) {
-      str += machine.buf.slice(0, machine.bufIndex).toString();
-    }
-
-    partLen = machine.headerLen - str.length;
-    part = chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen);
-    str += part.toString();
-
-    machine.chunkIndex += partLen;
-    machine.buf = null; // back to null
-    machine.bufIndex = 0; // back to 0
-
-    machine._headers = str.split(/,/g);
-
-    machine.family = machine._headers[0];
-    machine.address = machine._headers[1];
-    machine.port = machine._headers[2];
-    machine.bodyLen = parseInt(machine._headers[3], 10) || -1;
+    machine.chunkIndex += 1;
 
     return true;
-  }
-};
+  };
 
-machine.fns.data = function (chunk) {
-  //console.log('');
-  //console.log('[data]');
-  var curSize = machine.bufIndex + (chunk.length - machine.chunkIndex);
-  //console.log('curSize:', curSize);
-  //console.log('bodyLen:', machine.bodyLen, typeof machine.bodyLen);
-  var partLen = 0;
 
-  partLen = Math.min(machine.bodyLen - machine.bufIndex, chunk.length - machine.chunkIndex);
+  machine.headerLen = 0;
+  machine.fns.headerLength = function (chunk) {
+    //console.log('');
+    //console.log('[headerLength]');
+    machine.headerLen = chunk[machine.chunkIndex];
+    machine.chunkIndex += 1;
 
-  if (curSize < machine.bodyLen) {
-    //console.log('curSize < bodyLen');
+    return true;
+  };
 
-    // I still don't have the whole header,
-    // so just create a large enough buffer,
-    // write these bits, and wait for the next chunk.
-    if (!machine.buf) {
-      machine.buf = Buffer.alloc(machine.bodyLen);
+
+  machine.buf = null;
+  machine.bufIndex = 0;
+  //var buf = Buffer.alloc(4096);
+  machine.fns.header = function (chunk) {
+    //console.log('');
+    //console.log('[header]');
+    var curSize = machine.bufIndex + (chunk.length - machine.chunkIndex);
+    var partLen = 0;
+    var str = '';
+    var part;
+
+    if (curSize < machine.headerLen) {
+      // I still don't have the whole header,
+      // so just create a large enough buffer,
+      // write these bits, and wait for the next chunk.
+      if (!machine.buf) {
+        machine.buf = Buffer.alloc(machine.headerLen);
+      }
+
+      // partLen should be no more than the available size
+      partLen = Math.min(machine.headerLen - machine.bufIndex, chunk.length - machine.chunkIndex);
+      part = chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen);
+      chunk.copy(machine.buf, machine.bufIndex, machine.chunkIndex, machine.chunkIndex + partLen);
+      machine.chunkIndex += partLen; // this MUST be chunk.length
+      machine.bufIndex += partLen;
+
+      return false;
+    }
+    else {
+      // it's now ready to discover the whole header
+      if (machine.buf) {
+        str += machine.buf.slice(0, machine.bufIndex).toString();
+      }
+
+      partLen = machine.headerLen - str.length;
+      part = chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen);
+      str += part.toString();
+
+      machine.chunkIndex += partLen;
+      machine.buf = null; // back to null
+      machine.bufIndex = 0; // back to 0
+
+      machine._headers = str.split(/,/g);
+
+      machine.family = machine._headers[0];
+      machine.address = machine._headers[1];
+      machine.port = machine._headers[2];
+      machine.bodyLen = parseInt(machine._headers[3], 10) || -1;
+
+      return true;
+    }
+  };
+
+  machine.fns.data = function (chunk) {
+    //console.log('');
+    //console.log('[data]');
+    var curSize = machine.bufIndex + (chunk.length - machine.chunkIndex);
+    //console.log('curSize:', curSize);
+    //console.log('bodyLen:', machine.bodyLen, typeof machine.bodyLen);
+    var partLen = 0;
+
+    partLen = Math.min(machine.bodyLen - machine.bufIndex, chunk.length - machine.chunkIndex);
+
+    if (curSize < machine.bodyLen) {
+      //console.log('curSize < bodyLen');
+
+      // I still don't have the whole header,
+      // so just create a large enough buffer,
+      // write these bits, and wait for the next chunk.
+      if (!machine.buf) {
+        machine.buf = Buffer.alloc(machine.bodyLen);
+      }
+
+      chunk.copy(machine.buf, machine.bufIndex, machine.chunkIndex, machine.chunkIndex + partLen);
+      machine.chunkIndex += partLen; // this MUST be chunk.length
+      machine.bufIndex += partLen;
+
+      return false;
     }
 
-    chunk.copy(machine.buf, machine.bufIndex, machine.chunkIndex, machine.chunkIndex + partLen);
-    machine.chunkIndex += partLen; // this MUST be chunk.length
+    if (machine.bufIndex > 0) {
+      // the completing remainder of the body is in the current slice
+      chunk.copy(machine.buf, machine.bufIndex, machine.chunkIndex, machine.chunkIndex + partLen);
+    }
+    else {
+      // the whole body is in the current slice
+      machine.buf = chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen);
+    }
     machine.bufIndex += partLen;
 
-    return false;
-  }
+    machine.onMessage({
+      family: machine.family
+    , address: machine.address
+    , port: machine.port
+    , data: machine.buf.slice(0, machine.bufIndex)
+    });
 
-  if (machine.buf) {
-    // the completing remainder of the body is in the current slice
-    chunk.copy(machine.buf, machine.bufIndex, machine.chunkIndex, machine.chunkIndex + partLen);
-  }
-  else {
-    // the whole body is in the current slice
-    machine.buf = chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen);
-  }
+    machine.chunkIndex += partLen;  // === chunk.length
+    machine.buf = null;             // reset to null
+    machine.bufIndex = 0;           // reset to 0
 
-  machine.onMessage({
-    family: machine.family
-  , address: machine.address
-  , port: machine.port
-  , data: machine.buf
-  });
+    return true;
+  };
+  machine.fns.addChunk = function (chunk) {
+    //console.log('');
+    //console.log('[addChunk]');
+    machine.chunkIndex = 0;
+    while (machine.chunkIndex < chunk.length) {
+      //console.log('chunkIndex:', machine.chunkIndex, 'state:', machine.state);
 
-  machine.chunkIndex += partLen;  // === chunk.length
-  machine.buf = null;             // reset to null
-  machine.bufIndex = 0;           // reset to 0
-
-  return true;
-};
-machine.fns.addChunk = function (chunk) {
-  //console.log('');
-  //console.log('[addChunk]');
-  machine.chunkIndex = 0;
-  while (machine.chunkIndex < chunk.length) {
-    //console.log('chunkIndex:', machine.chunkIndex, 'state:', machine.state);
-
-    if (true === machine.fns[machine.states[machine.state]](chunk)) {
-      machine.state += 1;
-      machine.state %= machine.states_length;
+      if (true === machine.fns[machine.states[machine.state]](chunk)) {
+        machine.state += 1;
+        machine.state %= machine.states_length;
+      }
     }
-  }
+  };
+
+  return machine;
+
 };
-
-module.exports = machine;
-
-process.on('uncaughtException', function (err) {
-  console.error(err);
-  debug(Buffer.from([0]));
-});
diff --git a/test-machine.js b/test-machine.js
index 12ea52c..03e08dd 100644
--- a/test-machine.js
+++ b/test-machine.js
@@ -1,7 +1,7 @@
 'use strict';
 
 var sni = require('sni');
-var machine = require('./machine.js');
+var machine = require('./machine.js').create();
 var hello = require('fs').readFileSync('./sni.hello.bin');
 var version = 1;
 var header = 'IPv4,127.0.1.1,443,' + hello.byteLength;
@@ -12,6 +12,7 @@ var buf = Buffer.concat([
 ]);
 var services = { 'ssh': 22, 'http': 4080, 'https': 8443 };
 var clients = {};
+var count = 0;
 
 machine.onMessage = function (opts) {
   var id = opts.family + ',' + opts.address + ',' + opts.port;
@@ -24,7 +25,7 @@ machine.onMessage = function (opts) {
   if (!opts.data.equals(hello)) {
     throw new Error("'data' packet is not equal to original 'hello' packet");
   }
-  console.log('all ', opts.data.byteLength, 'bytes are equal');
+  console.log('all', opts.data.byteLength, 'bytes are equal');
   console.log('src:', opts.family, opts.address + ':' + opts.port);
   console.log('dst:', 'IPv4 127.0.0.1:' + port);
 
@@ -35,24 +36,28 @@ machine.onMessage = function (opts) {
     }
     console.log("servername: '" + servername + "'");
   }
+
+  count += 1;
 };
 
 
+console.log('');
+
 // full message in one go
 // 223 = 2 + 22 + 199
-console.log('');
 console.log('[WHOLE BUFFER]', 2, header.length, hello.length, buf.byteLength);
 clients = {};
 machine.fns.addChunk(buf);
+console.log('');
 
 
 // messages one byte at a time
-console.log('');
 console.log('[BYTE-BY-BYTE BUFFER]', 1);
 clients = {};
 buf.forEach(function (byte) {
   machine.fns.addChunk(Buffer.from([ byte ]));
 });
+console.log('');
 
 
 // split messages in overlapping thirds
@@ -63,7 +68,6 @@ buf.forEach(function (byte) {
 // 225-247  (22)
 // 247-446  (199)
 buf = Buffer.concat([ buf, buf ]);
-console.log('');
 console.log('[OVERLAPPING BUFFERS]', buf.length);
 clients = {};
 [ buf.slice(0, 7)                 // version + header
@@ -77,3 +81,12 @@ clients = {};
 ].forEach(function (buf) {
   machine.fns.addChunk(Buffer.from(buf));
 });
+console.log('');
+
+process.on('exit', function () {
+  if (count !== 4) {
+    throw new Error("should have delivered 4 messages, not", count);
+  }
+  console.log('TESTS PASS');
+  console.log('');
+});