Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use std::cell::RefCell;
use std::collections::{HashMap, HashSet, VecDeque};
use std::pin::pin;
use std::rc::Rc;
use crate::exception_reporting::{V8ExceptionReport, build_event_handler_exception_report};
use crate::module_runtime::{
ModuleAttributesKey, ModuleImportPhase, WasmDependencyModuleMessages, WasmImportRecord,
WasmModuleRecord, ensure_wasm_dependency_module_namespace_ready,
evaluate_wasm_synthetic_module, preserve_current_v8_module_exception, throw_wasm_link_error,
throw_wasm_synthetic_module_error, wasm_dependency_export_value,
};
use crate::util::{get_private_value, v8_string, v8str};
use crate::wasm_module_support::{
prepare_wasm_module_record, v8_exception_message_or, wasm_evaluation_import_modules,
};
use moli_fetch::{BrowserRequestMetadata, RequestCredentialsMode};
use moli_webapi_declare::WebApiObject;
use tokio::sync::mpsc;
use url::Url;
use super::global_scope::worker_current_script_url;
use super::handle::{WorkerParentErrorEventKind, WorkerScriptResource, WorkerScriptResourceKind};
use crate::content_security_policy::ContentSecurityPolicyUrlViolation;
pub(super) type WorkerBootstrapError = (
V8ExceptionReport,
Option<v8::Global<v8::Value>>,
WorkerParentErrorEventKind,
);
pub(super) type WorkerModuleGraphFetchId = u64;
pub(super) type WorkerModuleEvaluationId = u64;
const WORKER_MODULE_EVALUATION_REACTION_ID_SLOT: &str = "workerModuleEvaluationReactionId";
#[derive(WebApiObject)]
#[webapi(plain)]
struct WorkerModuleEvaluationReactionDataDeclaration {
#[webapi(slot = WORKER_MODULE_EVALUATION_REACTION_ID_SLOT)]
evaluation_id: f64,
}
#[derive(WebApiObject)]
#[webapi(plain)]
struct WorkerImportMetaDeclaration<'scope> {
#[webapi(data_property, enumerable)]
url: v8::Local<'scope, v8::String>,
#[webapi(
method,
enumerable,
callback = worker_import_meta_resolve_callback,
data = self.url,
length = 1
)]
resolve: (),
}
pub(super) struct WorkerModuleGraphFetchCompletion {
fetch_id: WorkerModuleGraphFetchId,
result: Result<WorkerModuleFetchedSource, String>,
csp_violation: Option<ContentSecurityPolicyUrlViolation>,
csp_report_only_violation: Option<ContentSecurityPolicyUrlViolation>,
}
pub(super) struct WorkerModuleFetchedSource {
final_url: Url,
source: WorkerModuleSource,
resource: Option<WorkerScriptResource>,
response_referrer_policy: Option<String>,
}
#[derive(Clone)]
pub(super) enum WorkerModuleSource {
Text(String),
Binary(Vec<u8>),
}
pub(super) struct WorkerModuleEvaluationCompletion {
evaluation_id: WorkerModuleEvaluationId,
result: Result<(), String>,
}
pub(super) enum WorkerDynamicModuleImportAdvance {
Complete,
NeedFetches(WorkerModuleGraphFetchBatch),
WaitingFetches,
WaitingEvaluation {
evaluation_id: WorkerModuleEvaluationId,
},
}
#[derive(Clone, Copy)]
enum WorkerDynamicModuleImportErrorKind {
Type,
Syntax,
}
struct WorkerDynamicModuleImportError {
message: String,
kind: WorkerDynamicModuleImportErrorKind,
rejection: Option<v8::Global<v8::Value>>,
stage: WorkerDynamicModuleImportErrorStage,
}
type WorkerDynamicModuleImportResult<T> = Result<T, WorkerDynamicModuleImportError>;
#[derive(Clone, Copy, PartialEq, Eq)]
enum WorkerDynamicModuleImportErrorStage {
Graph,
Instantiate,
Evaluate,
}
impl WorkerDynamicModuleImportError {
fn type_error(message: impl Into<String>) -> Self {
Self {
message: message.into(),
kind: WorkerDynamicModuleImportErrorKind::Type,
rejection: None,
stage: WorkerDynamicModuleImportErrorStage::Graph,
}
}
fn syntax_error(message: impl Into<String>) -> Self {
Self {
message: message.into(),
kind: WorkerDynamicModuleImportErrorKind::Syntax,
rejection: None,
stage: WorkerDynamicModuleImportErrorStage::Graph,
}
}
fn caught_instantiate_exception(
scope: &mut v8::PinScope<'_, '_>,
exception: Option<v8::Local<'_, v8::Value>>,
fallback: impl Into<String>,
) -> Self {
Self {
message: fallback.into(),
kind: WorkerDynamicModuleImportErrorKind::Type,
rejection: exception.map(|exception| v8::Global::new(scope, exception)),
stage: WorkerDynamicModuleImportErrorStage::Instantiate,
}
}
fn caught_evaluation_exception(
scope: &mut v8::PinScope<'_, '_>,
exception: Option<v8::Local<'_, v8::Value>>,
fallback: impl Into<String>,
) -> Self {
Self {
message: fallback.into(),
kind: WorkerDynamicModuleImportErrorKind::Type,
rejection: exception.map(|exception| v8::Global::new(scope, exception)),
stage: WorkerDynamicModuleImportErrorStage::Evaluate,
}
}
fn evaluation_rejection_value(
scope: &mut v8::PinScope<'_, '_>,
value: v8::Local<'_, v8::Value>,
fallback: impl Into<String>,
) -> Self {
Self {
message: fallback.into(),
kind: WorkerDynamicModuleImportErrorKind::Type,
rejection: Some(v8::Global::new(scope, value)),
stage: WorkerDynamicModuleImportErrorStage::Evaluate,
}
}
fn clone_for_scope(&self, scope: &mut v8::PinScope<'_, '_>) -> Self {
Self {
message: self.message.clone(),
kind: self.kind,
rejection: self
.rejection
.as_ref()
.map(|value| v8::Global::new(scope, v8::Local::new(scope, value))),
stage: self.stage,
}
}
}
impl From<String> for WorkerDynamicModuleImportError {
fn from(message: String) -> Self {
Self::type_error(message)
}
}
impl WorkerModuleGraphFetchCompletion {
pub(super) fn new(
fetch_id: WorkerModuleGraphFetchId,
result: Result<WorkerModuleFetchedSource, String>,
) -> Self {
Self {
fetch_id,
result,
csp_violation: None,
csp_report_only_violation: None,
}
}
pub(super) fn with_csp_violation(
mut self,
violation: ContentSecurityPolicyUrlViolation,
) -> Self {
self.csp_violation = Some(violation);
self
}
pub(super) fn with_csp_report_only_violation(
mut self,
violation: ContentSecurityPolicyUrlViolation,
) -> Self {
self.csp_report_only_violation = Some(violation);
self
}
pub(super) fn fetch_id(&self) -> WorkerModuleGraphFetchId {
self.fetch_id
}
pub(super) fn csp_violation(&self) -> Option<&ContentSecurityPolicyUrlViolation> {
self.csp_violation.as_ref()
}
pub(super) fn csp_report_only_violation(&self) -> Option<&ContentSecurityPolicyUrlViolation> {
self.csp_report_only_violation.as_ref()
}
pub(super) fn result(&self) -> Result<&WorkerModuleFetchedSource, &str> {
self.result.as_ref().map_err(String::as_str)
}
}
impl WorkerModuleFetchedSource {
pub(super) fn new(final_url: Url, source: WorkerModuleSource) -> Self {
Self {
final_url,
source,
resource: None,
response_referrer_policy: None,
}
}
pub(super) fn with_resource(mut self, resource: WorkerScriptResource) -> Self {
self.resource = Some(resource);
self
}
pub(super) fn with_response_referrer_policy(
mut self,
response_referrer_policy: Option<String>,
) -> Self {
self.response_referrer_policy = response_referrer_policy;
self
}
pub(super) fn final_url(&self) -> &Url {
&self.final_url
}
pub(super) fn source(&self) -> &WorkerModuleSource {
&self.source
}
pub(super) fn resource(&self) -> Option<&WorkerScriptResource> {
self.resource.as_ref()
}
fn effective_referrer_policy(&self, inherited_referrer_policy: Option<&str>) -> Option<String> {
self.response_referrer_policy
.clone()
.or_else(|| inherited_referrer_policy.map(str::to_owned))
}
}
impl WorkerModuleSource {
pub(super) fn from_response_parts(
module_type: WorkerModuleType,
url: &Url,
headers: &[(String, Vec<u8>)],
bytes: Vec<u8>,
) -> Result<Self, String> {
let kind = module_type.response_kind(url, headers, &bytes)?;
Ok(Self::from_bytes(kind, bytes))
}
pub(super) fn from_bytes(kind: WorkerScriptResourceKind, bytes: Vec<u8>) -> Self {
if kind == WorkerScriptResourceKind::WebAssemblyModule {
Self::binary(bytes)
} else {
Self::text(moli_encoding::decode_utf8(&bytes))
}
}
pub(super) fn text(source: String) -> Self {
Self::Text(source)
}
pub(super) fn binary(bytes: Vec<u8>) -> Self {
Self::Binary(bytes)
}
pub(super) fn len(&self) -> usize {
match self {
Self::Text(source) => source.len(),
Self::Binary(bytes) => bytes.len(),
}
}
fn text_source(&self) -> Option<&str> {
match self {
Self::Text(source) => Some(source),
Self::Binary(_) => None,
}
}
fn binary_source(&self) -> Option<&[u8]> {
match self {
Self::Text(_) => None,
Self::Binary(bytes) => Some(bytes),
}
}
}
impl WorkerModuleEvaluationCompletion {
fn new(evaluation_id: WorkerModuleEvaluationId, result: Result<(), String>) -> Self {
Self {
evaluation_id,
result,
}
}
pub(super) fn evaluation_id(&self) -> WorkerModuleEvaluationId {
self.evaluation_id
}
pub(super) fn result(&self) -> Result<(), &str> {
self.result.as_ref().map(|_| ()).map_err(String::as_str)
}
}
pub(super) fn evaluate_module_worker_bootstrap_source(
scope: &mut v8::PinScope<'_, '_>,
source: WorkerModuleSource,
script_url: &str,
static_import_initiator_url: Option<Url>,
credentials_mode: RequestCredentialsMode,
referrer_policy: Option<String>,
evaluation_completion_tx: mpsc::UnboundedSender<WorkerModuleEvaluationCompletion>,
) -> WorkerModuleBootstrapStart {
let try_catch = pin!(v8::TryCatch::new(scope));
let mut scope = try_catch.init();
let root_url = match Url::parse(script_url) {
Ok(url) => url,
Err(_) => {
return WorkerModuleBootstrapStart::Failed(Box::new(worker_bootstrap_error(
&mut scope,
script_url,
"Module worker script URL is invalid",
WorkerParentErrorEventKind::Event,
)));
}
};
let static_import_initiator_url =
static_import_initiator_url.unwrap_or_else(|| root_url.clone());
let runtime =
WorkerModuleRuntime::new(credentials_mode, referrer_policy, evaluation_completion_tx);
runtime.install_context_slot(scope.get_current_context());
let mut bootstrap = runtime.start_bootstrap(source, root_url, static_import_initiator_url);
match bootstrap.advance(&mut scope) {
WorkerModuleAdvance::ReadyToInstantiate { root_entry } => {
match finish_worker_module_bootstrap(
&mut scope,
&bootstrap.runtime,
root_entry,
script_url,
) {
Ok(WorkerModuleFinish::Complete) => WorkerModuleBootstrapStart::Complete,
Ok(WorkerModuleFinish::PendingEvaluation { evaluation_id }) => {
WorkerModuleBootstrapStart::Pending(Box::new(
WorkerModulePendingBootstrap::new_evaluation(bootstrap, evaluation_id),
))
}
Err(error) => WorkerModuleBootstrapStart::Failed(error),
}
}
WorkerModuleAdvance::NeedFetches(requests) => {
WorkerModuleBootstrapStart::Pending(Box::new(
WorkerModulePendingBootstrap::new_fetches(bootstrap, requests),
))
}
WorkerModuleAdvance::Failed(error) => WorkerModuleBootstrapStart::Failed(error),
}
}
pub(super) enum WorkerModuleBootstrapStart {
Complete,
Pending(Box<WorkerModulePendingBootstrap>),
Failed(Box<WorkerBootstrapError>),
}
pub(super) enum WorkerModuleBootstrapResume {
Complete,
NeedFetches(WorkerModuleGraphFetchBatch),
WaitingFetches,
WaitingEvaluation,
Failed(Box<WorkerBootstrapError>),
}
pub(super) struct WorkerModulePendingBootstrap {
job: WorkerModuleBootstrapJob,
state: WorkerModulePendingBootstrapState,
}
enum WorkerModulePendingBootstrapState {
Fetch(WorkerModuleGraphFetchBatch),
Evaluation {
evaluation_id: WorkerModuleEvaluationId,
},
}
impl WorkerModulePendingBootstrap {
fn new_fetches(
job: WorkerModuleBootstrapJob,
pending_requests: WorkerModuleGraphFetchBatch,
) -> Self {
Self {
job,
state: WorkerModulePendingBootstrapState::Fetch(pending_requests),
}
}
fn new_evaluation(
job: WorkerModuleBootstrapJob,
evaluation_id: WorkerModuleEvaluationId,
) -> Self {
Self {
job,
state: WorkerModulePendingBootstrapState::Evaluation { evaluation_id },
}
}
pub(super) fn pending_requests(&self) -> Option<&WorkerModuleGraphFetchBatch> {
match &self.state {
WorkerModulePendingBootstrapState::Fetch(requests) => Some(requests),
WorkerModulePendingBootstrapState::Evaluation { .. } => None,
}
}
pub(super) fn resume(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
completion: WorkerModuleGraphFetchCompletion,
) -> WorkerModuleBootstrapResume {
let fetch_id = completion.fetch_id();
let WorkerModulePendingBootstrapState::Fetch(pending_requests) = &mut self.state else {
return WorkerModuleBootstrapResume::Failed(Box::new(worker_bootstrap_error(
scope,
self.job.script_url(),
"Module worker graph fetch completion arrived while waiting for evaluation",
WorkerParentErrorEventKind::Event,
)));
};
let Some(pending_request) = pending_requests.remove_by_fetch_id(fetch_id) else {
return WorkerModuleBootstrapResume::Failed(Box::new(worker_bootstrap_error(
scope,
self.job.script_url(),
&format!(
"Module worker graph fetch completion id {fetch_id} did not match any pending id"
),
WorkerParentErrorEventKind::Event,
)));
};
let pending_keys = pending_requests.pending_keys();
match self.job.resume_fetch_with_pending_keys(
scope,
&pending_request,
completion,
pending_keys,
) {
WorkerModuleAdvance::ReadyToInstantiate { root_entry } => {
if !pending_requests.is_empty() {
return WorkerModuleBootstrapResume::WaitingFetches;
}
match finish_worker_module_bootstrap(
scope,
&self.job.runtime,
root_entry,
self.job.script_url(),
) {
Ok(WorkerModuleFinish::Complete) => WorkerModuleBootstrapResume::Complete,
Ok(WorkerModuleFinish::PendingEvaluation { evaluation_id }) => {
self.state =
WorkerModulePendingBootstrapState::Evaluation { evaluation_id };
WorkerModuleBootstrapResume::WaitingEvaluation
}
Err(error) => WorkerModuleBootstrapResume::Failed(error),
}
}
WorkerModuleAdvance::NeedFetches(requests) => {
let new_requests = requests.clone();
pending_requests.extend(requests);
WorkerModuleBootstrapResume::NeedFetches(new_requests)
}
WorkerModuleAdvance::Failed(error) => WorkerModuleBootstrapResume::Failed(error),
}
}
pub(super) fn resume_evaluation(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
completion: WorkerModuleEvaluationCompletion,
) -> WorkerModuleBootstrapResume {
let WorkerModulePendingBootstrapState::Evaluation { evaluation_id } = self.state else {
return WorkerModuleBootstrapResume::Failed(Box::new(worker_bootstrap_error(
scope,
self.job.script_url(),
"Module worker evaluation completion arrived while waiting for graph fetch",
WorkerParentErrorEventKind::Event,
)));
};
if completion.evaluation_id != evaluation_id {
return WorkerModuleBootstrapResume::Failed(Box::new(worker_bootstrap_error(
scope,
self.job.script_url(),
&format!(
"Module worker evaluation completion id {} did not match pending id {evaluation_id}",
completion.evaluation_id
),
WorkerParentErrorEventKind::Event,
)));
}
match completion.result {
Ok(()) => WorkerModuleBootstrapResume::Complete,
Err(message) => WorkerModuleBootstrapResume::Failed(Box::new(worker_bootstrap_error(
scope,
self.job.script_url(),
&message,
WorkerParentErrorEventKind::ErrorEvent,
))),
}
}
}
enum WorkerModuleFinish {
Complete,
PendingEvaluation {
evaluation_id: WorkerModuleEvaluationId,
},
}
fn finish_worker_module_bootstrap(
scope: &mut v8::PinScope<'_, '_>,
runtime: &WorkerModuleRuntime,
root_entry: usize,
script_url: &str,
) -> WorkerModuleBootstrapResult<WorkerModuleFinish> {
let try_catch = pin!(v8::TryCatch::new(scope));
let mut scope = try_catch.init();
let scope = &mut scope;
let root_module_global = runtime.graph.borrow().module(root_entry).clone();
let root_module = v8::Local::new(scope, &root_module_global);
// Include dependencies of synthetic Wasm modules, which V8's IsGraphAsync
// cannot see, while excluding dependencies reached only by import source.
// Reject before instantiation or evaluation can execute any module code.
if super::global_scope::get_worker_state(scope).is_some_and(|state| {
matches!(
state.borrow().global_kind,
super::thread::WorkerGlobalKind::Service { .. }
)
}) && runtime
.graph
.borrow()
.has_top_level_await(scope, root_entry)
{
let message = v8str(scope, "Top-level await is not allowed in service workers.");
let exception = v8::Exception::type_error(scope, message);
return Err(Box::new(worker_bootstrap_value_error(
scope,
script_url,
exception,
WorkerParentErrorEventKind::Event,
)));
}
match root_module.instantiate_module2(
scope,
worker_resolve_static_module_callback,
worker_resolve_static_source_callback,
) {
Some(true) => {}
Some(false) => {
return Err(Box::new(worker_bootstrap_error(
scope,
script_url,
"v8 reported module worker instantiate failure",
WorkerParentErrorEventKind::Event,
)));
}
None => {
let exception = scope.exception();
let message = scope.message();
let stack_trace = scope.stack_trace();
let report =
build_event_handler_exception_report(scope, exception, message, stack_trace);
return Err(Box::new((
report,
exception.map(|value| v8::Global::new(scope, value)),
WorkerParentErrorEventKind::Event,
)));
}
}
let Some(value) = crate::script_execution::evaluate_module(scope, root_module) else {
let exception = scope.exception();
let message = scope.message();
let stack_trace = scope.stack_trace();
let report = build_event_handler_exception_report(scope, exception, message, stack_trace);
return Err(Box::new((
report,
exception.map(|value| v8::Global::new(scope, value)),
WorkerParentErrorEventKind::ErrorEvent,
)));
};
scope.perform_microtask_checkpoint();
crate::context_bootstrap::run_end_of_microtask_checkpoint_tasks(scope);
if root_module.get_status() == v8::ModuleStatus::Errored {
return Err(Box::new(worker_bootstrap_value_error(
scope,
script_url,
root_module.get_exception(),
WorkerParentErrorEventKind::ErrorEvent,
)));
}
if let Ok(promise) = v8::Local::<v8::Promise>::try_from(value) {
match promise.state() {
v8::PromiseState::Fulfilled => return Ok(WorkerModuleFinish::Complete),
v8::PromiseState::Rejected => {
let reason = promise.result(scope);
return Err(Box::new(worker_bootstrap_value_error(
scope,
script_url,
reason,
WorkerParentErrorEventKind::ErrorEvent,
)));
}
v8::PromiseState::Pending => {
let evaluation_id = runtime.reserve_evaluation_id();
let promise = v8::Global::new(scope, promise);
attach_worker_module_evaluation_reactions(scope, evaluation_id, promise)?;
return Ok(WorkerModuleFinish::PendingEvaluation { evaluation_id });
}
}
}
Ok(WorkerModuleFinish::Complete)
}
struct WorkerModuleRuntime {
graph: Rc<RefCell<WorkerModuleGraph>>,
next_fetch_id: Rc<RefCell<WorkerModuleGraphFetchId>>,
next_evaluation_id: Rc<RefCell<WorkerModuleEvaluationId>>,
dynamic_imports: Rc<RefCell<WorkerDynamicModuleResolver>>,
evaluation_completion_tx: mpsc::UnboundedSender<WorkerModuleEvaluationCompletion>,
}
impl WorkerModuleRuntime {
fn new(
credentials_mode: RequestCredentialsMode,
referrer_policy: Option<String>,
evaluation_completion_tx: mpsc::UnboundedSender<WorkerModuleEvaluationCompletion>,
) -> Self {
Self {
graph: Rc::new(RefCell::new(WorkerModuleGraph::new(
credentials_mode,
referrer_policy,
))),
next_fetch_id: Rc::new(RefCell::new(0)),
next_evaluation_id: Rc::new(RefCell::new(0)),
dynamic_imports: Rc::new(RefCell::new(WorkerDynamicModuleResolver::default())),
evaluation_completion_tx,
}
}
fn install_context_slot(&self, context: v8::Local<'_, v8::Context>) {
let _previous_graph = context.set_slot(self.graph.clone());
let _previous_fetch_id = context.set_slot(Rc::new(WorkerModuleRuntimeFetchIdSlot {
next_fetch_id: Rc::clone(&self.next_fetch_id),
}));
let _previous_evaluation = context.set_slot(Rc::new(WorkerModuleRuntimeEvaluationSlot {
next_evaluation_id: Rc::clone(&self.next_evaluation_id),
evaluation_completion_tx: self.evaluation_completion_tx.clone(),
}));
let _previous_dynamic_imports = context.set_slot(self.dynamic_imports.clone());
}
fn start_bootstrap(
&self,
source: WorkerModuleSource,
root_url: Url,
static_import_initiator_url: Url,
) -> WorkerModuleBootstrapJob {
WorkerModuleBootstrapJob {
runtime: self.clone(),
source,
root_url,
static_import_initiator_url,
}
}
fn reserve_evaluation_id(&self) -> WorkerModuleEvaluationId {
let mut next_evaluation_id = self.next_evaluation_id.borrow_mut();
let evaluation_id = *next_evaluation_id;
*next_evaluation_id += 1;
evaluation_id
}
}
pub(super) fn install_classic_worker_dynamic_module_runtime(
scope: &mut v8::PinScope<'_, '_>,
referrer_policy: Option<String>,
evaluation_completion_tx: mpsc::UnboundedSender<WorkerModuleEvaluationCompletion>,
) {
WorkerModuleRuntime::new(
RequestCredentialsMode::SameOrigin,
referrer_policy,
evaluation_completion_tx,
)
.install_context_slot(scope.get_current_context());
}
pub(super) fn run_next_worker_dynamic_module_import(
scope: &mut v8::PinScope<'_, '_>,
) -> Option<WorkerDynamicModuleImportAdvance> {
let context = scope.get_current_context();
let dynamic_imports = context.get_slot::<RefCell<WorkerDynamicModuleResolver>>()?;
let mut imports = dynamic_imports.borrow_mut();
let index = imports
.pending_imports
.iter()
.position(|job| matches!(job.state, WorkerDynamicModuleImportJobState::Graph))?;
let mut job = imports
.pending_imports
.remove(index)
.expect("position came from pending_imports");
drop(imports);
match advance_worker_dynamic_module_import(scope, &mut job) {
Ok(WorkerDynamicModuleImportAdvance::Complete) => {
resolve_worker_dynamic_module_import(scope, job);
Some(WorkerDynamicModuleImportAdvance::Complete)
}
Ok(WorkerDynamicModuleImportAdvance::NeedFetches(requests)) => {
job.state = WorkerDynamicModuleImportJobState::Fetch(requests.clone());
dynamic_imports.borrow_mut().pending_imports.push_back(job);
Some(WorkerDynamicModuleImportAdvance::NeedFetches(requests))
}
Ok(WorkerDynamicModuleImportAdvance::WaitingFetches) => {
dynamic_imports.borrow_mut().pending_imports.push_back(job);
Some(WorkerDynamicModuleImportAdvance::WaitingFetches)
}
Ok(WorkerDynamicModuleImportAdvance::WaitingEvaluation { evaluation_id }) => {
job.state = WorkerDynamicModuleImportJobState::Evaluation { evaluation_id };
dynamic_imports.borrow_mut().pending_imports.push_back(job);
Some(WorkerDynamicModuleImportAdvance::WaitingEvaluation { evaluation_id })
}
Err(error) => {
finish_failed_worker_dynamic_module_import(scope, job, error);
Some(WorkerDynamicModuleImportAdvance::Complete)
}
}
}
pub(super) fn worker_dynamic_module_import_waits_for_fetch(
scope: &mut v8::PinScope<'_, '_>,
fetch_id: WorkerModuleGraphFetchId,
) -> bool {
let context = scope.get_current_context();
let Some(dynamic_imports) = context.get_slot::<RefCell<WorkerDynamicModuleResolver>>() else {
return false;
};
dynamic_imports.borrow().pending_imports.iter().any(|job| {
matches!(
&job.state,
WorkerDynamicModuleImportJobState::Fetch(requests) if requests.contains_fetch_id(fetch_id)
)
})
}
pub(super) fn worker_has_pending_dynamic_module_imports(scope: &mut v8::PinScope<'_, '_>) -> bool {
let context = scope.get_current_context();
let Some(dynamic_imports) = context.get_slot::<RefCell<WorkerDynamicModuleResolver>>() else {
return false;
};
!dynamic_imports.borrow().pending_imports.is_empty()
}
pub(super) fn worker_has_runnable_dynamic_module_imports(scope: &mut v8::PinScope<'_, '_>) -> bool {
let context = scope.get_current_context();
let Some(dynamic_imports) = context.get_slot::<RefCell<WorkerDynamicModuleResolver>>() else {
return false;
};
dynamic_imports
.borrow()
.pending_imports
.iter()
.any(|job| matches!(job.state, WorkerDynamicModuleImportJobState::Graph))
}
pub(super) fn resume_worker_dynamic_module_fetch(
scope: &mut v8::PinScope<'_, '_>,
completion: WorkerModuleGraphFetchCompletion,
) -> Option<WorkerDynamicModuleImportAdvance> {
let context = scope.get_current_context();
let dynamic_imports = context.get_slot::<RefCell<WorkerDynamicModuleResolver>>()?;
let mut imports = dynamic_imports.borrow_mut();
let index = imports.pending_imports.iter().position(|job| {
matches!(
&job.state,
WorkerDynamicModuleImportJobState::Fetch(requests)
if requests.contains_fetch_id(completion.fetch_id())
)
})?;
let mut job = imports
.pending_imports
.remove(index)
.expect("position came from pending_imports");
drop(imports);
let fetch_id = completion.fetch_id();
let (request, pending_keys) = match &mut job.state {
WorkerDynamicModuleImportJobState::Fetch(requests) => {
let request = requests
.remove_by_fetch_id(fetch_id)
.expect("position came from matching pending fetch id");
let pending_keys = requests.pending_keys();
(request, pending_keys)
}
_ => unreachable!(),
};
let had_pending_requests = !pending_keys.is_empty();
match job_resume_fetch_with_pending_keys(scope, &mut job, &request, completion, pending_keys) {
Ok(WorkerDynamicModuleImportAdvance::Complete) => {
if had_pending_requests {
dynamic_imports.borrow_mut().pending_imports.push_back(job);
return Some(WorkerDynamicModuleImportAdvance::WaitingFetches);
}
resolve_worker_dynamic_module_import(scope, job);
Some(WorkerDynamicModuleImportAdvance::Complete)
}
Ok(WorkerDynamicModuleImportAdvance::NeedFetches(requests)) => {
let new_requests = requests.clone();
match &mut job.state {
WorkerDynamicModuleImportJobState::Fetch(pending_requests) => {
pending_requests.extend(requests);
}
_ => unreachable!(),
}
dynamic_imports.borrow_mut().pending_imports.push_back(job);
Some(WorkerDynamicModuleImportAdvance::NeedFetches(new_requests))
}
Ok(WorkerDynamicModuleImportAdvance::WaitingFetches) => {
dynamic_imports.borrow_mut().pending_imports.push_back(job);
Some(WorkerDynamicModuleImportAdvance::WaitingFetches)
}
Ok(WorkerDynamicModuleImportAdvance::WaitingEvaluation { evaluation_id }) => {
if had_pending_requests {
dynamic_imports.borrow_mut().pending_imports.push_back(job);
return Some(WorkerDynamicModuleImportAdvance::WaitingFetches);
}
job.state = WorkerDynamicModuleImportJobState::Evaluation { evaluation_id };
dynamic_imports.borrow_mut().pending_imports.push_back(job);
Some(WorkerDynamicModuleImportAdvance::WaitingEvaluation { evaluation_id })
}
Err(error) => {
finish_failed_worker_dynamic_module_import(scope, job, error);
Some(WorkerDynamicModuleImportAdvance::Complete)
}
}
}
pub(super) fn resume_worker_dynamic_module_evaluation(
scope: &mut v8::PinScope<'_, '_>,
completion: &WorkerModuleEvaluationCompletion,
) -> bool {
let context = scope.get_current_context();
let Some(dynamic_imports) = context.get_slot::<RefCell<WorkerDynamicModuleResolver>>() else {
return false;
};
let mut imports = dynamic_imports.borrow_mut();
let Some(index) = imports.pending_imports.iter().position(|job| {
matches!(
job.state,
WorkerDynamicModuleImportJobState::Evaluation { evaluation_id }
if evaluation_id == completion.evaluation_id
)
}) else {
return false;
};
let job = imports
.pending_imports
.remove(index)
.expect("position came from pending_imports");
drop(imports);
match completion.result() {
Ok(()) => resolve_worker_dynamic_module_import(scope, job),
Err(message) => finish_failed_worker_dynamic_module_import(
scope,
job,
WorkerDynamicModuleImportError {
message: message.to_owned(),
kind: WorkerDynamicModuleImportErrorKind::Type,
rejection: None,
stage: WorkerDynamicModuleImportErrorStage::Evaluate,
},
),
}
true
}
impl Clone for WorkerModuleRuntime {
fn clone(&self) -> Self {
Self {
graph: Rc::clone(&self.graph),
next_fetch_id: Rc::clone(&self.next_fetch_id),
next_evaluation_id: Rc::clone(&self.next_evaluation_id),
dynamic_imports: Rc::clone(&self.dynamic_imports),
evaluation_completion_tx: self.evaluation_completion_tx.clone(),
}
}
}
#[derive(Default)]
struct WorkerDynamicModuleResolver {
pending_imports: VecDeque<WorkerDynamicModuleImportJob>,
}
impl WorkerDynamicModuleResolver {
fn queue_import(
&mut self,
context: v8::Global<v8::Context>,
resolver: v8::Global<v8::PromiseResolver>,
specifier: String,
base_url: Url,
fetch_initiator_url: Url,
attributes: ModuleAttributesKey,
phase: ModuleImportPhase,
audio_worklet_bootstrap: bool,
) {
self.pending_imports
.push_back(WorkerDynamicModuleImportJob::new(
context,
resolver,
specifier,
base_url,
fetch_initiator_url,
attributes,
phase,
audio_worklet_bootstrap,
));
}
fn root_import_in_flight(&self, key: &WorkerModuleKey) -> bool {
self.pending_imports.iter().any(|job| {
job.root_key.as_ref() == Some(key)
&& !matches!(
job.state,
WorkerDynamicModuleImportJobState::JoinedRoot { .. }
)
})
}
fn take_joined_root_imports(
&mut self,
key: &WorkerModuleKey,
phase: Option<ModuleImportPhase>,
) -> Vec<WorkerDynamicModuleImportJob> {
let mut joined = Vec::new();
let mut remaining = VecDeque::with_capacity(self.pending_imports.len());
while let Some(job) = self.pending_imports.pop_front() {
if matches!(
&job.state,
WorkerDynamicModuleImportJobState::JoinedRoot { key: joined_key }
if joined_key == key
) && phase.is_none_or(|phase| job.phase == phase)
{
joined.push(job);
} else {
remaining.push_back(job);
}
}
self.pending_imports = remaining;
joined
}
}
struct WorkerDynamicModuleImportJob {
context: v8::Global<v8::Context>,
resolver: v8::Global<v8::PromiseResolver>,
specifier: String,
// Referencing module URL used only for specifier resolution.
base_url: Url,
// Worker inside-settings URL used for fetch security checks.
fetch_initiator_url: Url,
attributes: ModuleAttributesKey,
phase: ModuleImportPhase,
audio_worklet_bootstrap: bool,
root_key: Option<WorkerModuleKey>,
resolved_entry: Option<usize>,
state: WorkerDynamicModuleImportJobState,
}
enum WorkerDynamicModuleImportJobState {
Graph,
JoinedRoot {
key: WorkerModuleKey,
},
Fetch(WorkerModuleGraphFetchBatch),
Evaluation {
evaluation_id: WorkerModuleEvaluationId,
},
}
impl WorkerDynamicModuleImportJob {
fn new(
context: v8::Global<v8::Context>,
resolver: v8::Global<v8::PromiseResolver>,
specifier: String,
base_url: Url,
fetch_initiator_url: Url,
attributes: ModuleAttributesKey,
phase: ModuleImportPhase,
audio_worklet_bootstrap: bool,
) -> Self {
Self {
context,
resolver,
specifier,
base_url,
fetch_initiator_url,
attributes,
phase,
audio_worklet_bootstrap,
root_key: None,
resolved_entry: None,
state: WorkerDynamicModuleImportJobState::Graph,
}
}
fn browser_request_metadata(&self) -> BrowserRequestMetadata {
if self.audio_worklet_bootstrap {
BrowserRequestMetadata::AudioWorklet
} else {
BrowserRequestMetadata::Fetch
}
}
}
fn advance_worker_dynamic_module_import(
scope: &mut v8::PinScope<'_, '_>,
job: &mut WorkerDynamicModuleImportJob,
) -> WorkerDynamicModuleImportResult<WorkerDynamicModuleImportAdvance> {
let context = scope.get_current_context();
let graph = context
.get_slot::<RefCell<WorkerModuleGraph>>()
.ok_or_else(|| "worker module graph is not available".to_owned())?;
let module_url = resolve_worker_module_specifier(&job.specifier, &job.base_url)?;
let module_key = worker_module_key_for_attributes(&module_url, &job.attributes)
.map_err(|message| format!("{message} for dynamic import `{}`", job.specifier))?;
if let Some(error) = graph.borrow().source_fetch_failure(&module_key) {
return Err(WorkerDynamicModuleImportError::type_error(format!(
"Failed to dynamically import module worker dependency `{module_url}`: {error}"
)));
}
let existing_root_entry = graph.borrow().entry_for_key(&module_key);
if job.phase == ModuleImportPhase::Source && existing_root_entry.is_some() {
// A compiled source is available even while another job is loading or
// evaluating its dependencies. This job does not own that root's waiters.
job.resolved_entry = existing_root_entry;
return Ok(WorkerDynamicModuleImportAdvance::Complete);
}
job.root_key = Some(module_key.clone());
if context
.get_slot::<RefCell<WorkerDynamicModuleResolver>>()
.is_some_and(|dynamic_imports| dynamic_imports.borrow().root_import_in_flight(&module_key))
{
job.state = WorkerDynamicModuleImportJobState::JoinedRoot { key: module_key };
return Ok(WorkerDynamicModuleImportAdvance::WaitingFetches);
}
let inherited_referrer_policy = graph.borrow().referrer_policy_for_url(&job.base_url);
let root_entry = match existing_root_entry {
Some(entry) => entry,
None => match load_worker_static_module_dependency(module_url, module_key.module_type)? {
WorkerModuleDependencyLoad::Source { url, source } => {
let key =
worker_module_key_for_attributes(&url, &job.attributes).map_err(|message| {
format!("{message} for dynamic import `{}`", job.specifier)
})?;
ensure_worker_module_entry(
scope,
&graph,
&source,
key,
url,
inherited_referrer_policy.clone(),
)
.map_err(|error| error.0.summary)?
}
WorkerModuleDependencyLoad::NeedFetch(_) => {
let fetch_id = reserve_worker_module_graph_fetch_id(scope);
return Ok(WorkerDynamicModuleImportAdvance::NeedFetches(
WorkerModuleGraphFetchBatch::single(WorkerModuleGraphFetchRequest::new(
fetch_id,
module_key,
job.fetch_initiator_url.clone(),
WorkerModuleGraphFetchCspSource::DynamicImportGraph,
None,
job.specifier.clone(),
job.attributes.clone(),
graph.borrow().credentials_mode(),
inherited_referrer_policy,
job.browser_request_metadata(),
)),
));
}
},
};
job.resolved_entry = Some(root_entry);
if job.phase == ModuleImportPhase::Source {
return Ok(WorkerDynamicModuleImportAdvance::Complete);
}
match continue_worker_module_graph(
scope,
&graph,
root_entry,
&job.fetch_initiator_url,
WorkerModuleGraphFetchCspSource::DynamicImportGraph,
job.browser_request_metadata(),
)
.map_err(|error| error.0.summary)?
{
WorkerModuleGraphBuild::Ready => {
finish_worker_dynamic_module_import_evaluation(scope, root_entry)
}
WorkerModuleGraphBuild::NeedFetches(requests) => {
Ok(WorkerDynamicModuleImportAdvance::NeedFetches(requests))
}
}
}
fn job_finish_fetch(
scope: &mut v8::PinScope<'_, '_>,
job: &mut WorkerDynamicModuleImportJob,
request: &WorkerModuleGraphFetchRequest,
completion: WorkerModuleGraphFetchCompletion,
) -> WorkerDynamicModuleImportResult<()> {
let context = scope.get_current_context();
let graph = context
.get_slot::<RefCell<WorkerModuleGraph>>()
.ok_or_else(|| "worker module graph is not available".to_owned())?;
let fetched_source = match completion.result {
Ok(source) => source,
Err(message) => {
graph
.borrow_mut()
.mark_source_fetch_failed(&request.key, message.clone());
return Err(format!(
"Failed to dynamically import module worker dependency `{}`: {message}",
request.url()
)
.into());
}
};
let referrer_policy = fetched_source.effective_referrer_policy(request.referrer_policy());
let target_entry = match ensure_worker_module_entry(
scope,
&graph,
fetched_source.source(),
request.key.clone(),
fetched_source.final_url().clone(),
referrer_policy,
) {
Ok(entry) => entry,
Err(error) => {
let message = error.0.summary.clone();
graph
.borrow_mut()
.mark_source_fetch_failed(&request.key, message.clone());
return Err(message.into());
}
};
if let Some(parent_entry) = request.parent_entry {
graph.borrow_mut().add_dependency(
parent_entry,
request.specifier.clone(),
request.attributes.clone(),
target_entry,
);
} else {
job.resolved_entry = Some(target_entry);
// Source imports only share the root fetch, not dependency loading or
// evaluation. Wake them before either of those steps can wait or fail.
if let Some(imports) = context.get_slot::<RefCell<WorkerDynamicModuleResolver>>() {
let mut imports = imports.borrow_mut();
let sources =
imports.take_joined_root_imports(&request.key, Some(ModuleImportPhase::Source));
for mut source in sources {
source.root_key = None;
source.state = WorkerDynamicModuleImportJobState::Graph;
imports.pending_imports.push_back(source);
}
}
}
Ok(())
}
fn job_resume_fetch_with_pending_keys(
scope: &mut v8::PinScope<'_, '_>,
job: &mut WorkerDynamicModuleImportJob,
request: &WorkerModuleGraphFetchRequest,
completion: WorkerModuleGraphFetchCompletion,
pending_keys: HashSet<WorkerModuleKey>,
) -> WorkerDynamicModuleImportResult<WorkerDynamicModuleImportAdvance> {
let has_pending_requests = !pending_keys.is_empty();
let context = scope.get_current_context();
let graph = context
.get_slot::<RefCell<WorkerModuleGraph>>()
.ok_or_else(|| "worker module graph is not available".to_owned())?;
job_finish_fetch(scope, job, request, completion)?;
let root_entry = job
.resolved_entry
.ok_or_else(|| "dynamic import root module is not compiled".to_owned())?;
if job.phase == ModuleImportPhase::Source {
return Ok(WorkerDynamicModuleImportAdvance::Complete);
}
match continue_worker_module_graph_with_pending_keys(
scope,
&graph,
root_entry,
&request.initiator_url,
request.csp_source(),
request.graph_browser_request_metadata(),
pending_keys,
)
.map_err(|error| error.0.summary)?
{
WorkerModuleGraphBuild::Ready => {
if has_pending_requests {
return Ok(WorkerDynamicModuleImportAdvance::WaitingFetches);
}
finish_worker_dynamic_module_import_evaluation(scope, root_entry)
}
WorkerModuleGraphBuild::NeedFetches(requests) => {
Ok(WorkerDynamicModuleImportAdvance::NeedFetches(requests))
}
}
}
fn finish_worker_dynamic_module_import_evaluation(
scope: &mut v8::PinScope<'_, '_>,
root_entry: usize,
) -> WorkerDynamicModuleImportResult<WorkerDynamicModuleImportAdvance> {
let try_catch = pin!(v8::TryCatch::new(scope));
let mut scope = try_catch.init();
let scope = &mut scope;
let context = scope.get_current_context();
let graph = context
.get_slot::<RefCell<WorkerModuleGraph>>()
.ok_or_else(|| "worker module graph is not available".to_owned())?;
let root_module_global = graph.borrow().module(root_entry).clone();
let root_module = v8::Local::new(scope, &root_module_global);
if root_module.get_status() == v8::ModuleStatus::Uninstantiated {
match root_module.instantiate_module2(
scope,
worker_resolve_static_module_callback,
worker_resolve_static_source_callback,
) {
Some(true) => {}
Some(false) => {
return Err(WorkerDynamicModuleImportError::type_error(
"v8 reported dynamic import instantiate failure",
));
}
None => {
let exception = scope.exception();
return Err(
WorkerDynamicModuleImportError::caught_instantiate_exception(
scope,
exception,
"dynamic import instantiate threw an exception",
),
);
}
}
} else if root_module.get_status() == v8::ModuleStatus::Evaluated {
return Ok(WorkerDynamicModuleImportAdvance::Complete);
} else if root_module.get_status() == v8::ModuleStatus::Errored {
return Err(WorkerDynamicModuleImportError::evaluation_rejection_value(
scope,
root_module.get_exception(),
"dynamic import module evaluation failed",
));
}
let Some(value) = crate::script_execution::evaluate_module(scope, root_module) else {
let exception = scope.exception();
return Err(WorkerDynamicModuleImportError::caught_evaluation_exception(
scope,
exception,
"dynamic import evaluation threw an exception",
));
};
scope.perform_microtask_checkpoint();
crate::context_bootstrap::run_end_of_microtask_checkpoint_tasks(scope);
if root_module.get_status() == v8::ModuleStatus::Errored {
return Err(WorkerDynamicModuleImportError::evaluation_rejection_value(
scope,
root_module.get_exception(),
"dynamic import module evaluation failed",
));
}
if let Ok(promise) = v8::Local::<v8::Promise>::try_from(value) {
match promise.state() {
v8::PromiseState::Fulfilled => Ok(WorkerDynamicModuleImportAdvance::Complete),
v8::PromiseState::Rejected => {
let reason = promise.result(scope);
Err(WorkerDynamicModuleImportError::evaluation_rejection_value(
scope,
reason,
"dynamic import module evaluation rejected",
))
}
v8::PromiseState::Pending => {
let evaluation_id = reserve_worker_module_evaluation_id(scope)?;
let promise = v8::Global::new(scope, promise);
attach_worker_module_evaluation_reactions(scope, evaluation_id, promise)
.map_err(|error| error.0.summary)?;
Ok(WorkerDynamicModuleImportAdvance::WaitingEvaluation { evaluation_id })
}
}
} else {
Ok(WorkerDynamicModuleImportAdvance::Complete)
}
}
fn resolve_worker_dynamic_module_import(
scope: &mut v8::PinScope<'_, '_>,
job: WorkerDynamicModuleImportJob,
) {
let resolved_entry = job.resolved_entry;
let phase = job.phase;
let joined_imports = take_worker_dynamic_module_imports_joined_to_root(scope, &job);
resolve_single_worker_dynamic_module_import(scope, job);
for mut joined_job in joined_imports {
joined_job.resolved_entry = resolved_entry;
if phase == ModuleImportPhase::Source && joined_job.phase == ModuleImportPhase::Evaluation {
// Sharing a source fetch does not link or evaluate the module. Resume
// evaluation jobs from the cached root instead of reading its namespace.
let context = v8::Local::new(scope, &joined_job.context);
let imports = context
.get_slot::<RefCell<WorkerDynamicModuleResolver>>()
.expect("dynamic import resolver should be installed");
joined_job.root_key = None;
joined_job.state = WorkerDynamicModuleImportJobState::Graph;
imports.borrow_mut().pending_imports.push_back(joined_job);
continue;
}
resolve_single_worker_dynamic_module_import(scope, joined_job);
}
}
fn resolve_single_worker_dynamic_module_import(
scope: &mut v8::PinScope<'_, '_>,
job: WorkerDynamicModuleImportJob,
) {
let context = v8::Local::new(scope, &job.context);
let scope = &mut v8::ContextScope::new(scope, context);
let Some(graph) = context.get_slot::<RefCell<WorkerModuleGraph>>() else {
reject_worker_dynamic_module_import(
scope,
job,
WorkerDynamicModuleImportError::type_error("worker module graph is not available"),
);
return;
};
let Some(entry) = job.resolved_entry else {
reject_worker_dynamic_module_import(
scope,
job,
WorkerDynamicModuleImportError::type_error("dynamic import module is not compiled"),
);
return;
};
let resolver = v8::Local::new(scope, &job.resolver);
let resolved_value = {
let graph = graph.borrow();
let record = &graph.records[entry];
match job.phase {
ModuleImportPhase::Evaluation => {
let module = v8::Local::new(scope, &record.module);
Ok(Some(module.get_module_namespace()))
}
ModuleImportPhase::Source => record
.wasm_module
.as_ref()
.ok_or_else(|| {
WorkerDynamicModuleImportError::syntax_error(
"source-phase dynamic import did not resolve to a WebAssembly module",
)
})
.map(|wasm_record| {
wasm_record
.source_module(scope)
.map(v8::Local::<v8::Value>::from)
}),
}
};
let resolved_value = match resolved_value {
Ok(value) => value,
Err(error) => {
reject_worker_dynamic_module_import(scope, job, error);
return;
}
};
let Some(resolved_value) = resolved_value else {
reject_worker_dynamic_module_import(
scope,
job,
WorkerDynamicModuleImportError::type_error(
"failed to materialize WebAssembly source for dynamic import",
),
);
return;
};
let _ = resolver.resolve(scope, resolved_value);
scope.perform_microtask_checkpoint();
crate::context_bootstrap::run_end_of_microtask_checkpoint_tasks(scope);
}
fn take_worker_dynamic_module_imports_joined_to_root(
scope: &mut v8::PinScope<'_, '_>,
job: &WorkerDynamicModuleImportJob,
) -> Vec<WorkerDynamicModuleImportJob> {
let Some(root_key) = job.root_key.as_ref() else {
return Vec::new();
};
let context = v8::Local::new(scope, &job.context);
let Some(dynamic_imports) = context.get_slot::<RefCell<WorkerDynamicModuleResolver>>() else {
return Vec::new();
};
dynamic_imports
.borrow_mut()
.take_joined_root_imports(root_key, None)
}
fn reject_worker_dynamic_module_import(
scope: &mut v8::PinScope<'_, '_>,
job: WorkerDynamicModuleImportJob,
error: WorkerDynamicModuleImportError,
) {
let context = v8::Local::new(scope, &job.context);
let scope = &mut v8::ContextScope::new(scope, context);
let resolver = v8::Local::new(scope, &job.resolver);
let rejection = match error.rejection {
Some(value) => v8::Local::new(scope, value),
None => v8::String::new(scope, &error.message)
.map(|message| match error.kind {
WorkerDynamicModuleImportErrorKind::Type => {
v8::Exception::type_error(scope, message)
}
WorkerDynamicModuleImportErrorKind::Syntax => {
v8::Exception::syntax_error(scope, message)
}
})
.unwrap_or_else(|| v8::undefined(scope).into()),
};
let _ = resolver.reject(scope, rejection);
scope.perform_microtask_checkpoint();
crate::context_bootstrap::run_end_of_microtask_checkpoint_tasks(scope);
}
fn finish_failed_worker_dynamic_module_import(
scope: &mut v8::PinScope<'_, '_>,
job: WorkerDynamicModuleImportJob,
error: WorkerDynamicModuleImportError,
) {
let resolved_entry = job.resolved_entry;
let joined_imports = take_worker_dynamic_module_imports_joined_to_root(scope, &job);
let joined_errors = joined_imports
.iter()
.map(|_| error.clone_for_scope(scope))
.collect::<Vec<_>>();
finish_failed_single_worker_dynamic_module_import(scope, job, error);
for (mut joined_job, joined_error) in joined_imports.into_iter().zip(joined_errors) {
joined_job.resolved_entry = resolved_entry;
finish_failed_single_worker_dynamic_module_import(scope, joined_job, joined_error);
}
}
fn finish_failed_single_worker_dynamic_module_import(
scope: &mut v8::PinScope<'_, '_>,
job: WorkerDynamicModuleImportJob,
error: WorkerDynamicModuleImportError,
) {
if job.audio_worklet_bootstrap && error.stage == WorkerDynamicModuleImportErrorStage::Evaluate {
resolve_worker_dynamic_module_import(scope, job);
} else {
reject_worker_dynamic_module_import(scope, job, error);
}
}
pub(super) struct WorkerModuleBootstrapJob {
runtime: WorkerModuleRuntime,
source: WorkerModuleSource,
root_url: Url,
static_import_initiator_url: Url,
}
impl WorkerModuleBootstrapJob {
fn script_url(&self) -> &str {
self.root_url.as_str()
}
fn advance(&mut self, scope: &mut v8::PinScope<'_, '_>) -> WorkerModuleAdvance {
let root_key = WorkerModuleKey::javascript_or_wasm(self.root_url.clone());
let root_referrer_policy = self
.runtime
.graph
.borrow()
.root_referrer_policy()
.map(str::to_owned);
let root_entry = match ensure_worker_module_entry(
scope,
&self.runtime.graph,
&self.source,
root_key,
self.root_url.clone(),
root_referrer_policy,
) {
Ok(root_entry) => root_entry,
Err(error) => return WorkerModuleAdvance::Failed(error),
};
match continue_worker_module_graph(
scope,
&self.runtime.graph,
root_entry,
&self.static_import_initiator_url,
WorkerModuleGraphFetchCspSource::StaticModuleGraph,
BrowserRequestMetadata::Fetch,
) {
Ok(WorkerModuleGraphBuild::Ready) => {
WorkerModuleAdvance::ReadyToInstantiate { root_entry }
}
Ok(WorkerModuleGraphBuild::NeedFetches(requests)) => {
WorkerModuleAdvance::NeedFetches(requests)
}
Err(error) => WorkerModuleAdvance::Failed(error),
}
}
fn finish_fetch(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
request: &WorkerModuleGraphFetchRequest,
completion: WorkerModuleGraphFetchCompletion,
) -> WorkerModuleBootstrapResult<()> {
let fetched_source = match completion.result {
Ok(source) => source,
Err(message) => {
return Err(Box::new(worker_bootstrap_error(
scope,
request.initiator_url.as_str(),
&message,
WorkerParentErrorEventKind::Event,
)));
}
};
let referrer_policy = fetched_source.effective_referrer_policy(request.referrer_policy());
let target_entry = ensure_worker_module_entry(
scope,
&self.runtime.graph,
fetched_source.source(),
request.key.clone(),
fetched_source.final_url().clone(),
referrer_policy,
)?;
self.runtime.graph.borrow_mut().add_dependency(
request
.parent_entry
.expect("bootstrap graph fetch must have a parent entry"),
request.specifier.clone(),
request.attributes.clone(),
target_entry,
);
Ok(())
}
fn resume_fetch_with_pending_keys(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
request: &WorkerModuleGraphFetchRequest,
completion: WorkerModuleGraphFetchCompletion,
pending_keys: HashSet<WorkerModuleKey>,
) -> WorkerModuleAdvance {
if let Err(error) = self.finish_fetch(scope, request, completion) {
return WorkerModuleAdvance::Failed(error);
}
let root_key = WorkerModuleKey::javascript_or_wasm(self.root_url.clone());
let root_entry = match self.runtime.graph.borrow().entry_for_key(&root_key) {
Some(entry) => entry,
None => {
return WorkerModuleAdvance::Failed(Box::new(worker_bootstrap_error(
scope,
self.root_url.as_str(),
"Module worker root disappeared while resuming graph fetch",
WorkerParentErrorEventKind::Event,
)));
}
};
match continue_worker_module_graph_with_pending_keys(
scope,
&self.runtime.graph,
root_entry,
&self.static_import_initiator_url,
WorkerModuleGraphFetchCspSource::StaticModuleGraph,
BrowserRequestMetadata::Fetch,
pending_keys,
) {
Ok(WorkerModuleGraphBuild::Ready) => {
WorkerModuleAdvance::ReadyToInstantiate { root_entry }
}
Ok(WorkerModuleGraphBuild::NeedFetches(requests)) => {
WorkerModuleAdvance::NeedFetches(requests)
}
Err(error) => WorkerModuleAdvance::Failed(error),
}
}
}
enum WorkerModuleAdvance {
ReadyToInstantiate { root_entry: usize },
NeedFetches(WorkerModuleGraphFetchBatch),
Failed(Box<WorkerBootstrapError>),
}
#[derive(Clone)]
pub(super) struct WorkerModuleGraphFetchRequest {
fetch_id: WorkerModuleGraphFetchId,
key: WorkerModuleKey,
initiator_url: Url,
csp_source: WorkerModuleGraphFetchCspSource,
parent_entry: Option<usize>,
specifier: String,
attributes: ModuleAttributesKey,
credentials_mode: RequestCredentialsMode,
referrer_policy: Option<String>,
browser_request_metadata: BrowserRequestMetadata,
}
#[derive(Clone)]
pub(super) struct WorkerModuleGraphFetchBatch {
requests: Vec<WorkerModuleGraphFetchRequest>,
}
impl WorkerModuleGraphFetchBatch {
fn new(requests: Vec<WorkerModuleGraphFetchRequest>) -> Self {
debug_assert!(
!requests.is_empty(),
"worker module graph fetch batch should not be empty"
);
Self { requests }
}
fn single(request: WorkerModuleGraphFetchRequest) -> Self {
Self::new(vec![request])
}
fn is_empty(&self) -> bool {
self.requests.is_empty()
}
pub(super) fn contains_fetch_id(&self, fetch_id: WorkerModuleGraphFetchId) -> bool {
self.requests
.iter()
.any(|request| request.fetch_id == fetch_id)
}
fn remove_by_fetch_id(
&mut self,
fetch_id: WorkerModuleGraphFetchId,
) -> Option<WorkerModuleGraphFetchRequest> {
let index = self
.requests
.iter()
.position(|request| request.fetch_id == fetch_id)?;
Some(self.requests.remove(index))
}
fn extend(&mut self, other: WorkerModuleGraphFetchBatch) {
self.requests.extend(other.requests);
}
fn pending_keys(&self) -> HashSet<WorkerModuleKey> {
self.requests
.iter()
.map(|request| request.key.clone())
.collect()
}
pub(super) fn iter(&self) -> impl Iterator<Item = &WorkerModuleGraphFetchRequest> {
self.requests.iter()
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum WorkerModuleGraphFetchCspSource {
StaticModuleGraph,
DynamicImportGraph,
}
impl WorkerModuleGraphFetchRequest {
fn new(
fetch_id: WorkerModuleGraphFetchId,
key: WorkerModuleKey,
initiator_url: Url,
csp_source: WorkerModuleGraphFetchCspSource,
parent_entry: Option<usize>,
specifier: String,
attributes: ModuleAttributesKey,
credentials_mode: RequestCredentialsMode,
referrer_policy: Option<String>,
browser_request_metadata: BrowserRequestMetadata,
) -> Self {
Self {
fetch_id,
key,
initiator_url,
csp_source,
parent_entry,
specifier,
attributes,
credentials_mode,
referrer_policy,
browser_request_metadata,
}
}
pub(super) fn fetch_id(&self) -> WorkerModuleGraphFetchId {
self.fetch_id
}
pub(super) fn url(&self) -> &Url {
&self.key.url
}
pub(super) fn initiator_url(&self) -> &Url {
&self.initiator_url
}
pub(super) fn csp_source(&self) -> WorkerModuleGraphFetchCspSource {
self.csp_source
}
pub(super) fn module_type(&self) -> WorkerModuleType {
self.key.module_type
}
pub(super) fn credentials_mode(&self) -> RequestCredentialsMode {
self.credentials_mode
}
pub(super) fn referrer_policy(&self) -> Option<&str> {
self.referrer_policy.as_deref()
}
pub(super) fn browser_request_metadata(&self) -> BrowserRequestMetadata {
worker_module_browser_request_metadata(self.key.module_type, self.browser_request_metadata)
}
fn graph_browser_request_metadata(&self) -> BrowserRequestMetadata {
self.browser_request_metadata
}
}
fn worker_module_browser_request_metadata(
module_type: WorkerModuleType,
graph_metadata: BrowserRequestMetadata,
) -> BrowserRequestMetadata {
match module_type {
WorkerModuleType::Json => BrowserRequestMetadata::JsonModule,
WorkerModuleType::JavaScriptOrWebAssembly => graph_metadata,
}
}
struct WorkerModuleGraph {
credentials_mode: RequestCredentialsMode,
root_referrer_policy: Option<String>,
failed_source_fetches: HashMap<WorkerModuleKey, String>,
records: Vec<WorkerModuleRecord>,
entries_by_key: HashMap<WorkerModuleKey, usize>,
module_to_entries: HashMap<i32, Vec<usize>>,
}
struct WorkerModuleRecord {
key: WorkerModuleKey,
source_url: Url,
source: WorkerModuleSource,
module: v8::Global<v8::Module>,
requests: Vec<WorkerModuleRequest>,
dependencies: Vec<WorkerModuleDependency>,
wasm_module: Option<WasmModuleRecord>,
referrer_policy: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
struct WorkerModuleKey {
url: Url,
module_type: WorkerModuleType,
attributes: ModuleAttributesKey,
}
impl WorkerModuleKey {
fn javascript_or_wasm(url: Url) -> Self {
Self {
url,
module_type: WorkerModuleType::JavaScriptOrWebAssembly,
attributes: ModuleAttributesKey::empty(),
}
}
fn json(url: Url, attributes: ModuleAttributesKey) -> Self {
Self {
url,
module_type: WorkerModuleType::Json,
attributes,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(super) enum WorkerModuleType {
// HTML keys the module map by the requested type. JavaScript and Wasm
// share this entry; the fetched MIME type selects the compiled record.
JavaScriptOrWebAssembly,
Json,
}
impl WorkerModuleType {
pub(super) fn response_kind(
self,
url: &Url,
headers: &[(String, Vec<u8>)],
bytes: &[u8],
) -> Result<WorkerScriptResourceKind, String> {
match self {
Self::Json => {
super::module_mime::ensure_worker_json_module_mime_from_headers(headers)?;
Ok(WorkerScriptResourceKind::JsonModule)
}
Self::JavaScriptOrWebAssembly => {
if super::worker_response_has_webassembly_mime(headers) {
return Ok(WorkerScriptResourceKind::WebAssemblyModule);
}
super::ensure_worker_script_mime_acceptable(url, headers, bytes).map_err(
|error| {
error.replace(
"unsupported script MIME type",
"unsupported module script MIME type",
)
},
)?;
Ok(WorkerScriptResourceKind::JavaScript)
}
}
}
}
#[derive(Clone)]
struct WorkerModuleRequest {
specifier: String,
attributes: ModuleAttributesKey,
phase: ModuleImportPhase,
}
struct WorkerModuleDependency {
specifier: String,
attributes: ModuleAttributesKey,
target_entry: usize,
}
enum WorkerSyntheticModuleRecord {
Json(String),
WebAssembly(WasmModuleRecord),
}
impl WorkerModuleGraph {
fn new(credentials_mode: RequestCredentialsMode, root_referrer_policy: Option<String>) -> Self {
Self {
credentials_mode,
root_referrer_policy,
failed_source_fetches: HashMap::new(),
records: Vec::new(),
entries_by_key: HashMap::new(),
module_to_entries: HashMap::new(),
}
}
fn credentials_mode(&self) -> RequestCredentialsMode {
self.credentials_mode
}
fn root_referrer_policy(&self) -> Option<&str> {
self.root_referrer_policy.as_deref()
}
fn referrer_policy(&self, entry: usize) -> Option<&str> {
self.records[entry].referrer_policy.as_deref()
}
fn referrer_policy_for_url(&self, url: &Url) -> Option<String> {
self.records
.iter()
.find(|record| record.key.url == *url || record.source_url == *url)
.and_then(|record| record.referrer_policy.clone())
.or_else(|| self.root_referrer_policy.clone())
}
fn entry_for_key(&self, key: &WorkerModuleKey) -> Option<usize> {
self.entries_by_key.get(key).copied()
}
fn source_fetch_failure(&self, key: &WorkerModuleKey) -> Option<String> {
self.failed_source_fetches.get(key).cloned()
}
fn mark_source_fetch_failed(&mut self, key: &WorkerModuleKey, message: String) {
self.failed_source_fetches.insert(key.clone(), message);
}
fn insert(
&mut self,
key: WorkerModuleKey,
source_url: Url,
source: WorkerModuleSource,
module: v8::Global<v8::Module>,
identity_hash: i32,
requests: Vec<WorkerModuleRequest>,
wasm_module: Option<WasmModuleRecord>,
referrer_policy: Option<String>,
) -> usize {
let entry = self.records.len();
self.records.push(WorkerModuleRecord {
key: key.clone(),
source_url,
source,
module,
requests,
dependencies: Vec::new(),
wasm_module,
referrer_policy,
});
self.entries_by_key.insert(key, entry);
self.module_to_entries
.entry(identity_hash)
.or_default()
.push(entry);
entry
}
fn module(&self, entry: usize) -> &v8::Global<v8::Module> {
&self.records[entry].module
}
fn has_top_level_await(&self, scope: &mut v8::PinScope<'_, '_>, root_entry: usize) -> bool {
let mut pending = vec![root_entry];
let mut seen = HashSet::new();
while let Some(entry) = pending.pop() {
if !seen.insert(entry) {
continue;
}
let module = v8::Local::new(scope, self.module(entry));
if module.has_top_level_await() {
return true;
}
for request in &self.records[entry].requests {
if request.phase == ModuleImportPhase::Evaluation
&& let Some(dependency) = self.resolve_static_dependency_entry(
module,
&request.specifier,
&request.attributes,
)
{
pending.push(dependency);
}
}
}
false
}
fn requests(&self, entry: usize) -> Vec<WorkerModuleRequest> {
self.records[entry].requests.clone()
}
fn add_dependency(
&mut self,
entry: usize,
specifier: String,
attributes: ModuleAttributesKey,
target_entry: usize,
) {
self.records[entry]
.dependencies
.push(WorkerModuleDependency {
specifier,
attributes,
target_entry,
});
}
fn url(&self, entry: usize) -> &Url {
&self.records[entry].source_url
}
fn dependency_entry(
&self,
entry: usize,
specifier: &str,
attributes: &ModuleAttributesKey,
) -> Option<usize> {
self.records[entry]
.dependencies
.iter()
.find(|dependency| {
dependency.specifier == specifier && dependency.attributes == *attributes
})
.map(|dependency| dependency.target_entry)
}
fn module_url_for(&self, module: v8::Local<'_, v8::Module>) -> Option<Url> {
let entry = self.entry_for_module(module)?;
Some(self.records[entry].source_url.clone())
}
fn wasm_instance_for_namespace<'s>(
&self,
scope: &mut v8::PinScope<'s, '_>,
namespace: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Object>> {
for record in &self.records {
let Some(wasm_record) = record.wasm_module.as_ref() else {
continue;
};
let module = v8::Local::new(scope, &record.module);
if !matches!(
module.get_status(),
v8::ModuleStatus::Instantiated
| v8::ModuleStatus::Evaluating
| v8::ModuleStatus::Evaluated
) {
continue;
}
let candidate = module.get_module_namespace();
if namespace.strict_equals(candidate) {
return wasm_record.instance(scope);
}
}
None
}
fn synthetic_module_record_for(
&self,
module: v8::Local<'_, v8::Module>,
) -> Option<WorkerSyntheticModuleRecord> {
let entry = self.entry_for_module(module)?;
let record = &self.records[entry];
if let Some(wasm) = &record.wasm_module {
return Some(WorkerSyntheticModuleRecord::WebAssembly(wasm.clone()));
}
match record.key.module_type {
WorkerModuleType::Json => record
.source
.text_source()
.map(|source| WorkerSyntheticModuleRecord::Json(source.to_owned())),
WorkerModuleType::JavaScriptOrWebAssembly => None,
}
}
fn resolve_static_dependency_entry(
&self,
referrer: v8::Local<'_, v8::Module>,
specifier: &str,
attributes: &ModuleAttributesKey,
) -> Option<usize> {
let referrer_entry = self.entry_for_module(referrer)?;
self.dependency_entry(referrer_entry, specifier, attributes)
}
fn resolve_static_dependency_record(
&self,
referrer: v8::Local<'_, v8::Module>,
specifier: &str,
attributes: &ModuleAttributesKey,
) -> Option<&WorkerModuleRecord> {
let dependency_entry =
self.resolve_static_dependency_entry(referrer, specifier, attributes)?;
Some(&self.records[dependency_entry])
}
fn resolve_static_dependency(
&self,
referrer: v8::Local<'_, v8::Module>,
specifier: &str,
attributes: &ModuleAttributesKey,
) -> Option<&v8::Global<v8::Module>> {
Some(
&self
.resolve_static_dependency_record(referrer, specifier, attributes)?
.module,
)
}
fn entry_for_module(&self, module: v8::Local<'_, v8::Module>) -> Option<usize> {
let identity_hash = module.get_identity_hash().get();
self.module_to_entries
.get(&identity_hash)?
.iter()
.copied()
.find(|entry| module == self.records[*entry].module)
}
}
type WorkerModuleBootstrapResult<T> = Result<T, Box<WorkerBootstrapError>>;
enum WorkerModuleGraphBuild {
Ready,
NeedFetches(WorkerModuleGraphFetchBatch),
}
fn ensure_worker_module_entry(
scope: &mut v8::PinScope<'_, '_>,
graph: &Rc<RefCell<WorkerModuleGraph>>,
source: &WorkerModuleSource,
key: WorkerModuleKey,
source_url: Url,
referrer_policy: Option<String>,
) -> WorkerModuleBootstrapResult<usize> {
let existing_entry = graph.borrow().entry_for_key(&key);
if let Some(entry) = existing_entry {
return Ok(entry);
}
let (module, identity_hash, requests, wasm_module) =
compile_worker_module_record(scope, source, &key, &source_url)?;
Ok(graph.borrow_mut().insert(
key,
source_url,
source.clone(),
module,
identity_hash,
requests,
wasm_module,
referrer_policy,
))
}
fn continue_worker_module_graph(
scope: &mut v8::PinScope<'_, '_>,
graph: &Rc<RefCell<WorkerModuleGraph>>,
root_entry: usize,
fetch_initiator_url: &Url,
csp_source: WorkerModuleGraphFetchCspSource,
browser_request_metadata: BrowserRequestMetadata,
) -> WorkerModuleBootstrapResult<WorkerModuleGraphBuild> {
continue_worker_module_graph_with_pending_keys(
scope,
graph,
root_entry,
fetch_initiator_url,
csp_source,
browser_request_metadata,
HashSet::new(),
)
}
fn continue_worker_module_graph_with_pending_keys(
scope: &mut v8::PinScope<'_, '_>,
graph: &Rc<RefCell<WorkerModuleGraph>>,
root_entry: usize,
fetch_initiator_url: &Url,
csp_source: WorkerModuleGraphFetchCspSource,
browser_request_metadata: BrowserRequestMetadata,
mut pending_keys: HashSet<WorkerModuleKey>,
) -> WorkerModuleBootstrapResult<WorkerModuleGraphBuild> {
// The module map also contains source-only and unrelated dynamic imports.
// Expand only evaluation edges reachable from this job's root.
let mut pending_entries = vec![root_entry];
let mut visited = HashSet::new();
let mut pending_requests = Vec::new();
while let Some(entry) = pending_entries.pop() {
if !visited.insert(entry) {
continue;
}
let url = graph.borrow().url(entry).clone();
let requests = graph.borrow().requests(entry);
for request in requests {
if graph
.borrow()
.dependency_entry(entry, &request.specifier, &request.attributes)
.is_none()
{
match resolve_worker_module_dependency(
scope,
graph,
entry,
&url,
fetch_initiator_url,
csp_source,
browser_request_metadata,
&request,
&mut pending_keys,
)? {
WorkerModuleGraphBuild::Ready => {}
WorkerModuleGraphBuild::NeedFetches(requests) => {
pending_requests.extend(requests.requests);
}
}
}
if request.phase == ModuleImportPhase::Evaluation
&& let Some(dependency) =
graph
.borrow()
.dependency_entry(entry, &request.specifier, &request.attributes)
{
pending_entries.push(dependency);
}
}
}
if !pending_requests.is_empty() {
return Ok(WorkerModuleGraphBuild::NeedFetches(
WorkerModuleGraphFetchBatch::new(pending_requests),
));
}
Ok(WorkerModuleGraphBuild::Ready)
}
fn resolve_worker_module_dependency(
scope: &mut v8::PinScope<'_, '_>,
graph: &Rc<RefCell<WorkerModuleGraph>>,
entry: usize,
url: &Url,
fetch_initiator_url: &Url,
csp_source: WorkerModuleGraphFetchCspSource,
browser_request_metadata: BrowserRequestMetadata,
request: &WorkerModuleRequest,
pending_keys: &mut HashSet<WorkerModuleKey>,
) -> WorkerModuleBootstrapResult<WorkerModuleGraphBuild> {
let dependency_url =
resolve_worker_module_specifier(&request.specifier, url).map_err(|error| {
Box::new(worker_bootstrap_error(
scope,
url.as_str(),
&format!(
"Failed to resolve module worker dependency `{}`: {error}",
request.specifier
),
WorkerParentErrorEventKind::Event,
))
})?;
let dependency_key = worker_module_key_for_attributes(&dependency_url, &request.attributes)
.map_err(|message| {
Box::new(worker_bootstrap_error(
scope,
url.as_str(),
&format!("{message} for import `{}`", request.specifier),
WorkerParentErrorEventKind::Event,
))
})?;
let (dependency_key, dependency_source) =
match load_worker_static_module_dependency(dependency_url, dependency_key.module_type)
.map_err(|message| {
Box::new(worker_bootstrap_error(
scope,
url.as_str(),
&message,
WorkerParentErrorEventKind::Event,
))
})? {
WorkerModuleDependencyLoad::Source { url, source } => {
let dependency_key = worker_module_key_for_attributes(&url, &request.attributes)
.map_err(|message| {
Box::new(worker_bootstrap_error(
scope,
url.as_str(),
&format!("{message} for import `{}`", request.specifier),
WorkerParentErrorEventKind::Event,
))
})?;
(dependency_key, source)
}
WorkerModuleDependencyLoad::NeedFetch(dependency_url) => {
let dependency_key =
worker_module_key_for_attributes(&dependency_url, &request.attributes)
.map_err(|message| {
Box::new(worker_bootstrap_error(
scope,
url.as_str(),
&format!("{message} for import `{}`", request.specifier),
WorkerParentErrorEventKind::Event,
))
})?;
let existing_entry = graph.borrow().entry_for_key(&dependency_key);
if let Some(target_entry) = existing_entry {
graph.borrow_mut().add_dependency(
entry,
request.specifier.clone(),
request.attributes.clone(),
target_entry,
);
return Ok(WorkerModuleGraphBuild::Ready);
}
if !pending_keys.insert(dependency_key.clone()) {
return Ok(WorkerModuleGraphBuild::Ready);
}
let fetch_id = reserve_worker_module_graph_fetch_id(scope);
let referrer_policy = graph.borrow().referrer_policy(entry).map(str::to_owned);
return Ok(WorkerModuleGraphBuild::NeedFetches(
WorkerModuleGraphFetchBatch::single(WorkerModuleGraphFetchRequest::new(
fetch_id,
dependency_key,
fetch_initiator_url.clone(),
csp_source,
Some(entry),
request.specifier.clone(),
request.attributes.clone(),
graph.borrow().credentials_mode(),
referrer_policy,
browser_request_metadata,
)),
));
}
};
let referrer_policy = graph.borrow().referrer_policy(entry).map(str::to_owned);
let target_entry = ensure_worker_module_entry(
scope,
graph,
&dependency_source,
dependency_key.clone(),
dependency_key.url.clone(),
referrer_policy,
)?;
graph.borrow_mut().add_dependency(
entry,
request.specifier.clone(),
request.attributes.clone(),
target_entry,
);
Ok(WorkerModuleGraphBuild::Ready)
}
fn reserve_worker_module_graph_fetch_id(
scope: &mut v8::PinScope<'_, '_>,
) -> WorkerModuleGraphFetchId {
let slot = scope
.get_current_context()
.get_slot::<WorkerModuleRuntimeFetchIdSlot>()
.expect("worker module runtime fetch id slot should be installed");
let mut next_fetch_id = slot.next_fetch_id.borrow_mut();
let fetch_id = *next_fetch_id;
*next_fetch_id = next_fetch_id
.checked_add(1)
.expect("worker module graph fetch id space exhausted");
fetch_id
}
fn reserve_worker_module_evaluation_id(
scope: &mut v8::PinScope<'_, '_>,
) -> Result<WorkerModuleEvaluationId, String> {
let slot = scope
.get_current_context()
.get_slot::<WorkerModuleRuntimeEvaluationSlot>()
.ok_or_else(|| "worker module runtime evaluation slot is not installed".to_owned())?;
let mut next_evaluation_id = slot.next_evaluation_id.borrow_mut();
let evaluation_id = *next_evaluation_id;
*next_evaluation_id += 1;
Ok(evaluation_id)
}
fn attach_worker_module_evaluation_reactions(
scope: &mut v8::PinScope<'_, '_>,
evaluation_id: WorkerModuleEvaluationId,
promise: v8::Global<v8::Promise>,
) -> WorkerModuleBootstrapResult<()> {
let data = WorkerModuleEvaluationReactionDataDeclaration {
evaluation_id: evaluation_id as f64,
}
.bind(scope)
.expect("worker module evaluation reaction data declaration should bind");
let on_fulfilled = v8::Function::builder(worker_module_evaluation_fulfilled_callback)
.data(data.into())
.build(scope)
.ok_or_else(|| {
Box::new(worker_bootstrap_error(
scope,
"worker module",
"failed to create worker module evaluation success reaction",
WorkerParentErrorEventKind::Event,
))
})?;
let on_rejected = v8::Function::builder(worker_module_evaluation_rejected_callback)
.data(data.into())
.build(scope)
.ok_or_else(|| {
Box::new(worker_bootstrap_error(
scope,
"worker module",
"failed to create worker module evaluation failure reaction",
WorkerParentErrorEventKind::Event,
))
})?;
let promise = v8::Local::new(scope, &promise);
promise
.then2(scope, on_fulfilled, on_rejected)
.map(|_| ())
.ok_or_else(|| {
Box::new(worker_bootstrap_error(
scope,
"worker module",
"failed to attach worker module evaluation reactions",
WorkerParentErrorEventKind::Event,
))
})
}
fn compile_worker_module_record(
scope: &mut v8::PinScope<'_, '_>,
source: &WorkerModuleSource,
key: &WorkerModuleKey,
source_url: &Url,
) -> WorkerModuleBootstrapResult<(
v8::Global<v8::Module>,
i32,
Vec<WorkerModuleRequest>,
Option<WasmModuleRecord>,
)> {
if key.module_type == WorkerModuleType::Json {
return compile_worker_synthetic_module_record(scope, source_url);
}
if let Some(bytes) = source.binary_source() {
return compile_worker_wasm_module_record(scope, bytes, source_url);
}
let Some(source) = source.text_source() else {
return Err(Box::new(worker_bootstrap_error(
scope,
source_url.as_str(),
"JavaScript module worker source is not text",
WorkerParentErrorEventKind::Event,
)));
};
let try_catch = pin!(v8::TryCatch::new(scope));
let mut scope = try_catch.init();
let source_str = v8::String::new(&scope, source).expect("v8 string allocation");
let origin = create_module_script_origin(&mut scope, source_url.as_str());
let mut compiler_source = v8::script_compiler::Source::new(source_str, Some(&origin));
let Some(module) = v8::script_compiler::compile_module(&scope, &mut compiler_source) else {
let exception = scope.exception();
let message = scope.message();
let stack_trace = scope.stack_trace();
let report =
build_event_handler_exception_report(&mut scope, exception, message, stack_trace);
return Err(Box::new((
report,
exception.map(|value| v8::Global::new(&scope, value)),
WorkerParentErrorEventKind::Event,
)));
};
let requests = collect_worker_module_requests(&mut scope, module)?;
let identity_hash = module.get_identity_hash().get();
Ok((
v8::Global::new(&scope, module),
identity_hash,
requests,
None,
))
}
fn compile_worker_synthetic_module_record(
scope: &mut v8::PinScope<'_, '_>,
source_url: &Url,
) -> WorkerModuleBootstrapResult<(
v8::Global<v8::Module>,
i32,
Vec<WorkerModuleRequest>,
Option<WasmModuleRecord>,
)> {
let try_catch = pin!(v8::TryCatch::new(scope));
let scope = try_catch.init();
let module_name = v8::String::new(&scope, source_url.as_str()).expect("v8 string allocation");
let default_export = v8::String::new(&scope, "default").expect("v8 string allocation");
let module = v8::Module::create_synthetic_module(
&scope,
module_name,
&[default_export],
worker_synthetic_module_evaluation_steps,
);
let identity_hash = module.get_identity_hash().get();
Ok((
v8::Global::new(scope.as_ref(), module),
identity_hash,
Vec::new(),
None,
))
}
fn compile_worker_wasm_module_record(
scope: &mut v8::PinScope<'_, '_>,
bytes: &[u8],
source_url: &Url,
) -> WorkerModuleBootstrapResult<(
v8::Global<v8::Module>,
i32,
Vec<WorkerModuleRequest>,
Option<WasmModuleRecord>,
)> {
let try_catch = pin!(v8::TryCatch::new(scope));
let mut scope = try_catch.init();
let prepared = prepare_wasm_module_record(&scope, bytes)
.map_err(|error| {
Box::new(worker_bootstrap_error(
&mut scope,
source_url.as_str(),
&error.to_string(),
WorkerParentErrorEventKind::Event,
))
})?
.ok_or_else(|| {
let exception = v8_exception_message_or(
&scope,
scope.exception(),
"unknown wasm compile exception",
);
Box::new(worker_bootstrap_error(
&mut scope,
source_url.as_str(),
&format!("v8 failed to compile WebAssembly module `{source_url}`: {exception}"),
WorkerParentErrorEventKind::Event,
))
})?;
let requests = if prepared.has_reserved_name_link_error {
Vec::new()
} else {
worker_wasm_module_requests_for_imports(prepared.record.imports())
};
let module_name = v8_string(&scope, source_url.as_str()).ok_or_else(|| {
Box::new(worker_bootstrap_error(
&mut scope,
source_url.as_str(),
"failed to allocate WebAssembly synthetic module worker name",
WorkerParentErrorEventKind::Event,
))
})?;
let mut export_names = Vec::with_capacity(prepared.record.exports().len());
for export in prepared.record.exports() {
let Some(export_name) = v8_string(&scope, export.name()) else {
return Err(Box::new(worker_bootstrap_error(
&mut scope,
source_url.as_str(),
"failed to allocate WebAssembly synthetic export name",
WorkerParentErrorEventKind::Event,
)));
};
export_names.push(export_name);
}
let module = v8::Module::create_synthetic_module(
&scope,
module_name,
&export_names,
worker_synthetic_module_evaluation_steps,
);
let identity_hash = module.get_identity_hash().get();
Ok((
v8::Global::new(&scope, module),
identity_hash,
requests,
Some(prepared.record),
))
}
fn worker_wasm_module_requests_for_imports(
imports: &[WasmImportRecord],
) -> Vec<WorkerModuleRequest> {
wasm_evaluation_import_modules(imports)
.into_iter()
.map(|module| WorkerModuleRequest {
specifier: module.to_owned(),
attributes: ModuleAttributesKey::empty(),
phase: ModuleImportPhase::Evaluation,
})
.collect()
}
fn collect_worker_module_requests(
scope: &mut v8::PinScope<'_, '_>,
module: v8::Local<'_, v8::Module>,
) -> WorkerModuleBootstrapResult<Vec<WorkerModuleRequest>> {
let requests = module.get_module_requests();
let mut records = Vec::with_capacity(requests.length());
for index in 0..requests.length() {
let Some(request_data) = requests.get(scope, index) else {
continue;
};
let Ok(request) = v8::Local::<v8::ModuleRequest>::try_from(request_data) else {
return Err(Box::new(worker_bootstrap_error(
scope,
"worker module",
"module request entry was not a ModuleRequest",
WorkerParentErrorEventKind::Event,
)));
};
let attributes = worker_module_request_attributes(scope, request);
if let Some(invalid_key) = attributes.invalid_import_attribute_key() {
return Err(Box::new(worker_bootstrap_error(
scope,
"worker module",
&format!("Invalid attribute key \"{invalid_key}\"."),
WorkerParentErrorEventKind::Event,
)));
}
records.push(WorkerModuleRequest {
specifier: request.get_specifier().to_rust_string_lossy(scope),
attributes,
phase: worker_module_import_phase(request.get_phase()),
});
}
Ok(records)
}
fn worker_module_request_attributes(
scope: &mut v8::PinScope<'_, '_>,
request: v8::Local<'_, v8::ModuleRequest>,
) -> ModuleAttributesKey {
let attributes = request.get_import_attributes();
let mut pairs = Vec::with_capacity(attributes.length() / 3);
let mut index = 0;
while index + 1 < attributes.length() {
let key = attributes
.get(scope, index)
.and_then(|value| v8::Local::<v8::String>::try_from(value).ok())
.map(|value| value.to_rust_string_lossy(scope));
let value = attributes
.get(scope, index + 1)
.and_then(|value| v8::Local::<v8::String>::try_from(value).ok())
.map(|value| value.to_rust_string_lossy(scope));
if let (Some(key), Some(value)) = (key, value) {
pairs.push((key, value));
}
index += 3;
}
ModuleAttributesKey::from_pairs(pairs)
}
fn worker_module_import_phase(phase: v8::ModuleImportPhase) -> ModuleImportPhase {
match phase {
v8::ModuleImportPhase::kSource => ModuleImportPhase::Source,
_ => ModuleImportPhase::Evaluation,
}
}
fn resolve_worker_module_specifier(specifier: &str, base_url: &Url) -> Result<Url, String> {
moli_import_map::resolve_url_like_module_specifier(specifier, base_url).ok_or_else(|| {
format!("Failed to resolve module specifier `{specifier}` from `{base_url}`")
})
}
fn load_worker_static_module_dependency(
dependency_url: Url,
module_type: WorkerModuleType,
) -> Result<WorkerModuleDependencyLoad, String> {
match dependency_url.scheme() {
"data" => {
let (bytes, mime) = moli_web_mime::data_url_body_and_mime_type(dependency_url.as_str())
.ok_or_else(|| format!("Failed to load module worker dependency: invalid data URL `{dependency_url}`"))?;
let source = WorkerModuleSource::from_response_parts(
module_type,
&dependency_url,
&[("content-type".to_owned(), mime.into_bytes())],
bytes,
)?;
Ok(WorkerModuleDependencyLoad::Source {
url: dependency_url,
source,
})
}
"http" | "https" => Ok(WorkerModuleDependencyLoad::NeedFetch(dependency_url)),
scheme => Err(format!(
"Module worker dependency scheme `{scheme}` is not allowed"
)),
}
}
fn worker_module_key_for_attributes(
url: &Url,
attributes: &ModuleAttributesKey,
) -> Result<WorkerModuleKey, String> {
let Some(module_type) = attributes.module_type() else {
return Ok(WorkerModuleKey::javascript_or_wasm(url.clone()));
};
match module_type {
"json" => Ok(WorkerModuleKey::json(url.clone(), attributes.clone())),
other => Err(format!("module type `{other}` is not a valid module type")),
}
}
enum WorkerModuleDependencyLoad {
Source {
url: Url,
source: WorkerModuleSource,
},
NeedFetch(Url),
}
struct WorkerModuleRuntimeFetchIdSlot {
next_fetch_id: Rc<RefCell<WorkerModuleGraphFetchId>>,
}
struct WorkerModuleRuntimeEvaluationSlot {
next_evaluation_id: Rc<RefCell<WorkerModuleEvaluationId>>,
evaluation_completion_tx: mpsc::UnboundedSender<WorkerModuleEvaluationCompletion>,
}
fn worker_bootstrap_error(
scope: &mut v8::PinScope<'_, '_>,
script_url: &str,
summary: &str,
event_kind: WorkerParentErrorEventKind,
) -> WorkerBootstrapError {
let exception =
v8::String::new(scope, summary).map(|message| v8::Exception::syntax_error(scope, message));
(
V8ExceptionReport {
summary: summary.to_owned(),
source: Some(script_url.to_owned()),
line: Some(1),
column: Some(1),
source_line: None,
stack: None,
callback_context: None,
exception: None,
},
exception.map(|value| v8::Global::new(scope, value)),
event_kind,
)
}
fn worker_bootstrap_value_error(
scope: &mut v8::PinScope<'_, '_>,
script_url: &str,
value: v8::Local<'_, v8::Value>,
event_kind: WorkerParentErrorEventKind,
) -> WorkerBootstrapError {
let summary = value
.to_string(scope)
.map(|message| message.to_rust_string_lossy(scope))
.unwrap_or_else(|| "module worker evaluation failed".to_owned());
(
V8ExceptionReport {
summary,
source: Some(script_url.to_owned()),
line: Some(1),
column: Some(1),
source_line: None,
stack: None,
callback_context: None,
exception: None,
},
Some(v8::Global::new(scope, value)),
event_kind,
)
}
fn worker_resolve_static_module_callback<'s>(
context: v8::Local<'s, v8::Context>,
specifier: v8::Local<'s, v8::String>,
import_attributes: v8::Local<'s, v8::FixedArray>,
referrer: v8::Local<'s, v8::Module>,
) -> Option<v8::Local<'s, v8::Module>> {
v8::callback_scope!(unsafe scope, context);
let graph = context.get_slot::<RefCell<WorkerModuleGraph>>()?;
let specifier = specifier.to_rust_string_lossy(scope);
let attributes = worker_import_attributes_key(scope, import_attributes);
let graph = graph.borrow();
let module = graph.resolve_static_dependency(referrer, &specifier, &attributes)?;
Some(v8::Local::new(scope, module))
}
fn worker_resolve_static_source_callback<'s>(
context: v8::Local<'s, v8::Context>,
specifier: v8::Local<'s, v8::String>,
import_attributes: v8::Local<'s, v8::FixedArray>,
referrer: v8::Local<'s, v8::Module>,
) -> Option<v8::Local<'s, v8::Object>> {
v8::callback_scope!(unsafe scope, context);
let graph = context.get_slot::<RefCell<WorkerModuleGraph>>()?;
let specifier = specifier.to_rust_string_lossy(scope);
let attributes = worker_import_attributes_key(scope, import_attributes);
let graph = graph.borrow();
let Some(record) = graph.resolve_static_dependency_record(referrer, &specifier, &attributes)
else {
return throw_worker_source_phase_syntax_error(
scope,
&format!("source-phase module `{specifier}` was not resolved"),
);
};
let Some(wasm_record) = record.wasm_module.as_ref() else {
return throw_worker_source_phase_syntax_error(
scope,
&format!("source-phase module `{specifier}` is not a WebAssembly module"),
);
};
let Some(source) = wasm_record.source_module(scope) else {
return throw_worker_source_phase_syntax_error(
scope,
&format!("failed to materialize WebAssembly source for `{specifier}`"),
);
};
Some(source.into())
}
fn throw_worker_source_phase_syntax_error<'s>(
scope: &mut v8::PinScope<'s, '_>,
message: &str,
) -> Option<v8::Local<'s, v8::Object>> {
let message = v8_string(scope, message)?;
let exception = v8::Exception::syntax_error(scope, message);
scope.throw_exception(exception);
None
}
fn worker_module_evaluation_fulfilled_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'s, v8::Value>,
) {
let Some(evaluation_id) = worker_module_evaluation_reaction_id(scope, args.data()) else {
return;
};
let context = scope.get_current_context();
let Some(slot) = context.get_slot::<WorkerModuleRuntimeEvaluationSlot>() else {
return;
};
let _ = slot
.evaluation_completion_tx
.send(WorkerModuleEvaluationCompletion::new(evaluation_id, Ok(())));
}
fn worker_module_evaluation_rejected_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'s, v8::Value>,
) {
let Some(evaluation_id) = worker_module_evaluation_reaction_id(scope, args.data()) else {
return;
};
let reason = args
.get(0)
.to_string(scope)
.map(|value| value.to_rust_string_lossy(scope))
.unwrap_or_else(|| "unknown module worker top-level await rejection".to_owned());
let context = scope.get_current_context();
let Some(slot) = context.get_slot::<WorkerModuleRuntimeEvaluationSlot>() else {
return;
};
let _ = slot
.evaluation_completion_tx
.send(WorkerModuleEvaluationCompletion::new(
evaluation_id,
Err(reason),
));
}
fn worker_module_evaluation_reaction_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
data: v8::Local<'s, v8::Value>,
) -> Option<WorkerModuleEvaluationId> {
let data = v8::Local::<v8::Object>::try_from(data).ok()?;
get_private_value(scope, data, WORKER_MODULE_EVALUATION_REACTION_ID_SLOT)?
.number_value(scope)
.map(|value| value as WorkerModuleEvaluationId)
}
pub(super) unsafe extern "C" fn worker_initialize_import_meta_object_callback(
context: v8::Local<'_, v8::Context>,
module: v8::Local<'_, v8::Module>,
meta: v8::Local<'_, v8::Object>,
) {
v8::callback_scope!(unsafe scope, context);
let module_url = context
.get_slot::<RefCell<WorkerModuleGraph>>()
.and_then(|graph| graph.borrow().module_url_for(module))
.or_else(|| worker_current_script_url(scope));
let Some(module_url) = module_url else { return };
let Some(value) = v8::String::new(scope, module_url.as_str()) else {
return;
};
let _ = WorkerImportMetaDeclaration::new(value).initialize(scope, meta);
}
pub(crate) fn worker_wasm_instance_for_namespace<'s>(
scope: &mut v8::PinScope<'s, '_>,
namespace: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Object>> {
let graph = scope
.get_current_context()
.get_slot::<RefCell<WorkerModuleGraph>>()?;
graph.borrow().wasm_instance_for_namespace(scope, namespace)
}
fn worker_import_meta_resolve_callback(
scope: &mut v8::PinScope<'_, '_>,
args: v8::FunctionCallbackArguments<'_>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let specifier = args.get(0);
let Some(specifier) = specifier.to_string(scope) else {
return;
};
let specifier = specifier.to_rust_string_lossy(scope);
let Some(base_url) = v8::Local::<v8::String>::try_from(args.data())
.ok()
.and_then(|value| Url::parse(&value.to_rust_string_lossy(scope)).ok())
else {
throw_worker_import_meta_resolve_type_error(scope, "Module base URL is invalid.");
return;
};
match resolve_worker_module_specifier(&specifier, &base_url) {
Ok(url) => {
let Some(value) = v8::String::new(scope, url.as_str()) else {
throw_worker_import_meta_resolve_type_error(
scope,
"Failed to allocate resolved module URL.",
);
return;
};
rv.set(value.into());
}
Err(message) => {
throw_worker_import_meta_resolve_type_error(scope, &message);
}
}
}
fn throw_worker_import_meta_resolve_type_error(scope: &mut v8::PinScope<'_, '_>, message: &str) {
let exception = v8::String::new(scope, message)
.map(|message| v8::Exception::type_error(scope, message))
.unwrap_or_else(|| v8::undefined(scope).into());
scope.throw_exception(exception);
}
fn worker_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 synthetic = context
.get_slot::<RefCell<WorkerModuleGraph>>()
.and_then(|graph| graph.borrow().synthetic_module_record_for(module))?;
match synthetic {
WorkerSyntheticModuleRecord::Json(source) => {
evaluate_worker_json_synthetic_module(scope, module, &source)
}
WorkerSyntheticModuleRecord::WebAssembly(wasm_record) => {
evaluate_wasm_synthetic_module(scope, module, &wasm_record, |scope, import| {
worker_wasm_import_value(scope, module, import)
})
}
}
}
fn evaluate_worker_json_synthetic_module<'s>(
scope: &mut v8::PinScope<'s, '_>,
module: v8::Local<'s, v8::Module>,
source: &str,
) -> Option<v8::Local<'s, v8::Value>> {
let Some(json_source) = v8::String::new(scope, source) else {
return throw_worker_synthetic_module_error(scope, "failed to allocate JSON module source");
};
let value = v8::json::parse(scope, json_source)?;
set_worker_synthetic_default_export(scope, module, value)
}
fn set_worker_synthetic_default_export<'s>(
scope: &mut v8::PinScope<'s, '_>,
module: v8::Local<'s, v8::Module>,
value: v8::Local<'s, v8::Value>,
) -> Option<v8::Local<'s, v8::Value>> {
let export_name = v8::String::new(scope, "default")?;
if module
.set_synthetic_module_export(scope, export_name, value)
.is_none_or(|ok| !ok)
{
return throw_worker_synthetic_module_error(
scope,
"failed to set worker synthetic module default export",
);
}
Some(v8::undefined(scope).into())
}
fn worker_wasm_import_value<'s>(
scope: &mut v8::PinScope<'s, '_>,
referrer: v8::Local<'s, v8::Module>,
import: &WasmImportRecord,
) -> Option<v8::Local<'s, v8::Value>> {
let Some(graph) = scope
.get_current_context()
.get_slot::<RefCell<WorkerModuleGraph>>()
else {
return throw_wasm_link_error(scope, "worker wasm import graph is not available");
};
let attributes = ModuleAttributesKey::empty();
let (dependency_module, dependency_wasm_record) = {
let graph = graph.borrow();
let Some(entry) =
graph.resolve_static_dependency_entry(referrer, import.module(), &attributes)
else {
return throw_wasm_link_error(scope, "worker wasm import dependency is not available");
};
(
graph.records[entry].module.clone(),
graph.records[entry].wasm_module.clone(),
)
};
let dependency = v8::Local::new(scope, &dependency_module);
ensure_worker_dependency_module_namespace_ready(scope, &graph, dependency)?;
wasm_dependency_export_value(
scope,
dependency,
dependency_wasm_record.as_ref(),
import.name(),
"failed to allocate worker wasm import export name",
"worker wasm import export is not available",
)
}
fn ensure_worker_dependency_module_namespace_ready<'s>(
scope: &mut v8::PinScope<'s, '_>,
graph: &RefCell<WorkerModuleGraph>,
module: v8::Local<'s, v8::Module>,
) -> Option<()> {
let mut dependency_modules_for =
|_: &mut v8::PinScope<'s, '_>, dependency: v8::Local<'s, v8::Module>| {
let graph = graph.borrow();
let entry = graph.entry_for_module(dependency)?;
graph.records[entry]
.requests
.iter()
.filter(|request| request.phase == ModuleImportPhase::Evaluation)
.map(|request| {
graph
.resolve_static_dependency(
dependency,
&request.specifier,
&request.attributes,
)
.cloned()
})
.collect::<Option<Vec<_>>>()
};
ensure_wasm_dependency_module_namespace_ready(
scope,
module,
|scope: &mut v8::PinScope<'s, '_>, module: v8::Local<'s, v8::Module>| match module
.instantiate_module2(
scope,
worker_resolve_static_module_callback,
worker_resolve_static_source_callback,
) {
Some(true) => Some(()),
Some(false) => {
throw_wasm_synthetic_module_error(
scope,
"worker module dependency instantiate returned false",
);
None
}
None => {
preserve_current_v8_module_exception(scope);
None
}
},
&mut dependency_modules_for,
|scope| {
scope.perform_microtask_checkpoint();
crate::context_bootstrap::run_end_of_microtask_checkpoint_tasks(scope);
Some(())
},
WasmDependencyModuleMessages {
instantiating: "worker module dependency is still instantiating",
already_failed: "worker module dependency already failed",
evaluation_failed: "worker module dependency evaluation failed",
not_instantiated: "worker module dependency is not instantiated",
cyclic: "cyclic worker WebAssembly module evaluation through JavaScript dependencies is not supported yet",
graph_unavailable: "worker module dependency graph is not available",
pending: "worker module dependency evaluation is pending",
},
)
}
fn throw_worker_synthetic_module_error<'s>(
scope: &mut v8::PinScope<'s, '_>,
message: &str,
) -> Option<v8::Local<'s, v8::Value>> {
let exception = v8::String::new(scope, message)
.map(|message| v8::Exception::type_error(scope, message))
.unwrap_or_else(|| v8::undefined(scope).into());
scope.throw_exception(exception);
None
}
fn worker_import_attributes_key(
scope: &mut v8::PinScope<'_, '_>,
attributes: v8::Local<'_, v8::FixedArray>,
) -> ModuleAttributesKey {
let mut pairs = Vec::with_capacity(attributes.length() / 2);
let mut index = 0;
while index + 1 < attributes.length() {
let key = attributes
.get(scope, index)
.and_then(|value| v8::Local::<v8::String>::try_from(value).ok())
.map(|value| value.to_rust_string_lossy(scope));
let value = attributes
.get(scope, index + 1)
.and_then(|value| v8::Local::<v8::String>::try_from(value).ok())
.map(|value| value.to_rust_string_lossy(scope));
if let (Some(key), Some(value)) = (key, value) {
pairs.push((key, value));
}
index += 2;
}
ModuleAttributesKey::from_pairs(pairs)
}
pub(super) fn worker_dynamic_import_callback<'s, 'i>(
scope: &mut v8::PinScope<'s, 'i>,
_host_defined_options: v8::Local<'s, v8::Data>,
resource_name: v8::Local<'s, v8::Value>,
specifier: v8::Local<'s, v8::String>,
import_attributes: v8::Local<'s, v8::FixedArray>,
) -> Option<v8::Local<'s, v8::Promise>> {
queue_worker_dynamic_import(
scope,
resource_name,
specifier,
import_attributes,
ModuleImportPhase::Evaluation,
)
}
fn queue_worker_dynamic_import<'s>(
scope: &mut v8::PinScope<'s, '_>,
resource_name: v8::Local<'s, v8::Value>,
specifier: v8::Local<'s, v8::String>,
import_attributes: v8::Local<'s, v8::FixedArray>,
phase: ModuleImportPhase,
) -> Option<v8::Local<'s, v8::Promise>> {
let resolver = v8::PromiseResolver::new(scope)?;
let promise = resolver.get_promise(scope);
// HostLoadImportedModule forbids dynamic imports in service workers,
// including modules already present in the static graph. Reject before
// resolving the specifier or scheduling any graph fetch.
if super::global_scope::get_worker_state(scope).is_some_and(|state| {
matches!(
state.borrow().global_kind,
super::thread::WorkerGlobalKind::Service { .. }
)
}) {
reject_worker_dynamic_import_resolver(
scope,
resolver,
"import() is disallowed on ServiceWorkerGlobalScope.",
);
return Some(promise);
}
let context = scope.get_current_context();
let specifier = specifier.to_rust_string_lossy(scope);
let attributes = worker_import_attributes_key(scope, import_attributes);
if let Some(invalid_key) = attributes.invalid_import_attribute_key() {
reject_worker_dynamic_import_resolver(
scope,
resolver,
&format!("Invalid attribute key \"{invalid_key}\"."),
);
return Some(promise);
}
let resource_url = resource_name
.to_string(scope)
.and_then(|value| Url::parse(&value.to_rust_string_lossy(scope)).ok())
.or_else(|| worker_current_script_url(scope));
let audio_worklet_import =
audio_worklet_dynamic_import(scope, resource_url.as_ref(), &specifier);
if audio_worklet_import == AudioWorkletDynamicImport::Forbidden {
reject_worker_dynamic_import_resolver(
scope,
resolver,
"import() is disallowed on WorkletGlobalScope.",
);
return Some(promise);
}
let base_url = resource_url;
let Some(base_url) = base_url else {
reject_worker_dynamic_import_resolver(
scope,
resolver,
"dynamic import in module worker has no base URL",
);
return Some(promise);
};
let fetch_initiator_url = worker_current_script_url(scope).unwrap_or_else(|| base_url.clone());
let Some(dynamic_imports) = context.get_slot::<RefCell<WorkerDynamicModuleResolver>>() else {
reject_worker_dynamic_import_resolver(
scope,
resolver,
"worker dynamic import resolver is not installed",
);
return Some(promise);
};
dynamic_imports.borrow_mut().queue_import(
v8::Global::new(scope, context),
v8::Global::new(scope, resolver),
specifier,
base_url,
fetch_initiator_url,
attributes,
phase,
audio_worklet_import == AudioWorkletDynamicImport::Bootstrap,
);
Some(promise)
}
pub(super) fn worker_dynamic_import_with_phase_callback<'s, 'i>(
scope: &mut v8::PinScope<'s, 'i>,
host_defined_options: v8::Local<'s, v8::Data>,
resource_name: v8::Local<'s, v8::Value>,
specifier: v8::Local<'s, v8::String>,
phase: v8::ModuleImportPhase,
import_attributes: v8::Local<'s, v8::FixedArray>,
) -> Option<v8::Local<'s, v8::Promise>> {
match phase {
v8::ModuleImportPhase::kEvaluation => worker_dynamic_import_callback(
scope,
host_defined_options,
resource_name,
specifier,
import_attributes,
),
v8::ModuleImportPhase::kSource => {
if audio_worklet_dynamic_import(scope, None, "") == AudioWorkletDynamicImport::Forbidden
{
return reject_audio_worklet_dynamic_import(scope);
}
queue_worker_dynamic_import(
scope,
resource_name,
specifier,
import_attributes,
ModuleImportPhase::Source,
)
}
v8::ModuleImportPhase::kDefer => reject_unsupported_worker_dynamic_import_phase(
scope,
"defer-phase dynamic import is not supported yet",
),
}
}
fn reject_worker_dynamic_import_resolver(
scope: &mut v8::PinScope<'_, '_>,
resolver: v8::Local<'_, v8::PromiseResolver>,
message: &str,
) {
let exception = v8::String::new(scope, message)
.map(|message| v8::Exception::type_error(scope, message))
.unwrap_or_else(|| v8::undefined(scope).into());
let _ = resolver.reject(scope, exception);
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum AudioWorkletDynamicImport {
None,
Bootstrap,
Forbidden,
}
fn audio_worklet_dynamic_import(
scope: &mut v8::PinScope<'_, '_>,
resource_url: Option<&Url>,
specifier: &str,
) -> AudioWorkletDynamicImport {
let Some(bootstrap_url) = audio_worklet_bootstrap_module_url(scope) else {
return AudioWorkletDynamicImport::None;
};
let Some(resource_url) = resource_url else {
return AudioWorkletDynamicImport::Forbidden;
};
let is_bootstrap_import = worker_current_script_url(scope)
.as_ref()
.is_some_and(|current_url| resource_url == current_url)
&& resource_url.join(specifier).ok().as_ref() == Some(&bootstrap_url);
if is_bootstrap_import {
AudioWorkletDynamicImport::Bootstrap
} else {
AudioWorkletDynamicImport::Forbidden
}
}
fn audio_worklet_bootstrap_module_url(scope: &mut v8::PinScope<'_, '_>) -> Option<Url> {
let global = scope.get_current_context().global(scope);
global
.get(
scope,
v8str(scope, "__moliAudioWorkletBootstrapModuleUrl").into(),
)
.and_then(|value| value.to_string(scope))
.and_then(|value| Url::parse(&value.to_rust_string_lossy(scope)).ok())
}
fn reject_audio_worklet_dynamic_import<'s>(
scope: &mut v8::PinScope<'s, '_>,
) -> Option<v8::Local<'s, v8::Promise>> {
let resolver = v8::PromiseResolver::new(scope)?;
let promise = resolver.get_promise(scope);
let exception = v8::String::new(scope, "import() is disallowed on WorkletGlobalScope.")
.map(|message| v8::Exception::type_error(scope, message))
.unwrap_or_else(|| v8::undefined(scope).into());
let _ = resolver.reject(scope, exception);
Some(promise)
}
fn reject_unsupported_worker_dynamic_import_phase<'s>(
scope: &mut v8::PinScope<'s, '_>,
message: &str,
) -> Option<v8::Local<'s, v8::Promise>> {
let resolver = v8::PromiseResolver::new(scope)?;
let promise = resolver.get_promise(scope);
let exception = v8::String::new(scope, message)
.map(|message| v8::Exception::syntax_error(scope, message))
.unwrap_or_else(|| v8::undefined(scope).into());
let _ = resolver.reject(scope, exception);
Some(promise)
}
fn create_module_script_origin<'s>(
scope: &mut v8::PinScope<'s, '_>,
url: &str,
) -> v8::ScriptOrigin<'s> {
let name = v8::String::new(scope, url).expect("v8 string allocation");
v8::ScriptOrigin::new(
scope,
name.into(),
0,
0,
false,
-1,
None,
false,
false,
true,
None,
)
}