Skip to content

armgit / moli

Public Imported from GitHub
0

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

22.0 KB
Raw Blame
use super::super::stream_adapter::{
    TeeStartError, apply_readable_stream_access_transition, disturb_readable_stream,
    enqueue_byte_chunk, install_readable_stream_pipe_to_abort_signal, lock_readable_stream,
    new_lazy_readable_byte_stream_object, new_readable_byte_stream_object,
    new_readable_stream_pipe_owner, prime_readable_stream_pipe_to, readable_stream_access_snapshot,
    register_readable_stream_pipe_owner, register_writable_stream_pipe_owner,
    set_writable_stream_locked, suppress_promise_unhandled_rejection, tee_readable_stream,
};
use super::*;
use crate::context_bootstrap::stream_objects::readable_stream_async_iterator_prototype;
use crate::web_api_interfaces;
use crate::webidl;
use moli_streams::pipe::{PipeEntryObservation, PipeEntryPlan, PipeOptions};
use moli_streams::readable::{AcquireReaderPlan, CancelEntryPlan, ReadableKind, ReaderKind};
use moli_webapi_declare::WebApiObject;

#[derive(WebApiObject)]
#[webapi(prototype = "Object", interface = web_api_interfaces::ReadableStreamAsyncIterator)]
struct ReadableStreamAsyncIteratorObjectDeclaration<'scope> {
    #[webapi(slot = READABLE_STREAM_ITERATOR_READER_SLOT)]
    reader: v8::Local<'scope, v8::Object>,
    #[webapi(slot = READABLE_STREAM_ITERATOR_CLOSED_SLOT, init = false)]
    closed: (),
    #[webapi(slot = READABLE_STREAM_ITERATOR_PREVENT_CANCEL_SLOT)]
    prevent_cancel: bool,
    #[webapi(slot = READABLE_STREAM_ITERATOR_RETURNING_SLOT, init = false)]
    returning: (),
    #[webapi(slot = READABLE_STREAM_ITERATOR_OPERATION_ACTIVE_SLOT, init = false)]
    operation_active: (),
    #[webapi(slot = READABLE_STREAM_ITERATOR_OPERATIONS_SLOT, init = "array")]
    operations: (),
    #[webapi(prototype)]
    prototype: v8::Local<'scope, v8::Object>,
}

#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "ReadableStream.cancel")]
struct ReadableStreamCancelArgs<'s> {
    #[webidl(converter = "raw")]
    reason: Option<v8::Local<'s, v8::Value>>,
}

#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "ReadableStream.pipeThrough")]
struct ReadableStreamPipeThroughArgs<'s> {
    #[webidl(required, name = "transform")]
    transform: v8::Local<'s, v8::Object>,
    #[webidl(index = 1, converter = "raw")]
    options: Option<v8::Local<'s, v8::Value>>,
}

#[derive(Default)]
struct StreamPipeOptions<'s> {
    core: PipeOptions,
    signal: Option<v8::Local<'s, v8::Object>>,
}

#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "ReadableStream.values")]
struct ReadableStreamValuesArgs {
    #[webidl(dictionary)]
    options: ReadableStreamIteratorOptions,
}

#[derive(Default, webidl::WebIdlDictionary)]
#[webidl(prefix = "ReadableStreamIteratorOptions")]
struct ReadableStreamIteratorOptions {
    #[webidl(default = false)]
    prevent_cancel: bool,
}

pub(crate) fn is_readable_stream_object<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    object: v8::Local<'s, v8::Object>,
) -> bool {
    web_api_interfaces::ReadableStream::is_instance(scope, object)
}

pub(crate) fn new_readable_stream_from_array_buffer<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    buffer: v8::Local<'s, v8::ArrayBuffer>,
    len: usize,
) -> Option<v8::Local<'s, v8::Object>> {
    let stream = new_readable_byte_stream_object(scope);
    if len != 0 {
        let source = v8::Uint8Array::new(scope, buffer, 0, len)?;
        let mut bytes = vec![0; len];
        let written = source.copy_contents(&mut bytes);
        bytes.truncate(written);
        let chunk = crate::context_bootstrap::shared::new_uint8_array_from_bytes(scope, bytes)?;
        let _ = enqueue_byte_chunk(scope, stream, chunk.into());
    }
    close_stream(scope, stream);
    Some(stream)
}

