Method create_isolate

components/vm/src/vm.rs:146–199

(
        extension_factory: &ExtensionFactory,
        module_manager: Rc<ModuleManager>,
        script_load_states: ScriptsStateStoreHandle,
        shutdown_handle: VmShutdownHandle,
    )

    }

    fn create_isolate(
        extension_factory: &ExtensionFactory,
        module_manager: Rc<ModuleManager>,
        script_load_states: ScriptsStateStoreHandle,
        shutdown_handle: VmShutdownHandle,
    ) -> JsRuntime {
        let mut extensions = extension_factory();
        let cloned_load_states = script_load_states.clone();

        extensions.insert(
            0,
            bl_core::init_ops_and_esm(crate::BlCoreOptions { cloned_load_states }),
        );

        let options = RuntimeOptions {
            extensions,
            module_loader: Some(module_manager),
            get_error_class_fn: Some(&|err| {
                deno_core::error::get_custom_error_class(err).unwrap_or("Error")
            }),
            // yeah i have no idea what these values needs to be aligned to, but this seems to work so whatever
            // if it breaks when you update deno or v8 try different values until it works, if only they'd document the alignment requirements somewhere...
            create_params: Some(
                CreateParams::default()
                    .heap_limits(512 * 1024, 50 * 1024 * 1024)
                    .allow_atomics_wait(false),
            ),
            startup_snapshot: Some(crate::BOTLOADER_CORE_SNAPSHOT),
            // js_error_create_fn: Some(create_err_fn),
            source_map_getter: Some(Rc::new(ScriptStateStoreWrapper(script_load_states))),
            ..Default::default()
        };

        let another_handle = shutdown_handle.clone();

        let mut rt = JsRuntime::new(options);
        {
            let op_state = rt.op_state();
            op_state.borrow_mut().put(another_handle);
        }
        rt.add_near_heap_limit_callback(move |current, initial| {
            info!(
                "near heap limit: current: {}, initial: {}",
                current, initial
            );
            shutdown_handle.shutdown_vm(ShutdownReason::OutOfMemory, true);
            if current != initial {
                current
            } else {
                current + initial
            }
        });
        rt
    }

    fn emit_isolate_handle(&mut self) {
        let handle = self.runtime.v8_isolate().thread_safe_handle();