use reqwest::header::HeaderMap;
pub const DEFAULT_THRESHOLD: u32 = 10;
pub const PROBE_PREFIX_LEN: usize = 64 * 1024;
const STRONG_SIGNAL_SCORE: u32 = 10;
const WEAK_SCRIPT_SRC_SCORE: u32 = 1;
const WEAK_MODULEPRELOAD_SCORE: u32 = 2;
const WEAK_TEXT_SPARSE_SCORE: u32 = 3;
const VISIBLE_TEXT_SPARSE_THRESHOLD: usize = 200;
const SCRIPT_MANY_THRESHOLD: u32 = 3;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProbeVerdict {
pub score: u32,
pub upgrade: bool,
pub reason: String,
}
#[derive(Debug, Clone)]
pub struct JsUpgradeProbe {
pub threshold: u32,
}
impl Default for JsUpgradeProbe {
fn default() -> Self {
Self {
threshold: DEFAULT_THRESHOLD,
}
}
}
impl JsUpgradeProbe {
pub fn new(threshold: u32) -> Self {
Self { threshold }
}
pub fn evaluate(&self, headers: &HeaderMap, body_prefix: &str) -> ProbeVerdict {
if let Some(verdict) = non_html_short_circuit(headers) {
return verdict;
}
let mut score: u32 = 0;
let mut reasons: Vec<&'static str> = Vec::new();
score += strong_signal_score(body_prefix, &mut reasons);
score += weak_signal_score(body_prefix, &mut reasons);
let upgrade = score >= self.threshold;
let reason = if reasons.is_empty() {
"no-js-signals".to_string()
} else {
reasons.join(",")
};
ProbeVerdict {
score,
upgrade,
reason,
}
}
}
fn non_html_short_circuit(headers: &HeaderMap) -> Option<ProbeVerdict> {
let ct = headers.get(reqwest::header::CONTENT_TYPE)?;
let ct_str = ct.to_str().ok()?;
let ct_lower = ct_str.to_ascii_lowercase();
if !ct_lower.contains("html") {
return Some(ProbeVerdict {
score: 0,
upgrade: false,
reason: format!("content-type non-html: {}", ct_str),
});
}
None
}
fn strong_signal_score(body_prefix: &str, reasons: &mut Vec<&'static str>) -> u32 {
let mut score: u32 = 0;
for sig in STRONG_FRAMEWORK_SIGNALS {
if body_prefix.contains(*sig) {
score += STRONG_SIGNAL_SCORE;
reasons.push(*sig);
}
}
if body_prefix.contains(REACT_ROOT_SHELL)
&& body_prefix.to_ascii_lowercase().contains("hydrate")
{
score += STRONG_SIGNAL_SCORE;
reasons.push("react-root-shell-hydrate");
}
if body_prefix.contains("<noscript>") && needs_js_hint(body_prefix) {
score += STRONG_SIGNAL_SCORE;
reasons.push("noscript-js-hint");
}
score
}
fn weak_signal_score(body_prefix: &str, reasons: &mut Vec<&'static str>) -> u32 {
let mut score: u32 = 0;
let script_src_count = count_non_tracking_script_srcs(body_prefix);
if script_src_count > 0 {
score += script_src_count * WEAK_SCRIPT_SRC_SCORE;
reasons.push("non-tracking-script-src");
}
let modulepreload_count = count_modulepreloads(body_prefix);
if modulepreload_count > 0 {
score += modulepreload_count * WEAK_MODULEPRELOAD_SCORE;
reasons.push("modulepreload");
}
if is_text_sparse(body_prefix) && count_all_scripts(body_prefix) >= SCRIPT_MANY_THRESHOLD {
score += WEAK_TEXT_SPARSE_SCORE;
reasons.push("text-sparse-script-heavy");
}
score
}
const STRONG_FRAMEWORK_SIGNALS: &[&str] = &[
"__NUXT_DATA__",
"__NEXT_DATA__",
"window.__INITIAL_STATE__",
"data-reactroot",
];
const REACT_ROOT_SHELL: &str = r#"<div id="root"></div>"#;
fn needs_js_hint(body: &str) -> bool {
let Some(start) = body.find("<noscript>") else {
return false;
};
let Some(rel_end) = body[start..].find("</noscript>") else {
return false;
};
let content = &body[start..start + rel_end];
let lower = content.to_ascii_lowercase();
lower.contains("enable javascript")
|| lower.contains("please enable javascript")
|| lower.contains("requires javascript")
|| lower.contains("javascript is required")
|| lower.contains("javascript is disabled")
|| lower.contains("enable js")
}
fn count_non_tracking_script_srcs(body: &str) -> u32 {
let mut count = 0u32;
let mut search_pos = 0;
while let Some(rel_start) = body[search_pos..].find("<script") {
let abs_start = search_pos + rel_start;
let Some(tag_end) = body[abs_start..].find('>') else {
break;
};
let tag = &body[abs_start..abs_start + tag_end];
if let Some(src) = extract_script_src(tag) {
if !is_tracking_script(&src.to_ascii_lowercase()) {
count += 1;
}
}
search_pos = abs_start + tag_end + 1;
}
count
}
fn skip_ws_and_eq(bytes: &[u8], mut i: usize) -> usize {
while i < bytes.len()
&& (bytes[i] == b' '
|| bytes[i] == b'='
|| bytes[i] == b'\t'
|| bytes[i] == b'\n'
|| bytes[i] == b'\r')
{
i += 1;
}
i
}
fn extract_script_src(tag: &str) -> Option<&str> {
let mut rest = tag;
while let Some(idx) = rest.find("src") {
let after = &rest[idx + 3..];
let bytes = after.as_bytes();
let i = skip_ws_and_eq(bytes, 0);
if i >= bytes.len() {
return None;
}
let quote = bytes[i];
if quote != b'"' && quote != b'\'' {
rest = &after[i..];
continue;
}
let start = i + 1;
let mut j = start;
while j < bytes.len() && bytes[j] != quote {
j += 1;
}
if j > bytes.len() {
return None;
}
return Some(&after[start..j]);
}
None
}
const TRACKING_SCRIPT_SIGNATURES: &[&str] = &[
"google-analytics",
"googletagmanager",
"/gtm.js",
"/gtm_",
"analytics.js",
"facebook.net/en_us/fbevents.js",
"/pixel.js",
"pixel-",
"hotjar",
"segment.com/analytics.js",
"mixpanel",
"amplitude",
"scorecardresearch",
"quantserve",
"chartbeat",
"bat.bing.com",
"clarity.ms",
"tiktok.com/i18n/pixel",
"snap.licdn.com",
"adsbygoogle",
"doubleclick",
"facebook.com/tr",
];
fn is_tracking_script(url: &str) -> bool {
TRACKING_SCRIPT_SIGNATURES
.iter()
.any(|sig| url.contains(sig))
}
fn count_modulepreloads(body: &str) -> u32 {
let mut count = 0u32;
let mut search_pos = 0;
while let Some(rel_start) = body[search_pos..].find("<link") {
let abs_start = search_pos + rel_start;
let Some(tag_end) = body[abs_start..].find('>') else {
break;
};
let tag = &body[abs_start..abs_start + tag_end];
let tag_lower = tag.to_ascii_lowercase();
if tag_lower.contains("rel") && tag_lower.contains("modulepreload") {
count += 1;
}
search_pos = abs_start + tag_end + 1;
}
count
}
fn count_all_scripts(body: &str) -> u32 {
let mut count = 0u32;
let mut search_pos = 0;
while let Some(rel_start) = body[search_pos..].find("<script") {
count += 1;
let abs_start = search_pos + rel_start;
search_pos = abs_start + "<script".len();
}
count
}
fn is_text_sparse(body: &str) -> bool {
let stripped = remove_tag_block(body, "<script", "</script>");
let stripped = remove_tag_block(&stripped, "<style", "</style>");
let visible = strip_html_tags(&stripped);
let visible_count = visible.chars().filter(|c| !c.is_whitespace()).count();
visible_count <= VISIBLE_TEXT_SPARSE_THRESHOLD
}
fn remove_tag_block(body: &str, start_tag: &str, end_tag: &str) -> String {
let mut out = String::with_capacity(body.len());
let mut search = 0;
while search < body.len() {
if let Some(rel) = body[search..].find(start_tag) {
let abs_start = search + rel;
out.push_str(&body[search..abs_start]);
let after = &body[abs_start..];
if let Some(rel_end) = after.find(end_tag) {
search = abs_start + rel_end + end_tag.len();
} else {
return out;
}
} else {
out.push_str(&body[search..]);
break;
}
}
out
}
fn strip_html_tags(body: &str) -> String {
let mut out = String::with_capacity(body.len());
let mut in_tag = false;
for ch in body.chars() {
match ch {
'<' => in_tag = true,
'>' => in_tag = false,
c if !in_tag => out.push(c),
_ => {}
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use reqwest::header::HeaderValue;
const LONG_VISIBLE_TEXT: &str = "This is a body with substantial visible text content designed to exceed the text-sparse threshold of two hundred non-whitespace characters. We include this paragraph to ensure the probe does not falsely trigger the text-sparse-script-heavy bonus during testing. The quick brown fox jumps over the lazy dog. Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";
fn html_headers() -> HeaderMap {
let mut h = HeaderMap::new();
h.insert(
reqwest::header::CONTENT_TYPE,
HeaderValue::from_static("text/html; charset=utf-8"),
);
h
}
fn json_headers() -> HeaderMap {
let mut h = HeaderMap::new();
h.insert(
reqwest::header::CONTENT_TYPE,
HeaderValue::from_static("application/json; charset=utf-8"),
);
h
}
#[test]
fn next_data_strong_signal_triggers_upgrade() {
let probe = JsUpgradeProbe::default();
let body = r#"<!DOCTYPE html><html><head><script id="__NEXT_DATA__" type="application/json">{"props":{}}</script></head><body><div id="__next"></div></body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert!(v.upgrade, "expected upgrade, got {:?}", v);
assert!(v.score >= 10, "score {} < 10", v.score);
assert!(v.reason.contains("__NEXT_DATA__"));
}
#[test]
fn nuxt_data_strong_signal_triggers_upgrade() {
let probe = JsUpgradeProbe::default();
let body =
r#"<html><body><script>window.__NUXT_DATA__ = {"data":[]};</script></body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert!(v.upgrade);
assert!(v.reason.contains("__NUXT_DATA__"));
}
#[test]
fn initial_state_strong_signal_triggers_upgrade() {
let probe = JsUpgradeProbe::default();
let body = r#"<html><body><script>window.__INITIAL_STATE__ = {};</script></body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert!(v.upgrade);
assert!(v.reason.contains("window.__INITIAL_STATE__"));
}
#[test]
fn data_reactroot_strong_signal_triggers_upgrade() {
let probe = JsUpgradeProbe::default();
let body = r#"<html><body><div data-reactroot="true"></div></body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert!(v.upgrade);
assert!(v.reason.contains("data-reactroot"));
}
#[test]
fn react_root_shell_with_hydrate_triggers_upgrade() {
let probe = JsUpgradeProbe::default();
let body = r#"<html><body><div id="root"></div><script>ReactDOM.hydrate(<App/>, ...);</script></body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert!(v.upgrade);
assert!(v.reason.contains("react-root-shell-hydrate"));
}
#[test]
fn react_root_shell_without_hydrate_does_not_trigger_strong_signal() {
let probe = JsUpgradeProbe::default();
let body = r#"<html><body><div id="root"></div></body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert!(!v.reason.contains("react-root-shell-hydrate"));
}
#[test]
fn noscript_enable_javascript_triggers_upgrade() {
let probe = JsUpgradeProbe::default();
let body = r#"<html><body><noscript>Please enable JavaScript to run this app.</noscript></body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert!(v.upgrade);
assert!(v.reason.contains("noscript-js-hint"));
}
#[test]
fn noscript_unrelated_text_does_not_trigger() {
let probe = JsUpgradeProbe::default();
let body = r#"<html><body><noscript>Your browser is too old.</noscript></body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert!(!v.reason.contains("noscript-js-hint"));
}
#[test]
fn static_page_does_not_trigger_upgrade() {
let probe = JsUpgradeProbe::default();
let body = r#"<!DOCTYPE html><html><head><title>Static</title></head><body><h1>Hello World</h1><p>This is a static page with plenty of visible text content to avoid being marked as text-sparse. Adding more content here to ensure we exceed the threshold for visible characters easily.</p><p>Another paragraph with substantial content.</p></body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert!(!v.upgrade, "static page should not upgrade, got {:?}", v);
assert_eq!(v.score, 0);
assert_eq!(v.reason, "no-js-signals");
}
#[test]
fn non_tracking_script_src_accumulates_weak_signal() {
let probe = JsUpgradeProbe::default();
let mut body = String::from("<html><body>");
for _ in 0..8 {
body.push_str(r#"<script src="/assets/app.js"></script>"#);
}
body.push_str(LONG_VISIBLE_TEXT);
body.push_str("</body></html>");
let v = probe.evaluate(&html_headers(), &body);
assert!(!v.upgrade, "8 srcs (score 8) < threshold 10, got {:?}", v);
assert_eq!(v.score, 8);
assert!(v.reason.contains("non-tracking-script-src"));
}
#[test]
fn modulepreload_accumulates_weak_signal() {
let probe = JsUpgradeProbe::default();
let mut body = String::from("<html><head>");
for _ in 0..5 {
body.push_str(r#"<link rel="modulepreload" href="/assets/chunk.js">"#);
}
body.push_str("</head><body>");
body.push_str(LONG_VISIBLE_TEXT);
body.push_str("</body></html>");
let v = probe.evaluate(&html_headers(), &body);
assert!(
v.upgrade,
"5 modulepreloads should reach threshold, got {:?}",
v
);
assert_eq!(v.score, 10);
assert!(v.reason.contains("modulepreload"));
}
#[test]
fn tracking_scripts_are_excluded_from_score() {
let probe = JsUpgradeProbe::default();
let body = format!(
r#"<html><head>
<script src="https://www.google-analytics.com/analytics.js"></script>
<script src="https://www.googletagmanager.com/gtm.js"></script>
<script src="https://connect.facebook.net/en_US/fbevents.js"></script>
<script src="https://snap.licdn.com/li.lms-analytics/insight.min.js"></script>
<script src="https://bat.bing.com/bat.js"></script>
<script src="https://www.facebook.com/tr?id=123"></script>
</head><body>{}</body></html>"#,
LONG_VISIBLE_TEXT
);
let v = probe.evaluate(&html_headers(), &body);
assert_eq!(v.score, 0, "tracking scripts should not score, got {:?}", v);
assert!(!v.upgrade);
}
#[test]
fn text_sparse_and_script_heavy_adds_bonus() {
let probe = JsUpgradeProbe::default();
let mut body = String::from("<html><head>");
for _ in 0..6 {
body.push_str(r#"<script src="/assets/x.js"></script>"#);
}
body.push_str("</head><body>Hi</body></html>");
let v = probe.evaluate(&html_headers(), &body);
assert_eq!(v.score, 9);
assert!(!v.upgrade);
assert!(v.reason.contains("text-sparse-script-heavy"));
assert!(v.reason.contains("non-tracking-script-src"));
}
#[test]
fn mixed_weak_signals_reach_threshold() {
let probe = JsUpgradeProbe::default();
let mut body = String::from("<html><head>");
for _ in 0..7 {
body.push_str(r#"<script src="/assets/a.js"></script>"#);
}
for _ in 0..2 {
body.push_str(r#"<link rel="modulepreload" href="/assets/b.js">"#);
}
body.push_str("</head><body>");
body.push_str(LONG_VISIBLE_TEXT);
body.push_str("</body></html>");
let v = probe.evaluate(&html_headers(), &body);
assert!(
v.upgrade,
"mixed signals should reach threshold, got {:?}",
v
);
assert_eq!(v.score, 11);
}
#[test]
fn custom_threshold_affects_decision() {
let probe = JsUpgradeProbe::new(15);
let body = r#"<html><body><script>window.__INITIAL_STATE__ = {};</script></body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert_eq!(v.score, 10);
assert!(!v.upgrade, "score 10 < threshold 15 should not upgrade");
}
#[test]
fn non_html_content_type_short_circuits() {
let probe = JsUpgradeProbe::default();
let body = r#"{"__NEXT_DATA__": "fake"}"#;
let v = probe.evaluate(&json_headers(), body);
assert!(!v.upgrade);
assert_eq!(v.score, 0);
assert!(v.reason.starts_with("content-type non-html"));
}
#[test]
fn missing_content_type_does_not_short_circuit() {
let probe = JsUpgradeProbe::default();
let h = HeaderMap::new();
let body = r#"<html><body><script>window.__INITIAL_STATE__ = {};</script></body></html>"#;
let v = probe.evaluate(&h, body);
assert!(
v.upgrade,
"missing CT should proceed to body eval, got {:?}",
v
);
}
#[test]
fn default_threshold_is_10() {
assert_eq!(DEFAULT_THRESHOLD, 10);
assert_eq!(JsUpgradeProbe::default().threshold, 10);
}
#[test]
fn empty_body_does_not_trigger_upgrade() {
let probe = JsUpgradeProbe::default();
let v = probe.evaluate(&html_headers(), "");
assert!(!v.upgrade);
assert_eq!(v.score, 0);
assert_eq!(v.reason, "no-js-signals");
}
#[test]
fn single_strong_signal_with_multiple_signals_does_not_double_count() {
let probe = JsUpgradeProbe::default();
let body = r#"<html><body>
<script>window.__INITIAL_STATE__ = {};</script>
<script>window.__INITIAL_STATE__ = {"x":1};</script>
</body></html>"#;
let v = probe.evaluate(&html_headers(), body);
assert_eq!(v.score, 10, "same strong signal should not double-count");
assert!(v.upgrade);
}
}