Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

40.1 KB
Raw Blame
use super::*;
use crate::web_api_interfaces;

#[derive(webidl::WebIdlDictionary)]
#[webidl(prefix = "WorkerOptions")]
pub(in crate::context_bootstrap) struct WorkerOptionsMembers {
    #[webidl(name = "type", default = WorkerScriptKind::Classic, converter = "enum")]
    pub(in crate::context_bootstrap) worker_type: WorkerScriptKind,
    #[webidl(default = "")]
    pub(in crate::context_bootstrap) name: String,
    #[webidl(name = "credentials", default = WorkerCredentials(moli_fetch::RequestCredentialsMode::SameOrigin), converter = "enum")]
    pub(in crate::context_bootstrap) credentials_mode: WorkerCredentials,
}

#[derive(webidl::WebIdlEnum)]
#[webidl(name = "RequestCredentials", parse_with = parse_credentials)]
pub(in crate::context_bootstrap) struct WorkerCredentials(
    pub(in crate::context_bootstrap) moli_fetch::RequestCredentialsMode,
);

fn parse_credentials(value: &str) -> Option<WorkerCredentials> {
    value.parse().ok().map(WorkerCredentials)
}

use crate::context_bootstrap::navigation_serialize::{
    current_document_content_security_policies, current_document_referrer_policy,
};
use crate::document_runtime::DomHandle;
use crate::service_worker_runtime::{ServiceWorkerClientId, ServiceWorkerClientType};
use crate::types::DedicatedWorkerId;
use crate::webidl;
use crate::worker::{NestedWorkerContext, WorkerScriptKind};
use moli_encoding::{encode_url_query_for_legacy_web, form_output_encoding_for_label};
use moli_webapi_declare::WebApiObject;
use url::Url;

const WORKER_INVALID_URL_MESSAGE: &str =
    "Failed to construct 'Worker': the provided URL is invalid.";
const WORKER_SCRIPT_URL_CONVERSION_SLOT: &str = "__moliWorkerScriptUrlConversion";
const WORKER_RECURSIVE_CONSTRUCTOR_MESSAGE: &str = "Maximum call stack size exceeded";

#[derive(Copy, Clone)]
struct WorkerEventHandler {
    slot_name: &'static str,
    event_type: &'static str,
}

const WORKER_EVENT_HANDLERS: &[WorkerEventHandler] = &[
    WorkerEventHandler {
        slot_name: WORKER_ONMESSAGE_SLOT,
        event_type: "message",
    },
    WorkerEventHandler {
        slot_name: WORKER_ONMESSAGEERROR_SLOT,
        event_type: "messageerror",
    },
    WorkerEventHandler {
        slot_name: WORKER_ONERROR_SLOT,
        event_type: "error",
    },
];

#[derive(WebApiObject)]
#[webapi(interface = web_api_interfaces::Worker)]
struct WorkerObjectDeclaration {
    #[webapi(slot = SIMPLE_EVENT_TARGET_LISTENERS_SLOT, init = "null_object")]
    event_listeners: (),

    #[webapi(slot = WORKER_ONMESSAGE_SLOT, init = "null")]
    onmessage_slot: (),

    #[webapi(slot = WORKER_ONMESSAGEERROR_SLOT, init = "null")]
    onmessageerror_slot: (),

    #[webapi(slot = WORKER_ONERROR_SLOT, init = "null")]
    onerror_slot: (),

    #[webapi(
        accessor_property,
        enumerable,
        getter = worker_event_handler_getter,
        setter = worker_event_handler_setter,
        data = callback_data_index_value(scope, 0)
    )]
    onmessage: (),

    #[webapi(
        accessor_property,
        enumerable,
        getter = worker_event_handler_getter,
        setter = worker_event_handler_setter,
        data = callback_data_index_value(scope, 1)
    )]
    onmessageerror: (),

    #[webapi(
        accessor_property,
        enumerable,
        getter = worker_event_handler_getter,
        setter = worker_event_handler_setter,
        data = callback_data_index_value(scope, 2)
    )]
    onerror: (),
}

pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    if !args.is_construct_call() {
        throw_type_error(
            scope,
            "Failed to construct 'Worker': Please use the 'new' operator.",
        );
        return;
    }

    if args.length() == 0 {
        throw_type_error(
            scope,
            "Failed to construct 'Worker': 1 argument required, but only 0 present.",
        );
        return;
    }
    let script_url_value = args.get(0);
    let worker_options = match parse_worker_options(scope, &args) {
        Ok(worker_options) => worker_options,
        Err(error) => {
            webidl::throw_error(scope, &error);
            return;
        }
    };
    let worker = args.this();
    WorkerObjectDeclaration::new()
        .initialize(scope, worker)
        .expect("Worker declaration should initialize");
    if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) {
        let requirements = unsafe { &*host_ptr }.trusted_types_for_script_requirements(scope);
        let Some(script_url_input) = trusted_worker_script_url_string_or_throw(
            scope,
            script_url_value,
            requirements,
            "Worker constructor",
            "Worker",
        ) else {
            return;
        };
        let global = scope.get_current_context().global(scope);
        let document_meta_content_security_policies =
            current_document_content_security_policies(scope, global);
        let document_referrer_policy = current_document_referrer_policy(scope, global);
        let host = unsafe { &mut *host_ptr };
        let child_handle = current_child_context_handle(scope)
            .or_else(|| child_context_handle_from_object_creation_context(scope, worker))
            .or_else(|| host.active_child_subresource_request_handle())
            .or_else(|| crate::native_bridge::active_child_window_handle(scope));
        let active_popup_base_url = child_handle
            .is_none()
            .then(|| host.active_lightweight_popup_base_url(scope))
            .flatten();
        let base_url = child_handle
            .and_then(|handle| host.child_browsing_context_base_url(handle))
            .or(active_popup_base_url)
            .unwrap_or_else(|| worker_constructor_base_url(host));
        let network_partition_key = child_handle
            .and_then(|handle| host.child_browsing_context_network_partition_key(handle));
        let query_encoding = document_query_encoding_override(host);
        let creator_storage_key = host
            .active_storage_context(scope, child_handle)
            .storage_key()
            .clone();
        let creator_top_level_site = creator_storage_key.top_level_site().to_owned();
        let owner_scope = if let Some(handle) = child_handle {
            crate::native_bridge::WorkerOwnerScope::Child(handle)
        } else if let Some(popup_id) = crate::native_bridge::active_lightweight_popup_id(scope) {
            crate::native_bridge::WorkerOwnerScope::LightweightPopup(popup_id)
        } else {
            crate::native_bridge::WorkerOwnerScope::Top
        };
        let dispatch_scope = crate::native_bridge::OwnerDispatchScope::from(owner_scope);
        let mut document_content_security_policies = if let Some(handle) = child_handle {
            host.child_browsing_context_content_security_policies(handle)
                .map(<[_]>::to_vec)
                .unwrap_or_else(|| host.document_content_security_policies().to_vec())
        } else if let Some(policies) =
            host.active_lightweight_popup_content_security_policies(scope)
        {
            policies.to_vec()
        } else {
            host.document_content_security_policies().to_vec()
        };
        document_content_security_policies.extend(document_meta_content_security_policies);
        let Some(creator_document_loader) =
            host.document_resource_loader_for_dispatch_scope(dispatch_scope)
        else {
            throw_type_error(
                scope,
                "Failed to construct 'Worker': execution context is no longer available.",
            );
            return;
        };
        let creator_request_client = creator_document_loader.request_client().clone();
        let Some(execution_context_owner) =
            host.current_window_execution_context_binding(scope, dispatch_scope)
        else {
            throw_type_error(
                scope,
                "Failed to construct 'Worker': execution context is no longer available.",
            );
            return;
        };
        let creator_policy_context =
            crate::network_host::effective_subresource_policy_context(scope, host, dispatch_scope);
        let resolved_url =
            match resolve_worker_script_url(&base_url, &script_url_input, query_encoding) {
                Ok(url) => url,
                Err(message) => {
                    throw_worker_dom_exception(scope, "SyntaxError", 12, &message);
                    return;
                }
            };
        if !worker_script_scheme_can_load(&resolved_url) {
            let Some(outside_settings_load) =
                host.register_dedicated_worker_outside_settings_load(dispatch_scope)
            else {
                throw_type_error(
                    scope,
                    "Failed to construct 'Worker': execution context is no longer available.",
                );
                return;
            };
            let worker_id = host.register_loading_worker(
                scope,
                worker,
                creator_top_level_site,
                creator_storage_key,
                worker_options.name.clone(),
                worker_options.credentials_mode.0,
                None,
                outside_settings_load,
                execution_context_owner,
            );
            let recorded = host.record_dedicated_worker_target_created(
                worker_id,
                base_url,
                worker_script_resource_url(&resolved_url),
                worker_options.name,
            );
            debug_assert!(
                recorded,
                "newly registered DedicatedWorker must publish its target before load failure"
            );
            let started = host.start_failed_worker_script_load(
                worker_id,
                resolved_url,
                "Failed to load worker script: unsupported worker script URL scheme.",
            );
            if !started {
                host.forget_worker(worker_id);
                throw_type_error(
                    scope,
                    "Failed to construct 'Worker': runtime is unavailable.",
                );
                return;
            }
            set_private_value(
                scope,
                worker,
                WORKER_ID_SLOT,
                v8::Number::new(scope, worker_id.as_u64() as f64).into(),
            );
            rv.set(worker.into());
            return;
        }
        let materialized = match materialize_worker_script_source(&resolved_url) {
            Ok(source) => source,
            Err(message) => {
                throw_type_error(scope, &message);
                return;
            }
        };
        let creator_secure_context = moli_url::is_potentially_trustworthy_url(&base_url);
        let worker_id = if let Some(script_source) = materialized {
            let request_url = worker_script_resource_url(&resolved_url);
            let network_response =
                local_worker_main_script_network_response(&resolved_url, &script_source);
            let secure_context =
                worker_secure_context_for_script_url(&resolved_url, creator_secure_context);
            let network_policy = WorkerNetworkPolicy {
                secure_context,
                permission_overrides: host.permission_overrides().to_vec(),
                extra_http_headers: host.extra_http_headers().clone(),
                network_offline: host.network_offline(),
                blocked_url_patterns: host.blocked_url_patterns().to_vec(),
                network_partition_key: network_partition_key.clone(),
                fetch_subresource_interception_enabled: host
                    .fetch_subresource_interception_enabled(),
                fetch_subresource_interception_resource_type: host
                    .fetch_subresource_interception_resource_type(),
            };
            let parent_service_worker_client_id =
                host.service_worker_client_id_for_worker_owner(owner_scope);
            let reserved_service_worker_client_id =
                reserve_inherited_service_worker_worker_client_for_local_script(
                    host.browser_context_runtime(),
                    &resolved_url,
                    creator_storage_key.serialized_storage_key(),
                    secure_context,
                    parent_service_worker_client_id,
                );
            let mut worker_policy_context = creator_policy_context;
            if resolved_url.scheme() == "data" {
                worker_policy_context.cross_origin_isolated = false;
            }
            let mut options = WorkerSpawnOptions::new_with_request_client(
                script_source,
                resolved_url.to_string(),
                creator_request_client.clone(),
            )
            .with_script_kind(worker_options.worker_type)
            .with_module_credentials_mode(worker_options.credentials_mode.0)
            .with_module_static_import_initiator_url(base_url.clone())
            .with_module_static_import_content_security_policies(document_content_security_policies)
            .with_network_policy(network_policy)
            .with_policy_context(worker_policy_context)
            .with_worker_context_runtime(host.browser_context_runtime().worker_context_runtime())
            .with_service_worker_runtime(host.browser_context_runtime().service_worker_runtime())
            .with_global_kind(WorkerGlobalKind::Dedicated {
                name: worker_options.name.clone(),
            })
            .with_storage_key_top_level_site(Some(creator_top_level_site.clone()))
            .with_creator_storage_key(creator_storage_key)
            .with_indexed_db_manager(host.indexed_db_manager())
            .with_storage_bucket_store(Some(host.storage_bucket_store()))
            .with_pause_evaluation_until_debugger(
                host.browser_context_runtime()
                    .dedicated_worker_pause_on_start_for_devtools(),
            );
            if let Some(client_id) = reserved_service_worker_client_id {
                options = options.with_reserved_service_worker_client_id(client_id);
            }
            let worker_handle = spawn_worker_with_options(options);
            let worker_id =
                host.register_worker(scope, worker, worker_handle, execution_context_owner);
            let recorded = host.record_dedicated_worker_target_created(
                worker_id,
                base_url.clone(),
                request_url,
                worker_options.name.clone(),
            );
            debug_assert!(
                recorded,
                "newly registered local DedicatedWorker must publish its target"
            );
            let recorded = host.record_dedicated_worker_target_script_loaded(
                worker_id,
                resolved_url.to_string(),
                Box::new(network_response),
            );
            debug_assert!(
                recorded,
                "newly registered local DedicatedWorker must publish its main script response"
            );
            worker_id
        } else {
            let cross_origin_http_worker_script =
                is_cross_origin_http_worker_script(&base_url, &resolved_url);
            let reserved_service_worker_client_id = if cross_origin_http_worker_script {
                None
            } else {
                Some(
                    host.browser_context_runtime()
                        .register_reserved_service_worker_worker_client(
                            resolved_url.clone(),
                            creator_storage_key.serialized_storage_key(),
                            ServiceWorkerClientType::DedicatedWorker,
                            worker_secure_context_for_script_url(
                                &resolved_url,
                                creator_secure_context,
                            ),
                        ),
                )
            };
            let Some(outside_settings_load) =
                host.register_dedicated_worker_outside_settings_load(dispatch_scope)
            else {
                throw_type_error(
                    scope,
                    "Failed to construct 'Worker': execution context is no longer available.",
                );
                return;
            };
            let worker_id = host.register_loading_worker(
                scope,
                worker,
                creator_top_level_site,
                creator_storage_key,
                worker_options.name.clone(),
                worker_options.credentials_mode.0,
                reserved_service_worker_client_id,
                outside_settings_load,
                execution_context_owner,
            );
            let recorded = host.record_dedicated_worker_target_created(
                worker_id,
                base_url.clone(),
                worker_script_resource_url(&resolved_url),
                worker_options.name.clone(),
            );
            debug_assert!(
                recorded,
                "newly registered external DedicatedWorker must publish its target before loading"
            );
            let started = if cross_origin_http_worker_script {
                host.start_failed_worker_script_load(
                    worker_id,
                    resolved_url,
                    "Failed to load worker script: cross-origin worker script blocked.",
                )
            } else {
                host.start_worker_script_load(
                    worker_id,
                    resolved_url,
                    base_url,
                    network_partition_key,
                    creator_policy_context,
                    worker_options.worker_type,
                    worker_options.credentials_mode.0,
                    document_referrer_policy,
                    document_content_security_policies,
                    worker_options.name.clone(),
                    reserved_service_worker_client_id,
                )
            };
            if !started {
                host.forget_worker(worker_id);
                throw_type_error(
                    scope,
                    "Failed to construct 'Worker': runtime is unavailable.",
                );
                return;
            }
            worker_id
        };
        set_private_value(
            scope,
            worker,
            WORKER_ID_SLOT,
            v8::Number::new(scope, worker_id.as_u64() as f64).into(),
        );
    } else if let Some(nested_context) = crate::worker::reserve_nested_worker_context(scope, worker)
    {
        let Some(script_url_input) = trusted_worker_script_url_string_or_throw(
            scope,
            script_url_value,
            crate::content_security_policy::TrustedTypesForScriptRequirements::enforced_only(
                nested_context.require_trusted_types_for_script,
            ),
            "Worker constructor",
            "Worker",
        ) else {
            return;
        };
        let resolved_url =
            match resolve_worker_script_url(&nested_context.base_url, &script_url_input, None) {
                Ok(url) => url,
                Err(message) => {
                    throw_worker_dom_exception(scope, "SyntaxError", 12, &message);
                    return;
                }
            };
        let (script_url, script_source) =
            match materialize_nested_worker_script_source(&resolved_url, &nested_context) {
                Ok(source) => source,
                Err(message) => {
                    let _ = nested_context.wake_tx.send(
                        crate::worker::WorkerMessage::NestedWorkerEvent {
                            worker_id: nested_context.worker_id,
                            message: Box::new(crate::worker::WorkerToParentMessage::Error {
                                message,
                                filename: resolved_url.to_string(),
                                lineno: 0,
                                colno: 0,
                                event_kind: crate::worker::WorkerParentErrorEventKind::Event,
                                phase: crate::worker::WorkerErrorPhase::Bootstrap,
                                source: crate::worker::WorkerErrorSource::Runtime,
                            }),
                        },
                    );
                    set_private_value(
                        scope,
                        worker,
                        WORKER_ID_SLOT,
                        v8::Number::new(scope, nested_context.worker_id.as_u64() as f64).into(),
                    );
                    return;
                }
            };
        let mut network_policy = nested_context.network_policy.clone();
        network_policy.secure_context = Url::parse(&script_url).ok().is_some_and(|script_url| {
            worker_secure_context_for_script_url(
                &script_url,
                nested_context.network_policy.secure_context,
            )
        });
        let reserved_service_worker_client_id =
            reserve_nested_inherited_service_worker_worker_client_for_local_script(
                &resolved_url,
                &nested_context,
                network_policy.secure_context,
            );
        let mut worker_policy_context = nested_context.policy_context;
        if resolved_url.scheme() == "data" {
            worker_policy_context.cross_origin_isolated = false;
        }
        let options = WorkerSpawnOptions::new_with_request_client(
            script_source,
            script_url,
            nested_context.loader.request_client().clone(),
        )
        .with_script_kind(worker_options.worker_type)
        .with_module_credentials_mode(worker_options.credentials_mode.0)
        .with_module_static_import_initiator_url(nested_context.base_url.clone())
        .with_module_static_import_content_security_policies(
            nested_context.module_static_import_content_security_policies,
        )
        .with_network_policy(network_policy)
        .with_policy_context(worker_policy_context)
        .with_worker_context_runtime(nested_context.worker_context_runtime.clone())
        .with_global_kind(WorkerGlobalKind::Dedicated {
            name: worker_options.name.clone(),
        })
        .with_storage_key_top_level_site(Some(nested_context.storage_key_top_level_site.clone()))
        .with_creator_storage_key(nested_context.creator_storage_key.clone())
        .with_indexed_db_manager(nested_context.indexed_db_manager.clone())
        .with_storage_bucket_store(nested_context.storage_bucket_store.clone());
        let options = if let Some(runtime) = nested_context.service_worker_runtime.clone() {
            options.with_service_worker_runtime(runtime)
        } else {
            options
        };
        let options = if let Some(client_id) = reserved_service_worker_client_id {
            options.with_reserved_service_worker_client_id(client_id)
        } else {
            options
        };
        let mut worker_handle = spawn_worker_with_options(options);
        if let Some(mut rx) = worker_handle.take_receiver() {
            let wake_tx = nested_context.wake_tx.clone();
            let worker_id = nested_context.worker_id;
            let _ = std::thread::Builder::new()
                .name(format!("nested-worker-pump:{worker_id}"))
                .spawn(move || {
                    while let Some(message) = rx.blocking_recv() {
                        let _ = wake_tx.send(crate::worker::WorkerMessage::NestedWorkerEvent {
                            worker_id,
                            message: Box::new(message),
                        });
                    }
                });
        }
        let handle_box = Box::new(worker_handle);
        let handle_ptr = Box::into_raw(handle_box);
        let external = v8::External::new(scope, handle_ptr as *mut std::ffi::c_void);
        set_private_value(scope, worker, WORKER_HANDLE_SLOT, external.into());
        set_private_value(
            scope,
            worker,
            WORKER_ID_SLOT,
            v8::Number::new(scope, nested_context.worker_id.as_u64() as f64).into(),
        );
    } else {
        #[cfg(not(test))]
        {
            throw_type_error(
                scope,
                "Failed to construct 'Worker': execution context is no longer available.",
            );
            return;
        }

        #[cfg(test)]
        {
            // Narrow V8 surface tests intentionally install only the Worker
            // constructor. Their isolate owns one standalone fetch runtime;
            // each Worker receives only its cloneable request handle. The
            // production callback never admits a Worker without a registered
            // Document or parent Worker authority.
            let Some(request_client) = scope
                .get_slot::<crate::network::ResourceRequestClientOwner>()
                .map(crate::network::ResourceRequestClientOwner::handle)
            else {
                throw_type_error(
                    scope,
                    "Failed to construct 'Worker': standalone test fetch runtime is unavailable.",
                );
                return;
            };
            let Some(script_url_input) = trusted_worker_script_url_string_or_throw(
                scope,
                script_url_value,
                crate::content_security_policy::TrustedTypesForScriptRequirements::default(),
                "Worker constructor",
                "Worker",
            ) else {
                return;
            };
            let script_source = match Url::parse(&script_url_input)
                .ok()
                .map(|url| materialize_worker_script_source(&url))
            {
                Some(Ok(Some(source))) => source,
                Some(Ok(None)) | None => script_url_input.clone(),
                Some(Err(message)) => {
                    throw_type_error(scope, &message);
                    return;
                }
            };
            let worker_handle = spawn_worker_with_options(
                WorkerSpawnOptions::new_with_request_client(
                    script_source,
                    script_url_input,
                    request_client,
                )
                .with_script_kind(worker_options.worker_type),
            );
            let handle_box = Box::new(worker_handle);
            let handle_ptr = Box::into_raw(handle_box);
            let external = v8::External::new(scope, handle_ptr as *mut std::ffi::c_void);
            set_private_value(scope, worker, WORKER_HANDLE_SLOT, external.into());
        }
    }

    rv.set(worker.into());
}

