diff --git a/node.gyp b/node.gyp
index 5a727eb0c92d34..15eb66a4094905 100644
--- a/node.gyp
+++ b/node.gyp
@@ -344,6 +344,7 @@
         'src/node.h',
         'src/node_buffer.h',
         'src/node_constants.h',
+        'src/node_contextify.h',
         'src/node_debug_options.h',
         'src/node_http2.h',
         'src/node_http2_state.h',
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index d50c6023dc8349..6fe9276d82ecab 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -23,8 +23,10 @@
 #include "node_watchdog.h"
 #include "base_object-inl.h"
 #include "v8-debug.h"
+#include "node_contextify.h"
 
 namespace node {
+namespace contextify {
 
 using v8::Array;
 using v8::ArrayBuffer;
@@ -92,550 +94,531 @@ Local<Name> Uint32ToName(Local<Context> context, uint32_t index) {
       .ToLocalChecked();
 }
 
-class ContextifyContext {
- protected:
-  // V8 reserves the first field in context objects for the debugger. We use the
-  // second field to hold a reference to the sandbox object.
-  enum { kSandboxObjectIndex = 1 };
-
-  Environment* const env_;
-  Persistent<Context> context_;
-
- public:
-  ContextifyContext(Environment* env,
-                    Local<Object> sandbox_obj,
-                    Local<Object> options_obj)
-      : env_(env) {
-    Local<Context> v8_context = CreateV8Context(env, sandbox_obj, options_obj);
-    context_.Reset(env->isolate(), v8_context);
-
-    // Allocation failure or maximum call stack size reached
-    if (context_.IsEmpty())
-      return;
-    context_.SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
-    context_.MarkIndependent();
-  }
-
-
-  ~ContextifyContext() {
-    context_.Reset();
-  }
-
+}  // anonymous namespace
 
-  inline Environment* env() const {
-    return env_;
-  }
+ContextifyContext::ContextifyContext(
+    Environment* env,
+    Local<Object> sandbox_obj, Local<Object> options_obj) : env_(env) {
+  Local<Context> v8_context = CreateV8Context(env, sandbox_obj, options_obj);
+  context_.Reset(env->isolate(), v8_context);
+
+  // Allocation failure or maximum call stack size reached
+  if (context_.IsEmpty())
+    return;
+  context_.SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
+  context_.MarkIndependent();
+}
 
 
-  inline Local<Context> context() const {
-    return PersistentToLocal(env()->isolate(), context_);
-  }
+ContextifyContext::~ContextifyContext() {
+  context_.Reset();
+}
 
 
-  inline Local<Object> global_proxy() const {
-    return context()->Global();
-  }
+// This is an object that just keeps an internal pointer to this
+// ContextifyContext.  It's passed to the NamedPropertyHandler.  If we
+// pass the main JavaScript context object we're embedded in, then the
+// NamedPropertyHandler will store a reference to it forever and keep it
+// from getting gc'd.
+Local<Value> ContextifyContext::CreateDataWrapper(Environment* env) {
+  EscapableHandleScope scope(env->isolate());
+  Local<Object> wrapper =
+      env->script_data_constructor_function()
+          ->NewInstance(env->context()).FromMaybe(Local<Object>());
+  if (wrapper.IsEmpty())
+    return scope.Escape(Local<Value>::New(env->isolate(), Local<Value>()));
+
+  Wrap(wrapper, this);
+  return scope.Escape(wrapper);
+}
 
 
-  inline Local<Object> sandbox() const {
-    return Local<Object>::Cast(context()->GetEmbedderData(kSandboxObjectIndex));
+Local<Context> ContextifyContext::CreateV8Context(
+    Environment* env,
+    Local<Object> sandbox_obj,
+    Local<Object> options_obj) {
+  EscapableHandleScope scope(env->isolate());
+  Local<FunctionTemplate> function_template =
+      FunctionTemplate::New(env->isolate());
+
+  function_template->SetClassName(sandbox_obj->GetConstructorName());
+
+  Local<ObjectTemplate> object_template =
+      function_template->InstanceTemplate();
+
+  NamedPropertyHandlerConfiguration config(PropertyGetterCallback,
+                                           PropertySetterCallback,
+                                           PropertyDescriptorCallback,
+                                           PropertyDeleterCallback,
+                                           PropertyEnumeratorCallback,
+                                           PropertyDefinerCallback,
+                                           CreateDataWrapper(env));
+
+  IndexedPropertyHandlerConfiguration indexed_config(
+      IndexedPropertyGetterCallback,
+      IndexedPropertySetterCallback,
+      IndexedPropertyDescriptorCallback,
+      IndexedPropertyDeleterCallback,
+      PropertyEnumeratorCallback,
+      IndexedPropertyDefinerCallback,
+      CreateDataWrapper(env));
+
+  object_template->SetHandler(config);
+  object_template->SetHandler(indexed_config);
+
+  Local<Context> ctx = NewContext(env->isolate(), object_template);
+
+  if (ctx.IsEmpty()) {
+    env->ThrowError("Could not instantiate context");
+    return Local<Context>();
   }
 
-  // This is an object that just keeps an internal pointer to this
-  // ContextifyContext.  It's passed to the NamedPropertyHandler.  If we
-  // pass the main JavaScript context object we're embedded in, then the
-  // NamedPropertyHandler will store a reference to it forever and keep it
-  // from getting gc'd.
-  Local<Value> CreateDataWrapper(Environment* env) {
-    EscapableHandleScope scope(env->isolate());
-    Local<Object> wrapper =
-        env->script_data_constructor_function()
-            ->NewInstance(env->context()).FromMaybe(Local<Object>());
-    if (wrapper.IsEmpty())
-      return scope.Escape(Local<Value>::New(env->isolate(), Local<Value>()));
-
-    Wrap(wrapper, this);
-    return scope.Escape(wrapper);
+  ctx->SetSecurityToken(env->context()->GetSecurityToken());
+
+  // We need to tie the lifetime of the sandbox object with the lifetime of
+  // newly created context. We do this by making them hold references to each
+  // other. The context can directly hold a reference to the sandbox as an
+  // embedder data field. However, we cannot hold a reference to a v8::Context
+  // directly in an Object, we instead hold onto the new context's global
+  // object instead (which then has a reference to the context).
+  ctx->SetEmbedderData(kSandboxObjectIndex, sandbox_obj);
+  sandbox_obj->SetPrivate(env->context(),
+                          env->contextify_global_private_symbol(),
+                          ctx->Global());
+
+  Local<Value> name =
+      options_obj->Get(env->context(), env->name_string())
+          .ToLocalChecked();
+  CHECK(name->IsString());
+  Utf8Value name_val(env->isolate(), name);
+
+  ContextInfo info(*name_val);
+
+  Local<Value> origin =
+      options_obj->Get(env->context(),
+                       FIXED_ONE_BYTE_STRING(env->isolate(), "origin"))
+          .ToLocalChecked();
+  if (!origin->IsUndefined()) {
+    CHECK(origin->IsString());
+    Utf8Value origin_val(env->isolate(), origin);
+    info.origin = *origin_val;
   }
 
+  env->AssignToContext(ctx, info);
 
-  Local<Context> CreateV8Context(Environment* env,
-                                 Local<Object> sandbox_obj,
-                                 Local<Object> options_obj) {
-    EscapableHandleScope scope(env->isolate());
-    Local<FunctionTemplate> function_template =
-        FunctionTemplate::New(env->isolate());
-
-    function_template->SetClassName(sandbox_obj->GetConstructorName());
-
-    Local<ObjectTemplate> object_template =
-        function_template->InstanceTemplate();
-
-    NamedPropertyHandlerConfiguration config(PropertyGetterCallback,
-                                             PropertySetterCallback,
-                                             PropertyDescriptorCallback,
-                                             PropertyDeleterCallback,
-                                             PropertyEnumeratorCallback,
-                                             PropertyDefinerCallback,
-                                             CreateDataWrapper(env));
-
-    IndexedPropertyHandlerConfiguration indexed_config(
-        IndexedPropertyGetterCallback,
-        IndexedPropertySetterCallback,
-        IndexedPropertyDescriptorCallback,
-        IndexedPropertyDeleterCallback,
-        PropertyEnumeratorCallback,
-        IndexedPropertyDefinerCallback,
-        CreateDataWrapper(env));
-
-    object_template->SetHandler(config);
-    object_template->SetHandler(indexed_config);
+  return scope.Escape(ctx);
+}
 
-    Local<Context> ctx = NewContext(env->isolate(), object_template);
 
-    if (ctx.IsEmpty()) {
-      env->ThrowError("Could not instantiate context");
-      return Local<Context>();
-    }
+void ContextifyContext::Init(Environment* env, Local<Object> target) {
+  Local<FunctionTemplate> function_template =
+      FunctionTemplate::New(env->isolate());
+  function_template->InstanceTemplate()->SetInternalFieldCount(1);
+  env->set_script_data_constructor_function(function_template->GetFunction());
 
-    ctx->SetSecurityToken(env->context()->GetSecurityToken());
-
-    // We need to tie the lifetime of the sandbox object with the lifetime of
-    // newly created context. We do this by making them hold references to each
-    // other. The context can directly hold a reference to the sandbox as an
-    // embedder data field. However, we cannot hold a reference to a v8::Context
-    // directly in an Object, we instead hold onto the new context's global
-    // object instead (which then has a reference to the context).
-    ctx->SetEmbedderData(kSandboxObjectIndex, sandbox_obj);
-    sandbox_obj->SetPrivate(env->context(),
-                            env->contextify_global_private_symbol(),
-                            ctx->Global());
-
-    Local<Value> name =
-        options_obj->Get(env->context(), env->name_string())
-            .ToLocalChecked();
-    CHECK(name->IsString());
-    Utf8Value name_val(env->isolate(), name);
-
-    ContextInfo info(*name_val);
-
-    Local<Value> origin =
-        options_obj->Get(env->context(),
-                         FIXED_ONE_BYTE_STRING(env->isolate(), "origin"))
-            .ToLocalChecked();
-    if (!origin->IsUndefined()) {
-      CHECK(origin->IsString());
-      Utf8Value origin_val(env->isolate(), origin);
-      info.origin = *origin_val;
-    }
+  env->SetMethod(target, "runInDebugContext", RunInDebugContext);
+  env->SetMethod(target, "makeContext", MakeContext);
+  env->SetMethod(target, "isContext", IsContext);
+}
 
-    env->AssignToContext(ctx, info);
 
-    return scope.Escape(ctx);
+void ContextifyContext::RunInDebugContext(
+    const FunctionCallbackInfo<Value>& args) {
+  Local<String> script_source(args[0]->ToString(args.GetIsolate()));
+  if (script_source.IsEmpty())
+    return;  // Exception pending.
+  Local<Context> debug_context = Debug::GetDebugContext(args.GetIsolate());
+  Environment* env = Environment::GetCurrent(args);
+  if (debug_context.IsEmpty()) {
+    // Force-load the debug context.
+    auto dummy_event_listener = [] (const Debug::EventDetails&) {};
+    Debug::SetDebugEventListener(args.GetIsolate(), dummy_event_listener);
+    debug_context = Debug::GetDebugContext(args.GetIsolate());
+    CHECK(!debug_context.IsEmpty());
+    // Ensure that the debug context has an Environment assigned in case
+    // a fatal error is raised.  The fatal exception handler in node.cc
+    // is not equipped to deal with contexts that don't have one and
+    // can't easily be taught that due to a deficiency in the V8 API:
+    // there is no way for the embedder to tell if the data index is
+    // in use.
+    const int index = Environment::kContextEmbedderDataIndex;
+    debug_context->SetAlignedPointerInEmbedderData(index, env);
   }
 
-
-  static void Init(Environment* env, Local<Object> target) {
-    Local<FunctionTemplate> function_template =
-        FunctionTemplate::New(env->isolate());
-    function_template->InstanceTemplate()->SetInternalFieldCount(1);
-    env->set_script_data_constructor_function(function_template->GetFunction());
-
-    env->SetMethod(target, "runInDebugContext", RunInDebugContext);
-    env->SetMethod(target, "makeContext", MakeContext);
-    env->SetMethod(target, "isContext", IsContext);
-  }
+  Context::Scope context_scope(debug_context);
+  MaybeLocal<Script> script = Script::Compile(debug_context, script_source);
+  if (script.IsEmpty())
+    return;  // Exception pending.
+  args.GetReturnValue().Set(script.ToLocalChecked()->Run());
+}
 
 
-  static void RunInDebugContext(const FunctionCallbackInfo<Value>& args) {
-    Local<String> script_source(args[0]->ToString(args.GetIsolate()));
-    if (script_source.IsEmpty())
-      return;  // Exception pending.
-    Local<Context> debug_context = Debug::GetDebugContext(args.GetIsolate());
-    Environment* env = Environment::GetCurrent(args);
-    if (debug_context.IsEmpty()) {
-      // Force-load the debug context.
-      auto dummy_event_listener = [] (const Debug::EventDetails&) {};
-      Debug::SetDebugEventListener(args.GetIsolate(), dummy_event_listener);
-      debug_context = Debug::GetDebugContext(args.GetIsolate());
-      CHECK(!debug_context.IsEmpty());
-      // Ensure that the debug context has an Environment assigned in case
-      // a fatal error is raised.  The fatal exception handler in node.cc
-      // is not equipped to deal with contexts that don't have one and
-      // can't easily be taught that due to a deficiency in the V8 API:
-      // there is no way for the embedder to tell if the data index is
-      // in use.
-      const int index = Environment::kContextEmbedderDataIndex;
-      debug_context->SetAlignedPointerInEmbedderData(index, env);
-    }
+void ContextifyContext::MakeContext(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
 
-    Context::Scope context_scope(debug_context);
-    MaybeLocal<Script> script = Script::Compile(debug_context, script_source);
-    if (script.IsEmpty())
-      return;  // Exception pending.
-    args.GetReturnValue().Set(script.ToLocalChecked()->Run());
+  if (!args[0]->IsObject()) {
+    return env->ThrowTypeError("sandbox argument must be an object.");
   }
+  Local<Object> sandbox = args[0].As<Object>();
 
+  // Don't allow contextifying a sandbox multiple times.
+  CHECK(
+      !sandbox->HasPrivate(
+          env->context(),
+          env->contextify_context_private_symbol()).FromJust());
 
-  static void MakeContext(const FunctionCallbackInfo<Value>& args) {
-    Environment* env = Environment::GetCurrent(args);
+  Local<Object> options = args[1].As<Object>();
+  CHECK(options->IsObject());
 
-    if (!args[0]->IsObject()) {
-      return env->ThrowTypeError("sandbox argument must be an object.");
-    }
-    Local<Object> sandbox = args[0].As<Object>();
+  TryCatch try_catch(env->isolate());
+  ContextifyContext* context = new ContextifyContext(env, sandbox, options);
 
-    // Don't allow contextifying a sandbox multiple times.
-    CHECK(
-        !sandbox->HasPrivate(
-            env->context(),
-            env->contextify_context_private_symbol()).FromJust());
+  if (try_catch.HasCaught()) {
+    try_catch.ReThrow();
+    return;
+  }
 
-    Local<Object> options = args[1].As<Object>();
-    CHECK(options->IsObject());
+  if (context->context().IsEmpty())
+    return;
 
-    TryCatch try_catch(env->isolate());
-    ContextifyContext* context = new ContextifyContext(env, sandbox, options);
+  sandbox->SetPrivate(
+      env->context(),
+      env->contextify_context_private_symbol(),
+      External::New(env->isolate(), context));
+}
 
-    if (try_catch.HasCaught()) {
-      try_catch.ReThrow();
-      return;
-    }
 
-    if (context->context().IsEmpty())
-      return;
+void ContextifyContext::IsContext(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
 
-    sandbox->SetPrivate(
-        env->context(),
-        env->contextify_context_private_symbol(),
-        External::New(env->isolate(), context));
+  if (!args[0]->IsObject()) {
+    env->ThrowTypeError("sandbox must be an object");
+    return;
   }
+  Local<Object> sandbox = args[0].As<Object>();
 
+  Maybe<bool> result =
+      sandbox->HasPrivate(env->context(),
+                          env->contextify_context_private_symbol());
+  args.GetReturnValue().Set(result.FromJust());
+}
 
-  static void IsContext(const FunctionCallbackInfo<Value>& args) {
-    Environment* env = Environment::GetCurrent(args);
 
-    if (!args[0]->IsObject()) {
-      env->ThrowTypeError("sandbox must be an object");
-      return;
-    }
-    Local<Object> sandbox = args[0].As<Object>();
+void ContextifyContext::WeakCallback(
+    const WeakCallbackInfo<ContextifyContext>& data) {
+  ContextifyContext* context = data.GetParameter();
+  delete context;
+}
 
-    Maybe<bool> result =
-        sandbox->HasPrivate(env->context(),
-                            env->contextify_context_private_symbol());
-    args.GetReturnValue().Set(result.FromJust());
+// static
+ContextifyContext* ContextifyContext::ContextFromContextifiedSandbox(
+    Environment* env,
+    const Local<Object>& sandbox) {
+  MaybeLocal<Value> maybe_value =
+      sandbox->GetPrivate(env->context(),
+                          env->contextify_context_private_symbol());
+  Local<Value> context_external_v;
+  if (maybe_value.ToLocal(&context_external_v) &&
+      context_external_v->IsExternal()) {
+    Local<External> context_external = context_external_v.As<External>();
+    return static_cast<ContextifyContext*>(context_external->Value());
   }
+  return nullptr;
+}
 
-
-  static void WeakCallback(const WeakCallbackInfo<ContextifyContext>& data) {
-    ContextifyContext* context = data.GetParameter();
-    delete context;
+// static
+void ContextifyContext::PropertyGetterCallback(
+    Local<Name> property,
+    const PropertyCallbackInfo<Value>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
+
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
+
+  Local<Context> context = ctx->context();
+  Local<Object> sandbox = ctx->sandbox();
+  MaybeLocal<Value> maybe_rv =
+      sandbox->GetRealNamedProperty(context, property);
+  if (maybe_rv.IsEmpty()) {
+    maybe_rv =
+        ctx->global_proxy()->GetRealNamedProperty(context, property);
   }
 
+  Local<Value> rv;
+  if (maybe_rv.ToLocal(&rv)) {
+    if (rv == sandbox)
+      rv = ctx->global_proxy();
 
-  static ContextifyContext* ContextFromContextifiedSandbox(
-      Environment* env,
-      const Local<Object>& sandbox) {
-    MaybeLocal<Value> maybe_value =
-        sandbox->GetPrivate(env->context(),
-                            env->contextify_context_private_symbol());
-    Local<Value> context_external_v;
-    if (maybe_value.ToLocal(&context_external_v) &&
-        context_external_v->IsExternal()) {
-      Local<External> context_external = context_external_v.As<External>();
-      return static_cast<ContextifyContext*>(context_external->Value());
-    }
-    return nullptr;
+    args.GetReturnValue().Set(rv);
   }
+}
 
-
-  static void PropertyGetterCallback(
-      Local<Name> property,
-      const PropertyCallbackInfo<Value>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
-
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
-
-    Local<Context> context = ctx->context();
-    Local<Object> sandbox = ctx->sandbox();
-    MaybeLocal<Value> maybe_rv =
-        sandbox->GetRealNamedProperty(context, property);
-    if (maybe_rv.IsEmpty()) {
-      maybe_rv =
-          ctx->global_proxy()->GetRealNamedProperty(context, property);
-    }
-
-    Local<Value> rv;
-    if (maybe_rv.ToLocal(&rv)) {
-      if (rv == sandbox)
-        rv = ctx->global_proxy();
-
-      args.GetReturnValue().Set(rv);
-    }
-  }
-
-
-  static void PropertySetterCallback(
-      Local<Name> property,
-      Local<Value> value,
-      const PropertyCallbackInfo<Value>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
-
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
-
-    auto attributes = PropertyAttribute::None;
-    bool is_declared_on_global_proxy = ctx->global_proxy()
-        ->GetRealNamedPropertyAttributes(ctx->context(), property)
-        .To(&attributes);
-    bool read_only =
-        static_cast<int>(attributes) &
-        static_cast<int>(PropertyAttribute::ReadOnly);
-
-    bool is_declared_on_sandbox = ctx->sandbox()
-        ->GetRealNamedPropertyAttributes(ctx->context(), property)
-        .To(&attributes);
-    read_only = read_only ||
-        (static_cast<int>(attributes) &
-        static_cast<int>(PropertyAttribute::ReadOnly));
-
-    if (read_only)
-      return;
-
-    // true for x = 5
-    // false for this.x = 5
-    // false for Object.defineProperty(this, 'foo', ...)
-    // false for vmResult.x = 5 where vmResult = vm.runInContext();
-    bool is_contextual_store = ctx->global_proxy() != args.This();
-
-    // Indicator to not return before setting (undeclared) function declarations
-    // on the sandbox in strict mode, i.e. args.ShouldThrowOnError() = true.
-    // True for 'function f() {}', 'this.f = function() {}',
-    // 'var f = function()'.
-    // In effect only for 'function f() {}' because
-    // var f = function(), is_declared = true
-    // this.f = function() {}, is_contextual_store = false.
-    bool is_function = value->IsFunction();
-
-    bool is_declared = is_declared_on_global_proxy || is_declared_on_sandbox;
-    if (!is_declared && args.ShouldThrowOnError() && is_contextual_store &&
-        !is_function)
-      return;
-
-    if (!is_declared_on_global_proxy && is_declared_on_sandbox  &&
-        args.ShouldThrowOnError() && is_contextual_store && !is_function) {
-      // The property exists on the sandbox but not on the global
-      // proxy. Setting it would throw because we are in strict mode.
-      // Don't attempt to set it by signaling that the call was
-      // intercepted. Only change the value on the sandbox.
-      args.GetReturnValue().Set(false);
-    }
-
-    ctx->sandbox()->Set(property, value);
+// static
+void ContextifyContext::PropertySetterCallback(
+    Local<Name> property,
+    Local<Value> value,
+    const PropertyCallbackInfo<Value>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
+
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
+
+  auto attributes = PropertyAttribute::None;
+  bool is_declared_on_global_proxy = ctx->global_proxy()
+      ->GetRealNamedPropertyAttributes(ctx->context(), property)
+      .To(&attributes);
+  bool read_only =
+      static_cast<int>(attributes) &
+      static_cast<int>(PropertyAttribute::ReadOnly);
+
+  bool is_declared_on_sandbox = ctx->sandbox()
+      ->GetRealNamedPropertyAttributes(ctx->context(), property)
+      .To(&attributes);
+  read_only = read_only ||
+      (static_cast<int>(attributes) &
+      static_cast<int>(PropertyAttribute::ReadOnly));
+
+  if (read_only)
+    return;
+
+  // true for x = 5
+  // false for this.x = 5
+  // false for Object.defineProperty(this, 'foo', ...)
+  // false for vmResult.x = 5 where vmResult = vm.runInContext();
+  bool is_contextual_store = ctx->global_proxy() != args.This();
+
+  // Indicator to not return before setting (undeclared) function declarations
+  // on the sandbox in strict mode, i.e. args.ShouldThrowOnError() = true.
+  // True for 'function f() {}', 'this.f = function() {}',
+  // 'var f = function()'.
+  // In effect only for 'function f() {}' because
+  // var f = function(), is_declared = true
+  // this.f = function() {}, is_contextual_store = false.
+  bool is_function = value->IsFunction();
+
+  bool is_declared = is_declared_on_global_proxy || is_declared_on_sandbox;
+  if (!is_declared && args.ShouldThrowOnError() && is_contextual_store &&
+      !is_function)
+    return;
+
+  if (!is_declared_on_global_proxy && is_declared_on_sandbox  &&
+      args.ShouldThrowOnError() && is_contextual_store && !is_function) {
+    // The property exists on the sandbox but not on the global
+    // proxy. Setting it would throw because we are in strict mode.
+    // Don't attempt to set it by signaling that the call was
+    // intercepted. Only change the value on the sandbox.
+    args.GetReturnValue().Set(false);
   }
 
+  ctx->sandbox()->Set(property, value);
+}
 
-  static void PropertyDescriptorCallback(
-      Local<Name> property,
-      const PropertyCallbackInfo<Value>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
+// static
+void ContextifyContext::PropertyDescriptorCallback(
+    Local<Name> property,
+    const PropertyCallbackInfo<Value>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
 
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
 
-    Local<Context> context = ctx->context();
+  Local<Context> context = ctx->context();
 
-    Local<Object> sandbox = ctx->sandbox();
+  Local<Object> sandbox = ctx->sandbox();
 
-    if (sandbox->HasOwnProperty(context, property).FromMaybe(false)) {
-      args.GetReturnValue().Set(
-          sandbox->GetOwnPropertyDescriptor(context, property)
-              .ToLocalChecked());
-    }
+  if (sandbox->HasOwnProperty(context, property).FromMaybe(false)) {
+    args.GetReturnValue().Set(
+        sandbox->GetOwnPropertyDescriptor(context, property)
+            .ToLocalChecked());
   }
+}
 
-
-  static void PropertyDefinerCallback(
-      Local<Name> property,
-      const PropertyDescriptor& desc,
-      const PropertyCallbackInfo<Value>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
-
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
-
-    Local<Context> context = ctx->context();
-    v8::Isolate* isolate = context->GetIsolate();
-
-    auto attributes = PropertyAttribute::None;
-    bool is_declared =
-        ctx->global_proxy()->GetRealNamedPropertyAttributes(ctx->context(),
-                                                            property)
-            .To(&attributes);
-    bool read_only =
-        static_cast<int>(attributes) &
-            static_cast<int>(PropertyAttribute::ReadOnly);
-
-    // If the property is set on the global as read_only, don't change it on
-    // the global or sandbox.
-    if (is_declared && read_only)
-      return;
-
-    Local<Object> sandbox = ctx->sandbox();
-
-    auto define_prop_on_sandbox =
-        [&] (PropertyDescriptor* desc_for_sandbox) {
-          if (desc.has_enumerable()) {
-            desc_for_sandbox->set_enumerable(desc.enumerable());
-          }
-          if (desc.has_configurable()) {
-            desc_for_sandbox->set_configurable(desc.configurable());
-          }
-          // Set the property on the sandbox.
-          sandbox->DefineProperty(context, property, *desc_for_sandbox)
-              .FromJust();
-        };
-
-    if (desc.has_get() || desc.has_set()) {
-      PropertyDescriptor desc_for_sandbox(
-          desc.has_get() ? desc.get() : v8::Undefined(isolate).As<Value>(),
-          desc.has_set() ? desc.set() : v8::Undefined(isolate).As<Value>());
-
+// static
+void ContextifyContext::PropertyDefinerCallback(
+    Local<Name> property,
+    const PropertyDescriptor& desc,
+    const PropertyCallbackInfo<Value>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
+
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
+
+  Local<Context> context = ctx->context();
+  v8::Isolate* isolate = context->GetIsolate();
+
+  auto attributes = PropertyAttribute::None;
+  bool is_declared =
+      ctx->global_proxy()->GetRealNamedPropertyAttributes(ctx->context(),
+                                                          property)
+          .To(&attributes);
+  bool read_only =
+      static_cast<int>(attributes) &
+          static_cast<int>(PropertyAttribute::ReadOnly);
+
+  // If the property is set on the global as read_only, don't change it on
+  // the global or sandbox.
+  if (is_declared && read_only)
+    return;
+
+  Local<Object> sandbox = ctx->sandbox();
+
+  auto define_prop_on_sandbox =
+      [&] (PropertyDescriptor* desc_for_sandbox) {
+        if (desc.has_enumerable()) {
+          desc_for_sandbox->set_enumerable(desc.enumerable());
+        }
+        if (desc.has_configurable()) {
+          desc_for_sandbox->set_configurable(desc.configurable());
+        }
+        // Set the property on the sandbox.
+        sandbox->DefineProperty(context, property, *desc_for_sandbox)
+            .FromJust();
+      };
+
+  if (desc.has_get() || desc.has_set()) {
+    PropertyDescriptor desc_for_sandbox(
+        desc.has_get() ? desc.get() : v8::Undefined(isolate).As<Value>(),
+        desc.has_set() ? desc.set() : v8::Undefined(isolate).As<Value>());
+
+    define_prop_on_sandbox(&desc_for_sandbox);
+  } else {
+    Local<Value> value =
+        desc.has_value() ? desc.value() : v8::Undefined(isolate).As<Value>();
+
+    if (desc.has_writable()) {
+      PropertyDescriptor desc_for_sandbox(value, desc.writable());
       define_prop_on_sandbox(&desc_for_sandbox);
     } else {
-      Local<Value> value =
-          desc.has_value() ? desc.value() : v8::Undefined(isolate).As<Value>();
-
-      if (desc.has_writable()) {
-        PropertyDescriptor desc_for_sandbox(value, desc.writable());
-        define_prop_on_sandbox(&desc_for_sandbox);
-      } else {
-        PropertyDescriptor desc_for_sandbox(value);
-        define_prop_on_sandbox(&desc_for_sandbox);
-      }
+      PropertyDescriptor desc_for_sandbox(value);
+      define_prop_on_sandbox(&desc_for_sandbox);
     }
   }
+}
 
-  static void PropertyDeleterCallback(
-      Local<Name> property,
-      const PropertyCallbackInfo<Boolean>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
-
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
+// static
+void ContextifyContext::PropertyDeleterCallback(
+    Local<Name> property,
+    const PropertyCallbackInfo<Boolean>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
 
-    Maybe<bool> success = ctx->sandbox()->Delete(ctx->context(), property);
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
 
-    if (success.FromMaybe(false))
-      return;
+  Maybe<bool> success = ctx->sandbox()->Delete(ctx->context(), property);
 
-    // Delete failed on the sandbox, intercept and do not delete on
-    // the global object.
-    args.GetReturnValue().Set(false);
-  }
+  if (success.FromMaybe(false))
+    return;
 
+  // Delete failed on the sandbox, intercept and do not delete on
+  // the global object.
+  args.GetReturnValue().Set(false);
+}
 
-  static void PropertyEnumeratorCallback(
-      const PropertyCallbackInfo<Array>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
+// static
+void ContextifyContext::PropertyEnumeratorCallback(
+    const PropertyCallbackInfo<Array>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
 
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
 
-    args.GetReturnValue().Set(ctx->sandbox()->GetPropertyNames());
-  }
+  args.GetReturnValue().Set(ctx->sandbox()->GetPropertyNames());
+}
 
-  static void IndexedPropertyGetterCallback(
-      uint32_t index,
-      const PropertyCallbackInfo<Value>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
+// static
+void ContextifyContext::IndexedPropertyGetterCallback(
+    uint32_t index,
+    const PropertyCallbackInfo<Value>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
 
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
-
-    PropertyGetterCallback(Uint32ToName(ctx->context(), index), args);
-  }
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
 
+  ContextifyContext::PropertyGetterCallback(
+      Uint32ToName(ctx->context(), index), args);
+}
 
-  static void IndexedPropertySetterCallback(
-      uint32_t index,
-      Local<Value> value,
-      const PropertyCallbackInfo<Value>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
 
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
+void ContextifyContext::IndexedPropertySetterCallback(
+    uint32_t index,
+    Local<Value> value,
+    const PropertyCallbackInfo<Value>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
 
-    PropertySetterCallback(Uint32ToName(ctx->context(), index), value, args);
-  }
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
 
+  ContextifyContext::PropertySetterCallback(
+      Uint32ToName(ctx->context(), index), value, args);
+}
 
-  static void IndexedPropertyDescriptorCallback(
-      uint32_t index,
-      const PropertyCallbackInfo<Value>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
+// static
+void ContextifyContext::IndexedPropertyDescriptorCallback(
+    uint32_t index,
+    const PropertyCallbackInfo<Value>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
 
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
 
-    PropertyDescriptorCallback(Uint32ToName(ctx->context(), index), args);
-  }
+  ContextifyContext::PropertyDescriptorCallback(
+      Uint32ToName(ctx->context(), index), args);
+}
 
 
-  static void IndexedPropertyDefinerCallback(
-      uint32_t index,
-      const PropertyDescriptor& desc,
-      const PropertyCallbackInfo<Value>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
+void ContextifyContext::IndexedPropertyDefinerCallback(
+    uint32_t index,
+    const PropertyDescriptor& desc,
+    const PropertyCallbackInfo<Value>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
 
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
 
-    PropertyDefinerCallback(Uint32ToName(ctx->context(), index), desc, args);
-  }
+  ContextifyContext::PropertyDefinerCallback(
+      Uint32ToName(ctx->context(), index), desc, args);
+}
 
-  static void IndexedPropertyDeleterCallback(
-      uint32_t index,
-      const PropertyCallbackInfo<Boolean>& args) {
-    ContextifyContext* ctx;
-    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
+// static
+void ContextifyContext::IndexedPropertyDeleterCallback(
+    uint32_t index,
+    const PropertyCallbackInfo<Boolean>& args) {
+  ContextifyContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Data().As<Object>());
 
-    // Still initializing
-    if (ctx->context_.IsEmpty())
-      return;
+  // Still initializing
+  if (ctx->context_.IsEmpty())
+    return;
 
-    Maybe<bool> success = ctx->sandbox()->Delete(ctx->context(), index);
+  Maybe<bool> success = ctx->sandbox()->Delete(ctx->context(), index);
 
-    if (success.FromMaybe(false))
-      return;
+  if (success.FromMaybe(false))
+    return;
 
-    // Delete failed on the sandbox, intercept and do not delete on
-    // the global object.
-    args.GetReturnValue().Set(false);
-  }
-};
+  // Delete failed on the sandbox, intercept and do not delete on
+  // the global object.
+  args.GetReturnValue().Set(false);
+}
 
 class ContextifyScript : public BaseObject {
  private:
@@ -1194,7 +1177,7 @@ void InitContextify(Local<Object> target,
   ContextifyScript::Init(env, target);
 }
 
-}  // anonymous namespace
+}  // namespace contextify
 }  // namespace node
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(contextify, node::InitContextify)
+NODE_BUILTIN_MODULE_CONTEXT_AWARE(contextify, node::contextify::InitContextify)
diff --git a/src/node_contextify.h b/src/node_contextify.h
new file mode 100644
index 00000000000000..9705c981a71e3b
--- /dev/null
+++ b/src/node_contextify.h
@@ -0,0 +1,100 @@
+#ifndef SRC_NODE_CONTEXTIFY_H_
+#define SRC_NODE_CONTEXTIFY_H_
+
+#include "node_internals.h"
+#include "node_watchdog.h"
+#include "base_object-inl.h"
+
+namespace node {
+namespace contextify {
+
+class ContextifyContext {
+ protected:
+  // V8 reserves the first field in context objects for the debugger. We use the
+  // second field to hold a reference to the sandbox object.
+  enum { kSandboxObjectIndex = 1 };
+
+  Environment* const env_;
+  v8::Persistent<v8::Context> context_;
+
+ public:
+  ContextifyContext(Environment* env,
+                    v8::Local<v8::Object> sandbox_obj,
+                    v8::Local<v8::Object> options_obj);
+  ~ContextifyContext();
+
+  v8::Local<v8::Value> CreateDataWrapper(Environment* env);
+  v8::Local<v8::Context> CreateV8Context(Environment* env,
+      v8::Local<v8::Object> sandbox_obj, v8::Local<v8::Object> options_obj);
+  static void Init(Environment* env, v8::Local<v8::Object> target);
+
+  static ContextifyContext* ContextFromContextifiedSandbox(
+      Environment* env,
+      const v8::Local<v8::Object>& sandbox);
+
+  inline Environment* env() const {
+    return env_;
+  }
+
+  inline v8::Local<v8::Context> context() const {
+    return PersistentToLocal(env()->isolate(), context_);
+  }
+
+  inline v8::Local<v8::Object> global_proxy() const {
+    return context()->Global();
+  }
+
+  inline v8::Local<v8::Object> sandbox() const {
+    return v8::Local<v8::Object>::Cast(
+        context()->GetEmbedderData(kSandboxObjectIndex));
+  }
+
+ private:
+  static void RunInDebugContext(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void MakeContext(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsContext(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void WeakCallback(
+      const v8::WeakCallbackInfo<ContextifyContext>& data);
+  static void PropertyGetterCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static void PropertySetterCallback(
+      v8::Local<v8::Name> property,
+      v8::Local<v8::Value> value,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static void PropertyDescriptorCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static void PropertyDefinerCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyDescriptor& desc,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static void PropertyDeleterCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Boolean>& args);
+  static void PropertyEnumeratorCallback(
+      const v8::PropertyCallbackInfo<v8::Array>& args);
+  static void IndexedPropertyGetterCallback(
+      uint32_t index,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static void IndexedPropertySetterCallback(
+      uint32_t index,
+      v8::Local<v8::Value> value,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static void IndexedPropertyDescriptorCallback(
+      uint32_t index,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static void IndexedPropertyDefinerCallback(
+      uint32_t index,
+      const v8::PropertyDescriptor& desc,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static void IndexedPropertyDeleterCallback(
+      uint32_t index,
+      const v8::PropertyCallbackInfo<v8::Boolean>& args);
+};
+
+}  // namespace contextify
+}  // namespace node
+
+#endif  // SRC_NODE_CONTEXTIFY_H_