diff --git a/.prettierignore b/.prettierignore
index 161611c702..7aa3708cf6 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -7,5 +7,6 @@ injected/src/features/Scriptlets
 **/*.json
 **/*.md
 **/*.html
+!injected/integration-test/test-pages/infra/pages/conditional-matching.html
 **/*.har
 **/*.css
diff --git a/injected/README.md b/injected/README.md
index f9d3cd5486..1d584d4b0d 100644
--- a/injected/README.md
+++ b/injected/README.md
@@ -188,6 +188,30 @@ Everything within `integration-test` is integration tests controlled by Playwrig
 npm run test-int
 ```
 
+**Running specific tests:**
+
+To run a specific test or test suite, you can use the `--grep` flag to filter tests by name:
+
+```shell
+# Run tests containing "Test infra" in their name
+npx playwright test pages.spec.js --grep "Test infra"
+
+# Run tests containing "Conditional frame matching" in their name
+npx playwright test pages.spec.js --grep "Conditional frame matching"
+
+# Run tests in headed mode (shows browser window)
+npx playwright test pages.spec.js --grep "Test infra" --headed
+```
+
+**Debugging tests:**
+
+For debugging, you can run tests in headed mode and add debugging output:
+
+```shell
+# Run with browser visible and debugging enabled
+npx playwright test pages.spec.js --grep "Test infra" --headed --debug
+```
+
 #### Feature Build process
 
 To produce all artefacts that are used by platforms, just run the `npm run build` command.
diff --git a/injected/entry-points/integration.js b/injected/entry-points/integration.js
index c7aaf755dd..90cbb3c618 100644
--- a/injected/entry-points/integration.js
+++ b/injected/entry-points/integration.js
@@ -1,21 +1,9 @@
 import { load, init } from '../src/content-scope-features.js';
 import { TestTransportConfig } from '../../messaging/index.js';
-function getTopLevelURL() {
-    try {
-        // FROM: https://stackoverflow.com/a/7739035/73479
-        // FIX: Better capturing of top level URL so that trackers in embedded documents are not considered first party
-        if (window.location !== window.parent.location) {
-            return new URL(window.location.href !== 'about:blank' ? document.referrer : window.parent.location.href);
-        } else {
-            return new URL(window.location.href);
-        }
-    } catch (error) {
-        return new URL(location.href);
-    }
-}
+import { getTabUrl } from '../src/utils.js';
 
 function generateConfig() {
-    const topLevelUrl = getTopLevelURL();
+    const topLevelUrl = getTabUrl();
     return {
         debug: false,
         sessionKey: 'randomVal',
@@ -35,8 +23,8 @@ function generateConfig() {
             },
         ],
         site: {
-            domain: topLevelUrl.hostname,
-            url: topLevelUrl.href,
+            domain: topLevelUrl?.hostname || '',
+            url: topLevelUrl?.href || '',
             isBroken: false,
             allowlisted: false,
             enabledFeatures: [
@@ -86,7 +74,7 @@ function mergeDeep(target, ...sources) {
 }
 
 async function initCode() {
-    const topLevelUrl = getTopLevelURL();
+    const topLevelUrl = getTabUrl();
     const processedConfig = generateConfig();
 
     // mock Messaging and allow for tests to intercept them
@@ -116,7 +104,7 @@ async function initCode() {
     // mark this phase as loaded
     setStatus('loaded');
 
-    if (!topLevelUrl.searchParams.has('wait-for-init-args')) {
+    if (!topLevelUrl?.searchParams.has('wait-for-init-args')) {
         await init(processedConfig);
         setStatus('initialized');
         return;
@@ -128,11 +116,14 @@ async function initCode() {
         async (evt) => {
             // @ts-expect-error https://app.asana.com/0/1201614831475344/1203979574128023/f
             const merged = mergeDeep(processedConfig, evt.detail);
+            // @ts-expect-error https://app.asana.com/0/1201614831475344/1203979574128023/f
+            window.__testContentScopeArgs = merged;
             // init features
             await init(merged);
 
             // set status to initialized so that tests can resume
             setStatus('initialized');
+            document.dispatchEvent(new CustomEvent('content-scope-init-completed'));
         },
         { once: true },
     );
diff --git a/injected/integration-test/test-pages/infra/config/conditional-matching.json b/injected/integration-test/test-pages/infra/config/conditional-matching.json
index 00a588de61..8827b2b573 100644
--- a/injected/integration-test/test-pages/infra/config/conditional-matching.json
+++ b/injected/integration-test/test-pages/infra/config/conditional-matching.json
@@ -13,6 +13,22 @@
                             "type": "number",
                             "value": 222
                         }
+                    },
+                    "testApi1": {
+                        "type": "descriptor",
+                        "getterValue": {
+                            "type": "number",
+                            "value": 100
+                        },
+                        "define": true
+                    },
+                    "testApi2": {
+                        "type": "descriptor",
+                        "getterValue": {
+                            "type": "number",
+                            "value": 200
+                        },
+                        "define": true
                     }
                 },
                 "conditionalChanges": [
@@ -27,11 +43,39 @@
                                 "value": 333
                             }
                         ]
+                    },
+                    {
+                        "condition": {
+                            "context": {
+                                "top": true
+                            }
+                        },
+                        "patchSettings": [
+                            {
+                                "op": "replace",
+                                "path": "/apiChanges/testApi1/getterValue/value",
+                                "value": 43339
+                            }
+                        ]
+                    },
+                    {
+                        "condition": {
+                            "context": {
+                                "frame": true
+                            }
+                        },
+                        "patchSettings": [
+                            {
+                                "op": "replace",
+                                "path": "/apiChanges/testApi1/getterValue/value",
+                                "value": 43338
+                            }
+                        ]
                     }
                 ]
             }
         }
     },
     "unprotectedTemporary": []
-  }
+}
   
\ No newline at end of file
diff --git a/injected/integration-test/test-pages/infra/pages/conditional-matching.html b/injected/integration-test/test-pages/infra/pages/conditional-matching.html
index 7b11d615c3..b4b6182942 100644
--- a/injected/integration-test/test-pages/infra/pages/conditional-matching.html
+++ b/injected/integration-test/test-pages/infra/pages/conditional-matching.html
@@ -1,64 +1,204 @@
-<!DOCTYPE html>
+<!doctype html>
 <html>
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width">
-  <title>Conditional Matching</title>
-  <link rel="stylesheet" href="../../shared/style.css">
-</head>
-<body>
-    <script src="../../shared/utils.js"></script>
-    <p><a href="../index.html">[Infra]</a></p>
-
-    <p>This page verifies that APIs get modified</p>
-
-    <script>
-        test('Conditional matching', async () => {
-            const results = [
-                {
-                    name: "APIs changing, expecting to always match",
+    <head>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width" />
+        <title>Conditional Matching</title>
+        <link rel="stylesheet" href="../../shared/style.css" />
+    </head>
+    <body>
+        <script src="../../shared/utils.js"></script>
+        <p><a href="../index.html">[Infra]</a></p>
+
+        <p>This page verifies that APIs get modified</p>
+
+        <script>
+            test('Conditional matching', async () => {
+                const results = [
+                    {
+                        name: 'APIs changing, expecting to always match',
+                        result: navigator.hardwareConcurrency,
+                        expected: 222,
+                    },
+                ];
+
+                const oldPathname = window.location.pathname;
+                const newUrl = new URL(window.location.href);
+                newUrl.pathname = '/test/test/path';
+                window.history.pushState(null, '', newUrl.href);
+                await new Promise((resolve) => requestIdleCallback(resolve));
+
+                results.push({
+                    name: 'Expect URL to be changed',
+                    result: window.location.pathname,
+                    expected: '/test/test/path',
+                });
+                results.push({
+                    name: 'APIs changing, expecting to match only when the URL is correct',
+                    result: navigator.hardwareConcurrency,
+                    expected: 333,
+                });
+
+                const popStatePromise = new Promise((resolve) => {
+                    window.addEventListener('popstate', resolve, { once: true });
+                });
+                // Call pop state to revert the URL
+                window.history.back();
+                await popStatePromise;
+
+                results.push({
+                    name: 'Expect URL to be reverted',
+                    result: window.location.pathname,
+                    expected: oldPathname,
+                });
+                results.push({
+                    name: 'APIs changing, expecting to match only when the URL is correct',
                     result: navigator.hardwareConcurrency,
-                    expected: 222
+                    expected: 222,
+                });
+
+                return results;
+            });
+
+            test('Conditional frame matching', async () => {
+                const results = [];
+                const frame = document.createElement('iframe');
+                const scriptTag = 'script';
+
+                // Set up listener for iframe-ready-for-init before the iframe loads
+                const iframeReadyPromise = new Promise((resolve) => {
+                    const handler = (event) => {
+                        if (event.data && event.data.type === 'iframe-ready-for-init') {
+                            window.removeEventListener('message', handler);
+                            resolve();
+                        }
+                    };
+                    window.addEventListener('message', handler);
+                });
+
+                frame.srcdoc = `
+                <!DOCTYPE html>
+                <html>
+                    <head></head>
+                    <body>
+                        <${scriptTag}>
+                            // Wait for parent to signal when to load content scope script
+                            window.addEventListener('message', function handler(event) {
+                                if (event.data && event.data.type === 'load-content-scope') {
+                                    window.removeEventListener('message', handler);
+                                    
+                                    // Now load the content scope script
+                                    const script = document.createElement('script');
+                                    script.src = '/build/contentScope.js';
+                                    script.onload = () => {
+                                        // Immediately dispatch the init args
+                                        document.dispatchEvent(new CustomEvent('content-scope-init-args', { detail: event.data.args }));
+                                    };
+                                    document.head.appendChild(script);
+                                }
+                            });
+                            
+                            // Notify parent we're ready to receive load signal
+                            window.parent.postMessage({ type: 'iframe-ready-for-init' }, '*');
+                            
+                            window.addEventListener('message', (event) => {
+                                if (event.data === 'getTestApi1') {
+                                    console.log('[iframe] testApi1 value:', window.testApi1);
+                                    event.source.postMessage({ type: 'testApi1', value: window.testApi1 }, event.origin);
+                                }
+                                if (event.data === 'getTestApi2') {
+                                    console.log('[iframe] testApi2 value:', window.testApi2);
+                                    event.source.postMessage({ type: 'testApi2', value: window.testApi2 }, event.origin);
+                                }
+                            });
+                            // Listen for content-scope-init-args event and signal completion
+                            document.addEventListener('content-scope-init-args', function (evt) {
+                                // Signal complete
+                                window.parent.postMessage('content-scope-init-completed', '*');
+                            });
+                            
+                            // Also listen for the content scope status to be 'initialized'
+                            const checkStatus = () => {
+                                if (window.__content_scope_status === 'initialized') {
+                                    window.parent.postMessage('content-scope-fully-initialized', '*');
+                                } else {
+                                    setTimeout(checkStatus, 10);
+                                }
+                            };
+                            checkStatus();
+                        </${scriptTag}>
+                    </body>
+                </html>
+            `;
+                document.body.appendChild(frame);
+                await new Promise((resolve) => (frame.onload = resolve));
+                // Wait for the iframe to signal it's ready for init
+                await iframeReadyPromise;
+
+                // Send content-scope-init-args to the iframe (use parent's args if available)
+                const args = window.__testContentScopeArgs || null;
+                if (!args) {
+                    throw new Error('args is blank');
                 }
-            ];
-            const oldPathname = window.location.pathname;
-            const newUrl = new URL(window.location.href);
-            newUrl.pathname = "/test/test/path";
-            window.history.pushState(null, '', newUrl.href);
-            await new Promise(resolve => requestIdleCallback(resolve));
-            results.push({
-                name: "Expect URL to be changed",
-                result: window.location.pathname,
-                expected: '/test/test/path'
-            })
-            results.push({
-                name: "APIs changing, expecting to match only when the URL is correct",
-                result: navigator.hardwareConcurrency,
-                expected: 333
-            })
-            const popStatePromise = new Promise(resolve => {
-                window.addEventListener('popstate', resolve, { once: true });
+
+                // Filter out non-serializable properties for postMessage
+                const serializableArgs = JSON.parse(JSON.stringify(args));
+                frame.contentWindow.postMessage({ type: 'load-content-scope', args: serializableArgs }, '*');
+                // Wait for the content-scope script to be initialized in the iframe
+                await new Promise((resolve) => {
+                    window.addEventListener('message', function handler(event) {
+                        if (event.data === 'content-scope-init-completed') {
+                            window.removeEventListener('message', handler);
+                            resolve();
+                        }
+                    });
+                });
+
+                // Wait for content scope to be fully initialized
+                await new Promise((resolve) => {
+                    window.addEventListener('message', function handler(event) {
+                        if (event.data === 'content-scope-fully-initialized') {
+                            window.removeEventListener('message', handler);
+                            resolve();
+                        }
+                    });
+                });
+
+                // Add a small delay to ensure API modifications are applied
+                await new Promise((resolve) => setTimeout(resolve, 100));
+
+                const testApi1Promise = new Promise((resolve) => {
+                    window.addEventListener(
+                        'message',
+                        (event) => {
+                            // Only resolve for testApi1 responses
+                            if (event.data && event.data.type === 'testApi1') {
+                                resolve(event.data.value);
+                            }
+                        },
+                        { once: true },
+                    );
+                    frame.contentWindow.postMessage('getTestApi1', '*');
+                });
+                const testApi1Value = await testApi1Promise;
+                console.log('[parent] testApi1 from iframe:', testApi1Value);
+                console.log('[parent] testApi1 in parent:', window.testApi1);
+
+                results.push({
+                    name: 'Ensure iframe changes work',
+                    result: testApi1Value,
+                    expected: 43338,
+                });
+                results.push({
+                    name: 'Expect frame top modification works',
+                    result: window.testApi1,
+                    expected: 43339,
+                });
+                return results;
             });
-            // Call pop state to revert the URL
-            window.history.back();
-            await popStatePromise;
-            results.push({
-                name: "Expect URL to be reverted",
-                result: window.location.pathname,
-                expected: oldPathname
-            })
-            results.push({
-                name: "APIs changing, expecting to match only when the URL is correct",
-                result: navigator.hardwareConcurrency,
-                expected: 222
-            })
-
-            return results;
-        });
-
-
-        // eslint-disable-next-line no-undef
-        renderResults();
-    </script>
-</body>
+
+            // eslint-disable-next-line no-undef
+            renderResults();
+        </script>
+    </body>
 </html>
diff --git a/injected/src/config-feature.js b/injected/src/config-feature.js
index 06fd6bee4a..9057173c48 100644
--- a/injected/src/config-feature.js
+++ b/injected/src/config-feature.js
@@ -119,6 +119,9 @@ export default class ConfigFeature {
      * @property {object} [experiment]
      * @property {string} [experiment.experimentName]
      * @property {string} [experiment.cohort]
+     * @property {object} [context]
+     * @property {boolean} [context.frame] - true if the condition applies to frames
+     * @property {boolean} [context.top] - true if the condition applies to the top frame
      */
 
     /**
@@ -144,6 +147,7 @@ export default class ConfigFeature {
         /** @type {Record<string, (conditionBlock: ConditionBlock) => boolean>} */
         const conditionChecks = {
             domain: this._matchDomainConditional,
+            context: this._matchContextConditional,
             urlPattern: this._matchUrlPatternConditional,
             experiment: this._matchExperimentConditional,
             minSupportedVersion: this._matchMinSupportedVersion,
@@ -208,6 +212,23 @@ export default class ConfigFeature {
         });
     }
 