pub(in crate::context_bootstrap) fn trusted_worker_script_url_string_or_throw<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    value: v8::Local<'s, v8::Value>,
    requirements: crate::content_security_policy::TrustedTypesForScriptRequirements,
    sink: &'static str,
    api_name: &'static str,
) -> Option<String> {
    let global = scope.get_current_context().global(scope);
    let previous = get_private_value(scope, global, WORKER_SCRIPT_URL_CONVERSION_SLOT);
    if previous.as_ref().is_some_and(|value| value.is_true()) {
        throw_range_error(scope, WORKER_RECURSIVE_CONSTRUCTOR_MESSAGE);
        return None;
    }

    set_private_value(
        scope,
        global,
        WORKER_SCRIPT_URL_CONVERSION_SLOT,
        v8::Boolean::new(scope, true).into(),
    );
    let result = crate::context_bootstrap::trusted_script_url_string_or_throw(
        scope,
        value,
        requirements,
        sink,
        api_name,
    );
    let global = scope.get_current_context().global(scope);
    let restored = previous.unwrap_or_else(|| v8::undefined(scope).into());
    set_private_value(scope, global, WORKER_SCRIPT_URL_CONVERSION_SLOT, restored);
    result
}

fn worker_event_handler_getter<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'s, v8::Value>,
) {
    let Some(handler) =
        callback_data_item(scope, &args, WORKER_EVENT_HANDLERS, "Worker event handlers")
    else {
        return;
    };
    let value = get_private_value(scope, args.this(), handler.slot_name)
        .unwrap_or_else(|| v8::null(scope).into());
    rv.set(value);
}

