diff --git a/pressure-vessel/wrap-context.c b/pressure-vessel/wrap-context.c
index dd711208e75810a0109df8766afacd7d9f8a7d99..8216431faebe3a48a4169b8cd0cf1ef470e2a534 100644
--- a/pressure-vessel/wrap-context.c
+++ b/pressure-vessel/wrap-context.c
@@ -98,9 +98,13 @@ pv_wrap_options_clear (PvWrapOptions *self)
 
 enum {
   PROP_0,
+  PROP_CURRENT_HOME,
+  PROP_CURRENT_ROOT,
   N_PROPERTIES
 };
 
+static GParamSpec *properties[N_PROPERTIES] = { NULL };
+
 struct _PvWrapContextClass
 {
   GObjectClass parent_class;
@@ -120,6 +124,78 @@ pv_wrap_context_init (PvWrapContext *self)
   self->options.copy_runtime = self->is_flatpak_env;
 }
 
+static void
+pv_wrap_context_get_property (GObject *object,
+                              guint prop_id,
+                              GValue *value,
+                              GParamSpec *pspec)
+{
+  PvWrapContext *self = PV_WRAP_CONTEXT (object);
+
+  switch (prop_id)
+    {
+      case PROP_CURRENT_HOME:
+        g_value_set_string (value, self->current_home);
+        break;
+
+      case PROP_CURRENT_ROOT:
+        g_value_set_object (value, self->current_root);
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+pv_wrap_context_set_property (GObject *object,
+                              guint prop_id,
+                              const GValue *value,
+                              GParamSpec *pspec)
+{
+  PvWrapContext *self = PV_WRAP_CONTEXT (object);
+
+  switch (prop_id)
+    {
+      case PROP_CURRENT_HOME:
+        /* Construct-only */
+        g_return_if_fail (self->current_home == NULL);
+        self->current_home = g_value_dup_string (value);
+        break;
+
+      case PROP_CURRENT_ROOT:
+        /* Construct-only */
+        g_return_if_fail (self->current_root == NULL);
+        self->current_root = g_value_dup_object (value);
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+pv_wrap_context_constructed (GObject *object)
+{
+  PvWrapContext *self = PV_WRAP_CONTEXT (object);
+
+  G_OBJECT_CLASS (pv_wrap_context_parent_class)->constructed (object);
+
+  if (self->current_home == NULL)
+    self->current_home = g_strdup (g_get_home_dir ());
+}
+
+static void
+pv_wrap_context_dispose (GObject *object)
+{
+  PvWrapContext *self = PV_WRAP_CONTEXT (object);
+
+  g_clear_object (&self->current_root);
+  g_clear_object (&self->runtime);
+
+  G_OBJECT_CLASS (pv_wrap_context_parent_class)->dispose (object);
+}
+
 static void
 pv_wrap_context_finalize (GObject *object)
 {
@@ -127,9 +203,11 @@ pv_wrap_context_finalize (GObject *object)
 
   pv_wrap_options_clear (&self->options);
 
+  g_clear_pointer (&self->exports, flatpak_exports_free);
   g_clear_pointer (&self->paths_not_exported, g_hash_table_unref);
   g_strfreev (self->original_argv);
   g_strfreev (self->original_environ);
+  g_free (self->current_home);
 
   G_OBJECT_CLASS (pv_wrap_context_parent_class)->finalize (object);
 }
@@ -139,13 +217,40 @@ pv_wrap_context_class_init (PvWrapContextClass *cls)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (cls);
 
+  object_class->get_property = pv_wrap_context_get_property;
+  object_class->set_property = pv_wrap_context_set_property;
+  object_class->constructed = pv_wrap_context_constructed;
+  object_class->dispose = pv_wrap_context_dispose;
   object_class->finalize = pv_wrap_context_finalize;
+
+  properties[PROP_CURRENT_HOME] =
+    g_param_spec_string ("current-home", "Current $HOME",
+                         ("Path to real or mock home directory "
+                          "within current-root"),
+                         NULL,
+                         (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
+                          G_PARAM_STATIC_STRINGS));
+
+  properties[PROP_CURRENT_ROOT] =
+    g_param_spec_object ("current-root", "Current root",
+                         ("Real or mock root directory for the current "
+                          "filesystem namespace"),
+                         SRT_TYPE_SYSROOT,
+                         (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
+                          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_properties (object_class, N_PROPERTIES, properties);
 }
 
 PvWrapContext *
-pv_wrap_context_new (GError **error)
+pv_wrap_context_new (SrtSysroot *current_root,
+                     const char *current_home,
+                     GError **error)
 {
+  /* Can't actually fail right now */
   return g_object_new (PV_TYPE_WRAP_CONTEXT,
+                       "current-home", current_home,
+                       "current-root", current_root,
                        NULL);
 }
 
@@ -1033,7 +1138,6 @@ export_not_allowed (PvWrapContext *self,
 /*
  * pv_wrap_context_export_if_allowed:
  * @self: The context
- * @exports: List of exported paths
  * @export_mode: Mode with which to add @path
  * @path: The path we propose to export, as an absolute path within the
  *  current execution environment
@@ -1052,7 +1156,6 @@ export_not_allowed (PvWrapContext *self,
  */
 gboolean
 pv_wrap_context_export_if_allowed (PvWrapContext *self,
-                                   FlatpakExports *exports,
                                    FlatpakFilesystemMode export_mode,
                                    const char *path,
                                    const char *host_path,
@@ -1065,7 +1168,7 @@ pv_wrap_context_export_if_allowed (PvWrapContext *self,
   size_t i;
 
   g_return_val_if_fail (PV_IS_WRAP_CONTEXT (self), FALSE);
-  g_return_val_if_fail (exports != NULL, FALSE);
+  g_return_val_if_fail (self->exports != NULL, FALSE);
   g_return_val_if_fail (export_mode > FLATPAK_FILESYSTEM_MODE_NONE, FALSE);
   g_return_val_if_fail (export_mode <= FLATPAK_FILESYSTEM_MODE_LAST, FALSE);
   g_return_val_if_fail (g_path_is_absolute (path), FALSE);
@@ -1106,7 +1209,7 @@ pv_wrap_context_export_if_allowed (PvWrapContext *self,
 
   /* This generally shouldn't fail in practice, because we already checked
    * against reserved_paths[] above */
-  pv_exports_expose_or_log (exports, export_mode, path);
+  pv_exports_expose_or_log (self->exports, export_mode, path);
 
   return TRUE;
 }
diff --git a/pressure-vessel/wrap-context.h b/pressure-vessel/wrap-context.h
index 17d2db2c2821faf7654445fe116a51af3e1e9b35..68cc601a14f0b5cf366419f7b8ef353ba7eef463 100644
--- a/pressure-vessel/wrap-context.h
+++ b/pressure-vessel/wrap-context.h
@@ -13,6 +13,7 @@
 
 #include "pressure-vessel/adverb-preload.h"
 #include "pressure-vessel/flatpak-exports-private.h"
+#include "pressure-vessel/runtime.h"
 
 #include "pressure-vessel/wrap-interactive.h"
 
@@ -92,9 +93,13 @@ struct _PvWrapContext
 {
   GObject parent_instance;
 
+  FlatpakExports *exports;
   GHashTable *paths_not_exported;
+  PvRuntime *runtime;
+  SrtSysroot *current_root;
   gchar **original_argv;
   gchar **original_environ;
+  gchar *current_home;
 
   PvWrapOptions options;
 
@@ -118,7 +123,9 @@ struct _PvWrapContext
 GType pv_wrap_context_get_type (void);
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (PvWrapContext, g_object_unref)
 
-PvWrapContext *pv_wrap_context_new (GError **error);
+PvWrapContext *pv_wrap_context_new (SrtSysroot *current_root,
+                                    const char *current_home,
+                                    GError **error);
 
 gboolean pv_wrap_options_parse_environment (PvWrapOptions *self,
                                             GError **error);
@@ -138,7 +145,6 @@ gboolean pv_wrap_options_parse_environment_after_argv (PvWrapOptions *self,
                                                        GError **error);
 
 gboolean pv_wrap_context_export_if_allowed (PvWrapContext *self,
-                                            FlatpakExports *exports,
                                             FlatpakFilesystemMode export_mode,
                                             const char *path,
                                             const char *host_path,
diff --git a/pressure-vessel/wrap-setup.c b/pressure-vessel/wrap-setup.c
index 8570ea535a2ff6ffc8c58689c535c2c3a887b41d..08c710134adf2040cd27f20dbc7c691e5eeb60cf 100644
--- a/pressure-vessel/wrap-setup.c
+++ b/pressure-vessel/wrap-setup.c
@@ -546,15 +546,13 @@ pv_wrap_move_into_scope (const char *steam_app_id)
 }
 
 static void
-append_preload_internal (GPtrArray *argv,
+append_preload_internal (PvWrapContext *context,
+                         GPtrArray *argv,
                          PvPreloadVariableIndex which,
                          gsize abi_index,
                          const char *export_path,
                          const char *original_path,
-                         GStrv env,
-                         PvAppendPreloadFlags flags,
-                         PvRuntime *runtime,
-                         FlatpakExports *exports)
+                         PvAppendPreloadFlags flags)
 {
   g_auto(PvAdverbPreloadModule) module = PV_ADVERB_PRELOAD_MODULE_INIT;
   g_autofree gchar *arg = NULL;
@@ -563,7 +561,7 @@ append_preload_internal (GPtrArray *argv,
   module.index_in_preload_variables = which;
   module.abi_index = abi_index;
 
-  if (runtime != NULL
+  if (context->runtime != NULL
       && (g_str_has_prefix (original_path, "/usr/")
           || g_str_has_prefix (original_path, "/lib")
           || (flatpak_subsandbox && g_str_has_prefix (original_path, "/app/"))))
@@ -578,9 +576,9 @@ append_preload_internal (GPtrArray *argv,
       module.name = g_strdup (original_path);
       g_debug ("%s -> unmodified", original_path);
 
-      if (exports != NULL && export_path != NULL && export_path[0] == '/')
+      if (context->exports != NULL && export_path != NULL && export_path[0] == '/')
         {
-          const gchar *steam_path = g_environ_getenv (env, "STEAM_COMPAT_CLIENT_INSTALL_PATH");
+          const gchar *steam_path = g_environ_getenv (context->original_environ, "STEAM_COMPAT_CLIENT_INSTALL_PATH");
 
           if (steam_path != NULL
               && flatpak_has_path_prefix (export_path, steam_path))
@@ -592,7 +590,7 @@ append_preload_internal (GPtrArray *argv,
           else
             {
               g_debug ("%s needs adding to exports", export_path);
-              pv_exports_expose_or_log (exports,
+              pv_exports_expose_or_log (context->exports,
                                         FLATPAK_FILESYSTEM_MODE_READ_ONLY,
                                         export_path);
             }
@@ -620,13 +618,11 @@ append_preload_internal (GPtrArray *argv,
  * Arguments are the same as for pv_wrap_append_preload().
  */
 static void
-append_preload_unsupported_token (GPtrArray *argv,
+append_preload_unsupported_token (PvWrapContext *context,
+                                  GPtrArray *argv,
                                   PvPreloadVariableIndex which,
                                   const char *preload,
-                                  GStrv env,
-                                  PvAppendPreloadFlags flags,
-                                  PvRuntime *runtime,
-                                  FlatpakExports *exports)
+                                  PvAppendPreloadFlags flags)
 {
   g_autofree gchar *export_path = NULL;
   char *dollar;
@@ -673,15 +669,13 @@ append_preload_unsupported_token (GPtrArray *argv,
                preload);
     }
 
-  append_preload_internal (argv,
+  append_preload_internal (context,
+                           argv,
                            which,
                            PV_UNSPECIFIED_ABI,
                            export_path,
                            preload,
-                           env,
-                           flags,
-                           runtime,
-                           exports);
+                           flags);
 }
 
 /*
@@ -695,13 +689,11 @@ append_preload_unsupported_token (GPtrArray *argv,
  * Arguments are the same as for pv_wrap_append_preload().
  */
 static void
-append_preload_per_architecture (GPtrArray *argv,
+append_preload_per_architecture (PvWrapContext *context,
+                                 GPtrArray *argv,
                                  PvPreloadVariableIndex which,
                                  const char *preload,
-                                 GStrv env,
-                                 PvAppendPreloadFlags flags,
-                                 PvRuntime *runtime,
-                                 FlatpakExports *exports)
+                                 PvAppendPreloadFlags flags)
 {
   g_autoptr(SrtSystemInfo) system_info = srt_system_info_new (NULL);
   gsize n_supported_architectures = PV_N_SUPPORTED_ARCHITECTURES;
@@ -775,15 +767,13 @@ append_preload_per_architecture (GPtrArray *argv,
         {
           g_debug ("Found %s version of %s at %s",
                    multiarch_tuple, preload, path);
-          append_preload_internal (argv,
+          append_preload_internal (context,
+                                   argv,
                                    which,
                                    i,
                                    path,
                                    path,
-                                   env,
-                                   flags,
-                                   runtime,
-                                   exports);
+                                   flags);
         }
       else
         {
@@ -794,18 +784,16 @@ append_preload_per_architecture (GPtrArray *argv,
 }
 
 static void
-append_preload_basename (GPtrArray *argv,
+append_preload_basename (PvWrapContext *context,
+                         GPtrArray *argv,
                          PvPreloadVariableIndex which,
                          const char *preload,
-                         GStrv env,
-                         PvAppendPreloadFlags flags,
-                         PvRuntime *runtime,
-                         FlatpakExports *exports)
+                         PvAppendPreloadFlags flags)
 {
   gboolean runtime_has_library = FALSE;
 
-  if (runtime != NULL)
-    runtime_has_library = pv_runtime_has_library (runtime, preload);
+  if (context->runtime != NULL)
+    runtime_has_library = pv_runtime_has_library (context->runtime, preload);
 
   if (flags & PV_APPEND_PRELOAD_FLAGS_IN_UNIT_TESTS)
     {
@@ -832,15 +820,13 @@ append_preload_basename (GPtrArray *argv,
                "passing %s through as-is",
                preload,
                pv_preload_variables[which].variable);
-      append_preload_internal (argv,
+      append_preload_internal (context,
+                               argv,
                                which,
                                PV_UNSPECIFIED_ABI,
                                NULL,
                                preload,
-                               env,
-                               flags,
-                               runtime,
-                               NULL);
+                               flags);
     }
   else
     {
@@ -851,50 +837,42 @@ append_preload_basename (GPtrArray *argv,
       g_debug ("Did not find \"%s\" in runtime or graphics stack provider, "
                "splitting architectures",
                preload);
-      append_preload_per_architecture (argv,
+      append_preload_per_architecture (context,
+                                       argv,
                                        which,
                                        preload,
-                                       env,
-                                       flags,
-                                       runtime,
-                                       exports);
+                                       flags);
     }
 }
 
 /**
  * pv_wrap_append_preload:
+ * @context: Context we are running in
  * @argv: (element-type filename): Array of command-line options to populate
  * @which: Either `LD_AUDIT` or `LD_PRELOAD`
  * @preload: (type filename): Path of preloadable module in current
  *  namespace, possibly including special ld.so tokens such as `$LIB`,
  *  or basename of a preloadable module to be found in the standard
  *  library search path
- * @env: (array zero-terminated=1) (element-type filename): Environment
- *  variables to be used instead of `environ`
  * @flags: Flags to adjust behaviour
- * @runtime: (nullable): Runtime to be used in container
- * @exports: (nullable): Used to configure extra paths that need to be
- *  exported into the container
  *
  * Adjust @preload to be valid for the container and append it
  * to @argv.
  */
 void
-pv_wrap_append_preload (GPtrArray *argv,
+pv_wrap_append_preload (PvWrapContext *context,
+                        GPtrArray *argv,
                         PvPreloadVariableIndex which,
                         const char *preload,
-                        GStrv env,
-                        PvAppendPreloadFlags flags,
-                        PvRuntime *runtime,
-                        FlatpakExports *exports)
+                        PvAppendPreloadFlags flags)
 {
   SrtLoadableKind kind;
   SrtLoadableFlags loadable_flags;
   const char *variable;
 
+  g_return_if_fail (PV_IS_WRAP_CONTEXT (context));
   g_return_if_fail (argv != NULL);
   g_return_if_fail (preload != NULL);
-  g_return_if_fail (runtime == NULL || PV_IS_RUNTIME (runtime));
   g_return_if_fail (which >= 0);
   g_return_if_fail (which < G_N_ELEMENTS (pv_preload_variables));
 
@@ -907,7 +885,7 @@ pv_wrap_append_preload (GPtrArray *argv,
       return;
     }
 
-  if ((flags & PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY)
+  if (context->options.remove_game_overlay
       && g_str_has_suffix (preload, "/gameoverlayrenderer.so"))
     {
       g_info ("Disabling Steam Overlay: %s", preload);
@@ -921,13 +899,11 @@ pv_wrap_append_preload (GPtrArray *argv,
       case SRT_LOADABLE_KIND_BASENAME:
         /* Basenames can't have dynamic string tokens. */
         g_warn_if_fail ((loadable_flags & SRT_LOADABLE_FLAGS_DYNAMIC_TOKENS) == 0);
-        append_preload_basename (argv,
+        append_preload_basename (context,
+                                 argv,
                                  which,
                                  preload,
-                                 env,
-                                 flags,
-                                 runtime,
-                                 exports);
+                                 flags);
         break;
 
       case SRT_LOADABLE_KIND_PATH:
@@ -935,40 +911,34 @@ pv_wrap_append_preload (GPtrArray *argv,
         if (loadable_flags & (SRT_LOADABLE_FLAGS_ORIGIN
                               | SRT_LOADABLE_FLAGS_UNKNOWN_TOKENS))
           {
-            append_preload_unsupported_token (argv,
+            append_preload_unsupported_token (context,
+                                              argv,
                                               which,
                                               preload,
-                                              env,
-                                              flags,
-                                              runtime,
-                                              exports);
+                                              flags);
           }
         else if (loadable_flags & SRT_LOADABLE_FLAGS_ABI_DEPENDENT)
           {
             g_debug ("Found $LIB or $PLATFORM in \"%s\", splitting architectures",
                      preload);
-            append_preload_per_architecture (argv,
+            append_preload_per_architecture (context,
+                                             argv,
                                              which,
                                              preload,
-                                             env,
-                                             flags,
-                                             runtime,
-                                             exports);
+                                             flags);
           }
         else
           {
             /* All dynamic tokens should be handled above, so we can
              * assume that preload is a concrete filename */
             g_warn_if_fail ((loadable_flags & SRT_LOADABLE_FLAGS_DYNAMIC_TOKENS) == 0);
-            append_preload_internal (argv,
+            append_preload_internal (context,
+                                     argv,
                                      which,
                                      PV_UNSPECIFIED_ABI,
                                      preload,
                                      preload,
-                                     env,
-                                     flags,
-                                     runtime,
-                                     exports);
+                                     flags);
           }
         break;
 
@@ -1161,9 +1131,7 @@ static const EnvMount known_required_env[] =
 
 static void
 bind_and_propagate_from_environ (PvWrapContext *self,
-                                 SrtSysroot *sysroot,
                                  PvHomeMode home_mode,
-                                 FlatpakExports *exports,
                                  SrtEnvOverlay *container_env,
                                  const char *variable,
                                  EnvMountFlags flags,
@@ -1171,14 +1139,18 @@ bind_and_propagate_from_environ (PvWrapContext *self,
 {
   g_auto(GStrv) values = NULL;
   FlatpakFilesystemMode mode = FLATPAK_FILESYSTEM_MODE_READ_WRITE;
+  SrtSysroot *sysroot;
   const char *value;
   const char *before;
   const char *after;
   gboolean changed = FALSE;
   gsize i;
 
-  g_return_if_fail (exports != NULL);
+  g_return_if_fail (PV_IS_WRAP_CONTEXT (self));
+  g_return_if_fail (self->exports != NULL);
   g_return_if_fail (variable != NULL);
+  sysroot = self->current_root;
+  g_return_if_fail (sysroot != NULL);
 
   if (home_mode != PV_HOME_MODE_SHARED
       && (flags & ENV_MOUNT_FLAGS_IF_HOME_SHARED))
@@ -1232,7 +1204,6 @@ bind_and_propagate_from_environ (PvWrapContext *self,
       value_host = pv_current_namespace_path_to_host_path (canon);
 
       if (!pv_wrap_context_export_if_allowed (self,
-                                              exports,
                                               mode,
                                               canon,
                                               value_host,
@@ -1260,15 +1231,9 @@ bind_and_propagate_from_environ (PvWrapContext *self,
     }
 }
 
-/*
- * @exports: (nullable): List of exported directories, or %NULL if running
- *  a Flatpak subsandbox
- */
 void
 pv_bind_and_propagate_from_environ (PvWrapContext *self,
-                                    SrtSysroot *sysroot,
                                     PvHomeMode home_mode,
-                                    FlatpakExports *exports,
                                     SrtEnvOverlay *container_env)
 {
   gsize i;
@@ -1281,13 +1246,12 @@ pv_bind_and_propagate_from_environ (PvWrapContext *self,
     {
       const char *name = known_required_env[i].name;
 
-      if (exports != NULL)
+      if (self->exports != NULL)
         {
           /* If we're using bubblewrap directly, we can and must make
            * sure that all required directories are bind-mounted */
-          bind_and_propagate_from_environ (self, sysroot, home_mode,
-                                           exports, container_env,
-                                           name,
+          bind_and_propagate_from_environ (self, home_mode,
+                                           container_env, name,
                                            known_required_env[i].flags,
                                            known_required_env[i].export_flags);
         }
diff --git a/pressure-vessel/wrap-setup.h b/pressure-vessel/wrap-setup.h
index 936314a4d0901c4947798b462bc6b112340518ba..26d1c7e40d59566bb944fe1b5369a50092fd1dc4 100644
--- a/pressure-vessel/wrap-setup.h
+++ b/pressure-vessel/wrap-setup.h
@@ -66,7 +66,6 @@ void pv_wrap_move_into_scope (const char *steam_app_id);
  * PvAppendPreloadFlags:
  * @PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX: The game will be run in
  *  a Flatpak subsandbox
- * @PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY: Disable the Steam Overlay
  * @PV_APPEND_PRELOAD_FLAGS_IN_UNIT_TESTS: Normalize $LIB and $PLATFORM,
  *  for unit testing
  * @PV_APPEND_PRELOAD_FLAGS_ONE_ARCHITECTURE: Behave as though there is
@@ -78,19 +77,16 @@ void pv_wrap_move_into_scope (const char *steam_app_id);
 typedef enum
 {
   PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX = (1 << 0),
-  PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY = (1 << 1),
   PV_APPEND_PRELOAD_FLAGS_IN_UNIT_TESTS = (1 << 2),
   PV_APPEND_PRELOAD_FLAGS_ONE_ARCHITECTURE = (1 << 3),
   PV_APPEND_PRELOAD_FLAGS_NONE = 0
 } PvAppendPreloadFlags;
 
-void pv_wrap_append_preload (GPtrArray *argv,
+void pv_wrap_append_preload (PvWrapContext *context,
+                             GPtrArray *argv,
                              PvPreloadVariableIndex which,
                              const char *preload,
-                             GStrv env,
-                             PvAppendPreloadFlags flags,
-                             PvRuntime *runtime,
-                             FlatpakExports *exports);
+                             PvAppendPreloadFlags flags);
 
 gboolean pv_wrap_maybe_load_nvidia_modules (GError **error);
 
@@ -100,7 +96,5 @@ void pv_wrap_detect_virtualization (SrtSysroot **interpreter_root_out,
 void pv_share_temp_dir (FlatpakExports *exports,
                         SrtEnvOverlay *container_env);
 void pv_bind_and_propagate_from_environ (PvWrapContext *self,
-                                         SrtSysroot *sysroot,
                                          PvHomeMode home_mode,
-                                         FlatpakExports *exports,
                                          SrtEnvOverlay *container_env);
diff --git a/pressure-vessel/wrap.c b/pressure-vessel/wrap.c
index eddd59e0057a40e780ca0eb150dc2ba14c7c7560..de714d16c4a899563f1390c0d4300aa4bbdcacb7 100644
--- a/pressure-vessel/wrap.c
+++ b/pressure-vessel/wrap.c
@@ -86,7 +86,6 @@ main (int argc,
   g_autoptr(FlatpakBwrap) bwrap_home_arguments = NULL;
   g_autoptr(FlatpakBwrap) argv_in_container = NULL;
   g_autoptr(FlatpakBwrap) final_argv = NULL;
-  g_autoptr(FlatpakExports) exports = NULL;
   g_autoptr(SrtSysroot) real_root = NULL;
   g_autoptr(SrtSysroot) interpreter_root = NULL;
   g_autofree gchar *bwrap_executable = NULL;
@@ -95,9 +94,7 @@ main (int argc,
   g_autofree gchar *cwd_l = NULL;
   g_autofree gchar *cwd_p_host = NULL;
   g_autofree gchar *private_home = NULL;
-  const gchar *home;
   g_autofree gchar *tools_dir = NULL;
-  g_autoptr(PvRuntime) runtime = NULL;
   glnx_autofd int original_stdout = -1;
   glnx_autofd int original_stderr = -1;
   const char *graphics_provider_mount_point = NULL;
@@ -130,7 +127,18 @@ main (int argc,
       goto out;
     }
 
-  self = pv_wrap_context_new (error);
+  /* FEX-Emu transparently rewrites most file I/O to check its "rootfs"
+   * first, and only use the real root if the corresponding file
+   * doesn't exist in the "rootfs". In many places we actively don't want
+   * this, because we're inspecting paths in order to pass them to bwrap,
+   * which will use them to set up bind-mounts, which are not subject to
+   * FEX-Emu's rewriting; so bypass it here. */
+  real_root = _srt_sysroot_new_real_root (error);
+
+  if (real_root == NULL)
+    return FALSE;
+
+  self = pv_wrap_context_new (real_root, g_get_home_dir (), error);
 
   if (self == NULL)
     goto out;
@@ -232,8 +240,6 @@ main (int argc,
   else
     steam_app_id = _srt_get_steam_app_id ();
 
-  home = g_get_home_dir ();
-
   if (self->options.share_home == TRISTATE_YES)
     {
       home_mode = PV_HOME_MODE_SHARED;
@@ -250,7 +256,7 @@ main (int argc,
   else if (self->options.freedesktop_app_id)
     {
       home_mode = PV_HOME_MODE_PRIVATE;
-      private_home = g_build_filename (home, ".var", "app",
+      private_home = g_build_filename (self->current_home, ".var", "app",
                                        self->options.freedesktop_app_id,
                                        NULL);
     }
@@ -259,7 +265,7 @@ main (int argc,
       home_mode = PV_HOME_MODE_PRIVATE;
       self->options.freedesktop_app_id = g_strdup_printf ("com.steampowered.App%s",
                                                           steam_app_id);
-      private_home = g_build_filename (home, ".var", "app",
+      private_home = g_build_filename (self->current_home, ".var", "app",
                                        self->options.freedesktop_app_id,
                                        NULL);
     }
@@ -438,17 +444,6 @@ main (int argc,
       goto out;
     }
 
-  /* FEX-Emu transparently rewrites most file I/O to check its "rootfs"
-   * first, and only use the real root if the corresponding file
-   * doesn't exist in the "rootfs". In many places we actively don't want
-   * this, because we're inspecting paths in order to pass them to bwrap,
-   * which will use them to set up bind-mounts, which are not subject to
-   * FEX-Emu's rewriting; so bypass it here. */
-  real_root = _srt_sysroot_new_real_root (error);
-
-  if (real_root == NULL)
-    return FALSE;
-
   /* Invariant: we are in exactly one of these two modes */
   g_assert (((flatpak_subsandbox != NULL)
              + (!self->is_flatpak_env))
@@ -461,7 +456,7 @@ main (int argc,
       g_assert (bwrap_executable != NULL);
       flatpak_bwrap_add_arg (bwrap, bwrap_executable);
       bwrap_filesystem_arguments = flatpak_bwrap_new (flatpak_bwrap_empty_env);
-      exports = flatpak_exports_new ();
+      self->exports = flatpak_exports_new ();
     }
   else
     {
@@ -469,7 +464,7 @@ main (int argc,
     }
 
   /* Invariant: we have bwrap or exports iff we also have the other */
-  g_assert ((bwrap != NULL) == (exports != NULL));
+  g_assert ((bwrap != NULL) == (self->exports != NULL));
   g_assert ((bwrap != NULL) == (bwrap_filesystem_arguments != NULL));
   g_assert ((bwrap != NULL) == (bwrap_executable != NULL));
 
@@ -479,7 +474,7 @@ main (int argc,
     {
       FlatpakFilesystemMode sysfs_mode = FLATPAK_FILESYSTEM_MODE_READ_ONLY;
 
-      g_assert (exports != NULL);
+      g_assert (self->exports != NULL);
       g_assert (bwrap_filesystem_arguments != NULL);
 
       if ((_srt_util_get_log_flags () & SRT_LOG_FLAGS_LEVEL)
@@ -678,21 +673,21 @@ main (int argc,
           goto out;
         }
 
-      runtime = pv_runtime_new (runtime_path,
-                                self->options.variable_dir,
-                                bwrap_executable,
-                                graphics_provider,
-                                interpreter_host_provider,
-                                _srt_const_strv (self->original_environ),
-                                flags,
-                                workarounds,
-                                error);
-
-      if (runtime == NULL)
+      self->runtime = pv_runtime_new (runtime_path,
+                                      self->options.variable_dir,
+                                      bwrap_executable,
+                                      graphics_provider,
+                                      interpreter_host_provider,
+                                      _srt_const_strv (self->original_environ),
+                                      flags,
+                                      workarounds,
+                                      error);
+
+      if (self->runtime == NULL)
         goto out;
 
-      if (!pv_runtime_bind (runtime,
-                            exports,
+      if (!pv_runtime_bind (self->runtime,
+                            self->exports,
                             bwrap_filesystem_arguments,
                             container_env,
                             error))
@@ -700,8 +695,8 @@ main (int argc,
 
       if (flatpak_subsandbox != NULL)
         {
-          const char *app = pv_runtime_get_modified_app (runtime);
-          const char *usr = pv_runtime_get_modified_usr (runtime);
+          const char *app = pv_runtime_get_modified_app (self->runtime);
+          const char *usr = pv_runtime_get_modified_usr (self->runtime);
 
           flatpak_bwrap_add_args (flatpak_subsandbox,
                                   "--app-path", app == NULL ? "" : app,
@@ -726,10 +721,10 @@ main (int argc,
       g_assert (!self->is_flatpak_env);
       g_assert (bwrap != NULL);
       g_assert (bwrap_filesystem_arguments != NULL);
-      g_assert (exports != NULL);
+      g_assert (self->exports != NULL);
 
       if (!pv_wrap_use_host_os (_srt_sysroot_get_fd (real_root),
-                                exports, bwrap_filesystem_arguments,
+                                self->exports, bwrap_filesystem_arguments,
                                 cmp, error))
         goto out;
     }
@@ -739,9 +734,9 @@ main (int argc,
    * so that it can be overridden by --filesystem=/home or
    * pv_wrap_use_home(), and so that it is sorted correctly with
    * respect to all the other home-directory-related exports. */
-  if (exports != NULL
+  if (self->exports != NULL
       && g_file_test ("/home", G_FILE_TEST_EXISTS))
-    pv_exports_mask_or_log (exports, "/home");
+    pv_exports_mask_or_log (self->exports, "/home");
 
   g_debug ("Making home directory available...");
 
@@ -766,12 +761,12 @@ main (int argc,
       g_assert (!self->is_flatpak_env);
       g_assert (bwrap != NULL);
       g_assert (bwrap_filesystem_arguments != NULL);
-      g_assert (exports != NULL);
+      g_assert (self->exports != NULL);
 
       bwrap_home_arguments = flatpak_bwrap_new (flatpak_bwrap_empty_env);
 
-      if (!pv_wrap_use_home (home_mode, home, private_home,
-                             exports, bwrap_home_arguments, container_env,
+      if (!pv_wrap_use_home (home_mode, self->current_home, private_home,
+                             self->exports, bwrap_home_arguments, container_env,
                              error))
         goto out;
     }
@@ -793,8 +788,8 @@ main (int argc,
         }
     }
 
-  if (exports != NULL)
-    pv_share_temp_dir (exports, container_env);
+  if (self->exports != NULL)
+    pv_share_temp_dir (self->exports, container_env);
 
   if (flatpak_subsandbox != NULL)
     {
@@ -821,9 +816,6 @@ main (int argc,
 
   adverb_preload_argv = g_ptr_array_new_with_free_func (g_free);
 
-  if (self->options.remove_game_overlay)
-    append_preload_flags |= PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY;
-
   /* We need the LD_PRELOADs from Steam visible at the paths that were
    * used for them, which might be their physical rather than logical
    * locations. Steam doesn't generally use LD_AUDIT, but the Steam app
@@ -842,19 +834,16 @@ main (int argc,
 
           g_assert (module->which >= 0);
           g_assert (module->which < G_N_ELEMENTS (pv_preload_variables));
-          pv_wrap_append_preload (adverb_preload_argv,
+          pv_wrap_append_preload (self,
+                                  adverb_preload_argv,
                                   module->which,
                                   module->preload,
-                                  environ,
-                                  append_preload_flags,
-                                  runtime,
-                                  exports);
+                                  append_preload_flags);
         }
     }
   while (0);
 
-  pv_bind_and_propagate_from_environ (self, real_root, home_mode,
-                                      exports, container_env);
+  pv_bind_and_propagate_from_environ (self, home_mode, container_env);
 
   if (flatpak_subsandbox == NULL)
     {
@@ -862,27 +851,27 @@ main (int argc,
 
       g_assert (bwrap != NULL);
       g_assert (bwrap_filesystem_arguments != NULL);
-      g_assert (exports != NULL);
+      g_assert (self->exports != NULL);
 
       /* Bind-mount /run/udev to support games that detect joysticks by using
        * udev directly. We only do that when the host's version of libudev.so.1
        * is in use, because there is no guarantees that the container's libudev
        * is compatible with the host's udevd. */
-      if (runtime != NULL)
+      if (self->runtime != NULL)
         {
           for (i = 0; i < PV_N_SUPPORTED_ARCHITECTURES; i++)
             {
               GStatBuf ignored;
               g_autofree gchar *override = NULL;
 
-              override = g_build_filename (pv_runtime_get_overrides (runtime),
+              override = g_build_filename (pv_runtime_get_overrides (self->runtime),
                                            "lib", pv_multiarch_tuples[i],
                                            "libudev.so.1", NULL);
 
               if (g_lstat (override, &ignored) == 0)
                 {
                   g_debug ("We are using the host's version of \"libudev.so.1\", trying to bind-mount /run/udev too...");
-                  pv_exports_expose_or_log (exports,
+                  pv_exports_expose_or_log (self->exports,
                                             FLATPAK_FILESYSTEM_MODE_READ_ONLY,
                                             "/run/udev");
                   break;
@@ -900,7 +889,7 @@ main (int argc,
             g_warning ("Not sharing %s with container to work around %s",
                        framework_paths->path, framework_paths->bug);
           else
-            pv_exports_expose_or_log (exports,
+            pv_exports_expose_or_log (self->exports,
                                       FLATPAK_FILESYSTEM_MODE_READ_ONLY,
                                       framework_paths->path);
         }
@@ -912,7 +901,7 @@ main (int argc,
           g_debug ("Processing --filesystem arguments...");
 
           for (i = 0; self->options.filesystems[i] != NULL; i++)
-            pv_wrap_context_export_if_allowed (self, exports,
+            pv_wrap_context_export_if_allowed (self,
                                                FLATPAK_FILESYSTEM_MODE_READ_WRITE,
                                                self->options.filesystems[i],
                                                self->options.filesystems[i],
@@ -926,7 +915,7 @@ main (int argc,
 
       cwd_p_host = pv_current_namespace_path_to_host_path (cwd_p);
 
-      if (_srt_is_same_file (home, cwd_p))
+      if (_srt_is_same_file (self->current_home, cwd_p))
         {
           g_info ("Not making physical working directory \"%s\" available to "
                   "container because it is the home directory",
@@ -941,7 +930,7 @@ main (int argc,
            * current namespace as well as in the host, because it's
            * either in our ~/.var/app/$FLATPAK_ID, or a --filesystem that
            * was exposed from the host. */
-          pv_exports_expose_or_warn (exports,
+          pv_exports_expose_or_warn (self->exports,
                                      FLATPAK_FILESYSTEM_MODE_READ_WRITE,
                                      cwd_p_host);
         }
@@ -961,7 +950,7 @@ main (int argc,
 
   /* Put Steam Runtime environment variables back, if /usr is mounted
    * from the host. */
-  if (runtime == NULL)
+  if (self->runtime == NULL)
     {
       g_debug ("Making Steam Runtime available...");
 
@@ -977,10 +966,10 @@ main (int argc,
 
               /* $STEAM_RUNTIME is functionally necessary if used, so
                * always warn if it cannot be exposed */
-              if (exports != NULL
+              if (self->exports != NULL
                   && g_str_has_prefix (self->options.env_if_host[i],
                                        "STEAM_RUNTIME=/"))
-                pv_exports_expose_or_warn (exports,
+                pv_exports_expose_or_warn (self->exports,
                                            FLATPAK_FILESYSTEM_MODE_READ_ONLY,
                                            equals + 1);
 
@@ -995,7 +984,7 @@ main (int argc,
     }
 
   /* Convert the exported directories into extra bubblewrap arguments */
-  if (exports != NULL)
+  if (self->exports != NULL)
     {
       g_autoptr(FlatpakBwrap) exports_bwrap =
         flatpak_bwrap_new (flatpak_bwrap_empty_env);
@@ -1014,9 +1003,10 @@ main (int argc,
           g_clear_pointer (&bwrap_home_arguments, flatpak_bwrap_free);
         }
 
-      flatpak_exports_append_bwrap_args (exports, exports_bwrap);
+      flatpak_exports_append_bwrap_args (self->exports, exports_bwrap);
       g_warn_if_fail (g_strv_length (exports_bwrap->envp) == 0);
-      if (!pv_bwrap_append_adjusted_exports (bwrap, exports_bwrap, home,
+      if (!pv_bwrap_append_adjusted_exports (bwrap, exports_bwrap,
+                                             self->current_home,
                                              interpreter_root, workarounds,
                                              error))
         goto out;
@@ -1035,11 +1025,12 @@ main (int argc,
 
       sharing_bwrap = pv_wrap_share_sockets (container_env,
                                              _srt_const_strv (self->original_environ),
-                                             (runtime != NULL),
+                                             (self->runtime != NULL),
                                              self->is_flatpak_env);
       g_warn_if_fail (g_strv_length (sharing_bwrap->envp) == 0);
 
-      if (!pv_bwrap_append_adjusted_exports (bwrap, sharing_bwrap, home,
+      if (!pv_bwrap_append_adjusted_exports (bwrap, sharing_bwrap,
+                                             self->current_home,
                                              interpreter_root, workarounds,
                                              error))
         goto out;
@@ -1049,9 +1040,9 @@ main (int argc,
       pv_wrap_set_icons_env_vars (container_env, _srt_const_strv (self->original_environ));
     }
 
-  if (runtime != NULL)
+  if (self->runtime != NULL)
     {
-      if (!pv_runtime_use_shared_sockets (runtime, bwrap, container_env,
+      if (!pv_runtime_use_shared_sockets (self->runtime, bwrap, container_env,
                                           error))
         goto out;
     }
@@ -1143,11 +1134,11 @@ main (int argc,
 
       adverb_argv = flatpak_bwrap_new (flatpak_bwrap_empty_env);
 
-      if (runtime != NULL)
+      if (self->runtime != NULL)
         {
           /* This includes the arguments necessary to regenerate the
            * ld.so cache */
-          if (!pv_runtime_get_adverb (runtime, adverb_argv, error))
+          if (!pv_runtime_get_adverb (self->runtime, adverb_argv, error))
             goto out;
         }
       else
@@ -1338,11 +1329,11 @@ main (int argc,
 
   if (_srt_util_is_debugging ())
     {
-      if (runtime != NULL && (pv_log_flags & PV_WRAP_LOG_FLAGS_OVERRIDES))
-        pv_runtime_log_overrides (runtime);
+      if (self->runtime != NULL && (pv_log_flags & PV_WRAP_LOG_FLAGS_OVERRIDES))
+        pv_runtime_log_overrides (self->runtime);
 
-      if (runtime != NULL && (pv_log_flags & PV_WRAP_LOG_FLAGS_CONTAINER))
-        pv_runtime_log_container (runtime);
+      if (self->runtime != NULL && (pv_log_flags & PV_WRAP_LOG_FLAGS_CONTAINER))
+        pv_runtime_log_container (self->runtime);
 
       g_debug ("Final command to execute:");
 
@@ -1366,8 +1357,8 @@ main (int argc,
     }
 
   /* Clean up temporary directory before running our long-running process */
-  if (runtime != NULL)
-    pv_runtime_cleanup (runtime);
+  if (self->runtime != NULL)
+    pv_runtime_cleanup (self->runtime);
 
   flatpak_bwrap_finish (final_argv);
 
diff --git a/tests/pressure-vessel/wrap-setup.c b/tests/pressure-vessel/wrap-setup.c
index c238b8af06900e43ec96e1a75602aba15b34726b..0dfada91955d445b01be26a559cd48076dcad146 100644
--- a/tests/pressure-vessel/wrap-setup.c
+++ b/tests/pressure-vessel/wrap-setup.c
@@ -83,7 +83,6 @@ typedef struct
   gchar *tmpdir;
   gchar *mock_runtime;
   gchar *var;
-  GStrv env;
   int tmpdir_fd;
   int mock_runtime_fd;
   int var_fd;
@@ -172,25 +171,26 @@ fixture_populate_dir (Fixture *f,
     }
 }
 
-static FlatpakExports *
+static void
 fixture_create_exports (Fixture *f)
 {
-  g_autoptr(FlatpakExports) exports = flatpak_exports_new ();
   glnx_autofd int fd = open_or_die (f->mock_host->path, O_RDONLY | O_DIRECTORY, 0755);
 
-  flatpak_exports_take_host_fd (exports, g_steal_fd (&fd));
-  return g_steal_pointer (&exports);
+  g_return_if_fail (f->context->exports == NULL);
+  f->context->exports = flatpak_exports_new ();
+  flatpak_exports_take_host_fd (f->context->exports, g_steal_fd (&fd));
 }
 
-static PvRuntime *
+static void
 fixture_create_runtime (Fixture *f,
                         PvRuntimeFlags flags)
 {
   g_autoptr(GError) local_error = NULL;
   g_autoptr(PvGraphicsProvider) graphics_provider = NULL;
-  g_autoptr(PvRuntime) runtime = NULL;
   const char *gfx_in_container;
 
+  g_assert_null (f->context->runtime);
+
   if (flags & PV_RUNTIME_FLAGS_FLATPAK_SUBSANDBOX)
     gfx_in_container = "/run/parent";
   else
@@ -201,20 +201,19 @@ fixture_create_runtime (Fixture *f,
   g_assert_no_error (local_error);
   g_assert_nonnull (graphics_provider);
 
-  runtime = pv_runtime_new (f->mock_runtime,
-                            f->var,
-                            NULL,
-                            graphics_provider,
-                            NULL,
-                            _srt_peek_environ_nonnull (),
-                            (flags
-                             | PV_RUNTIME_FLAGS_VERBOSE
-                             | PV_RUNTIME_FLAGS_SINGLE_THREAD),
-                            PV_WORKAROUND_FLAGS_NONE,
-                            &local_error);
+  f->context->runtime = pv_runtime_new (f->mock_runtime,
+                                        f->var,
+                                        NULL,
+                                        graphics_provider,
+                                        NULL,
+                                        _srt_peek_environ_nonnull (),
+                                        (flags
+                                         | PV_RUNTIME_FLAGS_VERBOSE
+                                         | PV_RUNTIME_FLAGS_SINGLE_THREAD),
+                                        PV_WORKAROUND_FLAGS_NONE,
+                                        &local_error);
   g_assert_no_error (local_error);
-  g_assert_nonnull (runtime);
-  return g_steal_pointer (&runtime);
+  g_assert_nonnull (f->context->runtime);
 }
 
 static void
@@ -243,10 +242,16 @@ setup (Fixture *f,
   glnx_opendirat (AT_FDCWD, f->var, TRUE, &f->var_fd, &local_error);
   g_assert_no_error (local_error);
 
-  f->context = pv_wrap_context_new (&local_error);
+  f->context = pv_wrap_context_new (f->mock_host, "/home/me", &local_error);
   g_assert_no_error (local_error);
   f->bwrap = flatpak_bwrap_new (flatpak_bwrap_empty_env);
-  f->env = g_get_environ ();
+
+  /* Some tests need to know where Steam is installed;
+   * pretend that we have it installed in /steam */
+  f->context->original_environ = g_environ_setenv (f->context->original_environ,
+                                                   "STEAM_COMPAT_CLIENT_INSTALL_PATH",
+                                                   "/steam",
+                                                   TRUE);
 }
 
 static void
@@ -285,9 +290,6 @@ setup_ld_preload (Fixture *f,
       fixture_populate_dir (f, f->mock_host->fd, touch_i386, G_N_ELEMENTS (touch_i386));
 #endif
     }
-
-  f->env = g_environ_setenv (f->env, "STEAM_COMPAT_CLIENT_INSTALL_PATH",
-                             "/steam", TRUE);
 }
 
 static void
@@ -311,7 +313,6 @@ teardown (Fixture *f,
   g_clear_pointer (&f->mock_runtime, g_free);
   g_clear_pointer (&f->tmpdir, g_free);
   g_clear_pointer (&f->var, g_free);
-  g_clear_pointer (&f->env, g_strfreev);
   g_clear_pointer (&f->bwrap, flatpak_bwrap_free);
 
   tests_check_fd_leaks_leave (f->old_fds);
@@ -376,15 +377,15 @@ test_bind_into_container (Fixture *f,
                           gconstpointer context)
 {
   const Config *config = context;
-  g_autoptr(PvRuntime) runtime = NULL;
   g_autoptr(GError) error = NULL;
   gboolean ok;
 
-  runtime = fixture_create_runtime (f, config->runtime_flags);
+  fixture_create_runtime (f, config->runtime_flags);
+  g_assert_nonnull (f->context->runtime);
 
   /* Successful cases */
 
-  ok = pv_runtime_bind_into_container (runtime, f->bwrap,
+  ok = pv_runtime_bind_into_container (f->context->runtime, f->bwrap,
                                        "/etc/machine-id", NULL, 0,
                                        "/etc/machine-id",
                                        PV_RUNTIME_EMULATION_ROOTS_BOTH,
@@ -392,7 +393,7 @@ test_bind_into_container (Fixture *f,
   g_assert_no_error (error);
   g_assert_true (ok);
 
-  ok = pv_runtime_bind_into_container (runtime, f->bwrap,
+  ok = pv_runtime_bind_into_container (f->context->runtime, f->bwrap,
                                        "/etc/arm-file", NULL, 0,
                                        "/etc/arm-file",
                                        PV_RUNTIME_EMULATION_ROOTS_REAL_ONLY,
@@ -400,7 +401,7 @@ test_bind_into_container (Fixture *f,
   g_assert_no_error (error);
   g_assert_true (ok);
 
-  ok = pv_runtime_bind_into_container (runtime, f->bwrap,
+  ok = pv_runtime_bind_into_container (f->context->runtime, f->bwrap,
                                        "/fex/etc/x86-file", NULL, 0,
                                        "/etc/x86-file",
                                        PV_RUNTIME_EMULATION_ROOTS_INTERPRETER_ONLY,
@@ -410,7 +411,7 @@ test_bind_into_container (Fixture *f,
 
   /* Error cases */
 
-  ok = pv_runtime_bind_into_container (runtime, f->bwrap,
+  ok = pv_runtime_bind_into_container (f->context->runtime, f->bwrap,
                                        "/nope", NULL, 0,
                                        "/nope",
                                        PV_RUNTIME_EMULATION_ROOTS_REAL_ONLY,
@@ -420,7 +421,7 @@ test_bind_into_container (Fixture *f,
   g_test_message ("Editing /nope not allowed, as expected: %s", error->message);
   g_clear_error (&error);
 
-  ok = pv_runtime_bind_into_container (runtime, f->bwrap,
+  ok = pv_runtime_bind_into_container (f->context->runtime, f->bwrap,
                                        "/usr/foo", NULL, 0,
                                        "/usr/foo",
                                        PV_RUNTIME_EMULATION_ROOTS_BOTH,
@@ -617,18 +618,20 @@ test_export_root_dirs (Fixture *f,
     "usr/local/",
     "var/tmp/",
   };
-  g_autoptr(FlatpakExports) exports = fixture_create_exports (f);
   g_autoptr(GError) local_error = NULL;
   gboolean ret;
 
+  fixture_create_exports (f);
+  g_assert_nonnull (f->context->exports);
   fixture_populate_dir (f, f->mock_host->fd, paths, G_N_ELEMENTS (paths));
-  ret = pv_export_root_dirs_like_filesystem_host (f->mock_host->fd, exports,
+  ret = pv_export_root_dirs_like_filesystem_host (f->mock_host->fd,
+                                                  f->context->exports,
                                                   FLATPAK_FILESYSTEM_MODE_READ_WRITE,
                                                   _srt_dirent_strcmp,
                                                   &local_error);
   g_assert_no_error (local_error);
   g_assert_true (ret);
-  flatpak_exports_append_bwrap_args (exports, f->bwrap);
+  flatpak_exports_append_bwrap_args (f->context->exports, f->bwrap);
 
   dump_bwrap (f->bwrap);
 
@@ -1021,12 +1024,12 @@ test_make_symlink_in_container (Fixture *f,
 {
   const Config *config = context;
   g_autoptr(GError) error = NULL;
-  g_autoptr(PvRuntime) runtime = NULL;
   gboolean ok;
   SrtSysroot *mutable_sysroot;
 
-  runtime = fixture_create_runtime (f, config->runtime_flags);
-  mutable_sysroot = pv_runtime_get_mutable_sysroot (runtime);
+  fixture_create_runtime (f, config->runtime_flags);
+  g_assert_nonnull (f->context->runtime);
+  mutable_sysroot = pv_runtime_get_mutable_sysroot (f->context->runtime);
 
   if (config->runtime_flags & PV_RUNTIME_FLAGS_COPY_RUNTIME)
     g_assert_nonnull (mutable_sysroot);
@@ -1035,7 +1038,7 @@ test_make_symlink_in_container (Fixture *f,
 
   /* Successful cases */
 
-  ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap,
+  ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap,
                                              "../usr/lib/os-release",
                                              "/etc/os-release",
                                              PV_RUNTIME_EMULATION_ROOTS_BOTH,
@@ -1043,7 +1046,7 @@ test_make_symlink_in_container (Fixture *f,
   g_assert_no_error (error);
   g_assert_true (ok);
 
-  ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap,
+  ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap,
                                              "/run/host/foo",
                                              "/var/foo",
                                              PV_RUNTIME_EMULATION_ROOTS_REAL_ONLY,
@@ -1051,7 +1054,7 @@ test_make_symlink_in_container (Fixture *f,
   g_assert_no_error (error);
   g_assert_true (ok);
 
-  ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap,
+  ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap,
                                              "/run/x86/bar",
                                              "/var/bar",
                                              PV_RUNTIME_EMULATION_ROOTS_INTERPRETER_ONLY,
@@ -1061,7 +1064,7 @@ test_make_symlink_in_container (Fixture *f,
 
   /* Conditionally OK, if there is an on-disk directory we can edit */
 
-  ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap,
+  ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap,
                                              "/run/host/foo",
                                              "/usr/foo",
                                              PV_RUNTIME_EMULATION_ROOTS_REAL_ONLY,
@@ -1090,7 +1093,7 @@ test_make_symlink_in_container (Fixture *f,
 
     }
 
-  ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap,
+  ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap,
                                              "/run/x86/bar",
                                              "/usr/bar",
                                              PV_RUNTIME_EMULATION_ROOTS_INTERPRETER_ONLY,
@@ -1110,7 +1113,7 @@ test_make_symlink_in_container (Fixture *f,
       g_assert_true (ok);
     }
 
-  ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap,
+  ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap,
                                              "/run/baz",
                                              "/usr/baz",
                                              PV_RUNTIME_EMULATION_ROOTS_BOTH,
@@ -1140,7 +1143,7 @@ test_make_symlink_in_container (Fixture *f,
 
   /* Error cases */
 
-  ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap,
+  ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap,
                                              "/nope",
                                              "/nope",
                                              PV_RUNTIME_EMULATION_ROOTS_REAL_ONLY,
@@ -1554,9 +1557,7 @@ test_passwd (Fixture *f,
 static void
 populate_ld_preload (Fixture *f,
                      GPtrArray *argv,
-                     PvAppendPreloadFlags flags,
-                     PvRuntime *runtime,
-                     FlatpakExports *exports)
+                     PvAppendPreloadFlags flags)
 {
   static const struct
   {
@@ -1589,6 +1590,11 @@ populate_ld_preload (Fixture *f,
   };
   gsize i;
 
+  if (flags & PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX)
+    g_assert_null (f->context->exports);
+  else
+    g_assert_nonnull (f->context->exports);
+
   for (i = 0; i < G_N_ELEMENTS (preloads); i++)
     {
       GLogLevelFlags old_fatal_mask = G_LOG_FATAL_MASK;
@@ -1611,13 +1617,11 @@ populate_ld_preload (Fixture *f,
                                  preloads[i].warning);
         }
 
-      pv_wrap_append_preload (argv,
+      pv_wrap_append_preload (f->context,
+                              argv,
                               PV_PRELOAD_VARIABLE_INDEX_LD_PRELOAD,
                               preloads[i].string,
-                              f->env,
-                              flags | PV_APPEND_PRELOAD_FLAGS_IN_UNIT_TESTS,
-                              runtime,
-                              exports);
+                              flags | PV_APPEND_PRELOAD_FLAGS_IN_UNIT_TESTS);
 
       /* If we modified the fatal mask, put back the old value. */
       if (preloads[i].warning != NULL)
@@ -1694,10 +1698,9 @@ test_remap_ld_preload (Fixture *f,
                        gconstpointer context)
 {
   const Config *config = context;
-  g_autoptr(FlatpakExports) exports = fixture_create_exports (f);
+  FlatpakExports *exports;
   g_autoptr(GPtrArray) argv = g_ptr_array_new_with_free_func (g_free);
   g_autoptr(GPtrArray) filtered = filter_expected_paths (config);
-  g_autoptr(PvRuntime) runtime = fixture_create_runtime (f, PV_RUNTIME_FLAGS_NONE);
   gsize i;
   gboolean expect_i386 = FALSE;
 
@@ -1706,7 +1709,13 @@ test_remap_ld_preload (Fixture *f,
     expect_i386 = TRUE;
 #endif
 
-  populate_ld_preload (f, argv, config->preload_flags, runtime, exports);
+  fixture_create_exports (f);
+  exports = f->context->exports;
+  g_assert_nonnull (exports);
+
+  fixture_create_runtime (f, PV_RUNTIME_FLAGS_NONE);
+  g_assert_nonnull (f->context->runtime);
+  populate_ld_preload (f, argv, config->preload_flags);
 
   g_assert_cmpuint (argv->len, ==, filtered->len);
 
@@ -1786,13 +1795,13 @@ test_remap_ld_preload_flatpak (Fixture *f,
   const Config *config = context;
   g_autoptr(GPtrArray) argv = g_ptr_array_new_with_free_func (g_free);
   g_autoptr(GPtrArray) filtered = filter_expected_paths (config);
-  g_autoptr(PvRuntime) runtime = fixture_create_runtime (f, PV_RUNTIME_FLAGS_FLATPAK_SUBSANDBOX);
   gsize i;
 
+  fixture_create_runtime (f, PV_RUNTIME_FLAGS_FLATPAK_SUBSANDBOX);
+  g_assert_nonnull (f->context->runtime);
   populate_ld_preload (f, argv,
                        (config->preload_flags
-                        | PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX),
-                       runtime, NULL);
+                        | PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX));
 
   g_assert_cmpuint (argv->len, ==, filtered->len);
 
@@ -1818,8 +1827,7 @@ test_remap_ld_preload_flatpak (Fixture *f,
 
 /*
  * In addition to testing the rare case where there's no runtime,
- * this one also exercises PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY,
- * which is the implementation of --remove-game-overlay.
+ * this one also exercises --remove-game-overlay.
  */
 static void
 test_remap_ld_preload_no_runtime (Fixture *f,
@@ -1828,19 +1836,23 @@ test_remap_ld_preload_no_runtime (Fixture *f,
   const Config *config = context;
   g_autoptr(GPtrArray) argv = g_ptr_array_new_with_free_func (g_free);
   g_autoptr(GPtrArray) filtered = filter_expected_paths (config);
-  g_autoptr(FlatpakExports) exports = fixture_create_exports (f);
+  FlatpakExports *exports;
   gsize i, j;
   gboolean expect_i386 = FALSE;
 
+  f->context->options.remove_game_overlay = TRUE;
+
 #if defined(__i386__) || defined(__x86_64__)
   if (!(config->preload_flags & PV_APPEND_PRELOAD_FLAGS_ONE_ARCHITECTURE))
     expect_i386 = TRUE;
 #endif
 
-  populate_ld_preload (f, argv,
-                       (config->preload_flags
-                        | PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY),
-                       NULL, exports);
+  fixture_create_exports (f);
+  exports = f->context->exports;
+  g_assert_nonnull (exports);
+
+  g_assert_null (f->context->runtime);
+  populate_ld_preload (f, argv, config->preload_flags);
 
   g_assert_cmpuint (argv->len, ==, filtered->len - 1);
 
@@ -1853,7 +1865,7 @@ test_remap_ld_preload_no_runtime (Fixture *f,
       argument += strlen("--ld-preload=");
 
       /* /steam/lib/gameoverlayrenderer.so is missing because we used the
-       * REMOVE_GAME_OVERLAY flag */
+       * equivalent of --remove-game-overlay */
       if (g_str_has_suffix (expected, "/gameoverlayrenderer.so"))
         {
           /* We expect to skip only one element */
@@ -1920,10 +1932,10 @@ test_remap_ld_preload_flatpak_no_runtime (Fixture *f,
   g_autoptr(GPtrArray) filtered = filter_expected_paths (config);
   gsize i;
 
+  g_assert_null (f->context->runtime);
   populate_ld_preload (f, argv,
                        (config->preload_flags
-                        | PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX),
-                       NULL, NULL);
+                        | PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX));
 
   g_assert_cmpuint (argv->len, ==, filtered->len);
 
@@ -2065,13 +2077,17 @@ test_use_home_shared (Fixture *f,
     NULL
   };
   g_autoptr(FlatpakBwrap) env_bwrap = NULL;
-  g_autoptr(FlatpakExports) exports = fixture_create_exports (f);
-  g_autoptr(FlatpakExports) env_exports = fixture_create_exports (f);
+  FlatpakExports *exports;
+  FlatpakExports *env_exports;
   g_autoptr(GError) local_error = NULL;
   g_autoptr(SrtEnvOverlay) container_env = _srt_env_overlay_new ();
   GLogLevelFlags was_fatal;
   gboolean ret;
 
+  fixture_create_exports (f);
+  exports = f->context->exports;
+  g_assert_nonnull (exports);
+
   fixture_populate_dir (f, f->mock_host->fd, paths, G_N_ELEMENTS (paths));
   ret = pv_wrap_use_home (PV_HOME_MODE_SHARED, "/home/user", NULL, exports,
                           f->bwrap, container_env, &local_error);
@@ -2138,12 +2154,17 @@ test_use_home_shared (Fixture *f,
   g_clear_pointer (&f->context->original_environ, g_strfreev);
   f->context->original_environ = _srt_strdupv (mock_environ);
 
+  g_clear_pointer (&f->context->exports, flatpak_exports_free);
+  exports = NULL;
+
+  fixture_create_exports (f);
+  env_exports = f->context->exports;
+  g_assert_nonnull (env_exports);
+
   /* Don't crash on warnings here */
   was_fatal = g_log_set_always_fatal (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
   pv_bind_and_propagate_from_environ (f->context,
-                                      f->mock_host,
                                       PV_HOME_MODE_SHARED,
-                                      env_exports,
                                       container_env);
   g_log_set_always_fatal (was_fatal);
 
@@ -2210,16 +2231,17 @@ test_use_host_os (Fixture *f,
     "usr/local/",
     "var/tmp/",
   };
-  g_autoptr(FlatpakExports) exports = fixture_create_exports (f);
   g_autoptr(GError) local_error = NULL;
   gboolean ret;
 
+  fixture_create_exports (f);
+  g_assert_nonnull (f->context->exports);
   fixture_populate_dir (f, f->mock_host->fd, paths, G_N_ELEMENTS (paths));
-  ret = pv_wrap_use_host_os (f->mock_host->fd, exports, f->bwrap,
+  ret = pv_wrap_use_host_os (f->mock_host->fd, f->context->exports, f->bwrap,
                              _srt_dirent_strcmp, &local_error);
   g_assert_no_error (local_error);
   g_assert_true (ret);
-  flatpak_exports_append_bwrap_args (exports, f->bwrap);
+  flatpak_exports_append_bwrap_args (f->context->exports, f->bwrap);
 
   dump_bwrap (f->bwrap);