diff --git a/.claude/settings.json b/.claude/settings.json
index c4261ade..95f403b4 100644
--- a/.claude/settings.json
+++ b/.claude/settings.json
@@ -10,22 +10,22 @@
       "Bash(tree:*)",
       "Bash(wc:*)",
       "Bash(which:*)",
-
       "Bash(npm ci:*)",
       "Bash(npm run:*)",
       "Bash(npm test:*)",
-
       "Bash(cargo build:*)",
       "Bash(cargo check:*)",
       "Bash(cargo clippy:*)",
       "Bash(cargo fmt:*)",
       "Bash(cargo metadata:*)",
       "Bash(cargo test:*)",
-
       "Bash(git branch:*)",
       "Bash(git diff:*)",
       "Bash(git log:*)",
-      "Bash(git status:*)"
+      "Bash(git status:*)",
+      "mcp__plugin_chrome-devtools-mcp_chrome-devtools__new_page",
+      "mcp__plugin_chrome-devtools-mcp_chrome-devtools__performance_stop_trace",
+      "mcp__plugin_chrome-devtools-mcp_chrome-devtools__evaluate_script"
     ]
   }
 }
diff --git a/CLAUDE.md b/CLAUDE.md
index abf6e896..9ad1845c 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -237,9 +237,10 @@ IntegrationRegistration::builder(ID)
     .build()
 ```
 
-- Integration IDs match JS directory names: `prebid`, `lockr`, `permutive`, `datadome`, `didomi`, `testlight`.
+- Integration IDs match JS directory names: `prebid` (deferred), `lockr`, `permutive`, `datadome`, `didomi`, `testlight`.
 - `creative` is JS-only (no Rust registration); `nextjs`, `aps`, `adserver_mock` are Rust-only.
-- `IntegrationRegistry::js_module_ids()` maps registered integrations to JS module names.
+- Integrations opt into deferred loading via `.with_deferred_js()` on the registration builder. Deferred modules are served as separate `<script defer>` tags instead of being concatenated into the main bundle.
+- `IntegrationRegistry::js_module_ids_immediate()` returns modules for the main bundle; `js_module_ids_deferred()` returns modules loaded with `defer`.
 
 ## JS Build Pipeline
 
diff --git a/crates/common/src/creative.rs b/crates/common/src/creative.rs
index d8e2793a..63db7e6f 100644
--- a/crates/common/src/creative.rs
+++ b/crates/common/src/creative.rs
@@ -322,7 +322,7 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                     let injected = injected_ts_creative.clone();
                     move |el| {
                         if !injected.get() {
-                            let script_tag = tsjs::tsjs_script_tag_all();
+                            let script_tag = tsjs::tsjs_unified_script_tag();
                             el.prepend(&script_tag, ContentType::Html);
                             injected.set(true);
                         }
diff --git a/crates/common/src/html_processor.rs b/crates/common/src/html_processor.rs
index a3b3c9bf..540ab29d 100644
--- a/crates/common/src/html_processor.rs
+++ b/crates/common/src/html_processor.rs
@@ -208,10 +208,13 @@ pub fn create_html_processor(config: HtmlProcessorConfig) -> impl StreamProcesso
                     for insert in integrations.head_inserts(&ctx) {
                         snippet.push_str(&insert);
                     }
-                    // Then inject the TSJS bundle — its top-level init code can now
-                    // read the config that was set by the inline scripts above.
-                    let module_ids = integrations.js_module_ids();
-                    snippet.push_str(&tsjs::tsjs_script_tag(&module_ids));
+                    // Main bundle: core + non-deferred integrations (synchronous).
+                    let immediate_ids = integrations.js_module_ids_immediate();
+                    snippet.push_str(&tsjs::tsjs_script_tag(&immediate_ids));
+                    // Deferred bundles: large modules like prebid loaded after
+                    // HTML parsing completes. Empty when none are enabled.
+                    let deferred_ids = integrations.js_module_ids_deferred();
+                    snippet.push_str(&tsjs::tsjs_deferred_script_tags(&deferred_ids));
                     el.prepend(&snippet, ContentType::Html);
                     injected_tsjs.set(true);
                 }
diff --git a/crates/common/src/integrations/prebid.rs b/crates/common/src/integrations/prebid.rs
index fb3fccc8..89a8826c 100644
--- a/crates/common/src/integrations/prebid.rs
+++ b/crates/common/src/integrations/prebid.rs
@@ -229,6 +229,7 @@ pub fn register(settings: &Settings) -> Option<IntegrationRegistration> {
             .with_proxy(integration.clone())
             .with_attribute_rewriter(integration.clone())
             .with_head_injector(integration)
+            .with_deferred_js()
             .build(),
     )
 }
@@ -320,7 +321,7 @@ impl IntegrationHeadInjector for PrebidIntegration {
             .replace("</", "<\\/");
 
         vec![format!(
-            r#"<script>window.__tsjs_prebid={config_json};</script>"#
+            r#"<script>window.pbjs=window.pbjs||{{}};window.pbjs.que=window.pbjs.que||[];window.pbjs.cmd=window.pbjs.cmd||[];window.__tsjs_prebid={config_json};</script>"#
         )]
     }
 }
@@ -1232,13 +1233,17 @@ template = "{{client_ip}}:{{user_agent}}"
             "Unified bundle should be injected"
         );
         assert!(
-            !processed.contains("prebid.min.js"),
-            "Prebid script should be removed when auto-config is enabled"
+            !processed.contains("cdn.prebid.org/prebid.min.js"),
+            "Publisher prebid script should be removed when auto-config is enabled"
         );
         assert!(
             !processed.contains("cdn.prebid.org/prebid.js"),
             "Prebid preload should be removed when auto-config is enabled"
         );
+        assert!(
+            processed.contains("tsjs-prebid.min.js"),
+            "Deferred prebid bundle should be injected"
+        );
     }
 
     #[test]
diff --git a/crates/common/src/integrations/registry.rs b/crates/common/src/integrations/registry.rs
index 07fec408..158a1e29 100644
--- a/crates/common/src/integrations/registry.rs
+++ b/crates/common/src/integrations/registry.rs
@@ -390,6 +390,7 @@ pub trait IntegrationHeadInjector: Send + Sync {
 /// Registration payload returned by integration builders.
 pub struct IntegrationRegistration {
     pub integration_id: &'static str,
+    pub js_deferred: bool,
     pub proxies: Vec<Arc<dyn IntegrationProxy>>,
     pub attribute_rewriters: Vec<Arc<dyn IntegrationAttributeRewriter>>,
     pub script_rewriters: Vec<Arc<dyn IntegrationScriptRewriter>>,
@@ -413,6 +414,7 @@ impl IntegrationRegistrationBuilder {
         Self {
             registration: IntegrationRegistration {
                 integration_id,
+                js_deferred: false,
                 proxies: Vec::new(),
                 attribute_rewriters: Vec::new(),
                 script_rewriters: Vec::new(),
@@ -458,6 +460,14 @@ impl IntegrationRegistrationBuilder {
         self
     }
 
+    /// Mark this integration's JS module for deferred loading via
+    /// `<script defer>` instead of the main synchronous bundle.
+    #[must_use]
+    pub fn with_deferred_js(mut self) -> Self {
+        self.registration.js_deferred = true;
+        self
+    }
+
     #[must_use]
     pub fn build(self) -> IntegrationRegistration {
         self.registration
@@ -476,6 +486,7 @@ struct IntegrationRegistryInner {
 
     // Metadata for introspection
     routes: Vec<(IntegrationEndpoint, &'static str)>,
+    deferred_js_ids: Vec<&'static str>,
     html_rewriters: Vec<Arc<dyn IntegrationAttributeRewriter>>,
     script_rewriters: Vec<Arc<dyn IntegrationScriptRewriter>>,
     html_post_processors: Vec<Arc<dyn IntegrationHtmlPostProcessor>>,
@@ -495,6 +506,7 @@ impl Default for IntegrationRegistryInner {
             script_rewriters: Vec::new(),
             html_post_processors: Vec::new(),
             head_injectors: Vec::new(),
+            deferred_js_ids: Vec::new(),
         }
     }
 }
@@ -600,6 +612,9 @@ impl IntegrationRegistry {
                 inner
                     .head_injectors
                     .extend(registration.head_injectors.into_iter());
+                if registration.js_deferred {
+                    inner.deferred_js_ids.push(registration.integration_id);
+                }
             }
         }
 
@@ -789,6 +804,30 @@ impl IntegrationRegistry {
         ids
     }
 
+    /// Return JS module IDs for the main (synchronous) bundle, excluding
+    /// modules registered with [`with_deferred_js`](IntegrationRegistrationBuilder::with_deferred_js).
+    #[must_use]
+    pub fn js_module_ids_immediate(&self) -> Vec<&'static str> {
+        self.js_module_ids()
+            .into_iter()
+            .filter(|id| !self.inner.deferred_js_ids.contains(id))
+            .collect()
+    }
+
+    /// Return JS module IDs that should be loaded with `<script defer>`.
+    ///
+    /// Only includes modules registered with
+    /// [`with_deferred_js`](IntegrationRegistrationBuilder::with_deferred_js)
+    /// that are actually enabled. Returns an empty vec when no deferred
+    /// integrations are configured.
+    #[must_use]
+    pub fn js_module_ids_deferred(&self) -> Vec<&'static str> {
+        self.js_module_ids()
+            .into_iter()
+            .filter(|id| self.inner.deferred_js_ids.contains(id))
+            .collect()
+    }
+
     #[cfg(test)]
     #[must_use]
     pub fn from_rewriters(
@@ -807,6 +846,7 @@ impl IntegrationRegistry {
                 script_rewriters,
                 html_post_processors: Vec::new(),
                 head_injectors: Vec::new(),
+                deferred_js_ids: Vec::new(),
             }),
         }
     }
@@ -830,6 +870,7 @@ impl IntegrationRegistry {
                 script_rewriters,
                 html_post_processors: Vec::new(),
                 head_injectors,
+                deferred_js_ids: Vec::new(),
             }),
         }
     }
@@ -885,6 +926,7 @@ impl IntegrationRegistry {
                 script_rewriters: Vec::new(),
                 html_post_processors: Vec::new(),
                 head_injectors: Vec::new(),
+                deferred_js_ids: Vec::new(),
             }),
         }
     }
@@ -1338,4 +1380,101 @@ mod tests {
             "POST response should have x-synthetic-id header"
         );
     }
+
+    #[test]
+    fn js_module_ids_immediate_excludes_prebid() {
+        let settings = crate::test_support::tests::create_test_settings();
+        let mut settings_with_prebid = settings;
+        settings_with_prebid
+            .integrations
+            .insert_config(
+                "prebid",
+                &serde_json::json!({
+                    "enabled": true,
+                    "server_url": "https://test-prebid.com/openrtb2/auction",
+                    "timeout_ms": 1000,
+                    "bidders": ["mocktioneer"],
+                    "debug": false
+                }),
+            )
+            .expect("should insert prebid config");
+
+        let registry =
+            IntegrationRegistry::new(&settings_with_prebid).expect("should create registry");
+
+        let all = registry.js_module_ids();
+        let immediate = registry.js_module_ids_immediate();
+        let deferred = registry.js_module_ids_deferred();
+
+        assert!(
+            all.contains(&"prebid"),
+            "should include prebid in full list"
+        );
+        assert!(
+            !immediate.contains(&"prebid"),
+            "should not include prebid in immediate IDs"
+        );
+        assert!(
+            deferred.contains(&"prebid"),
+            "should include prebid in deferred IDs"
+        );
+    }
+
+    #[test]
+    fn js_module_ids_deferred_empty_when_prebid_disabled() {
+        let mut settings = crate::test_support::tests::create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                "prebid",
+                &serde_json::json!({
+                    "enabled": false,
+                    "server_url": "https://test-prebid.com/openrtb2/auction"
+                }),
+            )
+            .expect("should update prebid config");
+
+        let registry = IntegrationRegistry::new(&settings).expect("should create registry");
+
+        let deferred = registry.js_module_ids_deferred();
+        assert!(
+            deferred.is_empty(),
+            "should have no deferred IDs when prebid is disabled"
+        );
+    }
+
+    #[test]
+    fn js_module_ids_split_is_exhaustive() {
+        let settings = crate::test_support::tests::create_test_settings();
+        let mut settings_with_prebid = settings;
+        settings_with_prebid
+            .integrations
+            .insert_config(
+                "prebid",
+                &serde_json::json!({
+                    "enabled": true,
+                    "server_url": "https://test-prebid.com/openrtb2/auction",
+                    "timeout_ms": 1000,
+                    "bidders": ["mocktioneer"],
+                    "debug": false
+                }),
+            )
+            .expect("should insert prebid config");
+
+        let registry =
+            IntegrationRegistry::new(&settings_with_prebid).expect("should create registry");
+
+        let all = registry.js_module_ids();
+        let mut recombined = registry.js_module_ids_immediate();
+        recombined.extend(registry.js_module_ids_deferred());
+        recombined.sort();
+
+        let mut all_sorted = all;
+        all_sorted.sort();
+
+        assert_eq!(
+            recombined, all_sorted,
+            "should reconstruct full module list from immediate + deferred"
+        );
+    }
 }
diff --git a/crates/common/src/integrations/testlight.rs b/crates/common/src/integrations/testlight.rs
index fda22ea9..1c8e31b5 100644
--- a/crates/common/src/integrations/testlight.rs
+++ b/crates/common/src/integrations/testlight.rs
@@ -218,8 +218,9 @@ fn default_timeout_ms() -> u32 {
 }
 
 fn default_shim_src() -> String {
-    // Testlight is included in the unified bundle, so we return the unified script source
-    tsjs::tsjs_script_src_all()
+    // Testlight is included in the unified bundle, so we return the unified script source.
+    // Uses conservative all-module hash since the registry is unavailable at config time.
+    tsjs::tsjs_unified_script_src()
 }
 
 fn default_enabled() -> bool {
@@ -260,7 +261,7 @@ mod tests {
 
     #[test]
     fn html_rewriter_replaces_integration_script() {
-        let shim_src = tsjs::tsjs_script_src_all();
+        let shim_src = tsjs::tsjs_unified_script_src();
         let config = TestlightConfig {
             enabled: true,
             endpoint: "https://example.com/openrtb".to_string(),
@@ -290,7 +291,7 @@ mod tests {
 
     #[test]
     fn html_rewriter_is_noop_when_disabled() {
-        let shim_src = tsjs::tsjs_script_src_all();
+        let shim_src = tsjs::tsjs_unified_script_src();
         let config = TestlightConfig {
             enabled: true,
             endpoint: "https://example.com/openrtb".to_string(),
diff --git a/crates/common/src/publisher.rs b/crates/common/src/publisher.rs
index 78489d2e..7c86d06d 100644
--- a/crates/common/src/publisher.rs
+++ b/crates/common/src/publisher.rs
@@ -17,9 +17,11 @@ use crate::synthetic::get_or_generate_synthetic_id;
 
 /// Unified tsjs static serving: `/static/tsjs=<filename>`
 ///
-/// Concatenates core + enabled integration JS modules at runtime based on the
-/// `IntegrationRegistry`. The URL remains `/static/tsjs=tsjs-unified(.min).js`
-/// for backward compatibility.
+/// Serves two types of bundles:
+/// - **Unified bundle** (`tsjs-unified.min.js`): core + immediate (non-deferred)
+///   integration modules.
+/// - **Deferred module** (`tsjs-{id}.min.js`): a single self-contained IIFE for
+///   modules loaded with `defer` (e.g., prebid).
 ///
 /// # Errors
 ///
@@ -29,23 +31,54 @@ pub fn handle_tsjs_dynamic(
     integration_registry: &IntegrationRegistry,
 ) -> Result<Response, Report<TrustedServerError>> {
     const PREFIX: &str = "/static/tsjs=";
-    const ALLOWED_FILENAMES: &[&str] = &["tsjs-unified.js", "tsjs-unified.min.js"];
+    const UNIFIED_FILENAMES: &[&str] = &["tsjs-unified.js", "tsjs-unified.min.js"];
+
     let path = req.get_path();
     if !path.starts_with(PREFIX) {
         return Ok(Response::from_status(StatusCode::NOT_FOUND).with_body("Not Found"));
     }
     let filename = &path[PREFIX.len()..];
-    if !ALLOWED_FILENAMES.contains(&filename) {
-        return Ok(Response::from_status(StatusCode::NOT_FOUND).with_body("Not Found"));
+
+    if UNIFIED_FILENAMES.contains(&filename) {
+        // Serve core + immediate modules (excludes deferred like prebid)
+        let module_ids = integration_registry.js_module_ids_immediate();
+        let body = trusted_server_js::concatenate_modules(&module_ids);
+        let mut resp = serve_static_with_etag(&body, req, "application/javascript; charset=utf-8");
+        resp.set_header(HEADER_X_COMPRESS_HINT, "on");
+        return Ok(resp);
+    }
+
+    if let Some(module_id) = parse_deferred_module_filename(filename) {
+        // Only serve if the deferred module is actually enabled
+        let deferred_ids = integration_registry.js_module_ids_deferred();
+        if !deferred_ids.contains(&module_id) {
+            return Ok(Response::from_status(StatusCode::NOT_FOUND).with_body("Not Found"));
+        }
+        if let Some(content) = trusted_server_js::module_bundle(module_id) {
+            let mut resp =
+                serve_static_with_etag(content, req, "application/javascript; charset=utf-8");
+            resp.set_header(HEADER_X_COMPRESS_HINT, "on");
+            return Ok(resp);
+        }
     }
 
-    // Concatenate core + enabled integration modules
-    let module_ids = integration_registry.js_module_ids();
-    let body = trusted_server_js::concatenate_modules(&module_ids);
+    Ok(Response::from_status(StatusCode::NOT_FOUND).with_body("Not Found"))
+}
 
-    let mut resp = serve_static_with_etag(&body, req, "application/javascript; charset=utf-8");
-    resp.set_header(HEADER_X_COMPRESS_HINT, "on");
-    Ok(resp)
+/// Extract a module ID from a deferred-module filename like `tsjs-prebid.min.js`.
+///
+/// Returns `Some(&'static str)` if the filename matches a known JS module ID,
+/// `None` otherwise. The caller must additionally verify that the module is
+/// both deferred and enabled via the [`IntegrationRegistry`].
+#[must_use]
+fn parse_deferred_module_filename(filename: &str) -> Option<&'static str> {
+    let stem = filename
+        .strip_prefix("tsjs-")
+        .and_then(|s| s.strip_suffix(".min.js").or_else(|| s.strip_suffix(".js")))?;
+
+    trusted_server_js::all_module_ids()
+        .into_iter()
+        .find(|&id| id == stem)
 }
 
 /// Parameters for processing response streaming