fn worker_event_handler_setter<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    _rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(handler) =
        callback_data_item(scope, &args, WORKER_EVENT_HANDLERS, "Worker event handlers")
    else {
        return;
    };
    simple_object_event_set_handler(
        scope,
        args.this(),
        handler.event_type,
        handler.slot_name,
        args.get(0),
    );
    if handler.event_type == "message" && args.get(0).is_object() {
        super::flush_pending_worker_messages_for_listener(scope, args.this());
    }
}

fn parse_worker_options<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: &v8::FunctionCallbackArguments<'s>,
) -> Result<WorkerOptionsMembers, webidl::WebIdlError> {
    webidl::convert::<webidl::Dictionary<WorkerOptionsMembers>>(
        scope,
        args.get(1),
        webidl::Context::argument("Worker", 2),
    )
    .map(|value| value.0)
}

pub(in crate::context_bootstrap) fn resolve_worker_script_url(
    base_url: &Url,
    input: &str,
    query_encoding: Option<&'static encoding_rs::Encoding>,
) -> Result<Url, String> {
    if let Some(encoding) = query_encoding {
        let input = encode_url_query_for_legacy_web(input, encoding);
        return Url::options()
            .base_url(Some(base_url))
            .parse(input.as_ref())
            .map_err(|_| WORKER_INVALID_URL_MESSAGE.to_owned());
    }
    Url::options()
        .base_url(Some(base_url))
        .parse(input)
        .map_err(|_| WORKER_INVALID_URL_MESSAGE.to_owned())
}

