Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(modules): bind synthetic sources to their compiled records
ldm0fdd0542c5315
diff --git a/moli-core/tests/scripts.rs b/moli-core/tests/scripts.rsindex 73032057c..29f5a2d89 100644--- a/moli-core/tests/scripts.rs+++ b/moli-core/tests/scripts.rs@@ -13,6 +13,9 @@ use moli_core::{use support::FixtureServer;use tokio::time::Duration;+#[path = "scripts/child_synthetic_modules.rs"]+mod child_synthetic_modules;+fn diagnostic_global<'a>(page: &'a moli_core::page::Page,name: &str,diff --git a/moli-core/tests/scripts/child_synthetic_modules.rs b/moli-core/tests/scripts/child_synthetic_modules.rsnew file mode 100644index 000000000..201429ddd--- /dev/null+++ b/moli-core/tests/scripts/child_synthetic_modules.rs@@ -0,0 +1,137 @@+use super::*;++async fn evaluate_child_synthetic_expression(expression: &str) -> Result<serde_json::Value> {+ let server = FixtureServer::spawn().await?;+ let browser = Browser::new(AppConfig::default())?;+ let mut page = browser.fetch(&server.url("/static")).await?;+ let result = page+ .evaluate_runtime_expression_with_await_async(expression, true)+ .await?;+ server.shutdown().await;+ Ok(result)+}++async fn child_synthetic_probe(source: &str) -> Result<serde_json::Value> {+ let html = format!(+ r#"<!doctype html><script>+ window.result = 'not evaluated';+ window.onerror = (message, url, line, column, error) => {{+ window.result = error.name + ': ' + error.message;+ }};+ </script><script type="module">{source}</script>"#+ );+ let expression = format!(+ r#"new Promise(resolve => {{+ const frame = document.createElement('iframe');+ frame.onload = () => resolve(frame.contentWindow.result);+ frame.srcdoc = {};+ document.body.appendChild(frame);+ }})"#,+ serde_json::to_string(&html)?+ );+ evaluate_child_synthetic_expression(&expression).await+}++#[tokio::test(flavor = "multi_thread")]+async fn child_synthetic_json_module_uses_its_own_document_source() -> Result<()> {+ let result = child_synthetic_probe(+ r#"import value from 'data:application/json,{"answer":42}' with { type: 'json' };+ window.result = value.answer + ':' + (Object.getPrototypeOf(value) === Object.prototype);"#,+ )+ .await?;+ assert_eq!(result["value"], "42:true", "{result:?}");+ Ok(())+}++#[tokio::test(flavor = "multi_thread")]+async fn child_synthetic_css_module_uses_its_own_document_source() -> Result<()> {+ let result = child_synthetic_probe(+ r#"import sheet from 'data:text/css,body%20%7B%20color%3A%20red%3B%20%7D' with { type: 'css' };+ window.result = (sheet instanceof CSSStyleSheet) + ':' + sheet.cssRules.length;"#,+ )+ .await?;+ assert_eq!(result["value"], "true:1", "{result:?}");+ Ok(())+}++#[tokio::test(flavor = "multi_thread")]+async fn child_synthetic_dynamic_import_after_load_uses_its_realm() -> Result<()> {+ let result = evaluate_child_synthetic_expression(+ r#"(async () => {+ const frame = document.createElement('iframe');+ const loaded = new Promise(resolve => frame.onload = resolve);+ frame.srcdoc = `<script>+ window.probe = async () => {+ await new Promise(resolve => setTimeout(resolve, 0));+ const jsonUrl = 'data:application/json,{"answer":42}';+ const cssUrl = 'data:text/css,body%7Bcolor%3Ared%7D';+ const json = await import(jsonUrl, {with: {type: 'json'}});+ const css = await import(cssUrl, {with: {type: 'css'}});+ const again = await import(jsonUrl, {with: {type: 'json'}});+ let failure;+ try { await import('data:application/json,invalid', {with: {type: 'json'}}); }+ catch (error) { failure = error; }+ return [json.default.answer === 42,+ Object.getPrototypeOf(json.default) === Object.prototype,+ css.default instanceof CSSStyleSheet, css.default.cssRules.length === 1,+ json === again, failure instanceof SyntaxError].join(':');+ };+ </script>`;+ document.body.appendChild(frame);+ await loaded;+ return await frame.contentWindow.probe();+ })()"#,+ )+ .await?;+ assert_eq!(+ result["value"], "true:true:true:true:true:true",+ "{result:?}"+ );+ Ok(())+}++#[tokio::test(flavor = "multi_thread")]+async fn child_synthetic_module_values_are_cached_per_realm_not_per_url() -> Result<()> {+ let result = evaluate_child_synthetic_expression(+ r#"(async () => {+ const jsonUrl = 'data:application/json,{"answer":42}';+ const cssUrl = 'data:text/css,body%7Bcolor%3Ared%7D';+ const rootJson = (await import(jsonUrl, {with: {type: 'json'}})).default;+ const rootSheet = (await import(cssUrl, {with: {type: 'css'}})).default;+ const makeFrame = async () => {+ const frame = document.createElement('iframe');+ const loaded = new Promise(resolve => frame.onload = resolve);+ frame.srcdoc = `<script type="module">+ import value from '${jsonUrl}' with {type: 'json'};+ import sheet from '${cssUrl}' with {type: 'css'};+ window.value = value;+ window.sheet = sheet;+ window.readAgain = async () => {+ const json = await import('${jsonUrl}', {with: {type: 'json'}});+ const css = await import('${cssUrl}', {with: {type: 'css'}});+ return json.default === value && css.default === sheet;+ };+ </script>`;+ document.body.appendChild(frame);+ await loaded;+ return frame.contentWindow;+ };+ const [left, right] = await Promise.all([makeFrame(), makeFrame()]);+ left.value.answer = 7;+ left.sheet.insertRule('p { color: blue; }', 1);+ return [rootJson.answer === 42, right.value.answer === 42,+ left.value.answer === 7, rootSheet.cssRules.length === 1,+ right.sheet.cssRules.length === 1, left.sheet.cssRules.length === 2,+ left.value !== right.value, left.value !== rootJson,+ left.sheet !== right.sheet, left.sheet !== rootSheet,+ Object.getPrototypeOf(left.value) === left.Object.prototype,+ Object.getPrototypeOf(right.value) === right.Object.prototype,+ left.sheet instanceof left.CSSStyleSheet,+ right.sheet instanceof right.CSSStyleSheet,+ await left.readAgain(), await right.readAgain()].join(':');+ })()"#,+ )+ .await?;+ assert_eq!(result["value"], ["true"; 16].join(":"), "{result:?}");+ Ok(())+}diff --git a/moli-renderer-v8/src/document_runtime/script_scheduling/module_facade.rs b/moli-renderer-v8/src/document_runtime/script_scheduling/module_facade.rsindex 7ee40424d..7f76029dd 100644--- a/moli-renderer-v8/src/document_runtime/script_scheduling/module_facade.rs+++ b/moli-renderer-v8/src/document_runtime/script_scheduling/module_facade.rs@@ -198,15 +198,6 @@ impl DocumentRuntime {.native_module_source(entry_id)}- pub(crate) fn native_module_source_for(- &self,- module: v8::Local<'_, v8::Module>,- ) -> Option<(ModuleMapKey, ModuleSource)> {- self.script_lifecycle- .scripts()- .native_module_source_for(module)- }-pub(crate) fn native_module_wasm_record_for(&self,module: v8::Local<'_, v8::Module>,diff --git a/moli-renderer-v8/src/host/scripts.rs b/moli-renderer-v8/src/host/scripts.rsindex acbaab3f9..c47bba132 100644--- a/moli-renderer-v8/src/host/scripts.rs+++ b/moli-renderer-v8/src/host/scripts.rs@@ -601,13 +601,6 @@ impl HostScriptScheduler {self.module_owner.native_module_source(entry_id)}- pub(crate) fn native_module_source_for(- &self,- module: v8::Local<'_, v8::Module>,- ) -> Option<(ModuleMapKey, ModuleSource)> {- self.module_owner.native_module_source_for(module)- }-pub(crate) fn native_module_wasm_record_for(&self,module: v8::Local<'_, v8::Module>,diff --git a/moli-renderer-v8/src/module_runtime.rs b/moli-renderer-v8/src/module_runtime.rsindex 2ac34262f..ca77ac351 100644--- a/moli-renderer-v8/src/module_runtime.rs+++ b/moli-renderer-v8/src/module_runtime.rs@@ -13,6 +13,7 @@ mod record_resolver;mod resolver;mod response_mime;mod single_module_fetch;+mod synthetic_text;#[cfg(test)]mod tests;mod tree_adapter;@@ -55,6 +56,7 @@ pub(crate) use self::response_mime::{validate_css_module_response_mime, validate_json_module_response_mime,};pub(crate) use self::single_module_fetch::NativeModuleSingleFetchRequest;+pub(crate) use self::synthetic_text::SyntheticTextModuleSource;pub(crate) use self::tree_owner::{NativeModuleTreeDocumentOwnerAdapter, NativeModuleTreeFrameDocumentOwner,};@@ -490,13 +492,6 @@ impl ModuleOwnerState {self.document_modulator.entry(entry_id).source().cloned()}- pub(crate) fn native_module_source_for(- &self,- module: v8::Local<'_, v8::Module>,- ) -> Option<(ModuleMapKey, ModuleSource)> {- self.document_modulator.module_source_for(module)- }-pub(crate) fn native_module_wasm_record_for(&self,module: v8::Local<'_, v8::Module>,diff --git a/moli-renderer-v8/src/module_runtime/modulator.rs b/moli-renderer-v8/src/module_runtime/modulator.rsindex 45c8f31cc..05e75121d 100644--- a/moli-renderer-v8/src/module_runtime/modulator.rs+++ b/moli-renderer-v8/src/module_runtime/modulator.rs@@ -655,14 +655,6 @@ impl NativeDocumentModulator {.set_record_state_for_entry(self.core.entry(entry_id), ModuleRecordState::Evaluated);}- pub(crate) fn module_source_for(- &self,- module: v8::Local<'_, v8::Module>,- ) -> Option<(ModuleMapKey, ModuleSource)> {- let entry = self.entry(self.module_entry_id_for(module)?);- Some((entry.effective_key().clone(), entry.source()?.clone()))- }-pub(crate) fn module_wasm_record_for(&self,module: v8::Local<'_, v8::Module>,diff --git a/moli-renderer-v8/src/module_runtime/record.rs b/moli-renderer-v8/src/module_runtime/record.rsindex 335fd32ad..aacf68ceb 100644--- a/moli-renderer-v8/src/module_runtime/record.rs+++ b/moli-renderer-v8/src/module_runtime/record.rs@@ -19,6 +19,8 @@ pub(crate) struct ModuleRecordEntry {compiled_module: v8::Global<v8::Module>,requests: Vec<ModuleRequestRecord>,wasm_module: Option<WasmModuleRecord>,+ // Own the evaluation data; the Context's lookup only keeps a weak reference.+ synthetic_text_module_source: Option<Rc<super::SyntheticTextModuleSource>>,state: ModuleRecordState,}@@ -33,6 +35,7 @@ impl ModuleRecordEntry {compiled_module,requests,wasm_module: None,+ synthetic_text_module_source: None,state: ModuleRecordState::Compiled,}}@@ -48,6 +51,7 @@ impl ModuleRecordEntry {compiled_module,requests,wasm_module: Some(wasm_module),+ synthetic_text_module_source: None,state: ModuleRecordState::Compiled,}}@@ -56,6 +60,14 @@ impl ModuleRecordEntry {&self.key}+ pub(crate) fn with_synthetic_text_module_source(+ mut self,+ source: Rc<super::SyntheticTextModuleSource>,+ ) -> Self {+ self.synthetic_text_module_source = Some(source);+ self+ }+pub(crate) fn compiled_module(&self) -> &v8::Global<v8::Module> {&self.compiled_module}diff --git a/moli-renderer-v8/src/module_runtime/synthetic_text.rs b/moli-renderer-v8/src/module_runtime/synthetic_text.rsnew file mode 100644index 000000000..2906395af--- /dev/null+++ b/moli-renderer-v8/src/module_runtime/synthetic_text.rs@@ -0,0 +1,153 @@+use std::cell::RefCell;+use std::collections::HashMap;+use std::rc::{Rc, Weak};++use super::{ModuleIdentityHash, ModuleMapKey, module_identity_hash_from_v8_module};++/// Evaluation data belongs to the compiled module record, not the page's+/// default Document. The Context only holds weak references, so this lookup+/// does not keep a disposed realm or its compiled modules alive.+#[derive(Debug)]+pub(crate) struct SyntheticTextModuleSource {+ module: v8::Global<v8::Module>,+ key: ModuleMapKey,+ source: String,+}++#[derive(Default)]+struct SyntheticTextModuleSources {+ entries: RefCell<HashMap<ModuleIdentityHash, Vec<Weak<SyntheticTextModuleSource>>>>,+}++impl SyntheticTextModuleSource {+ pub(crate) fn register(+ scope: &mut v8::PinScope<'_, '_>,+ module: v8::Local<'_, v8::Module>,+ key: ModuleMapKey,+ source: &str,+ ) -> Rc<Self> {+ let context = scope.get_current_context();+ let sources = context+ .get_slot::<SyntheticTextModuleSources>()+ .unwrap_or_else(|| {+ let sources = Rc::new(SyntheticTextModuleSources::default());+ context.set_slot(sources.clone());+ sources+ });+ let record = Rc::new(Self {+ module: v8::Global::new(scope, module),+ key,+ source: source.to_owned(),+ });+ let mut entries = sources.entries.borrow_mut();+ let candidates = entries+ .entry(module_identity_hash_from_v8_module(module))+ .or_default();+ candidates.retain(|candidate| candidate.strong_count() != 0);+ candidates.push(Rc::downgrade(&record));+ record+ }++ pub(crate) fn for_module(+ context: v8::Local<'_, v8::Context>,+ module: v8::Local<'_, v8::Module>,+ ) -> Option<Rc<Self>> {+ let sources = context.get_slot::<SyntheticTextModuleSources>()?;+ let entries = sources.entries.borrow();+ entries+ .get(&module_identity_hash_from_v8_module(module))?+ .iter()+ .filter_map(Weak::upgrade)+ // V8 identity hashes are not unique, even within one Context.+ .find(|candidate| module == candidate.module)+ }++ pub(crate) fn key(&self) -> &ModuleMapKey {+ &self.key+ }++ pub(crate) fn source(&self) -> &str {+ &self.source+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::module_runtime::{ModuleAttributesKey, ModuleRecordEntry};+ use url::Url;++ fn unused_evaluation_steps<'s>(+ context: v8::Local<'s, v8::Context>,+ _module: v8::Local<'s, v8::Module>,+ ) -> Option<v8::Local<'s, v8::Value>> {+ v8::callback_scope!(unsafe scope, context);+ Some(v8::undefined(scope).into())+ }++ #[test]+ fn synthetic_text_module_lookup_checks_context_and_exact_identity() {+ crate::ensure_v8_for_test();+ let mut isolate = v8::Isolate::new(Default::default());+ let scope = std::pin::pin!(v8::HandleScope::new(&mut isolate));+ let scope = &mut scope.init();+ let context = v8::Context::new(scope, Default::default());+ let scope = &mut v8::ContextScope::new(scope, context);+ let name = v8::String::new(scope, "https://example.test/shared.json").unwrap();+ let first = v8::Module::create_synthetic_module(scope, name, &[], unused_evaluation_steps);+ let second = v8::Module::create_synthetic_module(scope, name, &[], unused_evaluation_steps);+ let key = ModuleMapKey::json_with_attributes(+ Url::parse("https://example.test/shared.json").unwrap(),+ ModuleAttributesKey::empty(),+ );+ let first_source = SyntheticTextModuleSource::register(scope, first, key.clone(), "1");+ let second_source = SyntheticTextModuleSource::register(scope, second, key, "2");++ // Inject a conflicting candidate deterministically instead of waiting+ // for a random V8 identity-hash collision.+ let sources = context.get_slot::<SyntheticTextModuleSources>().unwrap();+ sources+ .entries+ .borrow_mut()+ .get_mut(&module_identity_hash_from_v8_module(second))+ .unwrap()+ .insert(0, Rc::downgrade(&first_source));+ assert!(Rc::ptr_eq(+ &SyntheticTextModuleSource::for_module(context, second).unwrap(),+ &second_source,+ ));+ let foreign = v8::Context::new(scope, Default::default());+ assert!(SyntheticTextModuleSource::for_module(foreign, first).is_none());+ }++ #[test]+ fn synthetic_text_module_lookup_does_not_keep_disposed_records_alive() {+ crate::ensure_v8_for_test();+ let mut isolate = v8::Isolate::new(Default::default());+ let scope = std::pin::pin!(v8::HandleScope::new(&mut isolate));+ let scope = &mut scope.init();+ let context = v8::Context::new(scope, Default::default());+ let scope = &mut v8::ContextScope::new(scope, context);+ let name = v8::String::new(scope, "https://example.test/value.json").unwrap();+ let module = v8::Module::create_synthetic_module(scope, name, &[], unused_evaluation_steps);+ let key = ModuleMapKey::json_with_attributes(+ Url::parse("https://example.test/value.json").unwrap(),+ ModuleAttributesKey::empty(),+ );+ let source = SyntheticTextModuleSource::register(scope, module, key.clone(), "42");+ let weak = Rc::downgrade(&source);+ let record = ModuleRecordEntry::new(key, v8::Global::new(scope, module), Vec::new())+ .with_synthetic_text_module_source(source);+ let clone = record.clone();+ drop(record);+ assert_eq!(+ SyntheticTextModuleSource::for_module(context, module)+ .unwrap()+ .source(),+ "42"+ );+ drop(clone);+ assert!(weak.upgrade().is_none());+ assert!(SyntheticTextModuleSource::for_module(context, module).is_none());+ }+}diff --git a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rsindex 638c8798e..bc781f462 100644--- a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs@@ -2,10 +2,7 @@ use super::{JsContextHost, OwnerDispatchScope};use crate::network::loads::{ResourceLoadDisposition, ResourceLoadKind, ResourceLoadLease};use crate::types::DedicatedWorkerId;use crate::{- module_runtime::{- ModuleAttributesKey, ModuleMapKey, ModuleSource, PendingDynamicModuleImport,- WasmModuleRecord,- },+ module_runtime::{ModuleAttributesKey, PendingDynamicModuleImport, WasmModuleRecord},page_task_queue::RendererResourceCompletionSender,renderer_resource_scheduler::RendererResourceScheduler,types::{@@ -86,14 +83,6 @@ impl JsContextHost {unsafe { &mut *self.runtime }.resolve_module_specifier(specifier, base_url)}- pub(crate) fn native_module_source_for(- &self,- module: v8::Local<'_, v8::Module>,- ) -> Option<(ModuleMapKey, ModuleSource)> {- // SAFETY: JsContextHost is owned by the ScriptVm that owns this DocumentRuntime.- unsafe { &*self.runtime }.native_module_source_for(module)- }-pub(crate) fn native_module_wasm_record_for(&self,module: v8::Local<'_, v8::Module>,diff --git a/moli-renderer-v8/src/script_vm/native_module.rs b/moli-renderer-v8/src/script_vm/native_module.rsindex 905e0b5fc..6490a27fa 100644--- a/moli-renderer-v8/src/script_vm/native_module.rs+++ b/moli-renderer-v8/src/script_vm/native_module.rs@@ -854,48 +854,43 @@ fn get_i64_reaction_data_slot<'s>(lossless.then_some(value)}-fn synthetic_module_evaluation_steps<'s>(+fn synthetic_text_module_evaluation_steps<'s>(context: v8::Local<'s, v8::Context>,module: v8::Local<'s, v8::Module>,) -> Option<v8::Local<'s, v8::Value>> {v8::callback_scope!(unsafe scope, context);- let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {- return throw_synthetic_module_error(scope, "synthetic module host is not available");- };- let Some((key, source)) = (unsafe { &*host_ptr }).native_module_source_for(module) else {+ let Some(record) =+ crate::module_runtime::SyntheticTextModuleSource::for_module(context, module)+ else {return throw_synthetic_module_error(scope, "synthetic module source is not available");};- match key.kind() {- ModuleKind::Json => {- let Some(source) = source.text_source() else {- return throw_synthetic_module_error(scope, "JSON module source is not text");- };- evaluate_json_synthetic_module(scope, module, source)- }+ let source = record.source();+ match record.key().kind() {+ ModuleKind::Json => evaluate_json_synthetic_module(scope, module, source),ModuleKind::Css => {- let Some(source) = source.text_source() else {- return throw_synthetic_module_error(scope, "CSS module source is not text");- };- evaluate_css_synthetic_module(scope, module, key.url().as_str(), source)+ evaluate_css_synthetic_module(scope, module, record.key().url().as_str(), source)}- ModuleKind::WebAssembly => {- let Some(wasm_record) = (unsafe { &*host_ptr }).native_module_wasm_record_for(module)- else {- return throw_synthetic_module_error(- scope,- "WebAssembly synthetic module record is not available",- );- };- evaluate_wasm_synthetic_module(scope, module, &wasm_record, |scope, import| {- wasm_import_value(scope, module, import)- })- }- ModuleKind::JavaScript | ModuleKind::ModulePreloadText => throw_synthetic_module_error(- scope,- "non-synthetic module reached synthetic module evaluation",- ),+ _ => throw_synthetic_module_error(scope, "unexpected synthetic text module kind"),}}+fn wasm_synthetic_module_evaluation_steps<'s>(+ context: v8::Local<'s, v8::Context>,+ module: v8::Local<'s, v8::Module>,+) -> Option<v8::Local<'s, v8::Value>> {+ v8::callback_scope!(unsafe scope, context);+ let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {+ return throw_synthetic_module_error(scope, "synthetic module host is not available");+ };+ let Some(wasm_record) = (unsafe { &*host_ptr }).native_module_wasm_record_for(module) else {+ return throw_synthetic_module_error(+ scope,+ "WebAssembly synthetic module record is not available",+ );+ };+ evaluate_wasm_synthetic_module(scope, module, &wasm_record, |scope, import| {+ wasm_import_value(scope, module, import)+ })+}fn evaluate_json_synthetic_module<'s>(scope: &mut v8::PinScope<'s, '_>,diff --git a/moli-renderer-v8/src/script_vm/native_module/module_graph.rs b/moli-renderer-v8/src/script_vm/native_module/module_graph.rsindex 7dde5f9d3..a811f9f0f 100644--- a/moli-renderer-v8/src/script_vm/native_module/module_graph.rs+++ b/moli-renderer-v8/src/script_vm/native_module/module_graph.rs@@ -164,21 +164,6 @@ impl ScriptVm {}})}- pub(super) fn compile_synthetic_module_record_in_context(- &mut self,- context_ptr: *const v8::Global<v8::Context>,- key: ModuleMapKey,- _source: &str,- source_url: &Url,- ) -> std::result::Result<(ModuleRecordEntry, ModuleIdentityHash), ModuleLoadError> {- self.compile_synthetic_module_record_with_exports_in_context(- context_ptr,- key,- source_url,- &["default"],- None,- )- }pub(super) fn compile_wasm_module_record_in_context(&mut self,context_ptr: *const v8::Global<v8::Context>,@@ -229,7 +214,7 @@ impl ScriptVm {&scope,module_name,&export_names,- synthetic_module_evaluation_steps,+ wasm_synthetic_module_evaluation_steps,);let identity = module_identity_hash_from_v8_module(module);let compiled_module = v8::Global::new(scope.as_ref(), module);@@ -248,13 +233,12 @@ impl ScriptVm {.with_error_constructor(ScriptErrorConstructorKind::WebAssemblyCompileError)})}- pub(super) fn compile_synthetic_module_record_with_exports_in_context(+ pub(super) fn compile_synthetic_module_record_in_context(&mut self,context_ptr: *const v8::Global<v8::Context>,key: ModuleMapKey,+ source: &str,source_url: &Url,- export_names: &[&str],- wasm_record: Option<(Vec<ModuleRequestRecord>, WasmModuleRecord)>,) -> std::result::Result<(ModuleRecordEntry, ModuleIdentityHash), ModuleLoadError> {self.renderer_document_isolate.with_entered_renderer_document_isolate(|isolate| {@@ -263,36 +247,29 @@ impl ScriptVm {let context = unsafe { v8::Local::new(scope, &*context_ptr) };let scope = &mut v8::ContextScope::new(scope, context);let try_catch = pin!(v8::TryCatch::new(scope));- let scope = try_catch.init();+ let mut scope = try_catch.init();let module_name = v8_string(&scope, source_url.as_str()).ok_or_else(|| {anyhow::anyhow!("failed to allocate v8 synthetic module name")})?;- let export_names = export_names- .iter()- .map(|name| {- v8_string(&scope, name).ok_or_else(|| {- anyhow::anyhow!("failed to allocate synthetic export name")- })- })- .collect::<Result<Vec<_>>>()?;+ let default_export = v8_string(&scope, "default")+ .ok_or_else(|| anyhow::anyhow!("failed to allocate synthetic export name"))?;let module = v8::Module::create_synthetic_module(&scope,module_name,- &export_names,- synthetic_module_evaluation_steps,+ &[default_export],+ synthetic_text_module_evaluation_steps,);let identity = module_identity_hash_from_v8_module(module);+ let evaluation_source = crate::module_runtime::SyntheticTextModuleSource::register(+ &mut scope,+ module,+ key.clone(),+ source,+ );let compiled_module = v8::Global::new(scope.as_ref(), module);- let entry = match wasm_record {- Some((requests, wasm_module)) => ModuleRecordEntry::new_with_wasm_module(- key,- compiled_module,- requests,- wasm_module,- ),- None => ModuleRecordEntry::new(key, compiled_module, Vec::new()),- };+ let entry = ModuleRecordEntry::new(key, compiled_module, Vec::new())+ .with_synthetic_text_module_source(evaluation_source);Ok((entry, identity))}).map_err(|error| ModuleLoadError::new(ModuleLoadStage::Compile, error.to_string()))