Add shared root caching with hybrid ESI and streaming assembly

.github/workflows/test.yml

@@ -27,6 +27,11 @@ jobs:
         run: echo "viceroy-version=$(grep '^viceroy ' .tool-versions | awk '{print $2}')" >> $GITHUB_OUTPUT
         shell: bash
 
+      - name: Retrieve Node.js version
+        id: node-version
+        run: echo "node-version=$(grep '^nodejs ' .tool-versions | awk '{print $2}')" >> $GITHUB_OUTPUT
+        shell: bash
+
       - name: Set up Rust toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
@@ -45,9 +50,20 @@ jobs:
         if: steps.cache-viceroy.outputs.cache-hit != 'true'
         run: cargo install viceroy --version "${{ steps.viceroy-version.outputs.viceroy-version }}" --locked --force
 
+      - name: Use Node.js for the served-seam contract
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ steps.node-version.outputs.node-version }}
+
       - name: Run tests
         run: cargo test-fastly
 
+      - name: Run C2 ESI local harness
+        run: ./scripts/c2-local-test.sh esi
+
+      - name: Run inline control harness
+        run: ./scripts/c2-local-test.sh inline
+
   test-axum:
     name: cargo test (axum native)
     runs-on: ubuntu-latest

Cargo.toml

@@ -71,6 +71,7 @@ getrandom = "0.2"
 hex = "0.4.3"
 hmac = "0.12.1"
 http = "1.4.0"
+httpdate = "1.0.3"
 http-body-util = "0.1"
 hyper = "1"
 hyper-util = "0.1"

crates/trusted-server-adapter-fastly/Cargo.toml

@@ -15,9 +15,11 @@ async-trait = { workspace = true }
 base64 = { workspace = true }
 bytes = { workspace = true }
 chrono = { workspace = true }
+derive_more = { workspace = true }
 edgezero-adapter-fastly = { workspace = true, features = ["fastly"] }
 edgezero-core = { workspace = true }
 error-stack = { workspace = true }
+esi = { git = "https://github.com/stackpop/esi.git", rev = "4c53feab4d22ad9a84641b4c46f3f63bc6d197e2" }
 fastly = { workspace = true }
 fern = { workspace = true }
 futures = { workspace = true }

crates/trusted-server-adapter-fastly/src/app.rs

@@ -257,6 +257,11 @@ fn build_per_request_services(state: &AppState, ctx: &RequestContext) -> Runtime
         .config_store(Arc::new(FastlyPlatformConfigStore))
         .secret_store(Arc::new(FastlyPlatformSecretStore))
         .kv_store(Arc::clone(&state.default_kv_store))
+        // Spike-only (#1009). Constructed unconditionally, but only read when the
+        // assembly mode is a shared-template one — which defaults to Inline, so this
+        // is inert until an operator opts in.
+        .template_cache(Arc::new(crate::template_cache::FastlyTemplateCache::new()))
+        .template_assembler(Arc::new(crate::esi_assembly::FastlyTemplateAssembler))
         .backend(Arc::new(FastlyPlatformBackend))
         .http_client(Arc::new(FastlyPlatformHttpClient))
         .geo(Arc::new(FastlyPlatformGeo))
@@ -1239,12 +1244,15 @@ mod tests {
 
     use super::{
         AppState, NAMED_ROUTES, NamedRouteHandler, PAGE_BIDS_LEGACY_PATH, PAGE_BIDS_PATH,
-        TrustedServerApp, build_state_from_settings, startup_error_router,
+        TrustedServerApp, build_per_request_services, build_state_from_settings,
+        startup_error_router,
     };
     use bytes::Bytes;
     use edgezero_core::body::Body;
+    use edgezero_core::context::RequestContext;
     use edgezero_core::http::{Method, Response, StatusCode, header, request_builder};
     use edgezero_core::key_value_store::NoopKvStore;
+    use edgezero_core::params::PathParams;
     use edgezero_core::router::RouterService;
     use std::net::{IpAddr, Ipv4Addr};
     use std::sync::Mutex;
@@ -1379,6 +1387,36 @@ mod tests {
         TrustedServerApp::routes_for_state(&state)
     }
 
+    #[test]
+    fn per_request_services_register_the_fastly_template_assembler() {
+        let state = build_state_from_settings(test_settings()).expect("should build test state");
+        let context = RequestContext::new(
+            empty_request(Method::GET, "/article"),
+            PathParams::default(),
+        );
+
+        let services = build_per_request_services(&state, &context);
+        let template = format!(
+            "<html><body>article{}</body></html>",
+            trusted_server_core::publisher::AD_ASSEMBLY_SEAM
+        );
+        let fragment = b"<script>reader state</script>";
+        let assembled = services
+            .template_assembler()
+            .assemble(template.as_bytes(), fragment)
+            .expect("Fastly services should provide ESI assembly");
+
+        assert_eq!(
+            assembled,
+            template
+                .replace(
+                    trusted_server_core::publisher::AD_ASSEMBLY_SEAM,
+                    std::str::from_utf8(fragment).expect("fragment should be UTF-8")
+                )
+                .into_bytes()
+        );
+    }
+
     /// Builds a router whose `AppState` uses a registry containing the given
     /// request filters (and no routes), so dispatch-level request-filter
     /// behavior can be exercised without a real integration.