pub(in crate::context_bootstrap) fn document_query_encoding_override(
    host: &crate::native_bridge::JsContextHost,
) -> Option<&'static encoding_rs::Encoding> {
    form_output_encoding_for_label(host.document_character_set())
        .filter(|encoding| *encoding != encoding_rs::UTF_8)
}

pub(in crate::context_bootstrap) fn worker_constructor_base_url(
    host: &crate::native_bridge::JsContextHost,
) -> Url {
    host.active_child_subresource_request_handle()
        .and_then(|handle| host.child_browsing_context_base_url(handle))
        .unwrap_or_else(|| {
            host.dom_host()
                .document_base_url()
                .unwrap_or_else(|| host.document_url().clone())
        })
}

pub(in crate::context_bootstrap) fn worker_script_resource_url(script_url: &Url) -> Url {
    let mut url = script_url.clone();
    url.set_fragment(None);
    url
}

pub(in crate::context_bootstrap) fn worker_script_scheme_can_load(script_url: &Url) -> bool {
    matches!(script_url.scheme(), "http" | "https" | "data" | "blob")
}

fn current_child_context_handle(scope: &mut v8::PinScope<'_, '_>) -> Option<DomHandle> {
    let global = scope.get_current_context().global(scope);
    child_context_handle_from_global(scope, global)
}