pub(crate) fn new_readable_stream_from_source<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    source: v8::Local<'s, v8::Object>,
) -> v8::Local<'s, v8::Object> {
    new_lazy_readable_byte_stream_object(scope, source)
}

pub(in crate::context_bootstrap) fn readable_stream_get_reader_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let stream = args.this();
    if !is_readable_stream_object(scope, stream) {
        throw_type_error(
            scope,
            "ReadableStream.getReader called on incompatible receiver",
        );
        return;
    }
    let Some(reader_kind) = readable_stream_get_reader_mode(scope, &args) else {
        return;
    };
    let stream_kind = ReadableKind::from_byte_stream(readable_stream_is_byte_stream(scope, stream));
    let transition = match readable_stream_access_snapshot(scope, stream)
        .plan_get_reader(reader_kind, stream_kind)
    {
        AcquireReaderPlan::RejectLocked => {
            throw_type_error(scope, "ReadableStream is locked");
            return;
        }
        AcquireReaderPlan::RejectIncompatibleByob => {
            throw_type_error(scope, "ReadableStream is not a byte stream");
            return;
        }
        AcquireReaderPlan::Acquire(transition) => transition,
    };
    let reader = match reader_kind {
        ReaderKind::Default => new_readable_stream_reader_object(scope, stream),
        ReaderKind::Byob => new_readable_stream_byob_reader_object(scope, stream),
    };
    let Some(reader) = reader else {
        rv.set_undefined();
        return;
    };
    apply_readable_stream_access_transition(scope, stream, transition);
    rv.set(reader.into());
}

fn readable_stream_get_reader_mode(
    scope: &mut v8::PinScope<'_, '_>,
    args: &v8::FunctionCallbackArguments<'_>,
) -> Option<ReaderKind> {
    let options = args.get(0);
    if options.is_null_or_undefined() {
        return Some(ReaderKind::Default);
    }
    let Ok(options) = v8::Local::<v8::Object>::try_from(options) else {
        throw_type_error(
            scope,
            "ReadableStream.getReader options must be a dictionary",
        );
        return None;
    };
    let mode_key = v8str(scope, "mode");
    let mode = options.get(scope, mode_key.into())?;
    if mode.is_undefined() {
        return Some(ReaderKind::Default);
    }
    let mode = mode.to_string(scope)?;
    let mode = mode.to_rust_string_lossy(scope);
    if mode == "byob" {
        Some(ReaderKind::Byob)
    } else {
        throw_type_error(
            scope,
            "ReadableStream.getReader mode must be undefined or 'byob'",
        );
        None
    }
}

pub(in crate::context_bootstrap) fn readable_stream_cancel_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    if !is_readable_stream_object(scope, args.this()) {
        let error = v8::Exception::type_error(
            scope,
            v8str(
                scope,
                "ReadableStream.cancel called on incompatible receiver",
            ),
        );
        if let Some(promise) = rejected_promise_value(scope, error) {
            rv.set(promise);
        }
        return;
    }
    let Some(parsed) = webidl::parse_args::<ReadableStreamCancelArgs<'s>>(scope, &args) else {
        return;
    };
    match readable_stream_access_snapshot(scope, args.this()).plan_cancel_entry() {
        CancelEntryPlan::RejectLocked => {
            let error =
                v8::Exception::type_error(scope, v8str(scope, "Cannot cancel a locked stream"));
            if let Some(promise) = rejected_promise_value(scope, error) {
                rv.set(promise);
            } else {
                rv.set_undefined();
            }
            return;
        }
        CancelEntryPlan::Continue => {}
    }
    let reason = parsed.reason.unwrap_or_else(|| v8::undefined(scope).into());
    if let Some(promise) = cancel_readable_stream(scope, args.this(), reason) {
        rv.set(promise);
    } else {
        rv.set_undefined();
    }
}

