diff --git a/tests/designSystem/dynamicStyles.test.mjs b/tests/designSystem/dynamicStyles.test.mjs
new file mode 100644
index 00000000..7aa060b0
--- /dev/null
+++ b/tests/designSystem/dynamicStyles.test.mjs
@@ -0,0 +1,276 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { JSDOM } from 'jsdom';
+import {
+  registerScope,
+  setVariables,
+  releaseScope,
+  getScopeAttributeName
+} from '../../js/designSystem/dynamicStyles.js';
+
+describe('js/designSystem/dynamicStyles.js', () => {
+  let dom;
+  let document;
+  let window;
+  let originalCSSStyleSheet;
+
+  beforeEach(() => {
+    dom = new JSDOM('<!DOCTYPE html><html><head></head><body></body></html>', {
+      url: 'http://localhost/',
+      pretendToBeVisual: true,
+    });
+    window = dom.window;
+    document = window.document;
+
+    originalCSSStyleSheet = globalThis.CSSStyleSheet;
+    // Polyfill global CSSStyleSheet for constructable stylesheets support if needed
+    // JSDOM supports it, but we need to expose it globally for the module to detect it
+    if (!globalThis.CSSStyleSheet) {
+        globalThis.CSSStyleSheet = window.CSSStyleSheet;
+    }
+  });
+
+  afterEach(() => {
+    // Clean up
+    dom = null;
+    document = null;
+    window = null;
+    globalThis.CSSStyleSheet = originalCSSStyleSheet;
+  });
+
+  describe('registerScope', () => {
+    it('should register a scope and return a string ID', () => {
+      const scopeId = registerScope('test-scope', [], { documentRef: document });
+      assert.equal(typeof scopeId, 'string');
+      assert.ok(scopeId.startsWith('test-scope'));
+    });
+
+    it('should create a style element or use adoptedStyleSheets', () => {
+      const scopeId = registerScope('test-scope', [], { documentRef: document });
+
+      // Check for style element fallback or adoptedStyleSheets
+      const styleElement = document.querySelector('style[data-ds-dynamic="true"]');
+      const adopted = document.adoptedStyleSheets && document.adoptedStyleSheets.length > 0;
+
+      assert.ok(styleElement || adopted, 'Should use either <style> or adoptedStyleSheets');
+    });
+
+    it('should insert rules with the correct selector', () => {
+      const scopeId = registerScope('test-scope', [':scope', '.child'], { documentRef: document });
+      const attr = getScopeAttributeName();
+
+      // Helper to find rule
+      const findRule = (selectorPart) => {
+        // Check style element
+        const styleElement = document.querySelector('style[data-ds-dynamic="true"]');
+        if (styleElement && styleElement.sheet) {
+          for (const rule of styleElement.sheet.cssRules) {
+            if (rule.selectorText.includes(selectorPart)) return rule;
+          }
+        }
+        // Check adopted sheets
+        if (document.adoptedStyleSheets) {
+          for (const sheet of document.adoptedStyleSheets) {
+            for (const rule of sheet.cssRules) {
+              if (rule.selectorText.includes(selectorPart)) return rule;
+            }
+          }
+        }
+        return null;
+      };
+
+      const scopeSelector = `[${attr}="${scopeId}"]`;
+      assert.ok(findRule(scopeSelector), 'Should have rule for :scope');
+      assert.ok(findRule(`${scopeSelector} .child`), 'Should have rule for .child');
+    });
+
+    it('should handle "&" in selectors', () => {
+      const scopeId = registerScope('amp-test', ['&.active'], { documentRef: document });
+      const attr = getScopeAttributeName();
+      const expectedSelector = `[${attr}="${scopeId}"].active`;
+
+      // Verify rule existence
+      let found = false;
+      const checkSheet = (sheet) => {
+        for (const rule of sheet.cssRules) {
+            // Note: selectorText might be normalized by JSDOM/browser
+            if (rule.selectorText === expectedSelector) found = true;
+        }
+      };
+
+      const styleElement = document.querySelector('style[data-ds-dynamic="true"]');
+      if (styleElement?.sheet) checkSheet(styleElement.sheet);
+      if (document.adoptedStyleSheets) document.adoptedStyleSheets.forEach(checkSheet);
+
+      assert.ok(found, `Rule for ${expectedSelector} should be found`);
+    });
+  });
+
+  describe('setVariables', () => {
+    it('should update CSS variables on the scope', () => {
+      const scopeId = registerScope('var-test', [], { documentRef: document });
+      const vars = { '--color': 'red', '--size': '10px' };
+
+      const success = setVariables(scopeId, vars);
+      assert.equal(success, true, 'setVariables should return true');
+
+      // Verify style property
+      // We need to access the rule.
+      // Since we can't easily export the internal registry, we inspect the DOM/OM.
+
+      let ruleStyle = null;
+       const checkSheet = (sheet) => {
+        for (const rule of sheet.cssRules) {
+             if (rule.selectorText.includes(scopeId)) {
+                 ruleStyle = rule['style'];
+             }
+        }
+      };
+
+      const styleElement = document.querySelector('style[data-ds-dynamic="true"]');
+      if (styleElement?.sheet) checkSheet(styleElement.sheet);
+      if (document.adoptedStyleSheets) document.adoptedStyleSheets.forEach(checkSheet);
+
+      assert.ok(ruleStyle, 'Rule style should be accessible');
+      assert.equal(ruleStyle.getPropertyValue('--color'), 'red');
+      assert.equal(ruleStyle.getPropertyValue('--size'), '10px');
+    });
+
+    it('should handle removing variables', () => {
+      const scopeId = registerScope('var-remove', [], { documentRef: document });
+      setVariables(scopeId, { '--temp': '123' });
+
+      setVariables(scopeId, { '--temp': null });
+
+      let ruleStyle = null;
+      // ... find rule style again (reuse helper logic ideally)
+       const checkSheet = (sheet) => {
+        for (const rule of sheet.cssRules) {
+             if (rule.selectorText.includes(scopeId)) {
+                 ruleStyle = rule['style'];
+             }
+        }
+      };
+      const styleElement = document.querySelector('style[data-ds-dynamic="true"]');
+      if (styleElement?.sheet) checkSheet(styleElement.sheet);
+      if (document.adoptedStyleSheets) document.adoptedStyleSheets.forEach(checkSheet);
+
+      assert.equal(ruleStyle.getPropertyValue('--temp'), '');
+    });
+  });
+
+  describe('releaseScope', () => {
+    it('should remove rules and clean up', () => {
+      const scopeId = registerScope('release-test', [], { documentRef: document });
+
+      // Verify exists
+      let foundBefore = false;
+      const checkSheet = (sheet) => {
+        for (const rule of sheet.cssRules) {
+             if (rule.selectorText.includes(scopeId)) foundBefore = true;
+        }
+      };
+      const styleElement = document.querySelector('style[data-ds-dynamic="true"]');
+      if (styleElement?.sheet) checkSheet(styleElement.sheet);
+      if (document.adoptedStyleSheets) document.adoptedStyleSheets.forEach(checkSheet);
+      assert.ok(foundBefore, 'Rule should exist before release');
+
+      const released = releaseScope(scopeId);
+      assert.equal(released, true, 'releaseScope should return true');
+
+      // Verify removed
+      let foundAfter = false;
+      const checkSheetAfter = (sheet) => {
+        for (const rule of sheet.cssRules) {
+             if (rule.selectorText.includes(scopeId)) foundAfter = true;
+        }
+      };
+      if (styleElement?.sheet) checkSheetAfter(styleElement.sheet);
+      if (document.adoptedStyleSheets) document.adoptedStyleSheets.forEach(checkSheetAfter);
+
+      assert.equal(foundAfter, false, 'Rule should be removed after release');
+    });
+
+    it('should return false for non-existent scope', () => {
+      const result = releaseScope('non-existent-scope');
+      assert.equal(result, false);
+    });
+  });
+
+  describe('Isolation', () => {
+    it('should manage scopes independently for different documents', () => {
+      const dom2 = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+      const doc2 = dom2.window.document;
+      // Polyfill if needed for doc2 environment
+      // But since we run in Node, global CSSStyleSheet is shared if we set it on globalThis.
+
+      const id1 = registerScope('iso', [], { documentRef: document });
+      const id2 = registerScope('iso', [], { documentRef: doc2 });
+
+      // They might get different IDs because registerScope checks global SCOPE_REGISTRY.
+      // But we just want to ensure they don't crash and rules are in respective docs.
+
+      // Check doc1
+      const style1 = document.querySelector('style[data-ds-dynamic="true"]');
+      const adopted1 = document.adoptedStyleSheets?.length > 0;
+      assert.ok(style1 || adopted1, 'Doc1 should have styles');
+
+      // Check doc2
+      const style2 = doc2.querySelector('style[data-ds-dynamic="true"]');
+      const adopted2 = doc2.adoptedStyleSheets?.length > 0;
+      assert.ok(style2 || adopted2, 'Doc2 should have styles');
+
+      // Clean up
+      releaseScope(id1);
+      releaseScope(id2);
+    });
+  });
+
+  describe('Edge cases', () => {
+      it('should handle invalid selectors gracefully', () => {
+          // It might just produce invalid CSS which insertRule might throw or ignore.
+          // dynamicStyles.js catches errors in insertEmptyRule.
+          const scopeId = registerScope('invalid', ['::::invalid'], { documentRef: document });
+          assert.equal(typeof scopeId, 'string');
+          // No crash
+      });
+
+      it('should handle missing document gracefully', () => {
+         // Passing null documentRef, falls back to global document.
+         // In test env, global document might be undefined unless set.
+         // If undefined, ensureManager returns null.
+         // registerScope returns null.
+
+         // Temporarily hide global document if it exists
+         const originalDoc = globalThis.document;
+         delete globalThis.document;
+
+         const result = registerScope('no-doc', [], { documentRef: null });
+         assert.equal(result, null);
+
+         globalThis.document = originalDoc;
+      });
+
+      it('should fallback to <style> element if CSSStyleSheet is missing', () => {
+        // Unset CSSStyleSheet to force fallback
+        globalThis.CSSStyleSheet = undefined;
+        // Also ensure JSDOM instance simulates lack of support if possible?
+        // dynamicStyles.js checks globalThis.CSSStyleSheet.
+
+        // We need a fresh document because ensureManager caches the manager per document.
+        const domFallback = new JSDOM('<!DOCTYPE html><html><head></head><body></body></html>');
+        const docFallback = domFallback.window.document;
+
+        const scopeId = registerScope('fallback', [], { documentRef: docFallback });
+        assert.ok(scopeId);
+
+        const styleElement = docFallback.querySelector('style[data-ds-dynamic="true"]');
+        assert.ok(styleElement, 'Should use <style> element');
+        assert.ok(styleElement.sheet, 'Style element should have a sheet');
+        // adoptedStyleSheets should not be used (or empty/not modified by us)
+        const adopted = docFallback.adoptedStyleSheets;
+        // JSDOM might initialize it as empty array.
+        // We just ensure we found the style element.
+      });
+  });
+});