fn child_context_handle_from_object_creation_context(
    scope: &mut v8::PinScope<'_, '_>,
    object: v8::Local<'_, v8::Object>,
) -> Option<DomHandle> {
    let context = object.get_creation_context(scope)?;
    let global = context.global(scope);
    child_context_handle_from_global(scope, global)
}

fn child_context_handle_from_global<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    global: v8::Local<'s, v8::Object>,
) -> Option<DomHandle> {
    let value = get_private_value(
        scope,
        global,
        crate::context_bootstrap::CHILD_BROWSING_CONTEXT_HANDLE_SLOT,
    )?;
    value
        .number_value(scope)
        .filter(|value| value.is_finite() && *value >= 0.0 && value.fract() == 0.0)
        .map(|value| DomHandle::new(value as usize))
}

fn materialize_nested_worker_script_source(
    script_url: &Url,
    context: &NestedWorkerContext,
) -> Result<(String, String), String> {
    if let Some(source) = materialize_worker_script_source(script_url)? {
        return Ok((script_url.to_string(), source));
    }
    let loader = context.loader.clone();
    let resource_url = worker_script_resource_url(script_url);
    let request = moli_fetch::Request::new("GET", resource_url.as_str(), None, vec![])
        .map_err(|error| error.to_string())?
        .with_page_network_policy()
        .with_network_partition_key(context.network_policy.network_partition_key.clone())
        .with_initiator_url(&context.base_url)
        .with_request_origin(moli_url::WebOrigin::from_url(&context.base_url));
    let response = loader
        .request_client()
        .fetch_text_for_worker_blocking_boundary(request)
        .map_err(|error| format!("Failed to load worker script `{resource_url}`: {error}"))?;
    crate::worker::ensure_worker_script_redirect_chain_same_origin(
        &context.base_url,
        &response.redirect_chain,
        &response.final_url,
    )
    .map_err(|message| format!("Failed to construct 'Worker': {message}"))?;
    moli_fetch::ensure_http_status_success(response.final_url.as_str(), response.status, false)
        .map_err(|error| error.to_string())?;
    crate::worker::ensure_worker_script_mime_acceptable(
        &response.final_url,
        &response.headers,
        response.body_bytes(),
    )?;
    let (head, body) = response.into_text_parts();
    let mut final_url = head.final_url;
    final_url.set_fragment(script_url.fragment());
    Ok((final_url.to_string(), body))
}

