Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(streams): disturb the source when piping starts
ldm0c019abeeb176
diff --git a/moli-core/tests/fixtures/runtime/pipe_disturbed.js b/moli-core/tests/fixtures/runtime/pipe_disturbed.jsnew file mode 100644index 000000000..097f7023a--- /dev/null+++ b/moli-core/tests/fixtures/runtime/pipe_disturbed.js@@ -0,0 +1,86 @@+async function runPipeDisturbedProbe(scenario) {+ const errors = [];+ const check = (condition, label) => {+ if (!condition) errors.push(label);+ };+ for (const byteStream of [false, true]) {+ for (const method of ['pipeTo', 'pipeThrough']) {+ const cases = scenario === 'start'+ ? ['backpressure', 'pre-aborted', 'source-closed', 'source-errored', 'sink-closed', 'sink-errored']+ : ['source-locked', 'sink-locked', 'invalid-sink', 'invalid-signal', 'throwing-options'];+ for (const state of cases) {+ const label = `${byteStream ? 'bytes' : 'default'}/${method}/${state}`;+ const reason = new Error(label);+ let sourceController, sinkController, pulls = 0, writes = 0;+ const source = new ReadableStream({+ ...(byteStream ? {type: 'bytes'} : {}),+ start(controller) { sourceController = controller; },+ pull() { ++pulls; }+ }, {highWaterMark: 0});+ const body = new Response(source);+ check(body.body === source, `${label}: body observes the tested source`);+ const sink = new WritableStream({+ start(controller) { sinkController = controller; },+ write() { ++writes; },+ abort() { check(body.bodyUsed, `${label}: abort observes disturbed source`); }+ }, {highWaterMark: 0});+ const output = new ReadableStream({}, {highWaterMark: 0});+ const outputBody = new Response(output);+ const abort = new AbortController();+ let options = {signal: abort.signal, preventCancel: true};+ let destination = sink, reader, writer;+ if (state === 'source-closed') sourceController.close();+ if (state === 'source-errored') sourceController.error(reason);+ if (state === 'sink-closed') await sink.close();+ if (state === 'sink-errored') sinkController.error(reason);+ if (state === 'pre-aborted') abort.abort(reason);+ if (state === 'source-locked') reader = source.getReader();+ if (state === 'sink-locked') writer = sink.getWriter();+ if (state === 'invalid-sink') destination = {};+ if (state === 'invalid-signal') options = {signal: {}};+ if (state === 'throwing-options') options = {get preventCancel() {throw reason;}};+ check(!body.bodyUsed, `${label}: initially undisturbed`);+ let completion, thrown;+ try {+ if (method === 'pipeTo') {+ completion = source.pipeTo(destination, options);+ completion.catch(() => {});+ } else {+ const result = source.pipeThrough({readable: output, writable: destination}, options);+ check(result === output, `${label}: returns output stream`);+ }+ } catch (error) {+ thrown = error;+ }+ if (scenario === 'start') {+ check(thrown === undefined, `${label}: accepted pipe does not throw`);+ check(body.bodyUsed, `${label}: synchronously disturbed without reading`);+ check(pulls === 0 && writes === 0, `${label}: no pull or write before return`);+ check(!outputBody.bodyUsed, `${label}: output remains undisturbed`);+ abort.abort(reason);+ if (completion) await completion.catch(() => {});+ for (let turn = 0; (source.locked || sink.locked) && turn < 30; ++turn) {+ await new Promise(resolve => setTimeout(resolve, 0));+ }+ check(!source.locked && !sink.locked, `${label}: pipe releases locks`);+ check(body.bodyUsed, `${label}: remains disturbed after shutdown`);+ } else {+ if (completion) {+ check(thrown === undefined, `${label}: pipeTo returns a rejection`);+ thrown = await completion.then(() => undefined, error => error);+ }+ check(state === 'throwing-options' ? thrown === reason : thrown instanceof TypeError,+ `${label}: validation rejects with original error`);+ reader?.releaseLock();+ writer?.releaseLock();+ check(!body.bodyUsed, `${label}: rejected pipe leaves source undisturbed`);+ check(!source.locked && !sink.locked, `${label}: rejected pipe acquires no locks`);+ check(pulls === 0 && writes === 0, `${label}: rejected pipe does not read or write`);+ }+ // Avoid invoking the observation above during test cleanup.+ await Promise.allSettled([source.cancel(), output.cancel()]);+ }+ }+ }+ return {errors};+}diff --git a/moli-core/tests/web_apis.rs b/moli-core/tests/web_apis.rsindex bad02af1b..f67629c7d 100644--- a/moli-core/tests/web_apis.rs+++ b/moli-core/tests/web_apis.rs@@ -1,3 +1,6 @@+#[path = "web_apis/pipe_disturbed.rs"]+mod pipe_disturbed;+use moli_test_support as support;use anyhow::Result;diff --git a/moli-core/tests/web_apis/pipe_disturbed.rs b/moli-core/tests/web_apis/pipe_disturbed.rsnew file mode 100644index 000000000..93f4e51fc--- /dev/null+++ b/moli-core/tests/web_apis/pipe_disturbed.rs@@ -0,0 +1,91 @@+use super::*;++async fn assert_pipe_disturbed(scenario: &str) -> Result<()> {+ let server = FixtureServer::spawn().await?;+ let browser = Browser::new(AppConfig::default())?;+ let source = format!(+ "{}\nrunPipeDisturbedProbe({}).then(finish, error => finish({{error: String(error)}}));",+ include_str!("../fixtures/runtime/pipe_disturbed.js"),+ serde_json::to_string(scenario)?,+ );+ for target in ["window", "child", "worker"] {+ let observed = tokio::time::timeout(+ Duration::from_secs(20),+ run_probe(&browser, &server, target, &source),+ )+ .await??;+ assert_eq!(+ observed,+ serde_json::json!({"errors": []}),+ "{scenario}/{target}"+ );+ }+ server.shutdown().await;+ Ok(())+}++#[tokio::test(flavor = "multi_thread")]+async fn piping_disturbs_fetch_bodies_before_reads_and_abort_handling() -> Result<()> {+ assert_pipe_disturbed("start").await+}++#[tokio::test(flavor = "multi_thread")]+async fn rejected_piping_preserves_undisturbed_fetch_bodies() -> Result<()> {+ assert_pipe_disturbed("reject").await+}++fn markup_url(server: &FixtureServer, markup: &str) -> String {+ let mut url = url::Url::parse(&server.url("/compat/child-dynamic-markup-document")).unwrap();+ url.query_pairs_mut().append_pair("markup", markup);+ url.into()+}++async fn run_probe(+ browser: &Browser,+ server: &FixtureServer,+ target: &str,+ source: &str,+) -> Result<serde_json::Value> {+ let markup = if target == "worker" {+ let source = serde_json::to_string(&format!(+ "self.finish = value => postMessage(value);\n{source}"+ ))?;+ format!(+ r#"<!doctype html><script>+ const worker = new Worker(URL.createObjectURL(new Blob([{source}], {{type: 'text/javascript'}})));+ window.done = new Promise(resolve => {{+ worker.onmessage = event => {{ resolve(event.data); worker.terminate(); }};+ }});+ worker.postMessage('go');+ </script>"#+ )+ } else {+ format!(+ "<!doctype html><script>self.done = new Promise(resolve => self.finish = resolve);\n{source}</script>"+ )+ };+ let url = markup_url(server, &markup);+ let url = if target == "child" {+ markup_url(+ server,+ &format!(+ "<!doctype html><iframe id=target src=\"{}\"></iframe>",+ url.replace('&', "&")+ ),+ )+ } else {+ url+ };+ let mut page = browser.fetch(&url).await?;+ let expression = if target == "child" {+ "document.getElementById('target').contentWindow.done.then(JSON.stringify)"+ } else {+ "done.then(JSON.stringify)"+ };+ let value = page+ .evaluate_runtime_expression_with_await_async(expression, true)+ .await?;+ Ok(serde_json::from_str(+ value["value"].as_str().expect("callback probe result"),+ )?)+}diff --git a/moli-renderer-v8/src/context_bootstrap/streams/readable.rs b/moli-renderer-v8/src/context_bootstrap/streams/readable.rsindex b676d6963..866edf2f8 100644--- a/moli-renderer-v8/src/context_bootstrap/streams/readable.rs+++ b/moli-renderer-v8/src/context_bootstrap/streams/readable.rs@@ -1,6 +1,6 @@use super::super::stream_adapter::{- TeeStartError, apply_readable_stream_access_transition, enqueue_byte_chunk,- install_readable_stream_pipe_to_abort_signal, lock_readable_stream,+ 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,@@ -414,6 +414,9 @@ fn start_readable_stream_pipe_to<'s>(}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);}