@@ -454,5 +487,106 @@ mod tests {
         assert_eq!(response.get_status(), StatusCode::OK);
     }
 
-    // Tests related to serving Prebid.js directly or intercepting its paths were removed.
+    #[test]
+    fn parse_deferred_module_filename_extracts_known_id() {
+        assert_eq!(
+            parse_deferred_module_filename("tsjs-prebid.min.js"),
+            Some("prebid"),
+            "should extract prebid from minified filename"
+        );
+        assert_eq!(
+            parse_deferred_module_filename("tsjs-prebid.js"),
+            Some("prebid"),
+            "should extract prebid from unminified filename"
+        );
+    }
+
+    #[test]
+    fn parse_deferred_module_filename_rejects_unknown_ids() {
+        assert_eq!(
+            parse_deferred_module_filename("tsjs-evil.min.js"),
+            None,
+            "should reject unknown module names"
+        );
+        assert_eq!(
+            parse_deferred_module_filename("tsjs-core.min.js"),
+            Some("core"),
+            "should accept any known module ID (deferred check happens in caller)"
+        );
+        assert_eq!(
+            parse_deferred_module_filename("prebid.min.js"),
+            None,
+            "should reject without tsjs- prefix"
+        );
+        assert_eq!(
+            parse_deferred_module_filename("tsjs-prebid.txt"),
+            None,
+            "should reject non-js extension"
+        );
+    }
+
+    #[test]
+    fn tsjs_dynamic_serves_deferred_prebid_when_enabled() {
+        // Default test settings include prebid enabled
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let req = Request::new(
+            Method::GET,
+            "https://publisher.example/static/tsjs=tsjs-prebid.min.js",
+        );
+
+        let response = handle_tsjs_dynamic(&req, &registry).expect("should handle tsjs request");
+        assert_eq!(
+            response.get_status(),
+            StatusCode::OK,
+            "should serve deferred prebid module when enabled"
+        );
+    }
+
+    #[test]
+    fn tsjs_dynamic_returns_not_found_for_disabled_deferred_module() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                "prebid",
+                &serde_json::json!({
+                    "enabled": false,
+                    "server_url": "https://test-prebid.com/openrtb2/auction"
+                }),
+            )
+            .expect("should update prebid config");
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let req = Request::new(
+            Method::GET,
+            "https://publisher.example/static/tsjs=tsjs-prebid.min.js",
+        );
+
+        let response = handle_tsjs_dynamic(&req, &registry).expect("should handle tsjs request");
+        assert_eq!(
+            response.get_status(),
+            StatusCode::NOT_FOUND,
+            "should return 404 for disabled deferred module"
+        );
+    }
+
+    #[test]
+    fn tsjs_dynamic_returns_not_found_for_arbitrary_module_name() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let req = Request::new(
+            Method::GET,
+            "https://publisher.example/static/tsjs=tsjs-evil.min.js",
+        );
+
+        let response = handle_tsjs_dynamic(&req, &registry).expect("should handle tsjs request");
+        assert_eq!(
+            response.get_status(),
+            StatusCode::NOT_FOUND,
+            "should reject unknown module names"
+        );
+    }
 }