fn worker_script_inherits_parent_service_worker_controller(script_url: &Url) -> bool {
    script_url.scheme() == "blob"
}

fn reserve_inherited_service_worker_worker_client_for_local_script(
    browser_context_runtime: crate::runtime::RendererBrowserContextRuntime,
    script_url: &Url,
    storage_key: String,
    secure_context: bool,
    parent_client_id: ServiceWorkerClientId,
) -> Option<ServiceWorkerClientId> {
    if !worker_script_inherits_parent_service_worker_controller(script_url) {
        return None;
    }
    browser_context_runtime.register_reserved_service_worker_worker_client_inheriting_controller(
        script_url.clone(),
        storage_key,
        ServiceWorkerClientType::DedicatedWorker,
        secure_context,
        parent_client_id,
    )
}

fn reserve_nested_inherited_service_worker_worker_client_for_local_script(
    script_url: &Url,
    context: &NestedWorkerContext,
    secure_context: bool,
) -> Option<ServiceWorkerClientId> {
    let service_worker_runtime = context.service_worker_runtime.as_ref()?;
    let parent_client_id = context.service_worker_client_id?;
    if !worker_script_inherits_parent_service_worker_controller(script_url) {
        return None;
    }
    service_worker_runtime.register_reserved_worker_client_inheriting_controller_from_client(
        script_url.clone(),
        context.creator_storage_key.serialized_storage_key(),
        ServiceWorkerClientType::DedicatedWorker,
        secure_context,
        parent_client_id,
    )
}

pub(in crate::context_bootstrap) fn is_cross_origin_http_worker_script(
    base_url: &Url,
    script_url: &Url,
) -> bool {
    matches!(script_url.scheme(), "http" | "https") && !moli_url::same_origin(base_url, script_url)
}

pub(in crate::context_bootstrap) fn throw_worker_dom_exception(
    scope: &mut v8::PinScope<'_, '_>,
    name: &'static str,
    _code: i32,
    message: &str,
) {
    let exception = crate::context_bootstrap::new_dom_exception_value(scope, message, name);
    scope.throw_exception(exception);
}

