feat(core) deno_core::extension! macro to simplify extension registration (#18210)

This implements two macros to simplify extension registration and centralize a lot of the boilerplate as a base for future improvements:

* `deno_core::ops!` registers a block of `#[op]`s, optionally with type
parameters, useful for places where we share lists of ops
* `deno_core::extension!` is used to register an extension, and creates
two methods that can be used at runtime/snapshot generation time:
`init_ops` and `init_ops_and_esm`.

---------

Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>

13 files changed, 327 insertions, 336 deletions

diff --git a/runtime/build.rs b/runtime/build.rs
index 63bc3439e..c1837de82 100644
--- a/runtime/build.rs
+++ b/runtime/build.rs
@@ -8,18 +8,18 @@ use std::path::PathBuf;
   not(feature = "dont_create_runtime_snapshot")
 ))]
 mod startup_snapshot {
-  use std::path::Path;
-
   use super::*;
   use deno_ast::MediaType;
   use deno_ast::ParseParams;
   use deno_ast::SourceTextInfo;
   use deno_cache::SqliteBackedCache;
   use deno_core::error::AnyError;
-  use deno_core::include_js_files;
   use deno_core::snapshot_util::*;
   use deno_core::Extension;
   use deno_core::ExtensionFileSource;
+  use std::cell::RefCell;
+  use std::path::Path;
+  use std::rc::Rc;
 
   fn transpile_ts_for_snapshotting(
     file_source: &ExtensionFileSource,
@@ -58,6 +58,7 @@ mod startup_snapshot {
     Ok(transpiled_source.text)
   }
 
+  #[derive(Clone)]
   struct Permissions;
 
   impl deno_fetch::FetchPermissions for Permissions {
@@ -200,36 +201,30 @@ mod startup_snapshot {
     }
   }
 
-  fn create_runtime_snapshot(
-    snapshot_path: PathBuf,
-    maybe_additional_extension: Option<Extension>,
-  ) {
-    let runtime_extension = Extension::builder_with_deps(
-      "runtime",
-      &[
-        "deno_webidl",
-        "deno_console",
-        "deno_url",
-        "deno_tls",
-        "deno_web",
-        "deno_fetch",
-        "deno_cache",
-        "deno_websocket",
-        "deno_webstorage",
-        "deno_crypto",
-        "deno_broadcast_channel",
-        // FIXME(bartlomieju): this should be reenabled
-        // "deno_node",
-        "deno_ffi",
-        "deno_net",
-        "deno_napi",
-        "deno_http",
-        "deno_flash",
-        "deno_io",
-        "deno_fs",
-      ],
-    )
-    .esm(include_js_files!(
+  deno_core::extension!(runtime,
+    deps = [
+      deno_webidl,
+      deno_console,
+      deno_url,
+      deno_tls,
+      deno_web,
+      deno_fetch,
+      deno_cache,
+      deno_websocket,
+      deno_webstorage,
+      deno_crypto,
+      deno_broadcast_channel,
+      // FIXME(bartlomieju): this should be reenabled
+      // "deno_node",
+      deno_ffi,
+      deno_net,
+      deno_napi,
+      deno_http,
+      deno_flash,
+      deno_io,
+      deno_fs
+    ],
+    esm = [
       dir "js",
       "01_errors.js",
       "01_version.ts",
@@ -245,55 +240,72 @@ mod startup_snapshot {
       "40_tty.js",
       "41_prompt.js",
       "90_deno_ns.js",
-      "98_global_scope.js",
-    ))
-    .build();
+      "98_global_scope.js"
+    ],
+  );
+
+  #[cfg(not(feature = "snapshot_from_snapshot"))]
+  deno_core::extension!(
+    runtime_main,
+    deps = [runtime],
+    customizer = |ext: &mut deno_core::ExtensionBuilder| {
+      ext.esm(vec![ExtensionFileSource {
+        specifier: "js/99_main.js".to_string(),
+        code: deno_core::ExtensionFileSourceCode::IncludedInBinary(
+          include_str!("js/99_main.js"),
+        ),
+      }]);
+    }
+  );
 
+  pub fn create_runtime_snapshot(snapshot_path: PathBuf) {
     // NOTE(bartlomieju): ordering is important here, keep it in sync with
     // `runtime/worker.rs`, `runtime/web_worker.rs` and `cli/build.rs`!
-    let mut extensions: Vec<Extension> = vec![
-      deno_webidl::init_esm(),
-      deno_console::init_esm(),
-      deno_url::init_ops_and_esm(),
-      deno_web::init_ops_and_esm::<Permissions>(
+    let extensions: Vec<Extension> = vec![
+      deno_webidl::deno_webidl::init_ops_and_esm(),
+      deno_console::deno_console::init_ops_and_esm(),
+      deno_url::deno_url::init_ops_and_esm(),
+      deno_web::deno_web::init_ops_and_esm::<Permissions>(
         deno_web::BlobStore::default(),
         Default::default(),
       ),
-      deno_fetch::init_ops_and_esm::<Permissions>(Default::default()),
-      deno_cache::init_ops_and_esm::<SqliteBackedCache>(None),
-      deno_websocket::init_ops_and_esm::<Permissions>(
+      deno_fetch::deno_fetch::init_ops_and_esm::<Permissions>(
+        Default::default(),
+      ),
+      deno_cache::deno_cache::init_ops_and_esm::<SqliteBackedCache>(None),
+      deno_websocket::deno_websocket::init_ops_and_esm::<Permissions>(
         "".to_owned(),
         None,
         None,
       ),
-      deno_webstorage::init_ops_and_esm(None),
-      deno_crypto::init_ops_and_esm(None),
-      deno_broadcast_channel::init_ops_and_esm(
+      deno_webstorage::deno_webstorage::init_ops_and_esm(None),
+      deno_crypto::deno_crypto::init_ops_and_esm(None),
+      deno_broadcast_channel::deno_broadcast_channel::init_ops_and_esm(
         deno_broadcast_channel::InMemoryBroadcastChannel::default(),
         false, // No --unstable.
       ),
-      deno_ffi::init_ops_and_esm::<Permissions>(false),
-      deno_net::init_ops_and_esm::<Permissions>(
+      deno_ffi::deno_ffi::init_ops_and_esm::<Permissions>(false),
+      deno_net::deno_net::init_ops_and_esm::<Permissions>(
         None, false, // No --unstable.
         None,
       ),
-      deno_tls::init_ops(),
-      deno_napi::init_ops::<Permissions>(),
-      deno_http::init_ops_and_esm(),
-      deno_io::init_ops_and_esm(Default::default()),
-      deno_fs::init_ops_and_esm::<Permissions>(false),
-      deno_flash::init_ops_and_esm::<Permissions>(false), // No --unstable
-      runtime_extension,
+      deno_tls::deno_tls::init_ops_and_esm(),
+      deno_napi::deno_napi::init_ops_and_esm::<Permissions>(),
+      deno_http::deno_http::init_ops_and_esm(),
+      deno_io::deno_io::init_ops_and_esm(Rc::new(RefCell::new(Some(
+        Default::default(),
+      )))),
+      deno_fs::deno_fs::init_ops_and_esm::<Permissions>(false),
+      deno_flash::deno_flash::init_ops_and_esm::<Permissions>(false), // No --unstable
+      runtime::init_ops_and_esm(),
       // FIXME(bartlomieju): these extensions are specified last, because they
       // depend on `runtime`, even though it should be other way around
-      deno_node::init_ops_and_esm::<Permissions>(None),
-      deno_node::init_polyfill_ops_and_esm(),
+      deno_node::deno_node_loading::init_ops_and_esm::<Permissions>(None),
+      deno_node::deno_node::init_ops_and_esm(),
+      #[cfg(not(feature = "snapshot_from_snapshot"))]
+      runtime_main::init_ops_and_esm(),
     ];
 
-    if let Some(additional_extension) = maybe_additional_extension {
-      extensions.push(additional_extension);
-    }
-
     create_snapshot(CreateSnapshotOptions {
       cargo_manifest_dir: env!("CARGO_MANIFEST_DIR"),
       snapshot_path,
@@ -303,28 +315,6 @@ mod startup_snapshot {
       snapshot_module_load_cb: Some(Box::new(transpile_ts_for_snapshotting)),
     });
   }
-
-  pub fn build_snapshot(runtime_snapshot_path: PathBuf) {
-    #[allow(unused_mut, unused_assignments)]
-    let mut maybe_additional_extension = None;
-
-    #[cfg(not(feature = "snapshot_from_snapshot"))]
-    {
-      use deno_core::ExtensionFileSourceCode;
-      maybe_additional_extension = Some(
-        Extension::builder_with_deps("runtime_main", &["runtime"])
-          .esm(vec![ExtensionFileSource {
-            specifier: "js/99_main.js".to_string(),
-            code: ExtensionFileSourceCode::IncludedInBinary(include_str!(
-              "js/99_main.js"
-            )),
-          }])
-          .build(),
-      );
-    }
-
-    create_runtime_snapshot(runtime_snapshot_path, maybe_additional_extension);
-  }
 }
 
 fn main() {
@@ -351,5 +341,5 @@ fn main() {
     not(feature = "docsrs"),
     not(feature = "dont_create_runtime_snapshot")
   ))]
-  startup_snapshot::build_snapshot(runtime_snapshot_path)
+  startup_snapshot::create_runtime_snapshot(runtime_snapshot_path)
 }
diff --git a/runtime/ops/fs_events.rs b/runtime/ops/fs_events.rs
index e550d204c..05cc22152 100644
--- a/runtime/ops/fs_events.rs
+++ b/runtime/ops/fs_events.rs
@@ -13,7 +13,6 @@ use deno_core::ResourceId;
 
 use deno_core::op;
 
-use deno_core::Extension;
 use notify::event::Event as NotifyEvent;
 use notify::Error as NotifyError;
 use notify::EventKind;
@@ -29,11 +28,10 @@ use std::path::PathBuf;
 use std::rc::Rc;
 use tokio::sync::mpsc;
 
-pub fn init() -> Extension {
-  Extension::builder("deno_fs_events")
-    .ops(vec![op_fs_events_open::decl(), op_fs_events_poll::decl()])
-    .build()
-}
+deno_core::extension!(
+  deno_fs_events,
+  ops = [op_fs_events_open, op_fs_events_poll]
+);
 
 struct FsEventsResource {
   #[allow(unused)]
diff --git a/runtime/ops/http.rs b/runtime/ops/http.rs
index 51562589e..b9899b4e3 100644
--- a/runtime/ops/http.rs
+++ b/runtime/ops/http.rs
@@ -8,7 +8,6 @@ use deno_core::error::bad_resource_id;
 use deno_core::error::custom_error;
 use deno_core::error::AnyError;
 use deno_core::op;
-use deno_core::Extension;
 use deno_core::OpState;
 use deno_core::RcRef;
 use deno_core::ResourceId;
@@ -28,15 +27,10 @@ use deno_net::io::UnixStreamResource;
 #[cfg(unix)]
 use tokio::net::UnixStream;
 
-pub fn init() -> Extension {
-  Extension::builder("deno_http_runtime")
-    .ops(vec![
-      op_http_start::decl(),
-      op_http_upgrade::decl(),
-      op_flash_upgrade_http::decl(),
-    ])
-    .build()
-}
+deno_core::extension!(
+  deno_http_runtime,
+  ops = [op_http_start, op_http_upgrade, op_flash_upgrade_http],
+);
 
 #[op]
 fn op_http_start(
diff --git a/runtime/ops/os/mod.rs b/runtime/ops/os/mod.rs
index b2c67db5c..87181654b 100644
--- a/runtime/ops/os/mod.rs
+++ b/runtime/ops/os/mod.rs
@@ -8,8 +8,6 @@ use deno_core::error::AnyError;
 use deno_core::op;
 use deno_core::url::Url;
 use deno_core::v8;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
 use deno_core::OpState;
 use deno_node::NODE_ENV_VAR_ALLOWLIST;
 use serde::Serialize;
@@ -18,47 +16,49 @@ use std::env;
 
 mod sys_info;
 
-fn init_ops(builder: &mut ExtensionBuilder) -> &mut ExtensionBuilder {
-  builder.ops(vec![
-    op_env::decl(),
-    op_exec_path::decl(),
-    op_exit::decl(),
-    op_delete_env::decl(),
-    op_get_env::decl(),
-    op_gid::decl(),
-    op_hostname::decl(),
-    op_loadavg::decl(),
-    op_network_interfaces::decl(),
-    op_os_release::decl(),
-    op_os_uptime::decl(),
-    op_node_unstable_os_uptime::decl(),
-    op_set_env::decl(),
-    op_set_exit_code::decl(),
-    op_system_memory_info::decl(),
-    op_uid::decl(),
-    op_runtime_memory_usage::decl(),
-  ])
-}
-
-pub fn init(exit_code: ExitCode) -> Extension {
-  let mut builder = Extension::builder("deno_os");
-  init_ops(&mut builder)
-    .state(move |state| {
-      state.put::<ExitCode>(exit_code.clone());
-    })
-    .build()
-}
-
-pub fn init_for_worker() -> Extension {
-  let mut builder = Extension::builder("deno_os_worker");
-  init_ops(&mut builder)
-    .middleware(|op| match op.name {
-      "op_exit" => noop_op::decl(),
-      "op_set_exit_code" => noop_op::decl(),
-      _ => op,
-    })
-    .build()
-}
+deno_core::ops!(
+  deno_ops,
+  [
+    op_env,
+    op_exec_path,
+    op_exit,
+    op_delete_env,
+    op_get_env,
+    op_gid,
+    op_hostname,
+    op_loadavg,
+    op_network_interfaces,
+    op_os_release,
+    op_os_uptime,
+    op_node_unstable_os_uptime,
+    op_set_env,
+    op_set_exit_code,
+    op_system_memory_info,
+    op_uid,
+    op_runtime_memory_usage,
+  ]
+);
+
+deno_core::extension!(
+  deno_os,
+  ops_fn = deno_ops,
+  config = {
+    exit_code: ExitCode,
+  },
+  state = |state, exit_code| {
+    state.put::<ExitCode>(exit_code);
+  },
+);
+
+deno_core::extension!(
+  deno_os_worker,
+  ops_fn = deno_ops,
+  middleware = |op| match op.name {
+    "op_exit" => noop_op::decl(),
+    "op_set_exit_code" => noop_op::decl(),
+    _ => op,
+  },
+);
 
 #[op]
 fn noop_op() -> Result<(), AnyError> {
diff --git a/runtime/ops/permissions.rs b/runtime/ops/permissions.rs
index 3c48c1e8d..c08d11e4a 100644
--- a/runtime/ops/permissions.rs
+++ b/runtime/ops/permissions.rs
@@ -7,20 +7,18 @@ use deno_core::error::uri_error;
 use deno_core::error::AnyError;
 use deno_core::op;
 use deno_core::url;
-use deno_core::Extension;
 use deno_core::OpState;
 use serde::Deserialize;
 use std::path::Path;
 
-pub fn init() -> Extension {
-  Extension::builder("deno_permissions")
-    .ops(vec![
-      op_query_permission::decl(),
-      op_revoke_permission::decl(),
-      op_request_permission::decl(),
-    ])
-    .build()
-}
+deno_core::extension!(
+  deno_permissions,
+  ops = [
+    op_query_permission,
+    op_revoke_permission,
+    op_request_permission,
+  ]
+);
 
 #[derive(Deserialize)]
 pub struct PermissionArgs {
diff --git a/runtime/ops/process.rs b/runtime/ops/process.rs
index 20db96af9..a15b63f80 100644
--- a/runtime/ops/process.rs
+++ b/runtime/ops/process.rs
@@ -7,7 +7,6 @@ use deno_core::op;
 use deno_core::serde_json;
 use deno_core::AsyncMutFuture;
 use deno_core::AsyncRefCell;
-use deno_core::Extension;
 use deno_core::OpState;
 use deno_core::RcRef;
 use deno_core::Resource;
@@ -99,18 +98,17 @@ impl StdioOrRid {
   }
 }
 
-pub fn init_ops() -> Extension {
-  Extension::builder("deno_process")
-    .ops(vec![
-      op_spawn_child::decl(),
-      op_spawn_wait::decl(),
-      op_spawn_sync::decl(),
-      deprecated::op_run::decl(),
-      deprecated::op_run_status::decl(),
-      deprecated::op_kill::decl(),
-    ])
-    .build()
-}
+deno_core::extension!(
+  deno_process,
+  ops = [
+    op_spawn_child,
+    op_spawn_wait,
+    op_spawn_sync,
+    deprecated::op_run,
+    deprecated::op_run_status,
+    deprecated::op_kill,
+  ]
+);
 
 struct ChildResource(tokio::process::Child);
 
diff --git a/runtime/ops/runtime.rs b/runtime/ops/runtime.rs
index 5ce9966e0..564d2279b 100644
--- a/runtime/ops/runtime.rs
+++ b/runtime/ops/runtime.rs
@@ -3,18 +3,17 @@
 use crate::permissions::PermissionsContainer;
 use deno_core::error::AnyError;
 use deno_core::op;
-use deno_core::Extension;
 use deno_core::ModuleSpecifier;
 use deno_core::OpState;
 
-pub fn init(main_module: ModuleSpecifier) -> Extension {
-  Extension::builder("deno_runtime")
-    .ops(vec![op_main_module::decl()])
-    .state(move |state| {
-      state.put::<ModuleSpecifier>(main_module.clone());
-    })
-    .build()
-}
+deno_core::extension!(
+  deno_runtime,
+  ops = [op_main_module],
+  config = { main_module: ModuleSpecifier },
+  state = |state, main_module| {
+    state.put::<ModuleSpecifier>(main_module);
+  }
+);
 
 #[op]
 fn op_main_module(state: &mut OpState) -> Result<String, AnyError> {
diff --git a/runtime/ops/signal.rs b/runtime/ops/signal.rs
index c2105a64e..9cc261d85 100644
--- a/runtime/ops/signal.rs
+++ b/runtime/ops/signal.rs
@@ -5,7 +5,6 @@ use deno_core::op;
 use deno_core::AsyncRefCell;
 use deno_core::CancelFuture;
 use deno_core::CancelHandle;
-use deno_core::Extension;
 use deno_core::OpState;
 use deno_core::RcRef;
 use deno_core::Resource;
@@ -30,15 +29,10 @@ use tokio::signal::windows::CtrlBreak;
 #[cfg(windows)]
 use tokio::signal::windows::CtrlC;
 
-pub fn init() -> Extension {
-  Extension::builder("deno_signal")
-    .ops(vec![
-      op_signal_bind::decl(),
-      op_signal_unbind::decl(),
-      op_signal_poll::decl(),
-    ])
-    .build()
-}
+deno_core::extension!(
+  deno_signal,
+  ops = [op_signal_bind, op_signal_unbind, op_signal_poll]
+);
 
 #[cfg(unix)]
 /// The resource for signal stream.
diff --git a/runtime/ops/tty.rs b/runtime/ops/tty.rs
index d577a6755..60144e408 100644
--- a/runtime/ops/tty.rs
+++ b/runtime/ops/tty.rs
@@ -2,7 +2,6 @@
 
 use deno_core::error::AnyError;
 use deno_core::op;
-use deno_core::Extension;
 use deno_core::OpState;
 use deno_io::StdFileResource;
 use std::io::Error;
@@ -33,15 +32,10 @@ fn get_windows_handle(
   Ok(handle)
 }
 
-pub fn init() -> Extension {
-  Extension::builder("deno_tty")
-    .ops(vec![
-      op_stdin_set_raw::decl(),
-      op_isatty::decl(),
-      op_console_size::decl(),
-    ])
-    .build()
-}
+deno_core::extension!(
+  deno_tty,
+  ops = [op_stdin_set_raw, op_isatty, op_console_size]
+);
 
 // ref: <https://learn.microsoft.com/en-us/windows/console/setconsolemode>
 #[cfg(windows)]
diff --git a/runtime/ops/web_worker.rs b/runtime/ops/web_worker.rs
index 617615424..45137913e 100644
--- a/runtime/ops/web_worker.rs
+++ b/runtime/ops/web_worker.rs
@@ -8,7 +8,6 @@ use deno_core::error::AnyError;
 use deno_core::op;
 
 use deno_core::CancelFuture;
-use deno_core::Extension;
 use deno_core::OpState;
 use deno_web::JsMessageData;
 use std::cell::RefCell;
@@ -16,18 +15,17 @@ use std::rc::Rc;
 
 use self::sync_fetch::op_worker_sync_fetch;
 
-pub fn init() -> Extension {
-  Extension::builder("deno_web_worker")
-    .ops(vec![
-      op_worker_post_message::decl(),
-      op_worker_recv_message::decl(),
-      // Notify host that guest worker closes.
-      op_worker_close::decl(),
-      op_worker_get_type::decl(),
-      op_worker_sync_fetch::decl(),
-    ])
-    .build()
-}
+deno_core::extension!(
+  deno_web_worker,
+  ops = [
+    op_worker_post_message,
+    op_worker_recv_message,
+    // Notify host that guest worker closes.
+    op_worker_close,
+    op_worker_get_type,
+    op_worker_sync_fetch,
+  ]
+);
 
 #[op]
 fn op_worker_post_message(
diff --git a/runtime/ops/worker_host.rs b/runtime/ops/worker_host.rs
index 6007a3260..de7e02e18 100644
--- a/runtime/ops/worker_host.rs
+++ b/runtime/ops/worker_host.rs
@@ -18,7 +18,6 @@ use deno_core::op;
 use deno_core::serde::Deserialize;
 use deno_core::CancelFuture;
 use deno_core::CancelHandle;
-use deno_core::Extension;
 use deno_core::ModuleSpecifier;
 use deno_core::OpState;
 use deno_web::JsMessageData;
@@ -88,39 +87,39 @@ impl Drop for WorkerThread {
 
 pub type WorkersTable = HashMap<WorkerId, WorkerThread>;
 
-pub fn init(
-  create_web_worker_cb: Arc<CreateWebWorkerCb>,
-  preload_module_cb: Arc<WorkerEventCb>,
-  pre_execute_module_cb: Arc<WorkerEventCb>,
-  format_js_error_fn: Option<Arc<FormatJsErrorFn>>,
-) -> Extension {
-  Extension::builder("deno_worker_host")
-    .state(move |state| {
-      state.put::<WorkersTable>(WorkersTable::default());
-      state.put::<WorkerId>(WorkerId::default());
-
-      let create_web_worker_cb_holder =
-        CreateWebWorkerCbHolder(create_web_worker_cb.clone());
-      state.put::<CreateWebWorkerCbHolder>(create_web_worker_cb_holder);
-      let preload_module_cb_holder =
-        PreloadModuleCbHolder(preload_module_cb.clone());
-      state.put::<PreloadModuleCbHolder>(preload_module_cb_holder);
-      let pre_execute_module_cb_holder =
-        PreExecuteModuleCbHolder(pre_execute_module_cb.clone());
-      state.put::<PreExecuteModuleCbHolder>(pre_execute_module_cb_holder);
-      let format_js_error_fn_holder =
-        FormatJsErrorFnHolder(format_js_error_fn.clone());
-      state.put::<FormatJsErrorFnHolder>(format_js_error_fn_holder);
-    })
-    .ops(vec![
-      op_create_worker::decl(),
-      op_host_terminate_worker::decl(),
-      op_host_post_message::decl(),
-      op_host_recv_ctrl::decl(),
-      op_host_recv_message::decl(),
-    ])
-    .build()
-}
+deno_core::extension!(
+  deno_worker_host,
+  ops = [
+    op_create_worker,
+    op_host_terminate_worker,
+    op_host_post_message,
+    op_host_recv_ctrl,
+    op_host_recv_message,
+  ],
+  config = {
+    create_web_worker_cb: Arc<CreateWebWorkerCb>,
+    preload_module_cb: Arc<WorkerEventCb>,
+    pre_execute_module_cb: Arc<WorkerEventCb>,
+    format_js_error_fn: Option<Arc<FormatJsErrorFn>>,
+  },
+  state = |state, create_web_worker_cb, preload_module_cb, pre_execute_module_cb, format_js_error_fn| {
+    state.put::<WorkersTable>(WorkersTable::default());
+    state.put::<WorkerId>(WorkerId::default());
+
+    let create_web_worker_cb_holder =
+      CreateWebWorkerCbHolder(create_web_worker_cb.clone());
+    state.put::<CreateWebWorkerCbHolder>(create_web_worker_cb_holder);
+    let preload_module_cb_holder =
+      PreloadModuleCbHolder(preload_module_cb.clone());
+    state.put::<PreloadModuleCbHolder>(preload_module_cb_holder);
+    let pre_execute_module_cb_holder =
+      PreExecuteModuleCbHolder(pre_execute_module_cb.clone());
+    state.put::<PreExecuteModuleCbHolder>(pre_execute_module_cb_holder);
+    let format_js_error_fn_holder =
+      FormatJsErrorFnHolder(format_js_error_fn.clone());
+    state.put::<FormatJsErrorFnHolder>(format_js_error_fn_holder);
+  }
+);
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
diff --git a/runtime/web_worker.rs b/runtime/web_worker.rs
index b6caba194..a78e7078b 100644
--- a/runtime/web_worker.rs
+++ b/runtime/web_worker.rs
@@ -368,16 +368,22 @@ impl WebWorker {
     worker_id: WorkerId,
     mut options: WebWorkerOptions,
   ) -> (Self, SendableWebWorkerHandle) {
+    deno_core::extension!(deno_permissions_web_worker,
+      config = {
+        permissions: PermissionsContainer,
+        unstable: bool,
+        enable_testing_features: bool,
+      },
+      state = |state, permissions, unstable, enable_testing_features| {
+        state.put::<PermissionsContainer>(permissions);
+        state.put(ops::UnstableChecker { unstable });
+        state.put(ops::TestingFeaturesEnabled(enable_testing_features));
+      },
+    );
+
     // Permissions: many ops depend on this
     let unstable = options.bootstrap.unstable;
     let enable_testing_features = options.bootstrap.enable_testing_features;
-    let perm_ext = Extension::builder("deno_permissions_web_worker")
-      .state(move |state| {
-        state.put::<PermissionsContainer>(permissions.clone());
-        state.put(ops::UnstableChecker { unstable });
-        state.put(ops::TestingFeaturesEnabled(enable_testing_features));
-      })
-      .build();
     let create_cache = options.cache_storage_dir.map(|storage_dir| {
       let create_cache_fn = move || SqliteBackedCache::new(storage_dir.clone());
       CreateCache(Arc::new(create_cache_fn))
@@ -387,68 +393,75 @@ impl WebWorker {
     // `runtime/build.rs`, `runtime/worker.rs` and `cli/build.rs`!
     let mut extensions: Vec<Extension> = vec![
       // Web APIs
-      deno_webidl::init(),
-      deno_console::init(),
-      deno_url::init_ops(),
-      deno_web::init_ops::<PermissionsContainer>(
+      deno_webidl::deno_webidl::init_ops(),
+      deno_console::deno_console::init_ops(),
+      deno_url::deno_url::init_ops(),
+      deno_web::deno_web::init_ops::<PermissionsContainer>(
         options.blob_store.clone(),
         Some(main_module.clone()),
       ),
-      deno_fetch::init_ops::<PermissionsContainer>(deno_fetch::Options {
-        user_agent: options.bootstrap.user_agent.clone(),
-        root_cert_store: options.root_cert_store.clone(),
-        unsafely_ignore_certificate_errors: options
-          .unsafely_ignore_certificate_errors
-          .clone(),
-        file_fetch_handler: Rc::new(deno_fetch::FsFetchHandler),
-        ..Default::default()
-      }),
-      deno_cache::init_ops::<SqliteBackedCache>(create_cache),
-      deno_websocket::init_ops::<PermissionsContainer>(
+      deno_fetch::deno_fetch::init_ops::<PermissionsContainer>(
+        deno_fetch::Options {
+          user_agent: options.bootstrap.user_agent.clone(),
+          root_cert_store: options.root_cert_store.clone(),
+          unsafely_ignore_certificate_errors: options
+            .unsafely_ignore_certificate_errors
+            .clone(),
+          file_fetch_handler: Rc::new(deno_fetch::FsFetchHandler),
+          ..Default::default()
+        },
+      ),
+      deno_cache::deno_cache::init_ops::<SqliteBackedCache>(create_cache),
+      deno_websocket::deno_websocket::init_ops::<PermissionsContainer>(
         options.bootstrap.user_agent.clone(),
         options.root_cert_store.clone(),
         options.unsafely_ignore_certificate_errors.clone(),
       ),
-      deno_webstorage::init_ops(None).disable(),
-      deno_crypto::init_ops(options.seed),
-      deno_broadcast_channel::init_ops(
+      deno_webstorage::deno_webstorage::init_ops(None).disable(),
+      deno_crypto::deno_crypto::init_ops(options.seed),
+      deno_broadcast_channel::deno_broadcast_channel::init_ops(
         options.broadcast_channel.clone(),
         unstable,
       ),
-      deno_ffi::init_ops::<PermissionsContainer>(unstable),
-      deno_net::init_ops::<PermissionsContainer>(
+      deno_ffi::deno_ffi::init_ops::<PermissionsContainer>(unstable),
+      deno_net::deno_net::init_ops::<PermissionsContainer>(
         options.root_cert_store.clone(),
         unstable,
         options.unsafely_ignore_certificate_errors.clone(),
       ),
-      deno_tls::init_ops(),
-      deno_napi::init_ops::<PermissionsContainer>(),
-      deno_http::init_ops(),
-      deno_io::init_ops(options.stdio),
-      deno_fs::init_ops::<PermissionsContainer>(unstable),
-      deno_flash::init_ops::<PermissionsContainer>(unstable),
-      deno_node::init_ops::<PermissionsContainer>(options.npm_resolver),
-      deno_node::init_polyfill_ops(),
+      deno_tls::deno_tls::init_ops(),
+      deno_napi::deno_napi::init_ops::<PermissionsContainer>(),
+      deno_http::deno_http::init_ops(),
+      deno_io::deno_io::init_ops(Rc::new(RefCell::new(Some(options.stdio)))),
+      deno_fs::deno_fs::init_ops::<PermissionsContainer>(unstable),
+      deno_flash::deno_flash::init_ops::<PermissionsContainer>(unstable),
+      deno_node::deno_node_loading::init_ops::<PermissionsContainer>(
+        options.npm_resolver,
+      ),
+      deno_node::deno_node::init_ops(),
       // Runtime ops that are always initialized for WebWorkers
-      ops::web_worker::init(),
-      ops::runtime::init(main_module.clone()),
-      ops::worker_host::init(
+      ops::web_worker::deno_web_worker::init_ops(),
+      ops::runtime::deno_runtime::init_ops(main_module.clone()),
+      ops::worker_host::deno_worker_host::init_ops(
         options.create_web_worker_cb.clone(),
         options.preload_module_cb.clone(),
         options.pre_execute_module_cb.clone(),
         options.format_js_error_fn.clone(),
       ),
-      ops::fs_events::init(),
-      ops::os::init_for_worker(),
-      ops::permissions::init(),
-      ops::process::init_ops(),
-      ops::signal::init(),
-      ops::tty::init(),
-      ops::http::init(),
+      ops::fs_events::deno_fs_events::init_ops(),
+      ops::os::deno_os_worker::init_ops(),
+      ops::permissions::deno_permissions::init_ops(),
+      ops::process::deno_process::init_ops(),
+      ops::signal::deno_signal::init_ops(),
+      ops::tty::deno_tty::init_ops(),
+      ops::http::deno_http_runtime::init_ops(),
+      deno_permissions_web_worker::init_ops(
+        permissions,
+        unstable,
+        enable_testing_features,
+      ),
     ];
 
-    extensions.push(perm_ext);
-
     // Append exts
     extensions.extend(std::mem::take(&mut options.extensions));
 
diff --git a/runtime/worker.rs b/runtime/worker.rs
index b7c05f7e1..8a7f5711d 100644
--- a/runtime/worker.rs
+++ b/runtime/worker.rs
@@ -1,5 +1,6 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
+use std::cell::RefCell;
 use std::pin::Pin;
 use std::rc::Rc;
 use std::sync::atomic::AtomicI32;
@@ -187,16 +188,22 @@ impl MainWorker {
     permissions: PermissionsContainer,
     mut options: WorkerOptions,
   ) -> Self {
+    deno_core::extension!(deno_permissions_worker,
+      config = {
+        permissions: PermissionsContainer,
+        unstable: bool,
+        enable_testing_features: bool,
+      },
+      state = |state, permissions, unstable, enable_testing_features| {
+        state.put::<PermissionsContainer>(permissions);
+        state.put(ops::UnstableChecker { unstable });
+        state.put(ops::TestingFeaturesEnabled(enable_testing_features));
+      },
+    );
+
     // Permissions: many ops depend on this
     let unstable = options.bootstrap.unstable;
     let enable_testing_features = options.bootstrap.enable_testing_features;
-    let perm_ext = Extension::builder("deno_permissions_worker")
-      .state(move |state| {
-        state.put::<PermissionsContainer>(permissions.clone());
-        state.put(ops::UnstableChecker { unstable });
-        state.put(ops::TestingFeaturesEnabled(enable_testing_features));
-      })
-      .build();
     let exit_code = ExitCode(Arc::new(AtomicI32::new(0)));
     let create_cache = options.cache_storage_dir.map(|storage_dir| {
       let create_cache_fn = move || SqliteBackedCache::new(storage_dir.clone());
@@ -207,67 +214,76 @@ impl MainWorker {
     // `runtime/build.rs`, `runtime/web_worker.rs` and `cli/build.rs`!
     let mut extensions = vec![
       // Web APIs
-      deno_webidl::init(),
-      deno_console::init(),
-      deno_url::init_ops(),
-      deno_web::init_ops::<PermissionsContainer>(
+      deno_webidl::deno_webidl::init_ops(),
+      deno_console::deno_console::init_ops(),
+      deno_url::deno_url::init_ops(),
+      deno_web::deno_web::init_ops::<PermissionsContainer>(
         options.blob_store.clone(),
         options.bootstrap.location.clone(),
       ),
-      deno_fetch::init_ops::<PermissionsContainer>(deno_fetch::Options {
-        user_agent: options.bootstrap.user_agent.clone(),
-        root_cert_store: options.root_cert_store.clone(),
-        unsafely_ignore_certificate_errors: options
-          .unsafely_ignore_certificate_errors
-          .clone(),
-        file_fetch_handler: Rc::new(deno_fetch::FsFetchHandler),
-        ..Default::default()
-      }),
-      deno_cache::init_ops::<SqliteBackedCache>(create_cache),
-      deno_websocket::init_ops::<PermissionsContainer>(
+      deno_fetch::deno_fetch::init_ops::<PermissionsContainer>(
+        deno_fetch::Options {
+          user_agent: options.bootstrap.user_agent.clone(),
+          root_cert_store: options.root_cert_store.clone(),
+          unsafely_ignore_certificate_errors: options
+            .unsafely_ignore_certificate_errors
+            .clone(),
+          file_fetch_handler: Rc::new(deno_fetch::FsFetchHandler),
+          ..Default::default()
+        },
+      ),
+      deno_cache::deno_cache::init_ops::<SqliteBackedCache>(create_cache),
+      deno_websocket::deno_websocket::init_ops::<PermissionsContainer>(
         options.bootstrap.user_agent.clone(),
         options.root_cert_store.clone(),
         options.unsafely_ignore_certificate_errors.clone(),
       ),
-      deno_webstorage::init_ops(options.origin_storage_dir.clone()),
-      deno_crypto::init_ops(options.seed),
-      deno_broadcast_channel::init_ops(
+      deno_webstorage::deno_webstorage::init_ops(
+        options.origin_storage_dir.clone(),
+      ),
+      deno_crypto::deno_crypto::init_ops(options.seed),
+      deno_broadcast_channel::deno_broadcast_channel::init_ops(
         options.broadcast_channel.clone(),
         unstable,
       ),
-      deno_ffi::init_ops::<PermissionsContainer>(unstable),
-      deno_net::init_ops::<PermissionsContainer>(
+      deno_ffi::deno_ffi::init_ops::<PermissionsContainer>(unstable),
+      deno_net::deno_net::init_ops::<PermissionsContainer>(
         options.root_cert_store.clone(),
         unstable,
         options.unsafely_ignore_certificate_errors.clone(),
       ),
-      deno_tls::init_ops(),
-      deno_napi::init_ops::<PermissionsContainer>(),
-      deno_http::init_ops(),
-      deno_io::init_ops(options.stdio),
-      deno_fs::init_ops::<PermissionsContainer>(unstable),
-      deno_flash::init_ops::<PermissionsContainer>(unstable),
-      deno_node::init_ops::<PermissionsContainer>(options.npm_resolver),
-      deno_node::init_polyfill_ops(),
+      deno_tls::deno_tls::init_ops(),
+      deno_napi::deno_napi::init_ops::<PermissionsContainer>(),
+      deno_http::deno_http::init_ops(),
+      deno_io::deno_io::init_ops(Rc::new(RefCell::new(Some(options.stdio)))),
+      deno_fs::deno_fs::init_ops::<PermissionsContainer>(unstable),
+      deno_flash::deno_flash::init_ops::<PermissionsContainer>(unstable),
+      deno_node::deno_node_loading::init_ops::<PermissionsContainer>(
+        options.npm_resolver,
+      ),
+      deno_node::deno_node::init_ops(),
       // Ops from this crate
-      ops::runtime::init(main_module.clone()),
-      ops::worker_host::init(
+      ops::runtime::deno_runtime::init_ops(main_module.clone()),
+      ops::worker_host::deno_worker_host::init_ops(
         options.create_web_worker_cb.clone(),
         options.web_worker_preload_module_cb.clone(),
         options.web_worker_pre_execute_module_cb.clone(),
         options.format_js_error_fn.clone(),
       ),
-      ops::fs_events::init(),
-      ops::os::init(exit_code.clone()),
-      ops::permissions::init(),
-      ops::process::init_ops(),
-      ops::signal::init(),
-      ops::tty::init(),
-      ops::http::init(),
+      ops::fs_events::deno_fs_events::init_ops(),
+      ops::os::deno_os::init_ops(exit_code.clone()),
+      ops::permissions::deno_permissions::init_ops(),
+      ops::process::deno_process::init_ops(),
+      ops::signal::deno_signal::init_ops(),
+      ops::tty::deno_tty::init_ops(),
+      ops::http::deno_http_runtime::init_ops(),
+      deno_permissions_worker::init_ops(
+        permissions,
+        unstable,
+        enable_testing_features,
+      ),
     ];
 
-    extensions.push(perm_ext);
-
     extensions.extend(std::mem::take(&mut options.extensions));
 
     #[cfg(not(feature = "dont_create_runtime_snapshot"))]