cfsolve 0.1.1 → 0.1.2

data/vendor/cfsolve/src/session/probes.rs

@@ -11,7 +11,7 @@ use url::Url;
 use wreq::ws::message::Message;
 
 use super::channel::Submission;
-use super::timing::{self, Schedule, Timer};
+use super::timing::{self, Schedule, Timeline, Timer};
 use super::widget::{Embedding, WidgetSession};
 use crate::browser::{Profile, Solve};
 use crate::challenge::payload;
@@ -59,8 +59,14 @@ pub(crate) async fn prepare(session: &WidgetSession<'_>, solve: &Solve) -> Resul
     let engine = session.client.engine();
     let plan = session.analysis.plan();
     let mut options = session.request.options.clone();
-    let (mut observed, fetches) = observe(session, plan, &options, profile).await?;
+    let mut observed = observe(session, plan, profile).await?;
     observed.page_signals = Some(merged.page_signals.clone());
+    let replay = answers.map(|answers| Replay::new(answers, plan));
+    let planned = durations(plan, &profile.durations, &observed, replay.as_ref());
+    // The stack is needed only for the records, so rebuild it while the probes run.
+    let probes = run_probes(session, plan, &options, profile, &mut observed, &planned);
+    let ((schedule, fetches), stack) = tokio::try_join!(probes, probe_stack(session, plan))?;
+    observed.stack = stack;
     // Resource timings now include the first POST and probe requests.
     if let Some(timing) = &merged.state.timing {
         let mut resources = merged.resources.clone();
@@ -82,17 +88,6 @@ pub(crate) async fn prepare(session: &WidgetSession<'_>, solve: &Solve) -> Resul
     }
     window.extend(profile.window.clone());
 
-    let replay = answers
-        .map(|answers| Replay::new(answers, plan, &session.fetched.source, &session.installed))
-        .transpose()?;
-    let pending_ms = i64::from(profile.pending_ms);
-    let schedule = timing::schedule(
-        &durations(plan, &profile.durations, &observed, replay.as_ref()),
-        profile.startup_ms.into(),
-        pending_ms,
-        session.arrived_ms,
-        performance_clock::epoch_ms(),
-    );
     if let Some((probe, Operation::PerformanceEntries { fields })) =
         plan.operation(Kind::PerformanceEntries)
     {
@@ -107,15 +102,19 @@ pub(crate) async fn prepare(session: &WidgetSession<'_>, solve: &Solve) -> Resul
             engine,
         ));
     }
+    let mut globals = merged.audit_globals.0.clone();
+    globals.extend(replay::Globals::recover(&session.fetched.source).0);
+    let globals = replay::Globals(globals);
     let stored = replay::Session {
-        iframe_url: session.fetched.iframe.url.as_str(),
         iframe_html: &session.fetched.iframe.html,
+        iframe_url: session.fetched.iframe.url.as_str(),
         modified: Local::now().format("%m/%d/%Y %H:%M:%S").to_string(),
         referrer: session.fetched.referrer.as_deref().unwrap_or_default(),
         navigation: &session.fetched.iframe.navigation,
         options: &options,
         trace: Trace::recover(&session.fetched.source),
         controller: plan.controller_trace.as_deref(),
+        globals: &globals,
     };
     let records = records(
         plan,
@@ -133,14 +132,14 @@ pub(crate) async fn prepare(session: &WidgetSession<'_>, solve: &Solve) -> Resul
         },
         records,
         &profile.document,
-        pending_ms,
+        profile.pending_ms.into(),
     )?;
     ensure!(
         plaintext.len() > plan.probes().len(),
         "the assembled payload holds nothing besides records"
     );
     payload::append_send_time_at(&mut plaintext, &merged.state, &options, schedule.send_at);
-    let geometry = window_geometry(replay.as_ref(), &plaintext);
+    let geometry = window_geometry(plan, replay.as_ref(), &plaintext);
     Ok(ProbeSubmission {
         payload: Submission {
             plaintext,
@@ -152,33 +151,28 @@ pub(crate) async fn prepare(session: &WidgetSession<'_>, solve: &Solve) -> Resul
     })
 }
 
-/// Collects native measurements, and the requests the iframe's resource timing lists. Runs
-/// requests and stack recovery concurrently.
+/// Collects the measurements that make no requests, except the stack. Probes with requests make
+/// them as they run; see [`run_probes`].
 async fn observe(
     session: &WidgetSession<'_>,
     plan: &ProbePlan,
-    options: &Options,
     profile: &Profile,
-) -> Result<(Observed, Vec<LoadTiming>)> {
+) -> Result<Observed> {
     let mut observed = Observed::default();
-    let requests = requests(session, plan, options, profile, &mut observed);
-    let stack = probe_stack(session, plan);
-    let (fetches, stack) = tokio::try_join!(requests, stack)?;
-    observed.stack = stack;
     let facts = &profile.facts;
     let resolution = session.clock_resolution();
-    if let Some((probe, Operation::Benchmark { fields })) = plan.operation(Kind::Benchmark) {
-        let measured = fields
-            .measure(&facts.benchmark_worker, resolution)
-            .with_context(|| format!("running probe {}'s benchmark", probe.index))?;
-        observed.benchmark = Some(measured);
-    }
     if let (Some((probe, _)), Some(previous)) = (plan.operation(Kind::Media), &facts.media) {
         let media = ice::refresh(previous.clone())
             .with_context(|| format!("refreshing probe {}'s media", probe.index))?;
         session.sink.json("media-measurement.json", &media)?;
         observed.media = Some(media);
     }
+    if let Some((probe, Operation::Benchmark { fields })) = plan.operation(Kind::Benchmark) {
+        let measured = fields
+            .measure(&facts.benchmark_worker, resolution)
+            .with_context(|| format!("running probe {}'s benchmark", probe.index))?;
+        observed.benchmark = Some(measured);
+    }
     // The worker compares 5000 consecutive clock-reading pairs. Chrome's call overhead usually
     // crosses a 100 µs boundary; faster native reads may miss all boundaries. Retry until a
     // pair crosses one.
@@ -190,7 +184,7 @@ async fn observe(
             .unwrap_or_else(|| worker.back_to_back(clock::PAIRS));
         observed.clock = Some(readings);
     }
-    Ok((observed, fetches))
+    Ok(observed)
 }
 
 /// Runs the WebSocket echo exchange. After opening, sends `String(performance.now())` and sends a
@@ -278,7 +272,8 @@ async fn probe_stack(session: &WidgetSession<'_>, plan: &ProbePlan) -> Result<Op
     let origin = fetched.script_position()?;
     let engine = session.client.engine();
     let stack = task::spawn_blocking(move || {
-        let geometry = call_stack::recover_probe(&javascript, &cases, calls)?;
+        let resumed = call_stack::Resumption::WorkerMessage;
+        let geometry = call_stack::recover_probe(&javascript, &cases, calls, resumed)?;
         anyhow::Ok(geometry.format(&origin, engine))
     })
     .await
@@ -310,109 +305,145 @@ fn durations(
     plan.probes().iter().map(duration).collect()
 }
 
-/// Makes probe requests as the iframe would and returns the loads included in resource timing.
-async fn requests(
+/// Runs the probes in order from the end of startup, or now if later. A probe that makes
+/// requests waits for its start and lasts at least until they end. Returns the probes' marks
+/// and the loads resource timing lists.
+async fn run_probes(
     session: &WidgetSession<'_>,
     plan: &ProbePlan,
     options: &Options,
     profile: &Profile,
     observed: &mut Observed,
-) -> Result<Vec<LoadTiming>> {
-    let (client, iframe) = (session.client, &session.fetched.iframe);
+    planned: &[i64],
+) -> Result<(Schedule, Vec<LoadTiming>)> {
+    let startup_end = session.arrived_ms + i64::from(profile.startup_ms);
+    let mut timeline = Timeline::starting(performance_clock::epoch_ms().max(startup_end));
     let mut fetches = Vec::new();
-    for probe in plan.probes() {
-        match &probe.operation {
-            Some(Operation::PrivateToken { fields }) => {
-                let url = fields.url(options, &probe.input, &iframe.url)?;
-                let started_ms = performance_clock::epoch_ms();
-                // The worker calls `r.text()` before posting results. Treat body-read failures
-                // like fetch failures because both reject the promise chain.
-                let fetched = http::fetch_from_worker(client, iframe, &url, FetchOptions::NoCache);
-                let outcome = async {
-                    let response = fetched.await?;
-                    let status = response.status();
-                    anyhow::Ok(private_token::WorkerOutcome::Response {
-                        ok: status.is_success(),
-                        status: status.as_u16(),
-                        text: response.text().await?,
-                    })
-                }
-                .await
-                .unwrap_or_else(|error| private_token::WorkerOutcome::Rejected {
-                    worker_error: error.to_string(),
-                });
-                observed.private_token = Some(private_token::Measurement {
-                    outcome,
-                    started_ms,
-                    finished_ms: performance_clock::epoch_ms(),
-                });
-            }
-            Some(Operation::WorkerFetch { .. }) if profile.facts.worker_fetch_rejected => {
-                observed.worker_fetch = Some(worker_fetch::Measurement::Rejected);
-            }
-            Some(Operation::HostReachability { fields }) => {
-                // CORS rejects a response that does not allow the iframe's origin.
-                let origin = iframe.url.origin().ascii_serialization();
-                let mut outcomes = Vec::new();
-                for url in &fields.urls {
-                    let url = Url::parse(url).context("parsing a host reachability URL")?;
-                    let timer = Timer::start();
-                    let options = FetchOptions::NoStoreWithoutCredentials;
-                    let fetched = http::fetch_from_worker(client, iframe, &url, options);
-                    outcomes.push(match time::timeout(REACHABILITY_TIMEOUT, fetched).await {
-                        Ok(Ok(response))
-                            if response
-                                .headers()
-                                .get("access-control-allow-origin")
-                                .and_then(|allowed| allowed.to_str().ok())
-                                .is_some_and(|allowed| allowed == "*" || allowed == origin) =>
-                        {
-                            host_reachability::Outcome::Answered {
-                                elapsed_ms: timer.elapsed_ms() as i64,
-                            }
-                        }
-                        _ => host_reachability::Outcome::Rejected,
-                    });
-                }
-                observed.host_reachability = Some(outcomes);
-            }
-            Some(Operation::WebSocketEcho { fields }) => {
-                observed.websocket_echo = Some(echo_websocket(session, fields, options).await?);
+    for (probe, &planned_ms) in plan.probes().iter().zip(planned) {
+        let requests = matches!(
+            probe.operation,
+            Some(
+                Operation::PrivateToken { .. }
+                    | Operation::WorkerFetch { .. }
+                    | Operation::HostReachability { .. }
+                    | Operation::WebSocketEcho { .. }
+                    | Operation::Image { .. }
+            )
+        );
+        let finished = if requests {
+            timing::sleep_until(timeline.next_start).await;
+            request(session, probe, options, profile, observed, &mut fetches).await?;
+            Some(performance_clock::epoch_ms())
+        } else {
+            None
+        };
+        timeline.finish(planned_ms, finished);
+    }
+    Ok((timeline.schedule(profile.pending_ms.into()), fetches))
+}
+
+/// Makes `probe`'s requests as the iframe would. Records its measurement in `observed` and the
+/// loads resource timing lists in `fetches`.
+async fn request(
+    session: &WidgetSession<'_>,
+    probe: &Probe,
+    options: &Options,
+    profile: &Profile,
+    observed: &mut Observed,
+    fetches: &mut Vec<LoadTiming>,
+) -> Result<()> {
+    let (client, iframe) = (session.client, &session.fetched.iframe);
+    match &probe.operation {
+        Some(Operation::PrivateToken { fields }) => {
+            let url = fields.url(options, &probe.input, &iframe.url)?;
+            let started_ms = performance_clock::epoch_ms();
+            // The worker calls `r.text()` before posting results. Treat body-read failures
+            // like fetch failures because both reject the promise chain.
+            let fetched = http::fetch_from_worker(client, iframe, &url, FetchOptions::NoCache);
+            let outcome = async {
+                let response = fetched.await?;
+                let status = response.status();
+                anyhow::Ok(private_token::WorkerOutcome::Response {
+                    ok: status.is_success(),
+                    status: status.as_u16(),
+                    text: response.text().await?,
+                })
             }
-            Some(Operation::WorkerFetch { fields }) => {
-                let url = fields.url(options)?;
+            .await
+            .unwrap_or_else(|error| private_token::WorkerOutcome::Rejected {
+                worker_error: error.to_string(),
+            });
+            observed.private_token = Some(private_token::Measurement {
+                outcome,
+                started_ms,
+                finished_ms: performance_clock::epoch_ms(),
+            });
+        }
+        Some(Operation::WorkerFetch { .. }) if profile.facts.worker_fetch_rejected => {
+            observed.worker_fetch = Some(worker_fetch::Measurement::Rejected);
+        }
+        Some(Operation::HostReachability { fields }) => {
+            // CORS rejects a response that does not allow the iframe's origin.
+            let origin = iframe.url.origin().ascii_serialization();
+            let mut outcomes = Vec::new();
+            for url in &fields.urls {
+                let url = Url::parse(url).context("parsing a host reachability URL")?;
+                let timer = Timer::start();
                 let options = FetchOptions::NoStoreWithoutCredentials;
-                let fetched = http::fetch_from_worker(client, iframe, &url, options).await;
-                observed.worker_fetch = Some(match fetched {
-                    Ok(response) => worker_fetch::Measurement::Response {
-                        status: response.status().as_u16(),
-                        headers: http::text_headers(response.headers())
-                            .map(|(name, value)| (name.to_owned(), value))
-                            .collect(),
-                    },
-                    Err(_) => worker_fetch::Measurement::Rejected,
+                let fetched = http::fetch_from_worker(client, iframe, &url, options);
+                outcomes.push(match time::timeout(REACHABILITY_TIMEOUT, fetched).await {
+                    Ok(Ok(response))
+                        if response
+                            .headers()
+                            .get("access-control-allow-origin")
+                            .and_then(|allowed| allowed.to_str().ok())
+                            .is_some_and(|allowed| allowed == "*" || allowed == origin) =>
+                    {
+                        host_reachability::Outcome::Answered {
+                            elapsed_ms: timer.elapsed_ms() as i64,
+                        }
+                    }
+                    _ => host_reachability::Outcome::Rejected,
                 });
             }
-            Some(Operation::Image { fields }) => {
-                let url = fields.url(options, &probe.input, &iframe.url)?;
-                let timer = Timer::start();
-                let response = http::fetch_image(client, iframe, &url).await?;
-                let waiting_ms = timer.elapsed_ms();
-                let ok = response.status().is_success();
-                let (body, network) = http::read_encoded(response)
-                    .await
-                    .context("reading a challenge image")?;
-                fetches.push(timer.phased(url.as_str(), waiting_ms, network.encoded_bytes));
-                observed.image = Some(image::Measurement::loaded(
-                    ok.then_some(&body[..]),
-                    &profile.image.effective_type,
-                    profile.image.online,
-                ));
-            }
-            _ => {}
+            observed.host_reachability = Some(outcomes);
         }
+        Some(Operation::WebSocketEcho { fields }) => {
+            observed.websocket_echo = Some(echo_websocket(session, fields, options).await?);
+        }
+        Some(Operation::WorkerFetch { fields }) => {
+            let url = fields.url(options)?;
+            let options = FetchOptions::NoStoreWithoutCredentials;
+            let fetched = http::fetch_from_worker(client, iframe, &url, options).await;
+            observed.worker_fetch = Some(match fetched {
+                Ok(response) => worker_fetch::Measurement::Response {
+                    status: response.status().as_u16(),
+                    headers: http::text_headers(response.headers())
+                        .map(|(name, value)| (name.to_owned(), value))
+                        .collect(),
+                },
+                Err(_) => worker_fetch::Measurement::Rejected,
+            });
+        }
+        Some(Operation::Image { fields }) => {
+            let url = fields.url(options, &probe.input, &iframe.url)?;
+            let timer = Timer::start();
+            let response = http::fetch_image(client, iframe, &url).await?;
+            let waiting_ms = timer.elapsed_ms();
+            let ok = response.status().is_success();
+            let (body, network) = http::read_encoded(response)
+                .await
+                .context("reading a challenge image")?;
+            fetches.push(timer.phased(url.as_str(), waiting_ms, network.encoded_bytes));
+            observed.image = Some(image::Measurement::loaded(
+                ok.then_some(&body[..]),
+                &profile.image.effective_type,
+                profile.image.online,
+            ));
+        }
+        _ => {}
     }
-    Ok(fetches)
+    Ok(())
 }
 
 /// Builds probe records with scheduled timestamps. Stored answers use `stored` and preserve the
@@ -464,9 +495,13 @@ fn records(
 }
 
 /// Window dimensions and position already reported by the environment audit.
-fn window_geometry(replay: Option<&Replay<'_>>, payload: &Payload) -> BTreeMap<String, f64> {
+fn window_geometry(
+    plan: &ProbePlan,
+    replay: Option<&Replay<'_>>,
+    payload: &Payload,
+) -> BTreeMap<String, f64> {
     let groups = replay
-        .and_then(|replay| replay.audit_groups(payload))
+        .and_then(|replay| replay.audit_groups(plan, payload))
         .into_iter()
         .flatten();
     let mut geometry = BTreeMap::new();

data/vendor/cfsolve/src/session/timing.rs

@@ -79,32 +79,43 @@ pub(crate) struct Schedule {
     pub send_at: i64,
 }
 
-/// Schedules probes at least `startup_ms` after `arrived_ms`. Reserves one millisecond after
-/// each probe, then `pending_ms` before sending. The send time is no earlier than `now_ms`.
-/// Programs without probes wait only for startup. Uses signed durations to match record
-/// timestamp differences.
-pub(crate) fn schedule(
-    durations: &[i64],
-    startup_ms: i64,
-    pending_ms: i64,
-    arrived_ms: i64,
-    now_ms: i64,
-) -> Schedule {
-    let span: i64 = durations.iter().map(|duration| duration + 1).sum();
-    let busy = if durations.is_empty() {
-        startup_ms
-    } else {
-        startup_ms + span + pending_ms
-    };
-    let send_at = now_ms.max(arrived_ms + busy);
-    let mut start = send_at - pending_ms - span;
-    let mut marks = Vec::with_capacity(durations.len());
-    for &duration in durations {
-        let end = start + duration;
-        marks.push(ProbeMarks { start, end });
-        start = end + 1;
+/// Probe marks laid out as the probes run: in order, one millisecond apart. A probe lasts its
+/// planned duration, or until the work it waits for, such as a request, ends.
+pub(crate) struct Timeline {
+    /// When the next probe starts, in epoch milliseconds.
+    pub next_start: i64,
+    marks: Vec<ProbeMarks>,
+}
+
+impl Timeline {
+    #[must_use]
+    pub(crate) fn starting(next_start: i64) -> Self {
+        Self {
+            next_start,
+            marks: Vec::new(),
+        }
+    }
+
+    /// Ends the next probe `planned_ms` after it starts, or at `finished_ms` if its work ended
+    /// later.
+    pub(crate) fn finish(&mut self, planned_ms: i64, finished_ms: Option<i64>) {
+        let start = self.next_start;
+        let planned_end = start + planned_ms;
+        let end = finished_ms.map_or(planned_end, |finished| finished.max(planned_end));
+        self.marks.push(ProbeMarks { start, end });
+        self.next_start = end + 1;
+    }
+
+    /// Sends `pending_ms` after the last probe's next mark. Programs without probes send when
+    /// they start.
+    #[must_use]
+    pub(crate) fn schedule(self, pending_ms: i64) -> Schedule {
+        let pending_ms = if self.marks.is_empty() { 0 } else { pending_ms };
+        Schedule {
+            marks: self.marks,
+            send_at: self.next_start + pending_ms,
+        }
     }
-    Schedule { marks, send_at }
 }
 
 #[cfg(test)]
@@ -112,13 +123,14 @@ mod tests {
     use super::*;
 
     #[test]
-    fn probes_end_pending_ms_before_a_send_no_sooner_than_a_browser_could() {
-        let schedule = schedule(&[3, 5], 400, 15, 1_000, 1_100);
-        assert_eq!(
-            schedule.send_at, 1_425,
-            "400 ms startup, then 3 + 1 and 5 + 1 ms of probes, then 15 ms pending: a browser \
-             could send 425 ms after the program arrived"
-        );
+    fn probes_run_in_order_and_last_until_their_requests_end() {
+        let mut timeline = Timeline::starting(1_400);
+        timeline.finish(3, None);
+        // The request took longer than planned.
+        timeline.finish(5, Some(1_430));
+        // The request ended before the planned duration ran out.
+        timeline.finish(10, Some(1_433));
+        let schedule = timeline.schedule(15);
         assert_eq!(
             schedule.marks,
             [
@@ -128,35 +140,28 @@ mod tests {
                 },
                 ProbeMarks {
                     start: 1_404,
-                    end: 1_409
+                    end: 1_430
                 },
-            ],
-            "the last probe's next mark is exactly `pending_ms` before sending"
+                ProbeMarks {
+                    start: 1_431,
+                    end: 1_441
+                },
+            ]
         );
-
-        let late = super::schedule(&[3, 5], 400, 15, 1_000, 2_000);
-        assert_eq!(late.send_at, 2_000);
         assert_eq!(
-            late.marks[0].start, 1_975,
-            "a late send moves every mark with it"
+            schedule.send_at, 1_457,
+            "the last probe's next mark is exactly `pending_ms` before sending"
         );
+        assert_eq!(Timeline::starting(900).schedule(15).send_at, 900);
     }
 
     #[test]
-    fn a_program_without_probes_waits_for_its_startup_alone() {
-        let schedule = schedule(&[], 400, 15, 1_000, 1_100);
+    fn signed_durations_are_kept() {
+        let mut timeline = Timeline::starting(0);
+        timeline.finish(-2, None);
         assert_eq!(
-            schedule,
-            Schedule {
-                marks: Vec::new(),
-                send_at: 1_400
-            }
+            timeline.schedule(0).marks,
+            [ProbeMarks { start: 0, end: -2 }]
         );
     }
-
-    #[test]
-    fn signed_durations_are_kept() {
-        let schedule = schedule(&[-2, 4], 0, 0, 0, 0);
-        assert_eq!(schedule.marks[0].end - schedule.marks[0].start, -2);
-    }
 }

data/vendor/cfsolve/src/session/widget.rs

@@ -11,7 +11,6 @@ use super::initial::{self, EmbeddingPage, Fetched, Merged};
 use super::timing::Timer;
 use super::{Sink, interaction, probes};
 use crate::browser::{Page, Solve};
-use crate::challenge::installed::Installed;
 use crate::challenge::orchestrator::ChallengePage;
 use crate::challenge::program::{ExtractedProgram, PreparedSession, SessionEncoder};
 use crate::challenge::source::InitialRequest;
@@ -128,7 +127,7 @@ enum Landing {
     /// A site's page with a Turnstile widget.
     Site(EmbeddingPage),
     /// A challenge page, whose orchestrator has rendered its widget.
-    ChallengePage(OrchestratorSession, EmbeddingPage),
+    ChallengePage(Box<OrchestratorSession>, EmbeddingPage),
 }
 
 impl Landing {
@@ -177,7 +176,10 @@ async fn land(
         document.referrer_policy,
     )
     .await?;
-    Ok(Landing::ChallengePage(orchestrator, embedding_page))
+    Ok(Landing::ChallengePage(
+        Box::new(orchestrator),
+        embedding_page,
+    ))
 }
 
 /// Starts the session of the widget rendered by `embedding_page` by sending its first payload.
@@ -212,7 +214,6 @@ async fn start_widget<'caller>(
         sink,
         fetched,
         request: program.request,
-        installed: program.installed,
         encoder,
         embedding: embedding_page.embedding,
         merged,
@@ -316,8 +317,6 @@ pub(crate) struct WidgetSession<'caller> {
     pub fetched: Fetched,
     /// POST destination and options reported by the first payload.
     pub request: InitialRequest,
-    /// Initial-program facts reused when refreshing captured probe answers.
-    pub installed: Installed,
     pub encoder: SessionEncoder,
     pub embedding: Embedding,
     pub merged: Merged,