pub(in crate::context_bootstrap) fn materialize_worker_script_source(
    script_url: &Url,
) -> Result<Option<String>, String> {
    match script_url.scheme() {
        "data" => {
            let resource_url = worker_script_resource_url(script_url);
            crate::worker::decode_data_url_script_source(
                &resource_url,
                "Failed to construct 'Worker'",
            )
            .map(Some)
        }
        "blob" => {
            crate::blob::object_url_body_and_type(worker_script_resource_url(script_url).as_str())
                .map(|(body, _)| Some(body))
                .ok_or_else(|| {
                    format!(
                        "Failed to construct 'Worker': blob URL `{}` is unavailable.",
                        script_url
                    )
                })
        }
        "http" | "https" => Ok(None),
        _ => Err(format!(
            "Failed to construct 'Worker': URL scheme `{}` is not allowed.",
            script_url.scheme()
        )),
    }
}

fn local_worker_main_script_network_response(
    script_url: &Url,
    source: &str,
) -> crate::protocol_types::NavigationResponse {
    let resource_url = worker_script_resource_url(script_url);
    let mime_type = match script_url.scheme() {
        "blob" => crate::blob::object_url_body_and_type(resource_url.as_str())
            .map(|(_, mime_type)| mime_type),
        "data" => moli_web_mime::data_url_mime_type(resource_url.as_str()),
        _ => None,
    }
    .filter(|mime_type| !mime_type.is_empty())
    .unwrap_or_else(|| "text/javascript".to_owned());
    crate::protocol_types::NavigationResponse::from_text_body(
        resource_url,
        200,
        vec![(
            "content-type".to_owned(),
            moli_fetch::header_value_from_byte_string(&mime_type)
                .expect("serialized MIME types contain ByteStrings"),
        )],
        source.to_owned(),
    )
}

/// Get the WorkerHandle pointer from a Worker JS object.
pub(super) fn get_worker_handle<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    worker: v8::Local<'s, v8::Object>,
) -> Option<*mut WorkerHandle> {
    let val = get_private_value(scope, worker, WORKER_HANDLE_SLOT)?;
    let external = v8::Local::<v8::External>::try_from(val).ok()?;
    let ptr = external.value() as *mut WorkerHandle;
    if ptr.is_null() { None } else { Some(ptr) }
}

pub(super) fn worker_id<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    worker: v8::Local<'s, v8::Object>,
) -> Option<DedicatedWorkerId> {
    let value = get_private_value(scope, worker, WORKER_ID_SLOT)?;
    value
        .integer_value(scope)
        .and_then(|id| u64::try_from(id).ok())
        .map(DedicatedWorkerId::new)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn worker_script_url_query_uses_document_encoding_override() {
        let base = Url::parse("https://example.test/page.html").expect("base url");
        let resolved = resolve_worker_script_url(
            &base,
            "resources/worker.js?\u{00df}",
            Some(encoding_rs::WINDOWS_1252),
        )
        .expect("worker URL should resolve");

        assert_eq!(
            resolved.as_str(),
            "https://example.test/resources/worker.js?%DF"
        );
    }

    #[test]
    fn worker_script_url_query_defaults_to_utf8_without_document_encoding_override() {
        let base = Url::parse("https://example.test/page.html").expect("base url");
        let resolved = resolve_worker_script_url(&base, "resources/worker.js?\u{00df}", None)
            .expect("worker URL should resolve");

        assert_eq!(
            resolved.as_str(),
            "https://example.test/resources/worker.js?%C3%9F"
        );
    }

    #[test]
    fn only_blob_worker_scripts_inherit_parent_service_worker_controller() {
        assert!(worker_script_inherits_parent_service_worker_controller(
            &Url::parse("blob:https://example.test/id").expect("blob url")
        ));
        assert!(!worker_script_inherits_parent_service_worker_controller(
            &Url::parse("data:text/javascript,postMessage(1)").expect("data url")
        ));
        assert!(!worker_script_inherits_parent_service_worker_controller(
            &Url::parse("https://example.test/worker.js").expect("http url")
        ));
    }

    #[test]
    fn worker_script_url_resolves_parseable_non_fetch_schemes() {
        let base = Url::parse("https://example.test/page.html").expect("base url");

        for (input, expected) in [
            ("unsupported:", "unsupported:"),
            ("about:blank", "about:blank"),
            ("javascript:postMessage(1)", "javascript:postMessage(1)"),
        ] {
            let resolved = resolve_worker_script_url(&base, input, None)
                .expect("parseable worker URL should resolve");
            assert_eq!(resolved.as_str(), expected);
            assert!(
                !worker_script_scheme_can_load(&resolved),
                "{resolved} should not be routed to worker script fetch"
            );
        }
    }
}