+    /**
+     * Takes a condition block and returns true if the current context matches the context.
+     * @param {ConditionBlock} conditionBlock
+     * @returns {boolean}
+     */
+    _matchContextConditional(conditionBlock) {
+        if (!conditionBlock.context) return false;
+        const isFrame = window.self !== window.top;
+        if (conditionBlock.context.frame && isFrame) {
+            return true;
+        }
+        if (conditionBlock.context.top && !isFrame) {
+            return true;
+        }
+        return false;
+    }
+
     /**
      * Takes a condtion block and returns true if the current url matches the urlPattern.
      * @param {ConditionBlock} conditionBlock
diff --git a/injected/src/features.js b/injected/src/features.js
index f156d62f27..76ad8fc383 100644
--- a/injected/src/features.js
+++ b/injected/src/features.js
@@ -59,6 +59,6 @@ export const platformSupport = {
     ],
     firefox: ['cookie', ...baseFeatures, 'clickToLoad'],
     chrome: ['cookie', ...baseFeatures, 'clickToLoad'],
-    'chrome-mv3': ['cookie', ...baseFeatures, 'clickToLoad'],
+    'chrome-mv3': ['cookie', ...baseFeatures, 'clickToLoad', 'webCompat'],
     integration: [...baseFeatures, ...otherFeatures],
 };
diff --git a/injected/src/features/web-compat.js b/injected/src/features/web-compat.js
index 6741b44b22..8e68a7706c 100644
--- a/injected/src/features/web-compat.js
+++ b/injected/src/features/web-compat.js
@@ -126,7 +126,7 @@ export class WebCompat extends ContentFeature {
         if (this.getFeatureSettingEnabled('modifyCookies')) {
             this.modifyCookies();
         }
-        if (this.getFeatureSettingEnabled('disableDeviceEnumeration') || this.getFeatureSettingEnabled('disableDeviceEnumerationFrames')) {
+        if (this.getFeatureSettingEnabled('disableDeviceEnumeration')) {
             this.preventDeviceEnumeration();
         }
     }
@@ -761,21 +761,12 @@ export class WebCompat extends ContentFeature {
         if (!window.MediaDevices) {
             return;
         }
-        let disableDeviceEnumeration = false;
-        const isFrame = window.self !== window.top;
-        if (isFrame) {
-            disableDeviceEnumeration = this.getFeatureSettingEnabled('disableDeviceEnumerationFrames');
-        } else {
-            disableDeviceEnumeration = this.getFeatureSettingEnabled('disableDeviceEnumeration');
-        }
-        if (disableDeviceEnumeration) {
-            const enumerateDevicesProxy = new DDGProxy(this, MediaDevices.prototype, 'enumerateDevices', {
-                apply() {
-                    return Promise.resolve([]);
-                },
-            });
-            enumerateDevicesProxy.overload();
-        }
+        const enumerateDevicesProxy = new DDGProxy(this, MediaDevices.prototype, 'enumerateDevices', {
+            apply() {
+                return Promise.resolve([]);
+            },
+        });
+        enumerateDevicesProxy.overload();
     }
 }