pub(in crate::context_bootstrap) fn readable_stream_pipe_through_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let stream = args.this();
    if !is_readable_stream_object(scope, stream) {
        throw_type_error(
            scope,
            "ReadableStream.pipeThrough called on incompatible receiver",
        );
        return;
    }
    let Some(parsed) = webidl::parse_args::<ReadableStreamPipeThroughArgs<'s>>(scope, &args) else {
        return;
    };
    let Some(readable) = readable_writable_pair_readable(scope, parsed.transform) else {
        return;
    };
    let Some(writable) = readable_writable_pair_writable(scope, parsed.transform) else {
        return;
    };
    let options = match parse_stream_pipe_options(scope, parsed.options) {
        Ok(options) => options,
        Err(error) => {
            scope.throw_exception(error);
            return;
        }
    };
    let source_locked = readable_stream_locked(scope, stream);
    let destination_locked = writable_stream_locked(scope, writable);
    match PipeEntryObservation::new(source_locked, destination_locked).plan() {
        PipeEntryPlan::RejectSourceLocked => {
            throw_type_error(scope, "Cannot pipe a locked stream");
            return;
        }
        PipeEntryPlan::RejectDestinationLocked => {
            throw_type_error(scope, "Cannot pipe to a locked stream");
            return;
        }
        PipeEntryPlan::Start => {}
    }
    if let Some(pipe_promise) = start_readable_stream_pipe_to(scope, stream, writable, options) {
        suppress_promise_unhandled_rejection(scope, pipe_promise);
    }
    rv.set(readable.into());
}

fn readable_writable_pair_readable<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    pair: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Object>> {
    let value = pair.get(scope, v8str(scope, "readable").into())?;
    let Ok(readable) = v8::Local::<v8::Object>::try_from(value) else {
        throw_type_error(
            scope,
            "ReadableWritablePair.readable must be a ReadableStream",
        );
        return None;
    };
    if !is_readable_stream_object(scope, readable) {
        throw_type_error(
            scope,
            "ReadableWritablePair.readable must be a ReadableStream",
        );
        return None;
    }
    Some(readable)
}

fn readable_writable_pair_writable<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    pair: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Object>> {
    let value = pair.get(scope, v8str(scope, "writable").into())?;
    let Ok(writable) = v8::Local::<v8::Object>::try_from(value) else {
        throw_type_error(
            scope,
            "ReadableWritablePair.writable must be a WritableStream",
        );
        return None;
    };
    if !is_writable_stream_object(scope, writable) {
        throw_type_error(
            scope,
            "ReadableWritablePair.writable must be a WritableStream",
        );
        return None;
    }
    Some(writable)
}

fn parse_stream_pipe_options<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    value: Option<v8::Local<'s, v8::Value>>,
) -> Result<StreamPipeOptions<'s>, v8::Local<'s, v8::Value>> {
    let Some(value) = value else {
        return Ok(StreamPipeOptions::default());
    };
    if value.is_null_or_undefined() {
        return Ok(StreamPipeOptions::default());
    }
    let Ok(options) = v8::Local::<v8::Object>::try_from(value) else {
        return Err(v8::Exception::type_error(
            scope,
            v8str(scope, "StreamPipeOptions must be an object"),
        ));
    };
    let prevent_abort = stream_pipe_option_bool(scope, options, "preventAbort")?;
    let prevent_cancel = stream_pipe_option_bool(scope, options, "preventCancel")?;
    let prevent_close = stream_pipe_option_bool(scope, options, "preventClose")?;
    let signal = stream_pipe_signal(scope, options)?;
    Ok(StreamPipeOptions {
        core: PipeOptions::new(prevent_close, prevent_abort, prevent_cancel),
        signal,
    })
}

fn stream_pipe_option_bool<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    options: v8::Local<'s, v8::Object>,
    name: &'static str,
) -> Result<bool, v8::Local<'s, v8::Value>> {
    let value = stream_pipe_option_value(scope, options, name)?;
    Ok(value.is_some_and(|value| value.boolean_value(scope)))
}

fn stream_pipe_signal<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    options: v8::Local<'s, v8::Object>,
) -> Result<Option<v8::Local<'s, v8::Object>>, v8::Local<'s, v8::Value>> {
    let Some(value) = stream_pipe_option_value(scope, options, "signal")? else {
        return Ok(None);
    };
    if value.is_undefined() {
        return Ok(None);
    }
    let Ok(signal) = v8::Local::<v8::Object>::try_from(value) else {
        return Err(v8::Exception::type_error(
            scope,
            v8str(scope, "StreamPipeOptions.signal must be an AbortSignal"),
        ));
    };
    if !stream_pipe_signal_is_abort_signal(scope, signal) {
        return Err(v8::Exception::type_error(
            scope,
            v8str(scope, "StreamPipeOptions.signal must be an AbortSignal"),
        ));
    }
    Ok(Some(signal))
}

