refactor: cleanup for creating worker structs (#25933)

7 files changed, 229 insertions, 197 deletions

diff --git a/cli/factory.rs b/cli/factory.rs
index 5e525ee32..770aeefa1 100644
--- a/cli/factory.rs
+++ b/cli/factory.rs
@@ -782,6 +782,7 @@ impl CliFactory {
     let npm_resolver = self.npm_resolver().await?;
     let fs = self.fs();
     let cli_node_resolver = self.cli_node_resolver().await?;
+    let cli_npm_resolver = self.npm_resolver().await?.clone();
     let maybe_file_watcher_communicator = if cli_options.has_hmr() {
       Some(self.watcher_communicator.clone().unwrap())
     } else {
@@ -811,6 +812,7 @@ impl CliFactory {
         self.main_module_graph_container().await?.clone(),
         self.module_load_preparer().await?.clone(),
         cli_node_resolver.clone(),
+        cli_npm_resolver.clone(),
         NpmModuleLoader::new(
           self.cjs_resolutions().clone(),
           self.node_code_translator().await?.clone(),
diff --git a/cli/module_loader.rs b/cli/module_loader.rs
index f4e219bea..293f41dda 100644
--- a/cli/module_loader.rs
+++ b/cli/module_loader.rs
@@ -23,6 +23,7 @@ use crate::graph_container::ModuleGraphUpdatePermit;
 use crate::graph_util::CreateGraphOptions;
 use crate::graph_util::ModuleGraphBuilder;
 use crate::node;
+use crate::npm::CliNpmResolver;
 use crate::resolver::CliGraphResolver;
 use crate::resolver::CliNodeResolver;
 use crate::resolver::ModuleCodeStringSource;
@@ -203,6 +204,7 @@ struct SharedCliModuleLoaderState {
   main_module_graph_container: Arc<MainModuleGraphContainer>,
   module_load_preparer: Arc<ModuleLoadPreparer>,
   node_resolver: Arc<CliNodeResolver>,
+  npm_resolver: Arc<dyn CliNpmResolver>,
   npm_module_loader: NpmModuleLoader,
   parsed_source_cache: Arc<ParsedSourceCache>,
   resolver: Arc<CliGraphResolver>,
@@ -221,6 +223,7 @@ impl CliModuleLoaderFactory {
     main_module_graph_container: Arc<MainModuleGraphContainer>,
     module_load_preparer: Arc<ModuleLoadPreparer>,
     node_resolver: Arc<CliNodeResolver>,
+    npm_resolver: Arc<dyn CliNpmResolver>,
     npm_module_loader: NpmModuleLoader,
     parsed_source_cache: Arc<ParsedSourceCache>,
     resolver: Arc<CliGraphResolver>,
@@ -241,6 +244,7 @@ impl CliModuleLoaderFactory {
         main_module_graph_container,
         module_load_preparer,
         node_resolver,
+        npm_resolver,
         npm_module_loader,
         parsed_source_cache,
         resolver,
@@ -478,7 +482,6 @@ impl<TGraphContainer: ModuleGraphContainer>
       Some(Module::Npm(module)) => {
         let package_folder = self
           .shared
-          .node_resolver
           .npm_resolver
           .as_managed()
           .unwrap() // byonm won't create a Module::Npm
diff --git a/cli/resolver.rs b/cli/resolver.rs
index d6e14c39d..211f8aba1 100644
--- a/cli/resolver.rs
+++ b/cli/resolver.rs
@@ -66,8 +66,7 @@ pub struct CliNodeResolver {
   cjs_resolutions: Arc<CjsResolutionStore>,
   fs: Arc<dyn deno_fs::FileSystem>,
   node_resolver: Arc<NodeResolver>,
-  // todo(dsherret): remove this pub(crate)
-  pub(crate) npm_resolver: Arc<dyn CliNpmResolver>,
+  npm_resolver: Arc<dyn CliNpmResolver>,
 }
 
 impl CliNodeResolver {
diff --git a/cli/worker.rs b/cli/worker.rs
index c355d18bd..71bdfd661 100644
--- a/cli/worker.rs
+++ b/cli/worker.rs
@@ -34,8 +34,10 @@ use deno_runtime::ops::worker_host::CreateWebWorkerCb;
 use deno_runtime::permissions::RuntimePermissionDescriptorParser;
 use deno_runtime::web_worker::WebWorker;
 use deno_runtime::web_worker::WebWorkerOptions;
+use deno_runtime::web_worker::WebWorkerServiceOptions;
 use deno_runtime::worker::MainWorker;
 use deno_runtime::worker::WorkerOptions;
+use deno_runtime::worker::WorkerServiceOptions;
 use deno_runtime::BootstrapOptions;
 use deno_runtime::WorkerExecutionMode;
 use deno_runtime::WorkerLogLevel;
@@ -570,6 +572,23 @@ impl CliMainWorkerFactory {
       }
     }
 
+    let services = WorkerServiceOptions {
+      root_cert_store_provider: Some(shared.root_cert_store_provider.clone()),
+      module_loader,
+      fs: shared.fs.clone(),
+      node_services: Some(shared.create_node_init_services()),
+      npm_process_state_provider: Some(shared.npm_process_state_provider()),
+      blob_store: shared.blob_store.clone(),
+      broadcast_channel: shared.broadcast_channel.clone(),
+      shared_array_buffer_store: Some(shared.shared_array_buffer_store.clone()),
+      compiled_wasm_module_store: Some(
+        shared.compiled_wasm_module_store.clone(),
+      ),
+      feature_checker,
+      permissions,
+      permission_desc_parser: shared.permission_desc_parser.clone(),
+      v8_code_cache: shared.code_cache.clone(),
+    };
     let options = WorkerOptions {
       bootstrap: BootstrapOptions {
         deno_version: crate::version::DENO_VERSION_INFO.deno.to_string(),
@@ -604,7 +623,6 @@ impl CliMainWorkerFactory {
         .options
         .unsafely_ignore_certificate_errors
         .clone(),
-      root_cert_store_provider: Some(shared.root_cert_store_provider.clone()),
       seed: shared.options.seed,
       format_js_error_fn: Some(Arc::new(format_js_error)),
       create_web_worker_cb,
@@ -612,29 +630,16 @@ impl CliMainWorkerFactory {
       should_break_on_first_statement: shared.options.inspect_brk,
       should_wait_for_inspector_session: shared.options.inspect_wait,
       strace_ops: shared.options.strace_ops.clone(),
-      module_loader,
-      fs: shared.fs.clone(),
-      node_services: Some(shared.create_node_init_services()),
-      npm_process_state_provider: Some(shared.npm_process_state_provider()),
       get_error_class_fn: Some(&errors::get_error_class_name),
       cache_storage_dir,
       origin_storage_dir,
-      blob_store: shared.blob_store.clone(),
-      broadcast_channel: shared.broadcast_channel.clone(),
-      shared_array_buffer_store: Some(shared.shared_array_buffer_store.clone()),
-      compiled_wasm_module_store: Some(
-        shared.compiled_wasm_module_store.clone(),
-      ),
       stdio,
-      feature_checker,
-      permission_desc_parser: shared.permission_desc_parser.clone(),
       skip_op_registration: shared.options.skip_op_registration,
-      v8_code_cache: shared.code_cache.clone(),
     };
 
     let mut worker = MainWorker::bootstrap_from_options(
       main_module.clone(),
-      permissions,
+      services,
       options,
     );
 
@@ -766,7 +771,27 @@ fn create_web_worker_callback(
       }
     }
 
+    let services = WebWorkerServiceOptions {
+      root_cert_store_provider: Some(shared.root_cert_store_provider.clone()),
+      module_loader,
+      fs: shared.fs.clone(),
+      node_services: Some(shared.create_node_init_services()),
+      blob_store: shared.blob_store.clone(),
+      broadcast_channel: shared.broadcast_channel.clone(),
+      shared_array_buffer_store: Some(shared.shared_array_buffer_store.clone()),
+      compiled_wasm_module_store: Some(
+        shared.compiled_wasm_module_store.clone(),
+      ),
+      maybe_inspector_server,
+      feature_checker,
+      permission_desc_parser: shared.permission_desc_parser.clone(),
+      npm_process_state_provider: Some(shared.npm_process_state_provider()),
+      permissions: args.permissions,
+    };
     let options = WebWorkerOptions {
+      name: args.name,
+      main_module: args.main_module.clone(),
+      worker_id: args.worker_id,
       bootstrap: BootstrapOptions {
         deno_version: crate::version::DENO_VERSION_INFO.deno.to_string(),
         args: shared.options.argv.clone(),
@@ -777,7 +802,7 @@ fn create_web_worker_callback(
         enable_op_summary_metrics: shared.options.enable_op_summary_metrics,
         enable_testing_features: shared.options.enable_testing_features,
         locale: deno_core::v8::icu::get_language_tag(),
-        location: Some(args.main_module.clone()),
+        location: Some(args.main_module),
         no_color: !colors::use_color(),
         color_level: colors::get_color_level(),
         is_stdout_tty: deno_terminal::is_stdout_tty(),
@@ -799,39 +824,19 @@ fn create_web_worker_callback(
         .options
         .unsafely_ignore_certificate_errors
         .clone(),
-      root_cert_store_provider: Some(shared.root_cert_store_provider.clone()),
       seed: shared.options.seed,
       create_web_worker_cb,
       format_js_error_fn: Some(Arc::new(format_js_error)),
-      module_loader,
-      fs: shared.fs.clone(),
-      node_services: Some(shared.create_node_init_services()),
       worker_type: args.worker_type,
-      maybe_inspector_server,
       get_error_class_fn: Some(&errors::get_error_class_name),
-      blob_store: shared.blob_store.clone(),
-      broadcast_channel: shared.broadcast_channel.clone(),
-      shared_array_buffer_store: Some(shared.shared_array_buffer_store.clone()),
-      compiled_wasm_module_store: Some(
-        shared.compiled_wasm_module_store.clone(),
-      ),
       stdio: stdio.clone(),
       cache_storage_dir,
-      feature_checker,
-      permission_desc_parser: shared.permission_desc_parser.clone(),
       strace_ops: shared.options.strace_ops.clone(),
       close_on_idle: args.close_on_idle,
       maybe_worker_metadata: args.maybe_worker_metadata,
-      npm_process_state_provider: Some(shared.npm_process_state_provider()),
     };
 
-    WebWorker::bootstrap_from_options(
-      args.name,
-      args.permissions,
-      args.main_module,
-      args.worker_id,
-      options,
-    )
+    WebWorker::bootstrap_from_options(services, options)
   })
 }
 
@@ -841,23 +846,43 @@ fn create_web_worker_callback(
 mod tests {
   use super::*;
   use deno_core::resolve_path;
+  use deno_core::FsModuleLoader;
   use deno_fs::RealFs;
   use deno_runtime::deno_permissions::Permissions;
 
   fn create_test_worker() -> MainWorker {
     let main_module =
       resolve_path("./hello.js", &std::env::current_dir().unwrap()).unwrap();
-    let permissions = PermissionsContainer::new(
-      Arc::new(RuntimePermissionDescriptorParser::new(Arc::new(RealFs))),
-      Permissions::none_without_prompt(),
-    );
-
+    let fs = Arc::new(RealFs);
+    let permission_desc_parser =
+      Arc::new(RuntimePermissionDescriptorParser::new(fs.clone()));
     let options = WorkerOptions {
       startup_snapshot: crate::js::deno_isolate_init(),
       ..Default::default()
     };
 
-    MainWorker::bootstrap_from_options(main_module, permissions, options)
+    MainWorker::bootstrap_from_options(
+      main_module,
+      WorkerServiceOptions {
+        module_loader: Rc::new(FsModuleLoader),
+        permissions: PermissionsContainer::new(
+          permission_desc_parser.clone(),
+          Permissions::none_without_prompt(),
+        ),
+        blob_store: Default::default(),
+        broadcast_channel: Default::default(),
+        feature_checker: Default::default(),
+        node_services: Default::default(),
+        npm_process_state_provider: Default::default(),
+        permission_desc_parser,
+        root_cert_store_provider: Default::default(),
+        shared_array_buffer_store: Default::default(),
+        compiled_wasm_module_store: Default::default(),
+        v8_code_cache: Default::default(),
+        fs,
+      },
+      options,
+    )
   }
 
   #[tokio::test]
diff --git a/runtime/examples/extension/main.rs b/runtime/examples/extension/main.rs
index 6f4f02508..71fbdfd6a 100644
--- a/runtime/examples/extension/main.rs
+++ b/runtime/examples/extension/main.rs
@@ -16,6 +16,7 @@ use deno_runtime::deno_permissions::PermissionsContainer;
 use deno_runtime::permissions::RuntimePermissionDescriptorParser;
 use deno_runtime::worker::MainWorker;
 use deno_runtime::worker::WorkerOptions;
+use deno_runtime::worker::WorkerServiceOptions;
 
 #[op2(fast)]
 fn op_hello(#[string] text: &str) {
@@ -35,13 +36,29 @@ async fn main() -> Result<(), AnyError> {
     Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/extension/main.js");
   let main_module = ModuleSpecifier::from_file_path(js_path).unwrap();
   eprintln!("Running {main_module}...");
+  let fs = Arc::new(RealFs);
+  let permission_desc_parser =
+    Arc::new(RuntimePermissionDescriptorParser::new(fs.clone()));
   let mut worker = MainWorker::bootstrap_from_options(
     main_module.clone(),
-    PermissionsContainer::allow_all(Arc::new(
-      RuntimePermissionDescriptorParser::new(Arc::new(RealFs)),
-    )),
-    WorkerOptions {
+    WorkerServiceOptions {
       module_loader: Rc::new(FsModuleLoader),
+      permissions: PermissionsContainer::allow_all(
+        permission_desc_parser.clone(),
+      ),
+      blob_store: Default::default(),
+      broadcast_channel: Default::default(),
+      feature_checker: Default::default(),
+      node_services: Default::default(),
+      npm_process_state_provider: Default::default(),
+      permission_desc_parser,
+      root_cert_store_provider: Default::default(),
+      shared_array_buffer_store: Default::default(),
+      compiled_wasm_module_store: Default::default(),
+      v8_code_cache: Default::default(),
+      fs,
+    },
+    WorkerOptions {
       extensions: vec![hello_runtime::init_ops_and_esm()],
       ..Default::default()
     },
diff --git a/runtime/web_worker.rs b/runtime/web_worker.rs
index 8892d5bc6..f13516268 100644
--- a/runtime/web_worker.rs
+++ b/runtime/web_worker.rs
@@ -337,6 +337,42 @@ fn create_handles(
   (internal_handle, external_handle)
 }
 
+pub struct WebWorkerServiceOptions {
+  pub blob_store: Arc<BlobStore>,
+  pub broadcast_channel: InMemoryBroadcastChannel,
+  pub compiled_wasm_module_store: Option<CompiledWasmModuleStore>,
+  pub feature_checker: Arc<FeatureChecker>,
+  pub fs: Arc<dyn FileSystem>,
+  pub maybe_inspector_server: Option<Arc<InspectorServer>>,
+  pub module_loader: Rc<dyn ModuleLoader>,
+  pub node_services: Option<NodeExtInitServices>,
+  pub npm_process_state_provider: Option<NpmProcessStateProviderRc>,
+  pub permissions: PermissionsContainer,
+  pub permission_desc_parser: Arc<dyn PermissionDescriptorParser>,
+  pub root_cert_store_provider: Option<Arc<dyn RootCertStoreProvider>>,
+  pub shared_array_buffer_store: Option<SharedArrayBufferStore>,
+}
+
+pub struct WebWorkerOptions {
+  pub name: String,
+  pub main_module: ModuleSpecifier,
+  pub worker_id: WorkerId,
+  pub bootstrap: BootstrapOptions,
+  pub extensions: Vec<Extension>,
+  pub startup_snapshot: Option<&'static [u8]>,
+  pub unsafely_ignore_certificate_errors: Option<Vec<String>>,
+  pub seed: Option<u64>,
+  pub create_web_worker_cb: Arc<ops::worker_host::CreateWebWorkerCb>,
+  pub format_js_error_fn: Option<Arc<FormatJsErrorFn>>,
+  pub worker_type: WebWorkerType,
+  pub get_error_class_fn: Option<GetErrorClassFn>,
+  pub cache_storage_dir: Option<std::path::PathBuf>,
+  pub stdio: Stdio,
+  pub strace_ops: Option<Vec<String>>,
+  pub close_on_idle: bool,
+  pub maybe_worker_metadata: Option<WorkerMetadata>,
+}
+
 /// This struct is an implementation of `Worker` Web API
 ///
 /// Each `WebWorker` is either a child of `MainWorker` or other
@@ -357,58 +393,21 @@ pub struct WebWorker {
   maybe_worker_metadata: Option<WorkerMetadata>,
 }
 
-pub struct WebWorkerOptions {
-  // todo(dsherret): extract out the service structs from this options bag
-  pub bootstrap: BootstrapOptions,
-  pub extensions: Vec<Extension>,
-  pub startup_snapshot: Option<&'static [u8]>,
-  pub unsafely_ignore_certificate_errors: Option<Vec<String>>,
-  pub root_cert_store_provider: Option<Arc<dyn RootCertStoreProvider>>,
-  pub seed: Option<u64>,
-  pub fs: Arc<dyn FileSystem>,
-  pub module_loader: Rc<dyn ModuleLoader>,
-  pub node_services: Option<NodeExtInitServices>,
-  pub create_web_worker_cb: Arc<ops::worker_host::CreateWebWorkerCb>,
-  pub format_js_error_fn: Option<Arc<FormatJsErrorFn>>,
-  pub worker_type: WebWorkerType,
-  pub maybe_inspector_server: Option<Arc<InspectorServer>>,
-  pub get_error_class_fn: Option<GetErrorClassFn>,
-  pub blob_store: Arc<BlobStore>,
-  pub broadcast_channel: InMemoryBroadcastChannel,
-  pub shared_array_buffer_store: Option<SharedArrayBufferStore>,
-  pub compiled_wasm_module_store: Option<CompiledWasmModuleStore>,
-  pub cache_storage_dir: Option<std::path::PathBuf>,
-  pub stdio: Stdio,
-  pub feature_checker: Arc<FeatureChecker>,
-  pub permission_desc_parser: Arc<dyn PermissionDescriptorParser>,
-  pub strace_ops: Option<Vec<String>>,
-  pub close_on_idle: bool,
-  pub maybe_worker_metadata: Option<WorkerMetadata>,
-  pub npm_process_state_provider: Option<NpmProcessStateProviderRc>,
-}
-
 impl WebWorker {
   pub fn bootstrap_from_options(
-    name: String,
-    permissions: PermissionsContainer,
-    main_module: ModuleSpecifier,
-    worker_id: WorkerId,
+    services: WebWorkerServiceOptions,
     options: WebWorkerOptions,
   ) -> (Self, SendableWebWorkerHandle) {
-    let bootstrap_options = options.bootstrap.clone();
-    let (mut worker, handle) =
-      Self::from_options(name, permissions, main_module, worker_id, options);
+    let (mut worker, handle, bootstrap_options) =
+      Self::from_options(services, options);
     worker.bootstrap(&bootstrap_options);
     (worker, handle)
   }
 
-  pub fn from_options(
-    name: String,
-    permissions: PermissionsContainer,
-    main_module: ModuleSpecifier,
-    worker_id: WorkerId,
+  fn from_options(
+    services: WebWorkerServiceOptions,
     mut options: WebWorkerOptions,
-  ) -> (Self, SendableWebWorkerHandle) {
+  ) -> (Self, SendableWebWorkerHandle, BootstrapOptions) {
     deno_core::extension!(deno_permissions_web_worker,
       options = {
         permissions: PermissionsContainer,
@@ -436,15 +435,15 @@ impl WebWorker {
       deno_console::deno_console::init_ops_and_esm(),
       deno_url::deno_url::init_ops_and_esm(),
       deno_web::deno_web::init_ops_and_esm::<PermissionsContainer>(
-        options.blob_store.clone(),
-        Some(main_module.clone()),
+        services.blob_store,
+        Some(options.main_module.clone()),
       ),
       deno_webgpu::deno_webgpu::init_ops_and_esm(),
       deno_canvas::deno_canvas::init_ops_and_esm(),
       deno_fetch::deno_fetch::init_ops_and_esm::<PermissionsContainer>(
         deno_fetch::Options {
           user_agent: options.bootstrap.user_agent.clone(),
-          root_cert_store_provider: options.root_cert_store_provider.clone(),
+          root_cert_store_provider: services.root_cert_store_provider.clone(),
           unsafely_ignore_certificate_errors: options
             .unsafely_ignore_certificate_errors
             .clone(),
@@ -457,17 +456,17 @@ impl WebWorker {
       ),
       deno_websocket::deno_websocket::init_ops_and_esm::<PermissionsContainer>(
         options.bootstrap.user_agent.clone(),
-        options.root_cert_store_provider.clone(),
+        services.root_cert_store_provider.clone(),
         options.unsafely_ignore_certificate_errors.clone(),
       ),
       deno_webstorage::deno_webstorage::init_ops_and_esm(None).disable(),
       deno_crypto::deno_crypto::init_ops_and_esm(options.seed),
       deno_broadcast_channel::deno_broadcast_channel::init_ops_and_esm(
-        options.broadcast_channel.clone(),
+        services.broadcast_channel,
       ),
       deno_ffi::deno_ffi::init_ops_and_esm::<PermissionsContainer>(),
       deno_net::deno_net::init_ops_and_esm::<PermissionsContainer>(
-        options.root_cert_store_provider.clone(),
+        services.root_cert_store_provider.clone(),
         options.unsafely_ignore_certificate_errors.clone(),
       ),
       deno_tls::deno_tls::init_ops_and_esm(),
@@ -477,7 +476,7 @@ impl WebWorker {
           options.seed,
           deno_kv::remote::HttpOptions {
             user_agent: options.bootstrap.user_agent.clone(),
-            root_cert_store_provider: options.root_cert_store_provider.clone(),
+            root_cert_store_provider: services.root_cert_store_provider,
             unsafely_ignore_certificate_errors: options
               .unsafely_ignore_certificate_errors
               .clone(),
@@ -492,25 +491,25 @@ impl WebWorker {
       deno_http::deno_http::init_ops_and_esm::<DefaultHttpPropertyExtractor>(),
       deno_io::deno_io::init_ops_and_esm(Some(options.stdio)),
       deno_fs::deno_fs::init_ops_and_esm::<PermissionsContainer>(
-        options.fs.clone(),
+        services.fs.clone(),
       ),
       deno_node::deno_node::init_ops_and_esm::<PermissionsContainer>(
-        options.node_services,
-        options.fs,
+        services.node_services,
+        services.fs,
       ),
       // Runtime ops that are always initialized for WebWorkers
-      ops::runtime::deno_runtime::init_ops_and_esm(main_module.clone()),
+      ops::runtime::deno_runtime::init_ops_and_esm(options.main_module.clone()),
       ops::worker_host::deno_worker_host::init_ops_and_esm(
-        options.create_web_worker_cb.clone(),
-        options.format_js_error_fn.clone(),
+        options.create_web_worker_cb,
+        options.format_js_error_fn,
       ),
       ops::fs_events::deno_fs_events::init_ops_and_esm(),
       ops::os::deno_os_worker::init_ops_and_esm(),
       ops::permissions::deno_permissions::init_ops_and_esm(
-        options.permission_desc_parser.clone(),
+        services.permission_desc_parser,
       ),
       ops::process::deno_process::init_ops_and_esm(
-        options.npm_process_state_provider,
+        services.npm_process_state_provider,
       ),
       ops::signal::deno_signal::init_ops_and_esm(),
       ops::tty::deno_tty::init_ops_and_esm(),
@@ -523,7 +522,7 @@ impl WebWorker {
         },
       ),
       deno_permissions_web_worker::init_ops_and_esm(
-        permissions,
+        services.permissions,
         enable_testing_features,
       ),
       runtime::init_ops_and_esm(),
@@ -556,17 +555,17 @@ impl WebWorker {
     );
 
     let mut js_runtime = JsRuntime::new(RuntimeOptions {
-      module_loader: Some(options.module_loader.clone()),
+      module_loader: Some(services.module_loader),
       startup_snapshot: options.startup_snapshot,
       get_error_class_fn: options.get_error_class_fn,
-      shared_array_buffer_store: options.shared_array_buffer_store.clone(),
-      compiled_wasm_module_store: options.compiled_wasm_module_store.clone(),
+      shared_array_buffer_store: services.shared_array_buffer_store,
+      compiled_wasm_module_store: services.compiled_wasm_module_store,
       extensions,
       extension_transpiler: Some(Rc::new(|specifier, source| {
         maybe_transpile_source(specifier, source)
       })),
-      inspector: options.maybe_inspector_server.is_some(),
-      feature_checker: Some(options.feature_checker.clone()),
+      inspector: services.maybe_inspector_server.is_some(),
+      feature_checker: Some(services.feature_checker),
       op_metrics_factory_fn,
       import_meta_resolve_callback: Some(Box::new(
         import_meta_resolve_callback,
@@ -582,9 +581,9 @@ impl WebWorker {
       js_runtime.op_state().borrow_mut().put(op_summary_metrics);
     }
 
-    if let Some(server) = options.maybe_inspector_server.clone() {
+    if let Some(server) = services.maybe_inspector_server {
       server.register_inspector(
-        main_module.to_string(),
+        options.main_module.to_string(),
         &mut js_runtime,
         false,
       );
@@ -599,7 +598,7 @@ impl WebWorker {
     let (internal_handle, external_handle) = {
       let handle = js_runtime.v8_isolate().thread_safe_handle();
       let (internal_handle, external_handle) =
-        create_handles(handle, name.clone(), options.worker_type);
+        create_handles(handle, options.name.clone(), options.worker_type);
       let op_state = js_runtime.op_state();
       let mut op_state = op_state.borrow_mut();
       op_state.put(internal_handle.clone());
@@ -630,12 +629,12 @@ impl WebWorker {
 
     (
       Self {
-        id: worker_id,
+        id: options.worker_id,
         js_runtime,
-        name,
+        name: options.name,
         internal_handle,
         worker_type: options.worker_type,
-        main_module,
+        main_module: options.main_module,
         poll_for_messages_fn: None,
         has_message_event_listener_fn: None,
         bootstrap_fn_global: Some(bootstrap_fn_global),
@@ -644,6 +643,7 @@ impl WebWorker {
         maybe_worker_metadata: options.maybe_worker_metadata,
       },
       external_handle,
+      options.bootstrap,
     )
   }
 
diff --git a/runtime/worker.rs b/runtime/worker.rs
index f72e6d7c0..3ce5562fa 100644
--- a/runtime/worker.rs
+++ b/runtime/worker.rs
@@ -19,7 +19,6 @@ use deno_core::v8;
 use deno_core::CompiledWasmModuleStore;
 use deno_core::Extension;
 use deno_core::FeatureChecker;
-use deno_core::FsModuleLoader;
 use deno_core::GetErrorClassFn;
 use deno_core::JsRuntime;
 use deno_core::LocalInspectorSession;
@@ -50,7 +49,6 @@ use crate::code_cache::CodeCacheType;
 use crate::inspector_server::InspectorServer;
 use crate::ops;
 use crate::ops::process::NpmProcessStateProviderRc;
-use crate::permissions::RuntimePermissionDescriptorParser;
 use crate::shared::maybe_transpile_source;
 use crate::shared::runtime;
 use crate::BootstrapOptions;
@@ -128,6 +126,43 @@ pub struct MainWorker {
   dispatch_process_exit_event_fn_global: v8::Global<v8::Function>,
 }
 
+pub struct WorkerServiceOptions {
+  pub blob_store: Arc<BlobStore>,
+  pub broadcast_channel: InMemoryBroadcastChannel,
+  pub feature_checker: Arc<FeatureChecker>,
+  pub fs: Arc<dyn FileSystem>,
+  /// Implementation of `ModuleLoader` which will be
+  /// called when V8 requests to load ES modules.
+  ///
+  /// If not provided runtime will error if code being
+  /// executed tries to load modules.
+  pub module_loader: Rc<dyn ModuleLoader>,
+  pub node_services: Option<NodeExtInitServices>,
+  pub npm_process_state_provider: Option<NpmProcessStateProviderRc>,
+  pub permission_desc_parser:
+    Arc<dyn deno_permissions::PermissionDescriptorParser>,
+  pub permissions: PermissionsContainer,
+  pub root_cert_store_provider: Option<Arc<dyn RootCertStoreProvider>>,
+
+  /// The store to use for transferring SharedArrayBuffers between isolates.
+  /// If multiple isolates should have the possibility of sharing
+  /// SharedArrayBuffers, they should use the same [SharedArrayBufferStore]. If
+  /// no [SharedArrayBufferStore] is specified, SharedArrayBuffer can not be
+  /// serialized.
+  pub shared_array_buffer_store: Option<SharedArrayBufferStore>,
+
+  /// The store to use for transferring `WebAssembly.Module` objects between
+  /// isolates.
+  /// If multiple isolates should have the possibility of sharing
+  /// `WebAssembly.Module` objects, they should use the same
+  /// [CompiledWasmModuleStore]. If no [CompiledWasmModuleStore] is specified,
+  /// `WebAssembly.Module` objects cannot be serialized.
+  pub compiled_wasm_module_store: Option<CompiledWasmModuleStore>,
+
+  /// V8 code cache for module and script source code.
+  pub v8_code_cache: Option<Arc<dyn CodeCache>>,
+}
+
 pub struct WorkerOptions {
   pub bootstrap: BootstrapOptions,
 
@@ -148,20 +183,8 @@ pub struct WorkerOptions {
   pub create_params: Option<v8::CreateParams>,
 
   pub unsafely_ignore_certificate_errors: Option<Vec<String>>,
-  pub root_cert_store_provider: Option<Arc<dyn RootCertStoreProvider>>,
   pub seed: Option<u64>,
 
-  pub fs: Arc<dyn FileSystem>,
-  /// Implementation of `ModuleLoader` which will be
-  /// called when V8 requests to load ES modules.
-  ///
-  /// If not provided runtime will error if code being
-  /// executed tries to load modules.
-  pub module_loader: Rc<dyn ModuleLoader>,
-  pub node_services: Option<NodeExtInitServices>,
-  pub npm_process_state_provider: Option<NpmProcessStateProviderRc>,
-  pub permission_desc_parser:
-    Arc<dyn deno_permissions::PermissionDescriptorParser>,
   // Callbacks invoked when creating new instance of WebWorker
   pub create_web_worker_cb: Arc<ops::worker_host::CreateWebWorkerCb>,
   pub format_js_error_fn: Option<Arc<FormatJsErrorFn>>,
@@ -182,69 +205,31 @@ pub struct WorkerOptions {
   pub get_error_class_fn: Option<GetErrorClassFn>,
   pub cache_storage_dir: Option<std::path::PathBuf>,
   pub origin_storage_dir: Option<std::path::PathBuf>,
-  pub blob_store: Arc<BlobStore>,
-  pub broadcast_channel: InMemoryBroadcastChannel,
-
-  /// The store to use for transferring SharedArrayBuffers between isolates.
-  /// If multiple isolates should have the possibility of sharing
-  /// SharedArrayBuffers, they should use the same [SharedArrayBufferStore]. If
-  /// no [SharedArrayBufferStore] is specified, SharedArrayBuffer can not be
-  /// serialized.
-  pub shared_array_buffer_store: Option<SharedArrayBufferStore>,
-
-  /// The store to use for transferring `WebAssembly.Module` objects between
-  /// isolates.
-  /// If multiple isolates should have the possibility of sharing
-  /// `WebAssembly.Module` objects, they should use the same
-  /// [CompiledWasmModuleStore]. If no [CompiledWasmModuleStore] is specified,
-  /// `WebAssembly.Module` objects cannot be serialized.
-  pub compiled_wasm_module_store: Option<CompiledWasmModuleStore>,
   pub stdio: Stdio,
-  pub feature_checker: Arc<FeatureChecker>,
-
-  /// V8 code cache for module and script source code.
-  pub v8_code_cache: Option<Arc<dyn CodeCache>>,
 }
 
-// todo(dsherret): this is error prone to use. We should separate
-// out the WorkerOptions from the services.
 impl Default for WorkerOptions {
   fn default() -> Self {
-    let real_fs = Arc::new(deno_fs::RealFs);
     Self {
       create_web_worker_cb: Arc::new(|_| {
         unimplemented!("web workers are not supported")
       }),
-      fs: real_fs.clone(),
-      module_loader: Rc::new(FsModuleLoader),
       skip_op_registration: false,
       seed: None,
       unsafely_ignore_certificate_errors: Default::default(),
       should_break_on_first_statement: Default::default(),
       should_wait_for_inspector_session: Default::default(),
       strace_ops: Default::default(),
-      compiled_wasm_module_store: Default::default(),
-      shared_array_buffer_store: Default::default(),
       maybe_inspector_server: Default::default(),
       format_js_error_fn: Default::default(),
       get_error_class_fn: Default::default(),
       origin_storage_dir: Default::default(),
       cache_storage_dir: Default::default(),
-      broadcast_channel: Default::default(),
-      root_cert_store_provider: Default::default(),
-      node_services: Default::default(),
-      blob_store: Default::default(),
       extensions: Default::default(),
       startup_snapshot: Default::default(),
       create_params: Default::default(),
-      npm_process_state_provider: Default::default(),
       bootstrap: Default::default(),
       stdio: Default::default(),
-      feature_checker: Default::default(),
-      permission_desc_parser: Arc::new(RuntimePermissionDescriptorParser::new(
-        real_fs,
-      )),
-      v8_code_cache: Default::default(),
     }
   }
 }
@@ -318,20 +303,20 @@ pub fn create_op_metrics(
 impl MainWorker {
   pub fn bootstrap_from_options(
     main_module: ModuleSpecifier,
-    permissions: PermissionsContainer,
+    services: WorkerServiceOptions,
     options: WorkerOptions,
   ) -> Self {
-    let bootstrap_options = options.bootstrap.clone();
-    let mut worker = Self::from_options(main_module, permissions, options);
+    let (mut worker, bootstrap_options) =
+      Self::from_options(main_module, services, options);
     worker.bootstrap(bootstrap_options);
     worker
   }
 
-  pub fn from_options(
+  fn from_options(
     main_module: ModuleSpecifier,
-    permissions: PermissionsContainer,
+    services: WorkerServiceOptions,
     mut options: WorkerOptions,
-  ) -> Self {
+  ) -> (Self, BootstrapOptions) {
     deno_core::extension!(deno_permissions_worker,
       options = {
         permissions: PermissionsContainer,
@@ -365,7 +350,7 @@ impl MainWorker {
       deno_console::deno_console::init_ops_and_esm(),
       deno_url::deno_url::init_ops_and_esm(),
       deno_web::deno_web::init_ops_and_esm::<PermissionsContainer>(
-        options.blob_store.clone(),
+        services.blob_store.clone(),
         options.bootstrap.location.clone(),
       ),
       deno_webgpu::deno_webgpu::init_ops_and_esm(),
@@ -373,7 +358,7 @@ impl MainWorker {
       deno_fetch::deno_fetch::init_ops_and_esm::<PermissionsContainer>(
         deno_fetch::Options {
           user_agent: options.bootstrap.user_agent.clone(),
-          root_cert_store_provider: options.root_cert_store_provider.clone(),
+          root_cert_store_provider: services.root_cert_store_provider.clone(),
           unsafely_ignore_certificate_errors: options
             .unsafely_ignore_certificate_errors
             .clone(),
@@ -386,7 +371,7 @@ impl MainWorker {
       ),
       deno_websocket::deno_websocket::init_ops_and_esm::<PermissionsContainer>(
         options.bootstrap.user_agent.clone(),
-        options.root_cert_store_provider.clone(),
+        services.root_cert_store_provider.clone(),
         options.unsafely_ignore_certificate_errors.clone(),
       ),
       deno_webstorage::deno_webstorage::init_ops_and_esm(
@@ -394,11 +379,11 @@ impl MainWorker {
       ),
       deno_crypto::deno_crypto::init_ops_and_esm(options.seed),
       deno_broadcast_channel::deno_broadcast_channel::init_ops_and_esm(
-        options.broadcast_channel.clone(),
+        services.broadcast_channel.clone(),
       ),
       deno_ffi::deno_ffi::init_ops_and_esm::<PermissionsContainer>(),
       deno_net::deno_net::init_ops_and_esm::<PermissionsContainer>(
-        options.root_cert_store_provider.clone(),
+        services.root_cert_store_provider.clone(),
         options.unsafely_ignore_certificate_errors.clone(),
       ),
       deno_tls::deno_tls::init_ops_and_esm(),
@@ -408,7 +393,7 @@ impl MainWorker {
           options.seed,
           deno_kv::remote::HttpOptions {
             user_agent: options.bootstrap.user_agent.clone(),
-            root_cert_store_provider: options.root_cert_store_provider.clone(),
+            root_cert_store_provider: services.root_cert_store_provider.clone(),
             unsafely_ignore_certificate_errors: options
               .unsafely_ignore_certificate_errors
               .clone(),
@@ -423,11 +408,11 @@ impl MainWorker {
       deno_http::deno_http::init_ops_and_esm::<DefaultHttpPropertyExtractor>(),
       deno_io::deno_io::init_ops_and_esm(Some(options.stdio)),
       deno_fs::deno_fs::init_ops_and_esm::<PermissionsContainer>(
-        options.fs.clone(),
+        services.fs.clone(),
       ),
       deno_node::deno_node::init_ops_and_esm::<PermissionsContainer>(
-        options.node_services,
-        options.fs,
+        services.node_services,
+        services.fs,
       ),
       // Ops from this crate
       ops::runtime::deno_runtime::init_ops_and_esm(main_module.clone()),
@@ -438,10 +423,10 @@ impl MainWorker {
       ops::fs_events::deno_fs_events::init_ops_and_esm(),
       ops::os::deno_os::init_ops_and_esm(exit_code.clone()),
       ops::permissions::deno_permissions::init_ops_and_esm(
-        options.permission_desc_parser,
+        services.permission_desc_parser,
       ),
       ops::process::deno_process::init_ops_and_esm(
-        options.npm_process_state_provider,
+        services.npm_process_state_provider,
       ),
       ops::signal::deno_signal::init_ops_and_esm(),
       ops::tty::deno_tty::init_ops_and_esm(),
@@ -454,7 +439,7 @@ impl MainWorker {
         },
       ),
       deno_permissions_worker::init_ops_and_esm(
-        permissions,
+        services.permissions,
         enable_testing_features,
       ),
       runtime::init_ops_and_esm(),
@@ -494,20 +479,20 @@ impl MainWorker {
     });
 
     let mut js_runtime = JsRuntime::new(RuntimeOptions {
-      module_loader: Some(options.module_loader.clone()),
+      module_loader: Some(services.module_loader.clone()),
       startup_snapshot: options.startup_snapshot,
       create_params: options.create_params,
       skip_op_registration: options.skip_op_registration,
       get_error_class_fn: options.get_error_class_fn,
-      shared_array_buffer_store: options.shared_array_buffer_store.clone(),
-      compiled_wasm_module_store: options.compiled_wasm_module_store.clone(),
+      shared_array_buffer_store: services.shared_array_buffer_store.clone(),
+      compiled_wasm_module_store: services.compiled_wasm_module_store.clone(),
       extensions,
       extension_transpiler: Some(Rc::new(|specifier, source| {
         maybe_transpile_source(specifier, source)
       })),
       inspector: options.maybe_inspector_server.is_some(),
       is_main: true,
-      feature_checker: Some(options.feature_checker.clone()),
+      feature_checker: Some(services.feature_checker.clone()),
       op_metrics_factory_fn,
       wait_for_inspector_disconnect_callback: Some(
         wait_for_inspector_disconnect_callback,
@@ -519,7 +504,7 @@ impl MainWorker {
         validate_import_attributes_callback,
       )),
       import_assertions_support: deno_core::ImportAssertionsSupport::Error,
-      eval_context_code_cache_cbs: options.v8_code_cache.map(|cache| {
+      eval_context_code_cache_cbs: services.v8_code_cache.map(|cache| {
         let cache_clone = cache.clone();
         (
           Box::new(move |specifier: &ModuleSpecifier, code: &v8::String| {
@@ -666,7 +651,7 @@ impl MainWorker {
       )
     };
 
-    Self {
+    let worker = Self {
       js_runtime,
       should_break_on_first_statement: options.should_break_on_first_statement,
       should_wait_for_inspector_session: options
@@ -678,7 +663,8 @@ impl MainWorker {
       dispatch_unload_event_fn_global,
       dispatch_process_beforeexit_event_fn_global,
       dispatch_process_exit_event_fn_global,
-    }
+    };
+    (worker, options.bootstrap)
   }
 
   pub fn bootstrap(&mut self, options: BootstrapOptions) {