diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4d5d0b9ea8..aa4e98e7ab 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -52,6 +52,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Lockr and Permutive SDK recognition now uses parsed vendor hostnames and SDK pathnames instead of searching the whole URL (#1199). The browser Lockr guard no longer replaces unrelated scripts that mention a Lockr host in their path or query, use a lookalike host, or serve a non-SDK resource from a Lockr host. Query strings and fragments no longer prevent SDK recognition in the server matchers, the browser Permutive guard, or the browser Lockr guard on `identity.loc.kr`. Matching URLs use the existing configured-SDK routes; their original query and fragment are not forwarded upstream. Server matching trims leading and trailing C0 controls and spaces, removes tab, CR, and LF, and accepts backslashes as authority separators. It no longer recognizes attribute values that contain a NUL or that write slashes as character references such as `/`, so markup like that can load the SDK from the vendor host.
 - `rewrite.exclude_domains` matching is now case-insensitive and ignores surrounding whitespace. Entries written with uppercase letters previously never matched and now take effect, so those hosts stop being proxied and click-wrapped, and `/first-party/sign` now rejects them with `502`; it used to sign them, or return `403` when the host was also outside `proxy.allowed_domains`. Empty and bare `"*"` `exclude_domains` entries, which never matched a host, are dropped at load with a warning, and other entries that can never match a host are logged with a warning. Absolute `http(s)` creative URLs that cannot be parsed (for example, a host containing a space) are now left untouched; previously the trimmed value was written back re-quoted (with `https:` prepended to `//` input, so `src=" //example.com invalid/x "` became `https://example.com invalid/x`), an unparseable quoted URL in `<style>` or `style=` was re-quoted through `cssparser::serialize_string`, and a link also gained `data-tsclick`. `/first-party/sign` now answers unparseable `http(s)` input with `unsupported url` instead of `invalid url`; both map to `502`. The first `ts config push` after upgrading shows a one-time `exclude_domains` diff for configs with mixed-case, padded, empty or bare `"*"` entries. Audit `exclude_domains` for mixed-case entries before upgrading.
 - Next.js and Google Tag Manager script rewrites now compose in streamed HTML instead of overwriting each other, preserving Pages Router JSON and App Router Flight payloads with recomputed decoded `T`-record lengths. GTM/GA Flight rewrites require both integrations to be enabled. Buffering is bounded and per document; an uncaptured data head (including inert text quoting a Flight push), an unsupported or binary push, or a size limit keeps the remaining Flight stream raw and restores queued originals, but cannot undo already-streamed rewrites. Complete serialized form state does not disable later rewriting, foreign property references no longer hide a later qualified Flight push, and placeholder-stage document fallback emits a reason-bearing warning without source data (#1206, #1207, #1208).
 - Publisher HTML is now processed when the request carries its host only in the URI (absolute-form HTTP/1.1, or HTTP/2 without a usable `Host`), instead of being returned unmodified with an "Empty request host" warning (#1118). URI userinfo is excluded from rewritten URLs, while ports and IPv6 brackets are preserved.
diff --git a/crates/trusted-server-cli/tests/proxy_trusted_server.rs b/crates/trusted-server-cli/tests/proxy_trusted_server.rs
index 39f0d3dd1b..a9dcccc15d 100644
--- a/crates/trusted-server-cli/tests/proxy_trusted_server.rs
+++ b/crates/trusted-server-cli/tests/proxy_trusted_server.rs
@@ -341,6 +341,8 @@ async fn send(
     request: Request<Full<Bytes>>,
 ) -> (StatusCode, HeaderMap, Bytes) {
     tokio::time::timeout(Duration::from_secs(5), async {
+        // Collecting the previous body can finish before Hyper's connection
+        // task makes the HTTP/1 dispatcher ready for another request.
         browser
             .ready()
             .await
diff --git a/crates/trusted-server-core/src/integrations/lockr.rs b/crates/trusted-server-core/src/integrations/lockr.rs
index 88c20fcc33..2bfc8a149d 100644
--- a/crates/trusted-server-core/src/integrations/lockr.rs
+++ b/crates/trusted-server-core/src/integrations/lockr.rs
@@ -19,6 +19,7 @@ use validator::Validate;
 
 use crate::constants::INTERNAL_HEADERS;
 use crate::error::TrustedServerError;
+use crate::integrations::sdk_url::parse_sdk_network_url;
 use crate::integrations::{
     AttributeRewriteAction, INTEGRATION_MAX_BODY_BYTES, IntegrationAttributeContext,
     IntegrationAttributeRewriter, IntegrationEndpoint, IntegrationProxy, IntegrationRegistration,
@@ -98,10 +99,15 @@ impl LockrIntegration {
 
     /// Check if a URL is a Lockr SDK URL.
     fn is_lockr_sdk_url(&self, url: &str) -> bool {
-        let lower = url.to_ascii_lowercase();
-        (lower.contains("aim.loc.kr") || lower.contains("identity.loc.kr"))
-            && lower.contains("identity-lockr")
-            && lower.ends_with(".js")
+        // Keep browser/Rust cases in crates/trusted-server-js/lib/test/fixtures/sdk-url-ownership.json aligned.
+        let Some(parsed) = parse_sdk_network_url(url) else {
+            return false;
+        };
+        let host = parsed.host_str().unwrap_or_default();
+        let path = parsed.path().to_ascii_lowercase();
+        matches!(host, "aim.loc.kr" | "identity.loc.kr")
+            && path.contains("identity-lockr")
+            && path.ends_with(".js")
     }
 
     /// Handle SDK serving — fetch from Lockr CDN and serve through first-party domain.
@@ -436,6 +442,9 @@ mod tests {
     use edgezero_core::http::Method as HttpMethod;
     use serde_json::json;
 
+    use crate::integrations::sdk_url_test_support::{
+        assert_sdk_html_attribute_rewrite, assert_sdk_url_rewrite, sdk_url_cases,
+    };
     use crate::platform::test_support::{StubHttpClient, build_services_with_http_client};
     use crate::test_support::tests::create_test_settings;
 
@@ -462,6 +471,33 @@ mod tests {
         }
     }
 
+    #[test]
+    fn sdk_url_ownership_matches_shared_corpus() {
+        let integration = LockrIntegration::new(test_config());
+
+        for case in sdk_url_cases() {
+            let matches = case.owner.as_deref() == Some(LOCKR_INTEGRATION_ID);
+            assert_eq!(
+                integration.is_lockr_sdk_url(&case.url),
+                matches,
+                "should match expected lockr ownership for {}: {}",
+                case.name,
+                case.url
+            );
+
+            assert_sdk_url_rewrite(
+                integration.as_ref(),
+                &case,
+                "https://edge.example.com/integrations/lockr/sdk",
+            );
+            assert_sdk_html_attribute_rewrite(
+                integration.as_ref(),
+                &case,
+                "https://edge.example.com/integrations/lockr/sdk",
+            );
+        }
+    }
+
     #[test]
     fn test_lockr_sdk_url_detection() {
         let integration = LockrIntegration::new(test_config());
@@ -471,6 +507,16 @@ mod tests {
         assert!(integration.is_lockr_sdk_url("https://aim.loc.kr/identity-lockr-trust-server.js"));
         assert!(integration.is_lockr_sdk_url("https://identity.loc.kr/identity-lockr-v2.0.js"));
 
+        // Hosts that only end with a Lockr SDK host are different hosts.
+        assert!(
+            !integration.is_lockr_sdk_url("https://notaim.loc.kr/identity-lockr.js"), // allow-domain: notaim.loc.kr
+            "should require an exact aim.loc.kr hostname"
+        );
+        assert!(
+            !integration.is_lockr_sdk_url("https://notidentity.loc.kr/identity-lockr.js"), // allow-domain: notidentity.loc.kr
+            "should require an exact identity.loc.kr hostname"
+        );
+
         // Should not match non-SDK resources on Lockr domains
         assert!(
             !integration.is_lockr_sdk_url("https://aim.loc.kr/pixel.gif"),
diff --git a/crates/trusted-server-core/src/integrations/mod.rs b/crates/trusted-server-core/src/integrations/mod.rs
index 9e3840b3fb..953db44931 100644
--- a/crates/trusted-server-core/src/integrations/mod.rs
+++ b/crates/trusted-server-core/src/integrations/mod.rs
@@ -25,6 +25,9 @@ pub mod osano;
 pub mod permutive;
 pub mod prebid;
 mod registry;
+mod sdk_url;
+#[cfg(test)]
+mod sdk_url_test_support;
 pub mod sourcepoint;
 pub mod testlight;
 
diff --git a/crates/trusted-server-core/src/integrations/permutive.rs b/crates/trusted-server-core/src/integrations/permutive.rs
index b59f4e3820..9a6b0249cd 100644
--- a/crates/trusted-server-core/src/integrations/permutive.rs
+++ b/crates/trusted-server-core/src/integrations/permutive.rs
@@ -15,6 +15,7 @@ use validator::Validate;
 
 use crate::constants::INTERNAL_HEADERS;
 use crate::error::TrustedServerError;
+use crate::integrations::sdk_url::parse_sdk_network_url;
 use crate::integrations::{
     AttributeRewriteAction, INTEGRATION_MAX_BODY_BYTES, IntegrationAttributeContext,
     IntegrationAttributeRewriter, IntegrationEndpoint, IntegrationProxy, IntegrationRegistration,
@@ -99,9 +100,17 @@ impl PermutiveIntegration {
 
     /// Check if a URL is a Permutive SDK URL.
     fn is_permutive_sdk_url(&self, url: &str) -> bool {
-        let lower = url.to_ascii_lowercase();
-        (lower.contains(".edge.permutive.app") || lower.contains("cdn.permutive.com"))
-            && lower.ends_with("-web.js")
+        // Keep browser/Rust cases in crates/trusted-server-js/lib/test/fixtures/sdk-url-ownership.json aligned.
+        let Some(parsed) = parse_sdk_network_url(url) else {
+            return false;
+        };
+        let host = parsed.host_str().unwrap_or_default();
+        let path = parsed.path().to_ascii_lowercase();
+        (host == "cdn.permutive.com"
+            || host
+                .strip_suffix(".edge.permutive.app")
+                .is_some_and(|subdomain| !subdomain.is_empty()))
+            && path.ends_with("-web.js")
     }
 
     /// Handle SDK serving - fetch from Permutive CDN and serve through first-party domain.
@@ -474,9 +483,44 @@ mod tests {
     use std::sync::Arc;
 
     use super::*;
+    use crate::integrations::sdk_url_test_support::{
+        assert_sdk_html_attribute_rewrite, assert_sdk_url_rewrite, sdk_url_cases,
+    };
     use crate::platform::test_support::{StubHttpClient, build_services_with_http_client};
     use crate::test_support::tests::create_test_settings;
 
+    #[test]
+    fn sdk_url_ownership_matches_shared_corpus() {
+        let integration = PermutiveIntegration::new(PermutiveConfig {
+            enabled: true,
+            organization_id: "example".to_string(),
+            workspace_id: "workspace".to_string(),
+            project_id: String::new(),
+            api_endpoint: default_api_endpoint(),
+            secure_signals_endpoint: default_secure_signals_endpoint(),
+            cache_ttl_seconds: 3600,
+            rewrite_sdk: true,
+        });
+
+        for case in sdk_url_cases() {
+            let matches = case.owner.as_deref() == Some(PERMUTIVE_INTEGRATION_ID);
+            assert_eq!(
+                integration.is_permutive_sdk_url(&case.url),
+                matches,
+                "should match expected permutive ownership for {}: {}",
+                case.name,
+                case.url
+            );
+
+            assert_sdk_url_rewrite(integration.as_ref(), &case, "/integrations/permutive/sdk");
+            assert_sdk_html_attribute_rewrite(
+                integration.as_ref(),
+                &case,
+                "/integrations/permutive/sdk",
+            );
+        }
+    }
+
     #[test]
     fn test_permutive_sdk_url_generation() {
         let config = PermutiveConfig {
diff --git a/crates/trusted-server-core/src/integrations/sdk_url.rs b/crates/trusted-server-core/src/integrations/sdk_url.rs
new file mode 100644
index 0000000000..5713163556
--- /dev/null
+++ b/crates/trusted-server-core/src/integrations/sdk_url.rs
@@ -0,0 +1,36 @@
+//! Shared input policy for SDK URL ownership checks.
+
+use std::borrow::Cow;
+
+use url::Url;
+
+/// Parse an HTTP(S) SDK URL with an explicit authority, or a protocol-relative URL.
+///
+/// Applies browser C0/space trimming, removes tab/CR/LF, and accepts backslash
+/// authority separators. Literal NULs, relative paths, and base-dependent shorthand
+/// stay unowned; HTML replaces NULs rather than treating them as URL whitespace.
+/// Browser/Rust ownership cases live in crates/trusted-server-js/lib/test/fixtures/sdk-url-ownership.json.
+pub(super) fn parse_sdk_network_url(url: &str) -> Option<Url> {
+    if url.contains('\0') {
+        return None;
+    }
+    let trimmed = url.trim_matches(|character| character <= '\u{20}');
+    let value = if trimmed.contains(['\t', '\n', '\r']) {
+        Cow::Owned(trimmed.replace(['\t', '\n', '\r'], ""))
+    } else {
+        Cow::Borrowed(trimmed)
+    };
+    let has_authority = |value: &str| matches!(value.as_bytes(), [b'/' | b'\\', b'/' | b'\\', ..]);
+    let parsed = if has_authority(&value) {
+        Url::parse(&format!("https:{value}"))
+    } else {
+        let (scheme, remainder) = value.split_once(':')?;
+        if !(scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https"))
+            || !has_authority(remainder)
+        {
+            return None;
+        }
+        Url::parse(&value)
+    };
+    parsed.ok()
+}
diff --git a/crates/trusted-server-core/src/integrations/sdk_url_test_support.rs b/crates/trusted-server-core/src/integrations/sdk_url_test_support.rs
new file mode 100644
index 0000000000..a1d504468e
--- /dev/null
+++ b/crates/trusted-server-core/src/integrations/sdk_url_test_support.rs
@@ -0,0 +1,126 @@
+//! Shared SDK URL corpus and attribute-rewrite assertions.
+
+use lol_html::{RewriteStrSettings, element, rewrite_str};
+use serde::Deserialize;
+
+use super::{AttributeRewriteAction, IntegrationAttributeContext, IntegrationAttributeRewriter};
+
+/// One raw URL and its expected integration owner from the shared corpus.
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct SdkUrlCase {
+    /// Descriptive case name for assertion failures.
+    pub(super) name: String,
+    /// Input before browser DOM URL resolution.
+    pub(super) url: String,
+    /// Expected integration ID, or none for an unowned URL.
+    pub(super) owner: Option<String>,
+    /// Owner once `lol_html` has read the attribute, when that differs from `owner`.
+    pub(super) server_html_owner: Option<String>,
+}
+
+/// Load the URL ownership cases used by both Rust and browser tests.
+///
+/// # Panics
+///
+/// Panics if the committed fixture is invalid.
+pub(super) fn sdk_url_cases() -> Vec<SdkUrlCase> {
+    serde_json::from_str(include_str!(
+        "../../../trusted-server-js/lib/test/fixtures/sdk-url-ownership.json"
+    ))
+    .expect("should parse shared SDK URL ownership corpus")
+}
+
+/// Assert SDK rewriting for both script and link attribute contexts.
+///
+/// # Panics
+///
+/// Panics if the rewrite result disagrees with the corpus owner and SDK route.
+pub(super) fn assert_sdk_url_rewrite(
+    integration: &dyn IntegrationAttributeRewriter,
+    case: &SdkUrlCase,
+    sdk_path: &str,
+) {
+    let expected = if case.owner.as_deref() == Some(integration.integration_id()) {
+        AttributeRewriteAction::Replace(sdk_path.to_string())
+    } else {
+        AttributeRewriteAction::Keep
+    };
+    for (attribute, element) in [("src", "script"), ("href", "link")] {
+        assert!(
+            integration.handles_attribute(attribute),
+            "should route {attribute} to the {} rewriter",
+            integration.integration_id()
+        );
+        let context = IntegrationAttributeContext {
+            attribute_name: attribute,
+            element_name: element,
+            request_host: "edge.example.com",
+            request_scheme: "https",
+            origin_host: "origin.example.com",
+        };
+        assert_eq!(
+            integration.rewrite(attribute, &case.url, &context),
+            expected,
+            "should apply expected {} {attribute} rewrite for {}: {}",
+            integration.integration_id(),
+            case.name,
+            case.url
+        );
+    }
+}
+
+/// Assert the SDK rewrite of a corpus URL after `lol_html` reads it from markup.
+///
+/// # Panics
+///
+/// Panics if HTML processing fails or the output disagrees with the server-side owner.
+pub(super) fn assert_sdk_html_attribute_rewrite(
+    integration: &dyn IntegrationAttributeRewriter,
+    case: &SdkUrlCase,
+    sdk_path: &str,
+) {
+    let owner = case.server_html_owner.as_ref().or(case.owner.as_ref());
+    let owned = owner.map(String::as_str) == Some(integration.integration_id());
+    for (attribute, tag) in [("src", "script"), ("href", "link")] {
+        let html = format!(
+            "<{tag} {attribute}=\"{}\"></{tag}>",
+            case.url.replace('"', "&quot;")
+        );
+        let context = IntegrationAttributeContext {
+            attribute_name: attribute,
+            element_name: tag,
+            request_host: "edge.example.com",
+            request_scheme: "https",
+            origin_host: "origin.example.com",
+        };
+        let output = rewrite_str(
+            &html,
+            RewriteStrSettings {
+                element_content_handlers: vec![element!(tag, |element| {
+                    let value = element
+                        .get_attribute(attribute)
+                        .expect("should read the SDK URL attribute");
+                    if let AttributeRewriteAction::Replace(next) =
+                        integration.rewrite(attribute, &value, &context)
+                    {
+                        element.set_attribute(attribute, &next)?;
+                    }
+                    Ok(())
+                })],
+                ..RewriteStrSettings::default()
+            },
+        )
+        .expect("should process SDK URL markup");
+        let expected = if owned {
+            format!("<{tag} {attribute}=\"{sdk_path}\"></{tag}>")
+        } else {
+            html
+        };
+        assert_eq!(
+            output, expected,
+            "should apply expected HTML {attribute} rewrite for {}",
+            case.name
+        );
+    }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/lockr/script_guard.ts b/crates/trusted-server-js/lib/src/integrations/lockr/script_guard.ts
index 77a6363677..559a0b8ef4 100644
--- a/crates/trusted-server-js/lib/src/integrations/lockr/script_guard.ts
+++ b/crates/trusted-server-js/lib/src/integrations/lockr/script_guard.ts
@@ -1,4 +1,5 @@
 import { createScriptGuard } from '../../shared/script_guard';
+import { parseSdkNetworkUrl } from '../../shared/sdk_url';
 
 /**
  * Lockr SDK Script Interception Guard
@@ -17,28 +18,18 @@ import { createScriptGuard } from '../../shared/script_guard';
 
 /**
  * Check if a URL is a Lockr SDK URL.
- * Matches the logic from lockr.rs:79-86
+ * Browser/Rust ownership cases live in test/fixtures/sdk-url-ownership.json.
  */
 function isLockrSdkUrl(url: string): boolean {
-  if (!url) return false;
-
-  const lower = url.toLowerCase();
-
-  // Check for aim.loc.kr domain
-  if (lower.includes('aim.loc.kr')) {
-    return true;
-  }
-
-  // Check for identity.loc.kr with identity-lockr and .js extension
-  if (
-    lower.includes('identity.loc.kr') &&
-    lower.includes('identity-lockr') &&
-    lower.endsWith('.js')
-  ) {
-    return true;
-  }
-
-  return false;
+  const parsed = parseSdkNetworkUrl(url);
+  if (!parsed) return false;
+
+  const path = parsed.pathname.toLowerCase();
+  return (
+    (parsed.hostname === 'aim.loc.kr' || parsed.hostname === 'identity.loc.kr') &&
+    path.includes('identity-lockr') &&
+    path.endsWith('.js')
+  );
 }
 
 const guard = createScriptGuard({
diff --git a/crates/trusted-server-js/lib/src/integrations/permutive/script_guard.ts b/crates/trusted-server-js/lib/src/integrations/permutive/script_guard.ts
index 31891db9bb..f9885792a9 100644
--- a/crates/trusted-server-js/lib/src/integrations/permutive/script_guard.ts
+++ b/crates/trusted-server-js/lib/src/integrations/permutive/script_guard.ts
@@ -1,16 +1,20 @@
 import { createScriptGuard } from '../../shared/script_guard';
+import { parseSdkNetworkUrl } from '../../shared/sdk_url';
 
 /**
  * Check if a URL is a Permutive SDK URL.
- * Matches the logic from permutive.rs:97-101
+ * Browser/Rust ownership cases live in test/fixtures/sdk-url-ownership.json.
  */
 function isPermutiveSdkUrl(url: string): boolean {
-  if (!url) return false;
+  const parsed = parseSdkNetworkUrl(url);
+  if (!parsed) return false;
 
-  const lower = url.toLowerCase();
+  const host = parsed.hostname;
+  const edgeSuffix = '.edge.permutive.app';
   return (
-    (lower.includes('.edge.permutive.app') || lower.includes('cdn.permutive.com')) &&
-    lower.endsWith('-web.js')
+    (host === 'cdn.permutive.com' ||
+      (host.endsWith(edgeSuffix) && host.length > edgeSuffix.length)) &&
+    parsed.pathname.toLowerCase().endsWith('-web.js')
   );
 }
 
diff --git a/crates/trusted-server-js/lib/src/shared/sdk_url.ts b/crates/trusted-server-js/lib/src/shared/sdk_url.ts
new file mode 100644
index 0000000000..ab6fc04237
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/shared/sdk_url.ts
@@ -0,0 +1,20 @@
+/**
+ * Parse an HTTP(S) SDK URL with an explicit authority, or a protocol-relative URL.
+ *
+ * Uses the same C0/space, tab/CR/LF, and authority policy as Rust's SDK URL parser.
+ * Literal NULs, relative paths, and base-dependent shorthand stay unowned.
+ * Browser/Rust ownership cases live in test/fixtures/sdk-url-ownership.json.
+ */
+export function parseSdkNetworkUrl(url: string): URL | null {
+  // HTML replaces NULs rather than treating them as URL whitespace.
+  if (url.includes('\0')) return null;
+  // eslint-disable-next-line no-control-regex -- Match WHATWG C0 control and space trimming.
+  const value = url.replace(/^[\u0000-\u0020]+|[\u0000-\u0020]+$/g, '').replace(/[\t\n\r]/g, '');
+  if (!/^(?:https?:)?[/\\]{2}/i.test(value)) return null;
+
+  try {
+    return new URL(/^[/\\]{2}/.test(value) ? `https:${value}` : value);
+  } catch {
+    return null;
+  }
+}
diff --git a/crates/trusted-server-js/lib/test/fixtures/sdk-url-ownership.json b/crates/trusted-server-js/lib/test/fixtures/sdk-url-ownership.json
new file mode 100644
index 0000000000..d7f7545a37
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/fixtures/sdk-url-ownership.json
@@ -0,0 +1,537 @@
+[
+  {
+    "name": "Lockr aim SDK",
+    "url": "https://aim.loc.kr/identity-lockr-trust-server.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr identity SDK",
+    "url": "https://identity.loc.kr/identity-lockr-v2.0.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr aim query",
+    "url": "https://aim.loc.kr/identity-lockr-trust-server.js?v=2",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr identity query",
+    "url": "https://identity.loc.kr/identity-lockr.js?v=2",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr aim fragment",
+    "url": "https://aim.loc.kr/identity-lockr.js#sdk",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr identity fragment",
+    "url": "https://identity.loc.kr/identity-lockr.js#sdk",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr protocol relative",
+    "url": "//aim.loc.kr/identity-lockr.js?v=2#sdk",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr identity protocol relative",
+    "url": "//identity.loc.kr/identity-lockr.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr uppercase",
+    "url": "HTTPS://AIM.LOC.KR/IDENTITY-LOCKR.JS",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr HTTP port",
+    "url": "http://identity.loc.kr:8080/identity-lockr.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr ASCII whitespace",
+    "url": " \t\r\n\f\u000bhttps://aim.loc.kr/identity-lockr.js \t\r\n\f\u000b",
+    "owner": "lockr"
+  },
+  {
+    "name": "Lockr nested path family",
+    "url": "https://aim.loc.kr/sdk/identity-lockr-v3.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Permutive CDN SDK",
+    "url": "https://cdn.permutive.com/abc123-web.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive edge SDK",
+    "url": "https://example.edge.permutive.app/workspace-web.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive CDN query",
+    "url": "https://cdn.permutive.com/abc123-web.js?v=2",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive edge query",
+    "url": "https://example.edge.permutive.app/workspace-web.js?v=2",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive CDN fragment",
+    "url": "https://cdn.permutive.com/abc123-web.js#sdk",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive edge fragment",
+    "url": "https://example.edge.permutive.app/workspace-web.js#sdk",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive protocol relative",
+    "url": "//cdn.permutive.com/abc123-web.js?v=2#sdk",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive edge protocol relative",
+    "url": "//example.edge.permutive.app/workspace-web.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive uppercase",
+    "url": "HTTPS://EXAMPLE.EDGE.PERMUTIVE.APP/ABC-WEB.JS",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive HTTP port",
+    "url": "http://cdn.permutive.com:8080/abc123-web.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive ASCII whitespace",
+    "url": " \t\r\n\f\u000b//cdn.permutive.com/abc123-web.js \t\r\n\f\u000b",
+    "owner": "permutive"
+  },
+  {
+    "name": "GPT canonical",
+    "url": "https://securepubads.g.doubleclick.net/tag/js/gpt.js",
+    "owner": "gpt"
+  },
+  {
+    "name": "GTM canonical",
+    "url": "https://www.googletagmanager.com/gtm.js?id=GTM-TEST",
+    "owner": "google_tag_manager"
+  },
+  {
+    "name": "DataDome canonical",
+    "url": "https://js.datadome.co/tags.js",
+    "owner": "datadome"
+  },
+  {
+    "name": "Sourcepoint canonical",
+    "url": "https://cdn.privacy-mgmt.com/unified/wrapperMessagingWithoutDetection.js",
+    "owner": "sourcepoint"
+  },
+  {
+    "name": "GPT query mentions Lockr",
+    "url": "https://securepubads.g.doubleclick.net/tag/js/gpt.js?ref=aim.loc.kr",
+    "owner": "gpt"
+  },
+  {
+    "name": "GTM query mentions Lockr",
+    "url": "https://www.googletagmanager.com/gtm.js?id=GTM-TEST&ref=aim.loc.kr",
+    "owner": "google_tag_manager"
+  },
+  {
+    "name": "DataDome query mentions Lockr",
+    "url": "https://js.datadome.co/tags.js?ref=aim.loc.kr",
+    "owner": "datadome"
+  },
+  {
+    "name": "Sourcepoint query mentions Lockr",
+    "url": "https://cdn.privacy-mgmt.com/wrapper.js?ref=aim.loc.kr",
+    "owner": "sourcepoint"
+  },
+  {
+    "name": "GPT path mentions Permutive",
+    "url": "https://securepubads.g.doubleclick.net/cdn.permutive.com/app-web.js",
+    "owner": "gpt"
+  },
+  {
+    "name": "GTM query mentions Permutive",
+    "url": "https://www.googletagmanager.com/gtm.js?id=GTM-TEST&ref=cdn.permutive.com/app-web.js",
+    "owner": "google_tag_manager"
+  },
+  {
+    "name": "DataDome path mentions Permutive",
+    "url": "https://js.datadome.co/cdn.permutive.com/app-web.js",
+    "owner": "datadome"
+  },
+  {
+    "name": "Sourcepoint path mentions Permutive",
+    "url": "https://cdn.privacy-mgmt.com/cdn.permutive.com/app-web.js",
+    "owner": "sourcepoint"
+  },
+  {
+    "name": "loader query mentions Lockr",
+    "url": "https://ads.example.com/loader.js?page=https%3A%2F%2Fpublisher.example.com%2F%3Futm_source%3Daim.loc.kr",
+    "owner": null
+  },
+  {
+    "name": "Lockr prefix host",
+    "url": "https://aim.loc.kr.example.com/loader.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr SDK prefix host",
+    "url": "https://aim.loc.kr.example.com/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr identity lookalike",
+    "url": "https://identity.loc.kr.example.com/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr host substring",
+    "url": "https://notaim.loc.kr.example.com/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr host in path",
+    "url": "https://static.example.com/aim.loc.kr/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr host in query",
+    "url": "https://static.example.com/identity-lockr.js?ref=aim.loc.kr",
+    "owner": null
+  },
+  {
+    "name": "Lockr other script",
+    "url": "https://aim.loc.kr/some-other-script.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr other identity script",
+    "url": "https://identity.loc.kr/some-other-script.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr wrong extension",
+    "url": "https://aim.loc.kr/identity-lockr.css",
+    "owner": null
+  },
+  {
+    "name": "Lockr query spoofs extension",
+    "url": "https://identity.loc.kr/identity-lockr.css?fake=.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr query spoofs SDK name",
+    "url": "https://identity.loc.kr/loader.js?file=identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr trailing path",
+    "url": "https://aim.loc.kr/identity-lockr.js/other",
+    "owner": null
+  },
+  {
+    "name": "Lockr userinfo lookalike",
+    "url": "https://aim.loc.kr@static.example.com/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr trailing dot",
+    "url": "https://aim.loc.kr./identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr encoded SDK path",
+    "url": "https://aim.loc.kr/%69dentity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr encoded extension",
+    "url": "https://aim.loc.kr/identity-lockr%2ejs",
+    "owner": null
+  },
+  {
+    "name": "Permutive prefix host",
+    "url": "https://cdn.permutive.com.example.com/abc123-web.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive host substring",
+    "url": "https://notcdn.permutive.com.example.com/abc123-web.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive host in path",
+    "url": "https://static.example.com/mirror/cdn.permutive.com/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive edge lookalike",
+    "url": "https://example.edge.permutive.app.example.com/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive edge in path",
+    "url": "https://static.example.com/example.edge.permutive.app/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive bare edge host",
+    "url": "https://edge.permutive.app/abc123-web.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive empty edge subdomain",
+    "url": "https://.edge.permutive.app/abc123-web.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive other script",
+    "url": "https://cdn.permutive.com/other.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive edge other script",
+    "url": "https://example.edge.permutive.app/other.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive query spoofs extension",
+    "url": "https://cdn.permutive.com/other.js?fake=-web.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive userinfo lookalike",
+    "url": "https://cdn.permutive.com@static.example.com/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive trailing dot",
+    "url": "https://cdn.permutive.com./app-web.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive encoded extension",
+    "url": "https://cdn.permutive.com/app-web%2ejs",
+    "owner": null
+  },
+  {
+    "name": "already proxied GPT",
+    "url": "http://localhost:3000/integrations/gpt/tag/js/gpt.js?ref=aim.loc.kr",
+    "owner": null
+  },
+  {
+    "name": "relative proxied GPT",
+    "url": "/integrations/gpt/tag/js/gpt.js?ref=cdn.permutive.com/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "relative path mentions Lockr",
+    "url": "/aim.loc.kr/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "relative SDK path",
+    "url": "identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "bare Lockr hostname",
+    "url": "aim.loc.kr/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "bare Permutive hostname",
+    "url": "cdn.permutive.com/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "empty input",
+    "url": "",
+    "owner": null
+  },
+  {
+    "name": "malformed Lockr authority",
+    "url": "https://[aim.loc.kr/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "malformed Permutive authority",
+    "url": "https://[cdn.permutive.com/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "malformed URL",
+    "url": "https://[",
+    "owner": null
+  },
+  {
+    "name": "Lockr non-network scheme",
+    "url": "ftp://aim.loc.kr/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive non-network scheme",
+    "url": "ftp://cdn.permutive.com/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "embedded URL in data",
+    "url": "data:text/plain,https://aim.loc.kr/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr shorthand scheme",
+    "url": "https:aim.loc.kr/identity-lockr.js",
+    "owner": null,
+    "insertionOwner": "lockr"
+  },
+  {
+    "name": "Permutive shorthand scheme",
+    "url": "https:/cdn.permutive.com/app-web.js",
+    "owner": null,
+    "insertionOwner": "permutive"
+  },
+  {
+    "name": "Lockr BOM whitespace",
+    "url": "\ufeffhttps://aim.loc.kr/identity-lockr.js",
+    "owner": null,
+    "serverHtmlOwner": "lockr"
+  },
+  {
+    "name": "Permutive NEL whitespace",
+    "url": "\u0085https://cdn.permutive.com/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "unrelated script",
+    "url": "https://static.example.com/loader.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr leading C0 controls",
+    "url": "\u0001\u001fhttps://aim.loc.kr/identity-lockr.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Permutive leading C0 controls",
+    "url": "\u0001\u001fhttps://cdn.permutive.com/app-web.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Lockr trailing C0 controls",
+    "url": "https://aim.loc.kr/identity-lockr.js\u0001\u001f",
+    "owner": "lockr"
+  },
+  {
+    "name": "Permutive trailing C0 controls",
+    "url": "https://cdn.permutive.com/app-web.js\u0001\u001f",
+    "owner": "permutive"
+  },
+  {
+    "name": "Lockr tabs in scheme",
+    "url": "ht\ttps://aim.loc.kr/identity-lockr.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Permutive newline in scheme",
+    "url": "ht\ntps://cdn.permutive.com/app-web.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Permutive CR in scheme",
+    "url": "ht\rtps://cdn.permutive.com/app-web.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Lockr CR between slashes",
+    "url": "https:/\r/aim.loc.kr/identity-lockr.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Permutive tab between slashes",
+    "url": "https:/\t/cdn.permutive.com/app-web.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Lockr newline after hostname",
+    "url": "https://aim.loc.kr\n/identity-lockr.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Permutive CR in pathname",
+    "url": "https://cdn.permutive.com/app-\rweb.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Lockr backslash authority",
+    "url": "https:\\\\aim.loc.kr/identity-lockr.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Permutive mixed slash authority",
+    "url": "https:/\\cdn.permutive.com/app-web.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Lockr backslash protocol relative",
+    "url": "\\\\aim.loc.kr/identity-lockr.js",
+    "owner": "lockr"
+  },
+  {
+    "name": "Permutive mixed protocol relative",
+    "url": "\\/cdn.permutive.com/app-web.js",
+    "owner": "permutive"
+  },
+  {
+    "name": "Lockr normalized userinfo lookalike",
+    "url": "ht\ttps:/\\aim.loc.kr@static.example.com/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive normalized lookalike",
+    "url": "ht\ntps:\\\\cdn.permutive.com.example.com/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr normalized host in path",
+    "url": "ht\ttps:/\\static.example.com/aim.loc.kr/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive normalized host in query",
+    "url": "ht\ttps:/\\static.example.com/app-web.js?ref=cdn.permutive.com",
+    "owner": null
+  },
+  {
+    "name": "Lockr internal C0 control",
+    "url": "htt\u0001ps://aim.loc.kr/identity-lockr.js",
+    "owner": null
+  },
+  {
+    "name": "Permutive internal C0 control",
+    "url": "https://cdn.permutive.com\u001f/app-web.js",
+    "owner": null
+  },
+  {
+    "name": "Lockr leading NUL differs in HTML and URL properties",
+    "url": "\u0000https://aim.loc.kr/identity-lockr.js",
+    "owner": null,
+    "insertionOwner": "lockr"
+  },
+  {
+    "name": "Permutive trailing NUL differs in HTML and URL properties",
+    "url": "https://cdn.permutive.com/app-web.js\u0000",
+    "owner": null,
+    "insertionOwner": "permutive"
+  }
+]
diff --git a/crates/trusted-server-js/lib/test/integrations/lockr/script_guard.test.ts b/crates/trusted-server-js/lib/test/integrations/lockr/script_guard.test.ts
index 2f53c06b27..a32fae8c0e 100644
--- a/crates/trusted-server-js/lib/test/integrations/lockr/script_guard.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/lockr/script_guard.test.ts
@@ -67,6 +67,20 @@ describe('Lockr SDK Script Interception Guard', () => {
   });
 
   describe('appendChild interception', () => {
+    it.each([
+      'https://notaim.loc.kr/identity-lockr.js', // allow-domain: notaim.loc.kr
+      'https://notidentity.loc.kr/identity-lockr.js', // allow-domain: notidentity.loc.kr
+    ])('should require an exact Lockr hostname for %s', (url) => {
+      installLockrGuard();
+
+      const script = document.createElement('script');
+      script.setAttribute('src', url);
+      document.head.appendChild(script);
+
+      expect(script.getAttribute('src')).toBe(url);
+      script.remove();
+    });
+
     it('should rewrite Lockr SDK URL from aim.loc.kr', () => {
       installLockrGuard();
 
diff --git a/crates/trusted-server-js/lib/test/integrations/lockr/url_collision.test.ts b/crates/trusted-server-js/lib/test/integrations/lockr/url_collision.test.ts
new file mode 100644
index 0000000000..92f8a54f3e
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/lockr/url_collision.test.ts
@@ -0,0 +1,149 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  installDataDomeGuard,
+  resetGuardState as resetDataDomeGuard,
+} from '../../../src/integrations/datadome/script_guard';
+import {
+  installGtmGuard,
+  resetGuardState as resetGtmGuard,
+} from '../../../src/integrations/google_tag_manager/script_guard';
+import {
+  installGptGuard,
+  resetGuardState as resetGptGuard,
+} from '../../../src/integrations/gpt/script_guard';
+import {
+  installLockrGuard,
+  resetGuardState as resetLockrGuard,
+} from '../../../src/integrations/lockr/script_guard';
+import {
+  installPermutiveGuard,
+  resetGuardState as resetPermutiveGuard,
+} from '../../../src/integrations/permutive/script_guard';
+import {
+  installSourcepointGuard,
+  resetGuardState as resetSourcepointGuard,
+} from '../../../src/integrations/sourcepoint/script_guard';
+import {
+  type DomInsertionHandler,
+  resetDomInsertionDispatcherForTests,
+} from '../../../src/shared/dom_insertion_dispatcher';
+import fixture from '../../fixtures/sdk-url-ownership.json';
+
+interface UrlCase {
+  name: string;
+  url: string;
+  owner: string | null;
+  insertionOwner?: string;
+}
+
+const corpus: UrlCase[] = fixture;
+const nativeSetAttribute = Element.prototype.setAttribute;
+
+function resetGuards(): void {
+  resetGptGuard();
+  resetDataDomeGuard();
+  resetGtmGuard();
+  resetLockrGuard();
+  resetPermutiveGuard();
+  resetSourcepointGuard();
+  resetDomInsertionDispatcherForTests();
+}
+
+function dispatcherState(): { orderedHandlers: DomInsertionHandler[] } {
+  return (globalThis as Record<PropertyKey, unknown>)[
+    Symbol.for('trusted-server.domInsertionDispatcher')
+  ] as { orderedHandlers: DomInsertionHandler[] };
+}
+
+function expectedSrc({ url, owner, insertionOwner }: UrlCase): string {
+  // jsdom's http: page resolves https: shorthand to an absolute vendor URL before insertion;
+  // on an https: page the same input would resolve to a same-origin path and stay unowned.
+  const actualOwner = insertionOwner ?? owner;
+  if (!actualOwner) return url;
+  const origin = window.location.origin;
+  if (actualOwner === 'lockr' || actualOwner === 'permutive') {
+    return `${origin}/integrations/${actualOwner}/sdk`;
+  }
+  const parsed = new URL(url, window.location.href);
+  const prefix = actualOwner === 'sourcepoint' ? 'sourcepoint/cdn' : actualOwner;
+  const fragment = actualOwner === 'gpt' ? parsed.hash : '';
+  return `${origin}/integrations/${prefix}${parsed.pathname}${parsed.search}${fragment}`;
+}
+
+describe.each(['normal order', 'Lockr first'])('SDK URL ownership with %s', (order) => {
+  beforeEach(() => {
+    resetGuards();
+    installPermutiveGuard();
+    installLockrGuard();
+    installSourcepointGuard();
+    installGtmGuard();
+    installDataDomeGuard();
+    installGptGuard();
+
+    if (order === 'Lockr first') {
+      // Change real dispatch order, not installation order, only for this test.
+      dispatcherState().orderedHandlers.sort(
+        (left, right) => Number(right.id === 'lockr') - Number(left.id === 'lockr')
+      );
+    }
+  });
+
+  afterEach(resetGuards);
+
+  it('installs all six guards', () => {
+    expect(
+      dispatcherState()
+        .orderedHandlers.map(({ id }) => id)
+        .sort()
+    ).toEqual(['datadome', 'google_tag_manager', 'gpt', 'lockr', 'permutive', 'sourcepoint']);
+  });
+
+  it.each(corpus)('$name has only its expected raw claimant', ({ url, owner }) => {
+    const claimants = dispatcherState()
+      .orderedHandlers.filter((handler) => {
+        // Do not set src: GPT's assignment patch would hide its raw ownership.
+        const element = document.createElement('script');
+        return handler.handle({ element, kind: 'script', url });
+      })
+      .map(({ id }) => id);
+
+    expect(claimants).toEqual(owner ? [owner] : []);
+  });
+
+  describe.each(['script.src', 'native setAttribute'])('insertion through %s', (mode) => {
+    it.each(corpus)('leaves $name to its owner', (row) => {
+      const script = document.createElement('script');
+      if (mode === 'script.src') {
+        script.src = row.url;
+      } else {
+        nativeSetAttribute.call(script, 'src', row.url);
+      }
+      document.head.appendChild(script);
+      expect(script.getAttribute('src')).toBe(expectedSrc(row));
+      script.remove();
+    });
+  });
+
+  describe.each(['preload', 'prefetch'])('%s script links', (rel) => {
+    describe.each(['appendChild', 'insertBefore'])('through %s', (method) => {
+      const affectedCases = corpus.filter(
+        ({ owner }) => owner === null || owner === 'lockr' || owner === 'permutive'
+      );
+
+      it.each(affectedCases)('leaves $name to its owner', (row) => {
+        const link = document.createElement('link');
+        link.setAttribute('rel', rel);
+        link.setAttribute('as', 'script');
+        link.href = row.url;
+        if (method === 'appendChild') {
+          document.head.appendChild(link);
+        } else {
+          document.head.insertBefore(link, null);
+        }
+        expect(link.getAttribute('href')).toBe(expectedSrc(row));
+        link.remove();
+      });
+    });
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/shared/sdk_url.test.ts b/crates/trusted-server-js/lib/test/shared/sdk_url.test.ts
new file mode 100644
index 0000000000..add341dc0b
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/shared/sdk_url.test.ts
@@ -0,0 +1,71 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  installLockrGuard,
+  resetGuardState as resetLockrGuard,
+} from '../../src/integrations/lockr/script_guard';
+import {
+  installPermutiveGuard,
+  resetGuardState as resetPermutiveGuard,
+} from '../../src/integrations/permutive/script_guard';
+import { parseSdkNetworkUrl } from '../../src/shared/sdk_url';
+
+describe.each(['http:', 'https:'])('SDK shorthand with an %s document base', (baseScheme) => {
+  let base: HTMLBaseElement;
+  let container: HTMLDivElement;
+
+  beforeEach(() => {
+    base = document.createElement('base');
+    base.href = `${baseScheme}//publisher.example.com/page`;
+    document.head.appendChild(base);
+    container = document.createElement('div');
+    document.body.appendChild(container);
+    installLockrGuard();
+    installPermutiveGuard();
+  });
+
+  afterEach(() => {
+    resetLockrGuard();
+    resetPermutiveGuard();
+    container.remove();
+    base.remove();
+  });
+
+  it.each([
+    '\0https://aim.loc.kr/identity-lockr.js',
+    'https://aim.loc.kr/identity-lockr.js\0',
+    '\0https://cdn.permutive.com/app-web.js',
+    'https://cdn.permutive.com/app-web.js\0',
+  ])('leaves NUL-containing static markup unowned: %s', (raw) => {
+    expect(parseSdkNetworkUrl(raw)).toBeNull();
+    const template = document.createElement('template');
+    template.innerHTML = `<script src="${raw}"></script>`;
+    const script = template.content.querySelector('script')!;
+    const attribute = raw.split('\0').join('\ufffd');
+    expect(script.getAttribute('src')).toBe(attribute);
+
+    container.appendChild(script);
+    expect(script.getAttribute('src')).toBe(attribute);
+  });
+
+  it.each([
+    ['http:', 'aim.loc.kr/identity-lockr.js', 'lockr'],
+    ['https:', 'aim.loc.kr/identity-lockr.js', 'lockr'],
+    ['http:', 'cdn.permutive.com/app-web.js', 'permutive'],
+    ['https:', 'cdn.permutive.com/app-web.js', 'permutive'],
+  ])('resolves %s%s before the %s guard claims it', (scheme, path, owner) => {
+    const raw = `${scheme}${path}`;
+    expect(parseSdkNetworkUrl(raw)).toBeNull();
+
+    const script = document.createElement('script');
+    script.setAttribute('src', raw);
+    expect(script.src).toBe(
+      scheme === baseScheme ? `${baseScheme}//publisher.example.com/${path}` : `${scheme}//${path}`
+    );
+    container.appendChild(script);
+
+    expect(script.getAttribute('src')).toBe(
+      scheme === baseScheme ? raw : `${window.location.origin}/integrations/${owner}/sdk`
+    );
+  });
+});
diff --git a/docs/guide/integrations/lockr.md b/docs/guide/integrations/lockr.md
index f6831545f3..577f4e3395 100644
--- a/docs/guide/integrations/lockr.md
+++ b/docs/guide/integrations/lockr.md
@@ -47,6 +47,16 @@ For example, `/integrations/lockr/api/example?mode=test` forwards to `https://id
 
 ### SDK URL rewriting
 
+Server-side attribute rewriting and the browser script guard recognize only
+`aim.loc.kr` and `identity.loc.kr` URLs whose pathname contains
+`identity-lockr` and ends in `.js`, case-insensitively. Absolute HTTP(S) and
+protocol-relative URLs are supported. Other scripts on those hosts, lookalike
+hosts, and vendor names embedded in another URL's path or query are not claimed.
+
+Query strings and fragments do not prevent SDK recognition. Matching URLs use
+`/integrations/lockr/sdk`, which serves the configured `sdk_url`; the original
+query and fragment are not forwarded to upstream.
+
 With `rewrite_sdk = true`, the server rewrites matching Lockr SDK URLs in HTML to an absolute first-party URL ending in `/integrations/lockr/sdk`, using the request scheme and request host. An external `<base href>` does not redirect the rewritten SDK load to another origin.
 
 The Lockr browser module also intercepts matching dynamically inserted SDK scripts and preload or prefetch links. It rewrites them to `window.location.origin` plus `/integrations/lockr/sdk`. This interception remains active when `rewrite_sdk = false`; that setting controls server-side HTML attribute rewriting only.
diff --git a/docs/guide/integrations/permutive.md b/docs/guide/integrations/permutive.md
index e3c9258421..5ef3f947bf 100644
--- a/docs/guide/integrations/permutive.md
+++ b/docs/guide/integrations/permutive.md
@@ -35,6 +35,18 @@ rewrite_sdk = true
 - `GET/POST /integrations/permutive/sync/*` - ID synchronization
 - `GET /integrations/permutive/cdn/*` - CDN proxy
 
+## SDK URL rewriting
+
+Server-side attribute rewriting and the browser script guard recognize URLs on
+`cdn.permutive.com` or a subdomain of `edge.permutive.app` whose pathname ends in
+`-web.js`, case-insensitively. Absolute HTTP(S) and protocol-relative URLs are
+supported. The bare `edge.permutive.app` host, unrelated scripts, lookalike hosts,
+and vendor names embedded in another URL's path or query are not claimed.
+
+Query strings and fragments do not prevent SDK recognition. Matching URLs use
+`/integrations/permutive/sdk`, which serves the SDK selected by `organization_id`
+and `workspace_id`; the original query and fragment are not forwarded to upstream.
+
 ## Features
 
 - **Real-time segmentation**: Build audience cohorts in real-time
diff --git a/docs/superpowers/specs/2026-10-16-1199-sdk-url-ownership-design.md b/docs/superpowers/specs/2026-10-16-1199-sdk-url-ownership-design.md
new file mode 100644
index 0000000000..b2f5f1f411
--- /dev/null
+++ b/docs/superpowers/specs/2026-10-16-1199-sdk-url-ownership-design.md
@@ -0,0 +1,305 @@
+# Lockr and Permutive SDK URL ownership
+
+Status: Implemented and independently reviewed. Validation results are recorded below.
+
+Issue: [#1199](https://github.com/IABTechLab/trusted-server/issues/1199).
+
+## Problem and invariant
+
+The browser Lockr guard claims any script URL containing `aim.loc.kr`, including
+another vendor's query string, a path segment, or a lookalike hostname. The
+server matcher is narrower but still searches the entire string. Both Permutive
+matchers have the same host-substring defect. Full-string extension checks also
+miss genuine SDK URLs with query strings.
+
+With all six insertion guards installed, a GPT URL whose query mentions Lockr
+has two claimants. GPT rewrites `script.src` at assignment time, preserving the
+query. Lockr then claims the first-party URL at insertion and replaces GPT with
+the configured Lockr SDK. Changing dispatcher order cannot fix that path.
+
+```mermaid
+flowchart TD
+    A[GPT URL with Lockr text in its query] --> B[GPT src setter rewrites it first-party]
+    B --> C[Dispatcher offers the URL to insertion guards]
+    C --> D[Old Lockr substring matcher claims the query text]
+    D --> E[Configured Lockr SDK replaces GPT]
+```
+
+For the URL cases covered by this change, each original vendor URL must have
+exactly its expected claimant, or none for an unowned URL. Lockr and Permutive
+must make the same ownership decision in browser and Rust code. Recognition
+must depend on the parsed vendor hostname and SDK pathname, never a vendor name
+elsewhere in the URL.
+
+## Scope
+
+Change only the Lockr and Permutive URL matchers, their tests, the shared URL
+fixture, and the relevant integration documentation. Leave dispatcher behavior,
+other vendors' matching rules, logging, configuration, upstream SDK serving,
+and proxy destinations unchanged.
+
+Issue #1247 and Lockr initialization, polling, and shim behavior are excluded.
+In particular, do not edit `src/integrations/lockr/index.ts` in the JS library.
+
+## Matching contract
+
+Use the browser `URL` parser and Rust's existing `url::Url` dependency. Keep the
+input normalization and parsing policy shared within each language. Keep vendor
+hostname and pathname checks local to each integration. Do not redesign shared
+guards.
+
+### Input forms
+
+- Reject literal NULs in raw matcher inputs: HTML replaces them with U+FFFD,
+  unlike direct URL-property assignment, which can trim them. A leading NUL
+  makes the markup URL a publisher-relative path, so rejecting it matches the
+  browser. A NUL after the authority can leave the vendor hostname and SDK
+  pathname intact: markup `//aim.loc.kr/<NUL>identity-lockr.js` loads
+  `https://aim.loc.kr/%EF%BF%BDidentity-lockr.js` from the vendor, while server
+  matching leaves it unowned. That fail-open case is accepted.
+- Before checking the prefix, apply the browser URL preprocessing rules: trim
+  leading/trailing C0 controls and space (U+0001–U+0020), then remove tab, LF, and
+  CR throughout the input. Do not trim Unicode whitespace such as U+FEFF or
+  U+0085. These boundary cases remain in the shared corpus.
+- Server matching reads the attribute text lol_html returns, which differs from
+  what a browser resolves. Character references stay encoded, so
+  `https:&#x2F;&#x2F;aim.loc.kr&#x2F;identity-lockr.js` (mustache.js escapes `/`
+  this way) is not recognized and the browser loads the vendor SDK directly,
+  while `https://static.example.com&quest;@aim.loc.kr/identity-lockr.js` is
+  claimed although the browser loads another host. A leading U+FEFF is dropped,
+  so the "Lockr BOM whitespace" input is claimed in served HTML although a
+  browser resolves it as a publisher path. Reading decoded attribute values
+  belongs in the HTML processor, for every attribute rewriter, and is out of
+  scope here. Follow-up [#1480](https://github.com/IABTechLab/trusted-server/issues/1480)
+  tracks character-reference decoding and the leading-BOM discrepancy.
+- Require an explicit HTTP(S) scheme followed by two authority separators, or
+  two separators for a protocol-relative URL. Each separator may be `/` or `\`,
+  matching browser HTTP(S) backslash handling. Scheme matching is case-insensitive.
+  Leave path/query interpretation to the native parser rather than replacing
+  backslashes globally.
+- Reject base-dependent shorthand such as `https:host/path` and `https:/host/path`
+  in raw/server matching. Whether those forms resolve to a vendor host or a
+  publisher path depends on the document scheme and base URL. Dynamic insertion
+  guards can recognize the DOM-resolved URL, but static markup using these forms
+  can still load the vendor SDK directly.
+- Accept absolute HTTP and HTTPS URLs, including uppercase schemes and hosts.
+  After preprocessing and the authority check, malformed means rejected by the
+  native URL parser. Normal parser normalization is allowed, but runtimes differ:
+  Node and Chromium accept some punycode labels rejected by Rust's `url` crate
+  and jsdom; Chromium also normalizes some fullwidth-percent encoded-dot host
+  spellings rejected by those runtimes. These remain fail-open recognition
+  limits, not a promise to recognize every browser-loadable spelling.
+- Accept protocol-relative URLs by adding `https:` before parsing. Ownership is
+  independent of the page's HTTP/HTTPS scheme.
+- Reject empty, malformed, non-network, relative-path, and bare-host inputs.
+  A bare hostname is not an authority in a browser script attribute. The DOM
+  resolves relative attributes before insertion handlers see them; on a normal
+  publisher page they remain publisher URLs and must not be claimed.
+- Match the parsed hostname, not the authority string. A port does not change
+  hostname ownership. User information must not make an unrelated host match.
+- Use exact hostname boundaries. Do not strip a trailing dot or invent extra
+  hostname aliases. Rely on the parsers' normal hostname normalization.
+- Inspect the parsed pathname without percent-decoding it. Query strings and
+  fragments do not participate in SDK recognition. Preserve existing
+  case-insensitive ASCII SDK path matching.
+
+### Lockr
+
+The hostname must be exactly `aim.loc.kr` or `identity.loc.kr`. The lowercased
+pathname must contain `identity-lockr` and end in `.js`.
+
+This retains the existing Rust SDK path family, including versioned and
+trust-server SDK names, rather than introducing a new basename allowlist. It
+intentionally stops claiming unrelated scripts or assets on the Lockr host.
+
+### Permutive
+
+The hostname must be exactly `cdn.permutive.com`, or have a nonempty subdomain
+prefix before `.edge.permutive.app`. The lowercased pathname must end in
+`-web.js`. Neither the bare `edge.permutive.app` hostname nor a lookalike suffix
+such as `.edge.permutive.app.example.com` matches.
+
+### Rewriting and compatibility
+
+Recognition of query-bearing and fragment-bearing SDK URLs is new for the Rust
+Lockr matcher, browser Lockr on `identity.loc.kr`, and both Permutive matchers.
+Cover both Lockr hosts explicitly. Those URLs must now take the existing proxy
+route. This does not forward their query or fragment to upstream: Lockr
+and Permutive serve the SDK selected by existing integration configuration.
+Keep `/integrations/lockr/sdk` and `/integrations/permutive/sdk` unchanged.
+
+Malformed inputs fail without throwing or preventing another guard from running.
+Narrowing non-network and bare-host strings is intentional. Preserve normal
+absolute and protocol-relative SDK URLs, and case-insensitive matching.
+
+## Files and test data
+
+Runtime changes belong in:
+
+- `crates/trusted-server-js/lib/src/integrations/lockr/script_guard.ts`
+- `crates/trusted-server-js/lib/src/integrations/permutive/script_guard.ts`
+- `crates/trusted-server-core/src/integrations/lockr.rs`
+- `crates/trusted-server-core/src/integrations/permutive.rs`
+- `crates/trusted-server-core/src/integrations/sdk_url.rs`
+- `crates/trusted-server-js/lib/src/shared/sdk_url.ts`
+
+Rust corpus loading and attribute-rewrite assertions are shared in the test-only
+`crates/trusted-server-core/src/integrations/sdk_url_test_support.rs` module.
+Direct private-matcher assertions remain in each integration's tests.
+
+Create `crates/trusted-server-js/lib/test/fixtures/sdk-url-ownership.json`. Each
+case records a descriptive name, input URL, and expected integration ID or null.
+An optional `insertionOwner` records a different expectation after native DOM URL
+resolution. In particular, raw matchers reject shorthand schemes. With the
+fixture's `https:` shorthand and jsdom's `http:` page, script and link URL getters
+resolve them to absolute vendor URLs before insertion. On an `https:` publisher
+page, the same inputs resolve to publisher paths and remain unowned.
+Rust tests and raw browser claimant tests use `owner`; DOM insertion tests use
+`insertionOwner` when present. This distinguishes parser input policy from the
+browser's existing attribute-resolution behavior. An optional `serverHtmlOwner`
+records a different expectation once lol_html has read the attribute from
+markup; the Rust HTML tests use it when present.
+Use fictional publisher/customer data. Public vendor hosts are necessary here
+to test the actual hard-coded ownership rules, not illustrative customer URLs.
+Import the same fixture in Vitest and Rust's inline test modules using the
+existing `aps-renderer-v1.json` include/import convention.
+
+The corpus must cover:
+
+- Canonical URLs for all six guards: Permutive, Lockr, Sourcepoint, GTM,
+  DataDome, and GPT.
+- Both Lockr hosts and both Permutive host families.
+- Real SDK paths with query strings, fragments, uppercase text, protocol-relative
+  forms, and ports.
+- Other vendors' URLs mentioning either affected vendor in queries or paths.
+- Host prefixes, suffixes, path mentions, and user-information lookalikes.
+- Unrelated resources on genuine vendor hosts and wrong SDK extensions.
+- Already-rewritten first-party GPT URLs whose query mentions a vendor host.
+- Empty/malformed, relative, bare-host, shorthand-scheme, and non-network inputs.
+- Trailing-dot hostnames, percent-encoded SDK path text, the bare
+  `edge.permutive.app` host, and C0/space/Unicode whitespace boundaries.
+- Tab/CR/LF preprocessing, backslash and mixed authority separators, and
+  normalized lookalike/user-information/path/query negatives.
+- NUL-containing raw attributes versus DOM URL properties and HTML tokenization.
+
+Replace stale comments pointing to Rust line numbers with pointers to this
+shared corpus.
+
+## Regression tests
+
+### Matcher and server tests
+
+For each corpus case, run both Rust matchers and assert whether the expected
+owner equals that integration. Run the corresponding JS guards against the
+same input URL so parser decisions cannot drift behind duplicated case lists.
+Also assert server attribute rewrite actions for matching and nonmatching cases,
+including `src` and `href`, while retaining disabled-rewrite coverage. Check
+attribute-routing eligibility before calling the rewriter. For every corpus
+case, also tokenize actual script/link markup with lol_html and assert the
+output: the SDK route when the case's server HTML owner is that integration,
+and the unchanged markup otherwise.
+
+### All-guard ownership and insertion tests
+
+Install all six real guards. Examine every registered handler against the
+original corpus URL, using a fresh untouched element per handler and passing the
+raw URL directly in the candidate. Do not initialize it through `script.src`,
+which would let GPT's assignment patches hide a claimant. This also prevents
+mutations by one handler influencing another. Assert the exact claimant ID list,
+not only a successful final rewrite. Do this entirely in test code without adding a new
+production dispatcher API.
+
+Separately exercise actual insertion through both `script.src = url` and native
+`Element.prototype.setAttribute.call(script, 'src', url)`, then append the node.
+Assert the final first-party route or unchanged attribute. Account for ordinary
+DOM relative-URL resolution separately from the raw matcher assertion. Exercise
+shorthand URLs with both HTTP and HTTPS document bases in
+`test/shared/sdk_url.test.ts`; same-scheme shorthand must remain a publisher path.
+
+Include the issue's three reproduced Lockr collision cases in
+`test/integrations/lockr/url_collision.test.ts`. Force Lockr ahead of GPT/GTM in
+test-only handler ordering as well as using normal dispatcher order. Reversing
+installation alone is insufficient because priorities and IDs set dispatch order.
+Ensure tests clean up guards, GPT's extra patches/observer, and dispatcher state.
+
+Cover preload and prefetch script links for both affected integrations, including
+query-bearing valid SDKs and false positives, through append and insertBefore.
+
+## Delivery and validation
+
+1. Record an independent fresh-context review of this spec, verify its findings,
+   and revise the contract where warranted before implementation.
+2. Add the shared corpus and regression tests. Confirm the relevant cases fail
+   against the original matchers before fixing runtime code.
+3. Apply the four matcher corrections and run focused JS and native Rust tests.
+4. Update the Lockr/Permutive guides with SDK ownership and query behavior.
+5. Run broader suites and repository-required handoff gates. Reuse passing checks
+   while their relevant inputs remain unchanged. Record failures and unavailable
+   checks explicitly and keep the pull request in draft.
+
+Focused checks from the JS library directory:
+
+```sh
+npx vitest run test/integrations/lockr test/integrations/permutive test/shared/sdk_url.test.ts test/shared/dom_insertion_dispatcher.test.ts
+```
+
+Focused checks from the repository root, using the pinned Rust toolchain
+and core's default feature set:
+
+```sh
+cargo test -p trusted-server-core integrations::lockr::tests
+cargo test -p trusted-server-core integrations::permutive::tests
+cargo fmt --all -- --check
+```
+
+At the combined checkpoint, run the full JS suite, JS lint/format/build, docs
+format, and the CI gates specified in `AGENTS.md`, including target-matched
+adapter tests/clippy and integration parity. Cargo builds depend on the JS
+crate, whose build script installs missing npm dependencies and builds bundles;
+coordinate those commands instead of running competing dependency installs.
+
+## Independent review
+
+A fresh-context reviewer read this spec, the full
+issue, and current code without conversation history or edits. It found no
+blocking defects. Its suggestions were accepted: bypass GPT assignment patches
+in raw claimant tests, add explicit trailing-dot/encoded-path/bare-edge-host
+fixture rows, and document query/fragment recognition on browser Lockr's
+`identity.loc.kr` host. Its open questions about whitespace and malformed URL
+spellings were resolved by the explicit common input rules above.
+
+A second fresh-context correctness review inspected the implementation, tests,
+fixture, and guides, traced the insertion and server rewrite paths, and ran the
+focused JS tests. It reported no findings.
+
+## Validation results
+
+The original regression tests failed against the substring matchers before the
+ownership fixes. The normalization regressions also failed before expanding the
+common preprocessing policy. The shared corpus now contains 106 cases, including
+23 normalization positives and negatives. The all-guard test expands them into
+1,390 ownership and insertion checks across both handler orders and DOM paths.
+
+| Check                                                                                                         | Result                                                                                           |
+| ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| Full JS suite, `npx vitest run --maxWorkers=4`                                                                | Passed, 2,640 tests across 52 files; scoped Vitest type assertions pass                          |
+| JS `npm run lint`, `npm run format`, `npm run build`                                                          | Passed                                                                                           |
+| Native Lockr and Permutive inline test modules                                                                | Passed, 11 and 9 tests, including the shared corpus and attribute rewriting                      |
+| `cargo test-fastly`, `cargo test-fastly-reuse`, `cargo test-axum`, `cargo test-cloudflare`, `cargo test-spin` | Passed (the Fastly aliases in CI with the pinned Viceroy); existing ignored tests remain ignored |
+| All eight target-specific clippy aliases listed in `AGENTS.md`                                                | Passed                                                                                           |
+| Integration parity test                                                                                       | Passed                                                                                           |
+| Native template build-digest tests and clippy                                                                 | Passed                                                                                           |
+| `cargo fmt --all -- --check`, wasm clock lint                                                                 | Passed                                                                                           |
+| Docs and repository Markdown formatting                                                                       | Passed                                                                                           |
+| URL-host lint on added lines                                                                                  | Passed                                                                                           |
+
+No live vendor SDK fetch or production deployment smoke test was performed.
+
+## Investigation evidence
+
+At `5bc388625`, an in-memory esbuild bundle of the actual guard source executed
+in JSDOM with all six guards installed reproduces GPT replacement via `script.src`,
+Lockr query/path/lookalike false positives, Permutive lookalike false positives,
+and the Permutive query-string false negative. The native setAttribute path
+leaves GPT correctly owned under current ordering. This is diagnostic evidence,
+not a substitute for the committed regression tests or full validation.