fn stream_pipe_signal_is_abort_signal<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    signal: v8::Local<'s, v8::Object>,
) -> bool {
    if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope)
        && unsafe { &mut *host_ptr }.is_abort_signal(scope, signal)
    {
        return true;
    }
    crate::worker::abort::worker_abort_signal_id(scope, signal).is_some()
}

fn stream_pipe_option_value<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    options: v8::Local<'s, v8::Object>,
    name: &'static str,
) -> Result<Option<v8::Local<'s, v8::Value>>, v8::Local<'s, v8::Value>> {
    let try_catch = std::pin::pin!(v8::TryCatch::new(scope));
    let scope = try_catch.init();
    let Some(key) = v8_string(&scope, name) else {
        return Ok(None);
    };
    match options.get(&scope, key.into()) {
        Some(value) => Ok(Some(value)),
        None if scope.has_caught() => Err(scope
            .exception()
            .unwrap_or_else(|| v8::undefined(&scope).into())),
        None => Ok(None),
    }
}

fn start_readable_stream_pipe_to<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    stream: v8::Local<'s, v8::Object>,
    writable: v8::Local<'s, v8::Object>,
    options: StreamPipeOptions<'s>,
) -> Option<v8::Local<'s, v8::Value>> {
    let (promise, owner) = new_readable_stream_pipe_owner(scope, stream, writable, options.core)?;
    register_readable_stream_pipe_owner(scope, stream, owner);
    if !lock_readable_stream(scope, stream) {
        return None;
    }
    set_writable_stream_locked(scope, writable, true);
    register_writable_stream_pipe_owner(scope, writable, owner);
    // ReadableStreamPipeTo disturbs the source before handling aborts or
    // waiting for destination backpressure to permit the first read.
    disturb_readable_stream(scope, stream);
    if let Some(signal) = options.signal {
        install_readable_stream_pipe_to_abort_signal(scope, stream, signal);
    }
    prime_readable_stream_pipe_to(scope, stream);
    Some(promise.into())
}

/// Connect a browser-owned cross-realm readable endpoint to a writable
/// destination. Transfer admission has already established that both streams
/// are unlocked; the ordinary pipe owner remains responsible for all later
/// close/error/backpressure settlement.
pub(super) fn start_internal_readable_stream_pipe_to<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    stream: v8::Local<'s, v8::Object>,
    writable: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Value>> {
    debug_assert!(!readable_stream_access_snapshot(scope, stream).locked());
    debug_assert!(!writable_stream_snapshot(scope, writable).locked());
    start_readable_stream_pipe_to(scope, stream, writable, StreamPipeOptions::default())
}

pub(in crate::context_bootstrap) fn readable_stream_pipe_to_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let stream = args.this();
    if !is_readable_stream_object(scope, stream) {
        set_rejected_pipe_to_type_error(scope, &mut rv, "Cannot pipe an invalid ReadableStream");
        return;
    }
    if args.length() < 1 {
        set_rejected_pipe_to_type_error(
            scope,
            &mut rv,
            "ReadableStream.pipeTo requires a destination",
        );
        return;
    }
    let Ok(writable) = v8::Local::<v8::Object>::try_from(args.get(0)) else {
        set_rejected_pipe_to_type_error(
            scope,
            &mut rv,
            "ReadableStream.pipeTo destination must be an object",
        );
        return;
    };
    if !is_writable_stream_object(scope, writable) {
        set_rejected_pipe_to_type_error(scope, &mut rv, "Cannot pipe to an invalid WritableStream");
        return;
    }
    let options_value = (args.length() > 1 && !args.get(1).is_undefined()).then(|| args.get(1));
    let options = match parse_stream_pipe_options(scope, options_value) {
        Ok(options) => options,
        Err(error) => {
            set_rejected_pipe_to_error(scope, &mut rv, error);
            return;
        }
    };
    let source_locked = readable_stream_locked(scope, stream);
    let destination_locked = writable_stream_locked(scope, writable);
    match PipeEntryObservation::new(source_locked, destination_locked).plan() {
        PipeEntryPlan::RejectSourceLocked => {
            set_rejected_pipe_to_type_error(scope, &mut rv, "Cannot pipe a locked stream");
            return;
        }
        PipeEntryPlan::RejectDestinationLocked => {
            set_rejected_pipe_to_type_error(scope, &mut rv, "Cannot pipe to a locked stream");
            return;
        }
        PipeEntryPlan::Start => {}
    }
    if let Some(promise) = start_readable_stream_pipe_to(scope, stream, writable, options) {
        rv.set(promise);
    }
}

