diff --git a/moli-renderer-v8/src/network_host/event_source/request.rs b/moli-renderer-v8/src/network_host/event_source/request.rs index 715a3d80ff2..0d556b2703c 100644 --- a/moli-renderer-v8/src/network_host/event_source/request.rs +++ b/moli-renderer-v8/src/network_host/event_source/request.rs @@ -2,11 +2,13 @@ use super::*; use crate::native_bridge::{JsContextHost, throw_dom_exception}; use crate::network_host::{ BLOCKED_BY_CLIENT_ERROR_TEXT, active_subresource_network_partition_key, - effective_subresource_policy_context, local_url_response, merge_subresource_request_headers, + effective_subresource_policy_context, effective_subresource_referrer_policy, + local_url_response, merge_subresource_request_headers, observe_subresource_request_cookie_report, resolve_context_url, spawn_async_subresource_fetch, }; use crate::service_worker_runtime::{ - ServiceWorkerFetchDispatch, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination, + ServiceWorkerFetchDispatch, ServiceWorkerRequestDestination, + service_worker_fetch_request_metadata, }; use crate::types::{ PendingSubresourceFetchInfo, SubresourceNetworkRecord, SubresourceResourceType, @@ -44,6 +46,8 @@ struct PreparedEventSourceRequest { owner: crate::native_bridge::OwnerDispatchScope, resource_loader: crate::network::context::DocumentResourceLoader, document_url: url::Url, + referrer_source: Option, + document_referrer_policy: Option, request_origin: moli_url::WebOrigin, resolved_url: url::Url, request_headers: moli_fetch::RequestHeaders, @@ -399,6 +403,8 @@ fn prepare_event_source_request<'s>( owner, resource_loader, document_url, + referrer_source: host.document_client_referrer_source(owner), + document_referrer_policy: effective_subresource_referrer_policy(host, owner), request_origin, resolved_url, request_headers, @@ -425,6 +431,7 @@ fn dispatch_service_worker_event_source<'s>( &prepared.document_url, &prepared.resolved_url, )?; + let native_request = build_event_source_request(prepared).ok()?; let cancel_handle = FetchCancelHandle::new(); let registered = register_event_source_request( @@ -446,11 +453,7 @@ fn dispatch_service_worker_event_source<'s>( prepared.credentials_mode, RequestRedirectMode::Follow, None, - ServiceWorkerFetchRequestMetadata { - mixed_content_policy: Default::default(), - cache: "no-store".to_owned(), - ..ServiceWorkerFetchRequestMetadata::default() - }, + service_worker_fetch_request_metadata(&native_request), ); let dispatch = ServiceWorkerFetchDispatch { request_body_owner: None, @@ -492,26 +495,35 @@ fn dispatch_service_worker_event_source<'s>( } fn build_event_source_request(prepared: &PreparedEventSourceRequest) -> Result { - Request::new( + let request = Request::new( "GET", prepared.resolved_url.as_str(), None, prepared.request_headers.clone(), ) - .map_err(|error| error.to_string()) - .map(|request| { - request - .with_initiator_url(&prepared.document_url) - .with_request_origin(prepared.request_origin.clone()) - .with_request_mode(RequestMode::Cors) - .with_credentials_mode(prepared.credentials_mode) - .with_network_partition_key(prepared.network_partition_key.clone()) - .with_redirect_mode(RequestRedirectMode::Follow) - .with_cache_mode(RequestCacheMode::NoStore) - .with_browser_request_metadata(BrowserRequestMetadata::EventSource) - .with_subframe_context(prepared.frame_id.is_some()) - .without_request_timeout() - }) + .map_err(|error| error.to_string())? + .with_fetch_referrer( + prepared + .referrer_source + .as_ref() + .map_or("", url::Url::as_str), + ) + .map_err(|error| error.to_string())?; + Ok(request + .with_initiator_url(&prepared.document_url) + .with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata { + document_referrer_policy: prepared.document_referrer_policy.clone(), + ..Default::default() + }) + .with_request_origin(prepared.request_origin.clone()) + .with_request_mode(RequestMode::Cors) + .with_credentials_mode(prepared.credentials_mode) + .with_network_partition_key(prepared.network_partition_key.clone()) + .with_redirect_mode(RequestRedirectMode::Follow) + .with_cache_mode(RequestCacheMode::NoStore) + .with_browser_request_metadata(BrowserRequestMetadata::EventSource) + .with_subframe_context(prepared.frame_id.is_some()) + .without_request_timeout()) } struct RegisteredEventSourceRequest { diff --git a/moli-renderer-v8/src/network_host/xhr/send.rs b/moli-renderer-v8/src/network_host/xhr/send.rs index b9a1e98ef40..a2a69fccf7a 100644 --- a/moli-renderer-v8/src/network_host/xhr/send.rs +++ b/moli-renderer-v8/src/network_host/xhr/send.rs @@ -26,7 +26,7 @@ use super::events::{ use super::*; use crate::runtime::RendererPageContextCancelReason; use crossbeam_channel::{after, bounded, never}; -use moli_fetch::{BrowserRequestMetadata, FetchCancelHandle, RequestMode}; +use moli_fetch::{FetchCancelHandle, RequestMode}; use std::{thread, time::Duration}; pub(super) fn xhr_send_callback<'s>( @@ -298,24 +298,7 @@ fn send_synchronous_network_xhr( timing.capture_window_initiator(scope, host); let csp = crate::network_host::WindowCspRequestContext::capture(scope, host, prepared.owner) .expect("synchronous XHR prepared a live Document request authority"); - let mut request = Request::new_bytes( - &prepared.method, - prepared.resolved_url.as_str(), - prepared.send_body.clone(), - prepared.request_headers.clone(), - ) - .expect("xhr request url was already resolved") - .with_page_network_policy() - .with_initiator_url(&prepared.document_url) - .with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata { - document_referrer_policy: prepared.document_referrer_policy.clone(), - ..Default::default() - }) - .with_request_origin(prepared.request_origin.clone()) - .with_credentials_mode(prepared.credentials_mode) - .with_network_partition_key(prepared.network_partition_key.clone()) - .with_browser_request_metadata(BrowserRequestMetadata::Xhr) - .with_use_cors_preflight(prepared.use_cors_preflight); + let mut request = prepared.request().with_page_network_policy(); if let Some(check) = csp.redirect_check( scope, &prepared.document_url, diff --git a/moli-renderer-v8/src/network_host/xhr/send/paths.rs b/moli-renderer-v8/src/network_host/xhr/send/paths.rs index d4ff68cc830..deef218e83e 100644 --- a/moli-renderer-v8/src/network_host/xhr/send/paths.rs +++ b/moli-renderer-v8/src/network_host/xhr/send/paths.rs @@ -2,11 +2,11 @@ use super::super::delivery::{queue_xhr_failure_delivery, queue_xhr_response_deli use super::super::*; use super::request::PreparedXhrSendRequest; use crate::service_worker_runtime::{ - ServiceWorkerFetchDispatch, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination, + ServiceWorkerFetchDispatch, ServiceWorkerRequestDestination, + service_worker_fetch_request_metadata, }; use moli_fetch::{ - BrowserRequestMetadata, FetchCancelHandle, RequestRedirectMode, - should_request_be_blocked_due_to_bad_port, + FetchCancelHandle, RequestRedirectMode, should_request_be_blocked_due_to_bad_port, }; pub(super) fn record_intercepted_xhr( @@ -122,11 +122,7 @@ pub(super) fn dispatch_service_worker_xhr( prepared.credentials_mode, RequestRedirectMode::Follow, None, - ServiceWorkerFetchRequestMetadata { - mixed_content_policy: Default::default(), - use_cors_preflight: prepared.use_cors_preflight, - ..ServiceWorkerFetchRequestMetadata::default() - }, + service_worker_fetch_request_metadata(&prepared.request()), ); let dispatch = ServiceWorkerFetchDispatch { request_body_owner: None, @@ -313,24 +309,9 @@ pub(super) fn spawn_network_xhr_fetch( prepared: PreparedXhrSendRequest, request_client: ResourceRequestClient, ) -> u64 { - let mut request = Request::new_bytes( - &prepared.method, - prepared.resolved_url.as_str(), - prepared.send_body.clone(), - prepared.request_headers.clone(), - ) - .expect("xhr request url was already resolved") - .with_initiator_url(&prepared.document_url) - .with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata { - document_referrer_policy: prepared.document_referrer_policy.clone(), - ..Default::default() - }) - .with_request_origin(prepared.request_origin.clone()) - .with_credentials_mode(prepared.credentials_mode) - .with_network_partition_key(prepared.network_partition_key.clone()) - .with_browser_request_metadata(BrowserRequestMetadata::Xhr) - .with_use_cors_preflight(prepared.use_cors_preflight) - .with_subframe_context(prepared.frame_id.is_some()); + let mut request = prepared + .request() + .with_subframe_context(prepared.frame_id.is_some()); let request_cookie_report = observe_subresource_request_cookie_report( prepared.resource_loader.request_client(), diff --git a/moli-renderer-v8/src/network_host/xhr/send/request.rs b/moli-renderer-v8/src/network_host/xhr/send/request.rs index 7329ddefabd..fc4b0cb9870 100644 --- a/moli-renderer-v8/src/network_host/xhr/send/request.rs +++ b/moli-renderer-v8/src/network_host/xhr/send/request.rs @@ -19,6 +19,7 @@ pub(super) struct PreparedXhrSendRequest { pub(super) resource_loader: crate::network::context::DocumentResourceLoader, pub(super) document_url: url::Url, pub(super) document_referrer_policy: Option, + referrer_source: Option, pub(super) request_origin: moli_url::WebOrigin, pub(super) network_partition_key: Option, pub(super) policy_context: crate::types::SubresourcePolicyContext, @@ -32,6 +33,32 @@ pub(super) struct PreparedXhrSendRequest { pub(super) use_cors_preflight: bool, } +impl PreparedXhrSendRequest { + pub(super) fn request(&self) -> moli_fetch::Request { + // Network dispatch and Service Worker metadata share the captured + // client's referrer without rebinding its cookie or request origin. + moli_fetch::Request::new_bytes( + &self.method, + self.resolved_url.as_str(), + self.send_body.clone(), + self.request_headers.clone(), + ) + .expect("xhr request url was already resolved") + .with_fetch_referrer(self.referrer_source.as_ref().map_or("", url::Url::as_str)) + .expect("XHR referrer source is a captured Document URL") + .with_initiator_url(&self.document_url) + .with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata { + document_referrer_policy: self.document_referrer_policy.clone(), + ..Default::default() + }) + .with_request_origin(self.request_origin.clone()) + .with_credentials_mode(self.credentials_mode) + .with_network_partition_key(self.network_partition_key.clone()) + .with_browser_request_metadata(moli_fetch::BrowserRequestMetadata::Xhr) + .with_use_cors_preflight(self.use_cors_preflight) + } +} + pub(super) enum XhrSendPrepareError { ExecutionContext, Url(ResolveContextUrlError), @@ -105,6 +132,7 @@ pub(super) fn prepare_xhr_send_request<'s>( request_origin, network_partition_key, document_referrer_policy, + referrer_source: host.document_client_referrer_source(owner), policy_context, resolved_url, blob_url_entry: blob_url_entry(scope, xhr) diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs b/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs index e52368b4809..d4ea1a04782 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs @@ -2534,6 +2534,7 @@ mod audio_worklet_and_message_ports; mod blob_storage_key; mod message_port_transfer_semantics; mod service_and_shared_worker_lifecycle; +mod window_request_referrer; mod window_service_worker_response_policy; mod worker_messages_and_service_workers; mod worker_security_and_audio_worklets; diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/worker/window_request_referrer.rs b/moli-renderer-v8/src/runtime/page_vm/tests/worker/window_request_referrer.rs new file mode 100644 index 00000000000..ea146572dfa --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/tests/worker/window_request_referrer.rs @@ -0,0 +1,150 @@ +use super::*; + +const CLIENT: &str = + include_str!("../../../../../tests/fixtures/window-request-referrer-client.js"); +const SERVICE_WORKER: &str = + include_str!("../../../../../tests/fixtures/window-request-referrer-sw.js"); + +async fn check_window_request_referrer(policy: &'static str) { + for controlled in [false, true] { + run_page_vm_async_test(async move { + let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + listener.set_nonblocking(true).unwrap(); + let address = listener.local_addr().unwrap(); + let origin = format!("http://{address}"); + let cross = format!("http://localhost:{}", address.port()); + let server_origin = origin.clone(); + let server_cross = cross.clone(); + let (requests, mut received) = tokio::sync::mpsc::unbounded_channel(); + let (stop, mut stopped) = tokio::sync::oneshot::channel::<()>(); + let server = std::thread::spawn(move || { + tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async move { + let listener = TcpListener::from_std(listener).unwrap(); + loop { + let accepted = tokio::select! { + result = listener.accept() => result.ok(), + _ = &mut stopped => None, + _ = tokio::time::sleep(Duration::from_secs(30)) => None, + }; + let Some((mut stream, _)) = accepted else { break }; + let head = read_http_request_head(&mut stream).await.unwrap(); + let path = head.lines().next().unwrap().split_whitespace().nth(1).unwrap(); + let url = Url::parse(&format!("{server_origin}{path}")).unwrap(); + let referrer = head.lines().find_map(|line| { + let (name, value) = line.split_once(':')?; + name.eq_ignore_ascii_case("referer").then(|| value.trim().to_owned()) + }); + requests.send((path.to_owned(), referrer.clone())).unwrap(); + let api = url.query_pairs().find(|(key, _)| key == "api").map(|(_, value)| value.into_owned()); + let mut status = "200 OK"; + let mut extra = String::new(); + let (body, content_type) = if head.starts_with("OPTIONS ") { + (String::new(), "text/plain") + } else if url.path() == "/app/sw.js" { + (format!("const CROSS = {};\n{SERVICE_WORKER}", serde_json::to_string(&server_cross).unwrap()), "text/javascript") + } else if url.path() == "/app/network-redirect" { + status = "307 Temporary Redirect"; + extra = format!("Location: {server_cross}/network?api={}\r\nReferrer-Policy: no-referrer\r\n", api.as_deref().unwrap()); + (String::new(), "text/plain") + } else { + let value = serde_json::json!({"source":"network","referrer":referrer}).to_string(); + if api.as_deref() == Some("eventsource") { + (format!("data: {value}\n\n"), "text/event-stream") + } else { (value, "application/json") } + }; + let response = format!("HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\nCache-Control: no-store\r\nAccess-Control-Allow-Origin: {server_origin}\r\nAccess-Control-Allow-Credentials: true\r\nAccess-Control-Allow-Methods: GET, OPTIONS\r\nAccess-Control-Allow-Headers: cache-control, last-event-id\r\n{extra}\r\n{body}", body.len()); + stream.write_all(response.as_bytes()).await.unwrap(); + } + }); + }); + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let mut hooks = PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(); + hooks.resource_task_runner = Some(loader.browser_resource_runtime().resource_task_runner()); + let document_url = Url::parse(&format!("{origin}/app/page.html?policy={policy}&marker=private#fragment")).unwrap(); + let mut page = test_page_vm_with_loader_document_url_and_hooks(&loader, Vec::new(), document_url.clone(), hooks); + page.retain_standalone_request_client_owner_for_test(loader); + let headers = if policy == "default" { Vec::new() } else { + vec![("Referrer-Policy".to_owned(), if policy == "meta-no-referrer" { b"unsafe-url".to_vec() } else { policy.as_bytes().to_vec() })] + }; + page.vm_mut().set_main_navigation_policy_container( + crate::document_runtime::DocumentPolicyContainer::from_navigation_response_headers(&headers, &document_url), + ); + let mut full_referrer = document_url.clone(); + full_referrer.set_fragment(None); + let local = page.local_executor.clone(); + local.run(async move { + let meta = if policy == "meta-no-referrer" { "document.head.appendChild(Object.assign(document.createElement('meta'), {name: 'referrer', content: 'no-referrer'}));" } else { "" }; + let source = format!("const ORIGIN = {}, CROSS = {}, CONTROLLED = {controlled};\ndocument.head.appendChild(Object.assign(document.createElement('base'), {{href: ORIGIN + '/unrelated-base/'}}));\n{meta}\n{CLIENT}", serde_json::to_string(&origin).unwrap(), serde_json::to_string(&cross).unwrap()); + page.vm_mut().eval(&source)?; + drive_service_worker_page_vm_until_done(&mut page, "String(referrerResult !== null || referrerError !== null)", "Window XHR and EventSource must preserve the requesting Document referrer across SW dispatch and fallback").await?; + assert_eq!(page.vm_mut().eval("String(referrerError)")?, "null"); + let result: serde_json::Value = serde_json::from_str(&page.vm_mut().eval("JSON.stringify(referrerResult)")?)?; + let rows = result["rows"].as_array().unwrap(); + assert_eq!(rows.len(), 27); + let effective_policy = match policy { "default" => "strict-origin-when-cross-origin", "meta-no-referrer" => "no-referrer", other => other }; + for row in rows { + assert!(row.get("error").is_none(), "{policy}/{controlled}: {row}"); + let route = row["route"].as_str().unwrap(); + let synthetic = controlled && matches!(route, "synthetic-same" | "synthetic-cross"); + let is_cross = route.ends_with("-cross") || (controlled && route == "synthetic-redirect"); + let expected = if route == "network-policy-redirect" || effective_policy == "no-referrer" || (effective_policy == "same-origin" && is_cross) { + None + } else if effective_policy == "origin" || (effective_policy == "strict-origin-when-cross-origin" && is_cross) { + Some(format!("{origin}/")) + } else { Some(full_referrer.to_string()) }; + let data = &row["data"]; + if synthetic { + assert_eq!(data["source"], "serviceworker"); + assert_eq!(data["referrer"], expected.as_deref().unwrap_or(""), "{policy}/{controlled}: {row}"); + assert_eq!(data["referrerPolicy"], effective_policy); + assert_eq!(data["cache"], if row["kind"] == "eventsource" { "no-store" } else { "default" }); + } else { + assert_eq!(data["source"], "network"); + assert_eq!(data["referrer"], serde_json::to_value(expected)?, "{policy}/{controlled}: {row}"); + } + } + anyhow::Ok(()) + }).await.unwrap(); + let _ = stop.send(()); + server.join().unwrap(); + let mut observed = Vec::new(); + while let Ok(request) = received.try_recv() { observed.push(request); } + assert_eq!(observed.iter().filter(|(path, _)| path == "/app/sw.js").count(), usize::from(controlled)); + assert!(observed.iter().any(|(path, _)| path.starts_with("/app/network?api=xhr"))); + assert!(observed.iter().any(|(path, _)| path.starts_with("/app/network?api=eventsource"))); + if matches!(policy, "no-referrer" | "meta-no-referrer") { + assert!(observed.iter().filter(|(path, _)| path != "/app/sw.js").all(|(_, referrer)| referrer.is_none())); + } + }).await; + } +} + +#[tokio::test] +async fn window_request_referrer_default_policy() { + check_window_request_referrer("default").await; +} + +#[tokio::test] +async fn window_request_referrer_no_referrer_policy() { + check_window_request_referrer("no-referrer").await; +} + +#[tokio::test] +async fn window_request_referrer_origin_policy() { + check_window_request_referrer("origin").await; +} + +#[tokio::test] +async fn window_request_referrer_same_origin_policy() { + check_window_request_referrer("same-origin").await; +} + +#[tokio::test] +async fn window_request_referrer_unsafe_url_policy() { + check_window_request_referrer("unsafe-url").await; +} + +#[tokio::test] +async fn window_request_referrer_meta_no_referrer_policy() { + check_window_request_referrer("meta-no-referrer").await; +} diff --git a/moli-renderer-v8/tests/fixtures/window-request-referrer-client.js b/moli-renderer-v8/tests/fixtures/window-request-referrer-client.js new file mode 100644 index 00000000000..1036f9ba1cb --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/window-request-referrer-client.js @@ -0,0 +1,45 @@ + +globalThis.referrerResult = null; +globalThis.referrerError = null; +(async () => { + if (CONTROLLED) { + await navigator.serviceWorker.register('/app/sw.js', {scope: '/app/'}); + await navigator.serviceWorker.ready; + if (!navigator.serviceWorker.controller) await new Promise(resolve => + navigator.serviceWorker.addEventListener('controllerchange', resolve, {once: true})); + } + function take(kind, url) { + if (kind === 'fetch') return fetch(url).then(response => response.json()); + if (kind === 'eventsource') return new Promise((resolve, reject) => { + const source = new EventSource(url); + source.onmessage = event => {source.close(); resolve(JSON.parse(event.data));}; + source.onerror = () => {source.close(); reject(new Error('EventSource failed: ' + url));}; + }); + if (kind === 'syncxhr') { + const xhr = new XMLHttpRequest(); xhr.open('GET', url, false); xhr.send(); + if (xhr.status !== 200) throw new Error('sync XHR status ' + xhr.status); + return Promise.resolve(JSON.parse(xhr.responseText)); + } + return new Promise((resolve, reject) => { + const xhr = new XMLHttpRequest(); xhr.open('GET', url, true); + xhr.onload = () => xhr.status === 200 ? resolve(JSON.parse(xhr.responseText)) : reject(new Error('XHR status ' + xhr.status)); + xhr.onerror = () => reject(new Error('XHR failed: ' + url)); xhr.send(); + }); + } + const routes = [ + ['synthetic-same', ORIGIN + '/app/echo'], ['synthetic-cross', CROSS + '/echo'], + ['forward-same', ORIGIN + '/app/forward'], ['forward-cross', CROSS + '/forward'], + ['fallback-same', ORIGIN + '/app/network'], ['fallback-cross', CROSS + '/network'], + ['synthetic-redirect', ORIGIN + '/app/sw-redirect'], + ['network-policy-redirect', ORIGIN + '/app/network-redirect'] + ]; + const rows = []; + for (const kind of ['xhr', 'syncxhr', 'eventsource', 'fetch']) { + for (const [route, url] of routes) { + if (kind === 'syncxhr' && !route.startsWith('synthetic-')) continue; + try { rows.push({kind, route, data: await take(kind, url + '?api=' + kind)}); } + catch (error) { rows.push({kind, route, error: String(error)}); } + } + } + referrerResult = {url: location.href, documentReferrerPolicy: document.referrerPolicy, rows}; +})().catch(error => referrerError = String(error)); void 0; diff --git a/moli-renderer-v8/tests/fixtures/window-request-referrer-sw.js b/moli-renderer-v8/tests/fixtures/window-request-referrer-sw.js new file mode 100644 index 00000000000..04ace3324c8 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/window-request-referrer-sw.js @@ -0,0 +1,21 @@ + +self.oninstall = event => event.waitUntil(self.skipWaiting()); +self.onactivate = event => event.waitUntil(self.clients.claim()); +self.onfetch = event => { + const url = new URL(event.request.url), path = url.pathname; + const kind = url.searchParams.get('api'); + if (path.endsWith('/echo')) { + const result = {source: 'serviceworker', referrer: event.request.referrer, + referrerPolicy: event.request.referrerPolicy, cache: event.request.cache, + method: event.request.method, mode: event.request.mode, + credentials: event.request.credentials, destination: event.request.destination, + bodyIsNull: event.request.body === null, clientId: event.clientId, + resultingClientId: event.resultingClientId}; + event.respondWith(new Response(kind === 'eventsource' ? 'data: ' + JSON.stringify(result) + '\n\n' : JSON.stringify(result), + {headers: {'Content-Type': kind === 'eventsource' ? 'text/event-stream' : 'application/json'}})); + } else if (path.endsWith('/forward')) { + event.respondWith(fetch(event.request)); + } else if (path.endsWith('/sw-redirect')) { + event.respondWith(Response.redirect(CROSS + '/network?api=' + kind, 307)); + } +};