diff --git a/crates/common/src/tsjs.rs b/crates/common/src/tsjs.rs
index 2bec8a3b..4921a9bb 100644
--- a/crates/common/src/tsjs.rs
+++ b/crates/common/src/tsjs.rs
@@ -1,4 +1,4 @@
-use trusted_server_js::{all_module_ids, concatenated_hash};
+use trusted_server_js::{all_module_ids, concatenated_hash, single_module_hash};
 
 /// `/static` URL for the tsjs bundle with cache-busting hash based on
 /// the concatenated content of the given module set.
@@ -17,17 +17,50 @@ pub fn tsjs_script_tag(module_ids: &[&str]) -> String {
     )
 }
 
-/// `/static` URL using **all** available modules. Used in contexts that lack
-/// an `IntegrationRegistry` (e.g., creative rewriting, config defaults).
+/// `/static` URL for the unified bundle with a conservative cache-busting hash.
+///
+/// Hashes all compiled module IDs so the cache invalidates whenever any module
+/// changes. Over-invalidates slightly (includes deferred modules in the hash)
+/// but never serves stale content. Use [`tsjs_script_src`] with exact module
+/// IDs when the [`IntegrationRegistry`] is available.
 #[must_use]
-pub fn tsjs_script_src_all() -> String {
+pub fn tsjs_unified_script_src() -> String {
     let ids = all_module_ids();
     tsjs_script_src(&ids)
 }
 
-/// `<script>` tag using **all** available modules.
+/// `<script>` tag for the unified bundle with a conservative cache-busting hash.
+///
+/// See [`tsjs_unified_script_src`] for details.
 #[must_use]
-pub fn tsjs_script_tag_all() -> String {
+pub fn tsjs_unified_script_tag() -> String {
     let ids = all_module_ids();
     tsjs_script_tag(&ids)
 }
+
+/// `/static` URL for a single deferred module with its own cache-busting hash.
+#[must_use]
+pub fn tsjs_deferred_script_src(module_id: &str) -> String {
+    let hash = single_module_hash(module_id).unwrap_or_default();
+    format!("/static/tsjs=tsjs-{module_id}.min.js?v={hash}")
+}
+
+/// `<script defer>` tag for a single deferred module.
+#[must_use]
+pub fn tsjs_deferred_script_tag(module_id: &str) -> String {
+    format!(
+        "<script src=\"{}\" defer></script>",
+        tsjs_deferred_script_src(module_id)
+    )
+}
+
+/// Generate all deferred `<script defer>` tags for the given module IDs.
+///
+/// Returns an empty string when no deferred modules are present.
+#[must_use]
+pub fn tsjs_deferred_script_tags(module_ids: &[&str]) -> String {
+    module_ids
+        .iter()
+        .map(|id| tsjs_deferred_script_tag(id))
+        .collect::<String>()
+}
diff --git a/crates/js/src/bundle.rs b/crates/js/src/bundle.rs
index 3152af6c..7ae44aaa 100644
--- a/crates/js/src/bundle.rs
+++ b/crates/js/src/bundle.rs
@@ -54,6 +54,18 @@ pub fn concatenated_hash(ids: &[&str]) -> String {
     encode(hasher.finalize())
 }
 
+/// SHA-256 hash of a single module's content (without prepending core).
+///
+/// Used for cache-busting URLs of deferred modules served individually.
+#[must_use]
+pub fn single_module_hash(id: &str) -> Option<String> {
+    module_bundle(id).map(|content| {
+        let mut hasher = Sha256::new();
+        hasher.update(content.as_bytes());
+        encode(hasher.finalize())
+    })
+}
+
 fn module_map() -> &'static HashMap<&'static str, &'static str> {
     static MAP: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
     MAP.get_or_init(|| TSJS_MODULES.iter().map(|m| (m.id, m.bundle)).collect())
diff --git a/crates/js/src/lib.rs b/crates/js/src/lib.rs
index a5977431..7c92212b 100644
--- a/crates/js/src/lib.rs
+++ b/crates/js/src/lib.rs
@@ -1,3 +1,5 @@
 pub mod bundle;
 
-pub use bundle::{all_module_ids, concatenate_modules, concatenated_hash, module_bundle};
+pub use bundle::{
+    all_module_ids, concatenate_modules, concatenated_hash, module_bundle, single_module_hash,
+};
diff --git a/docs/guide/integration-guide.md b/docs/guide/integration-guide.md
index c18c5a90..f199db94 100644
--- a/docs/guide/integration-guide.md
+++ b/docs/guide/integration-guide.md
@@ -212,12 +212,12 @@ impl IntegrationScriptRewriter for MyIntegration {
 `html_processor.rs` calls these hooks after applying the standard origin→first-party rewrite, so you can simply swap URLs, append query parameters, or mutate inline JSON. Use this to point `<script>` tags at your own tsjs-managed bundle (for example, `/static/tsjs=tsjs-testlight.min.js`) or to rewrite embedded Next.js payloads.
 
 ::: warning Removing Elements
-Returning `AttributeRewriteAction::remove_element()` (or `ScriptRewriteAction::RemoveNode` for inline content) removes the element entirely, so integrations can drop publisher-provided markup when the Trusted Server already injects a safe alternative. Prebid, for example, simply removes `prebid.js` because the unified TSJS bundle is injected automatically at the start of `<head>`.
+Returning `AttributeRewriteAction::remove_element()` (or `ScriptRewriteAction::RemoveNode` for inline content) removes the element entirely, so integrations can drop publisher-provided markup when the Trusted Server already injects a safe alternative. Prebid, for example, removes publisher `prebid.js` tags because it ships its own deferred bundle (`tsjs-prebid.min.js`).
 :::
 
 ### 5b. Implement Head Injection (Optional)
 
-If the integration needs to inject HTML snippets at the start of `<head>` (for example, configuration scripts that run after the unified TSJS bundle), implement `IntegrationHeadInjector`. Snippets returned by this trait are prepended into `<head>` immediately after the TSJS bundle tag, so the `tsjs` API is available.
+If the integration needs to inject HTML snippets at the start of `<head>` (for example, configuration scripts or global bootstraps), implement `IntegrationHeadInjector`. Snippets are prepended into `<head>` before the TSJS bundle tags, so they run first.
 
 ```rust
 impl IntegrationHeadInjector for MyIntegration {
@@ -232,7 +232,7 @@ impl IntegrationHeadInjector for MyIntegration {
 }
 ```
 
-`html_processor.rs` calls `head_inserts` once per HTML response when the `<head>` element is first encountered. The returned snippets are concatenated after the unified script tag and prepended together, so ordering between integrations is not guaranteed — keep snippets self-contained.
+`html_processor.rs` calls `head_inserts` once per HTML response when the `<head>` element is first encountered. The returned snippets are concatenated before the unified script tag, so ordering between integrations is not guaranteed — keep snippets self-contained.
 
 ::: tip When to Use Head Injection
 Use `IntegrationHeadInjector` when you need to emit configuration, inline scripts, or `<meta>` tags that must appear early in `<head>`. For attribute or script content changes on existing elements, prefer `IntegrationAttributeRewriter` or `IntegrationScriptRewriter` instead.
@@ -251,7 +251,7 @@ Add the module to `crates/common/src/integrations/mod.rs`'s builder list. The re
 
 Place any integration-specific JavaScript entrypoint under `crates/js/lib/src/integrations/` (for example, `crates/js/lib/src/integrations/testlight.ts`). The shared `npm run build` script automatically discovers every file in that directory and produces a bundle named `tsjs-<entry>.js`, which the Rust crate embeds as `/static/tsjs=tsjs-<entry>.min.js`.
 
-Integrations that ship additional JS (such as Testlight) typically expose a `shim_src` config and rewrite publisher tags to point at that URL. Others (like Prebid) can simply drop the legacy tag because the unified bundle is injected automatically at the start of `<head>`.
+Integrations that ship additional JS (such as Testlight) typically expose a `shim_src` config and rewrite publisher tags to point at that URL. Others (like Prebid) drop the publisher tag because the server injects its own deferred bundle automatically.
 
 ### 8. Test Locally
 
@@ -268,10 +268,17 @@ By following these steps you can ship independent integration modules that plug
 
 ## Existing Integrations
 
-Two built-in integrations demonstrate how the framework pieces fit together:
+Two built-in integrations demonstrate how the framework pieces fit together.
+
+Integrations are loaded in one of two ways:
+
+- **Immediate** (default) — concatenated into the main `tsjs-unified.min.js` bundle, loaded synchronously at `<head>` start.
+- **Deferred** — served as a separate `<script defer>` tag (`tsjs-{id}.min.js`), loaded after HTML parsing completes. Used for large modules that would otherwise block rendering. Integrations opt in by calling `.with_deferred_js()` on their registration builder.
 
 ### Testlight
 
+**Loading**: Immediate
+
 **Purpose**: Sample partner stub showing request proxying, attribute rewrites, and asset injection.
 
 **Key files**:
@@ -281,7 +288,9 @@ Two built-in integrations demonstrate how the framework pieces fit together:
 
 ### Prebid
 
-**Purpose**: Production Prebid Server bridge that owns `/first-party/ad` & `/third-party/ad`, injects synthetic IDs, rewrites creatives/notification URLs, and removes publisher-supplied Prebid scripts because the NPM-bundled Prebid.js already ships in the unified TSJS build.
+**Loading**: Deferred (`<script defer>`)
+
+**Purpose**: Production Prebid Server bridge that owns `/first-party/ad` & `/third-party/ad`, injects synthetic IDs, rewrites creatives/notification URLs, and removes publisher-supplied Prebid scripts. The NPM-bundled Prebid.js is served as a separate deferred bundle (`tsjs-prebid.min.js`) to avoid blocking page rendering (168 KB).
 
 **Key files**:
 
@@ -313,11 +322,11 @@ Tests or scaffolding can inject configs by calling `settings.integrations.insert
 
 **3. HTML Rewrites Through the Registry**
 
-When the integration is enabled, the `IntegrationAttributeRewriter` removes any `<script src="prebid*.js">` or `<link href=…>` references that match `script_patterns`. The unified TSJS bundle is injected at the start of `<head>`, so dropping the publisher assets prevents duplicate downloads and still runs before any inline `pbjs` config.
+When the integration is enabled, the `IntegrationAttributeRewriter` removes any `<script src="prebid*.js">` or `<link href=…>` references that match `script_patterns`. The Prebid module is loaded as a separate `<script defer>` tag after the main TSJS bundle, so dropping the publisher assets prevents duplicate downloads. The server-injected config (`window.__tsjs_prebid`) is an inline script that runs before both bundles, ensuring configuration is available when the deferred Prebid module auto-initializes.
 
 **4. TSJS Assets & Testing**
 
-The NPM integration lives in `crates/js/lib/src/integrations/prebid/index.ts`. Tests typically assert that publisher references disappear, relying on the html processor's unified bundle injection to deliver the Prebid.js bundle.
+The NPM integration lives in `crates/js/lib/src/integrations/prebid/index.ts`. Tests typically assert that publisher references disappear and the deferred `tsjs-prebid.min.js` tag is present.
 
 Reusing these patterns makes it straightforward to convert additional legacy flows (for example, Next.js rewrites) into first-class integrations.