pub(in crate::context_bootstrap) fn readable_stream_tee_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let stream = args.this();
    if !is_readable_stream_object(scope, stream) {
        throw_type_error(scope, "ReadableStream.tee called on incompatible receiver");
        return;
    }
    match tee_readable_stream(scope, stream) {
        Ok(result) => rv.set(result.into()),
        Err(TeeStartError::Locked) => throw_type_error(scope, "Cannot tee a locked stream"),
        Err(TeeStartError::Unavailable) => rv.set_undefined(),
    }
}

fn set_rejected_pipe_to_type_error(
    scope: &mut v8::PinScope<'_, '_>,
    rv: &mut v8::ReturnValue<'_, v8::Value>,
    message: &str,
) {
    let message = v8::String::new(scope, message).expect("pipeTo TypeError message");
    let error = v8::Exception::type_error(scope, message);
    set_rejected_pipe_to_error(scope, rv, error);
}

fn set_rejected_pipe_to_error<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    rv: &mut v8::ReturnValue<'_, v8::Value>,
    error: v8::Local<'s, v8::Value>,
) {
    if let Some(promise) = rejected_promise_value(scope, error) {
        rv.set(promise);
    } else {
        rv.set_undefined();
    }
}

pub(in crate::context_bootstrap) fn readable_stream_async_iterator_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let stream = args.this();
    if !is_readable_stream_object(scope, stream) {
        throw_type_error(
            scope,
            "ReadableStream.values called on incompatible receiver",
        );
        return;
    }
    let Some(parsed) = webidl::parse_args::<ReadableStreamValuesArgs>(scope, &args) else {
        return;
    };
    let transition = match readable_stream_access_snapshot(scope, stream).plan_get_reader(
        ReaderKind::Default,
        ReadableKind::from_byte_stream(readable_stream_is_byte_stream(scope, stream)),
    ) {
        AcquireReaderPlan::RejectLocked => {
            throw_type_error(scope, "ReadableStream is locked");
            return;
        }
        AcquireReaderPlan::Acquire(transition) => transition,
        AcquireReaderPlan::RejectIncompatibleByob => unreachable!("default readers are compatible"),
    };
    let Some(reader) = new_readable_stream_reader_object(scope, stream) else {
        rv.set_undefined();
        return;
    };
    apply_readable_stream_access_transition(scope, stream, transition);
    let Some(iterator) = new_readable_stream_async_iterator_object(
        scope,
        stream,
        reader,
        parsed.options.prevent_cancel,
    ) else {
        release_readable_stream_reader(scope, reader);
        rv.set_undefined();
        return;
    };
    rv.set(iterator.into());
}

fn new_readable_stream_async_iterator_object<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    stream: v8::Local<'s, v8::Object>,
    reader: v8::Local<'s, v8::Object>,
    prevent_cancel: bool,
) -> Option<v8::Local<'s, v8::Object>> {
    let relevant_context = stream.get_creation_context(scope)?;
    if relevant_context == scope.get_current_context() {
        let prototype = readable_stream_async_iterator_prototype(scope)?;
        return ReadableStreamAsyncIteratorObjectDeclaration::new(
            reader,
            prevent_cancel,
            prototype,
        )
        .bind(scope)
        .ok();
    }
    let reader = v8::Global::new(scope, reader);
    let iterator = {
        let target_scope = &mut v8::ContextScope::new(scope, relevant_context);
        let reader = v8::Local::new(target_scope, &reader);
        let prototype = readable_stream_async_iterator_prototype(target_scope)?;
        let iterator =
            ReadableStreamAsyncIteratorObjectDeclaration::new(reader, prevent_cancel, prototype)
                .bind(target_scope)
                .ok()?;
        v8::Global::new(target_scope, iterator)
    };
    Some(v8::Local::new(scope, &iterator))
}

pub(in crate::context_bootstrap) fn readable_stream_locked_getter<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    if !is_readable_stream_object(scope, args.this()) {
        throw_type_error(
            scope,
            "ReadableStream.locked called on incompatible receiver",
        );
        return;
    }
    let locked = readable_stream_locked(scope, args.this());
    rv.set(v8::Boolean::new(scope, locked).into());
}