@3fn/core 13.0.0 → 14.0.0

package/src/components/core/Avatar-Base/__tests__/Avatar.accessibility.test.ts

@@ -212,14 +212,20 @@ describe('Avatar Component Accessibility', () => {
     });
 
     it('should apply empty alt when alt is empty string', async () => {
+      // Spec 126 (O2): uses the raw-attribute form (setAttribute) to produce a
+      // genuine alt="" — the `alt` *property* setter treats '' as falsy and calls
+      // removeAttribute, collapsing `avatar.alt = ''` to the same "absent" state as
+      // omitting alt entirely (see Avatar.web.ts `set alt`). Only the attribute form
+      // yields a real empty-string alt, and under the settled warn condition
+      // (`alt == null`), a real empty-string alt does not warn — so no spy is needed.
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
       avatar.type = 'human';
       avatar.src = 'https://example.com/profile.jpg';
-      avatar.alt = '';
+      avatar.setAttribute('alt', '');
       document.body.appendChild(avatar);
-      
+
       await new Promise(resolve => setTimeout(resolve, 0));
-      
+
       const img = avatar.shadowRoot?.querySelector('.avatar__image');
       expect(img).toBeTruthy();
       expect(img?.getAttribute('alt')).toBe('');
@@ -285,16 +291,124 @@ describe('Avatar Component Accessibility', () => {
 
     it('should NOT warn when no src is provided', async () => {
       const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-      
+
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
       avatar.type = 'human';
       // No src, no alt
       document.body.appendChild(avatar);
-      
+
       await new Promise(resolve => setTimeout(resolve, 0));
-      
+
       expect(consoleSpy).not.toHaveBeenCalled();
-      
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  // ============================================================================
+  // Alt Text Warning — Decorative & Type-Scope Edge Semantics (Spec 126, O2)
+  // ============================================================================
+  //
+  // Settled warn condition: `type === 'human' && src && alt == null && !decorative`
+  // @see Requirements: 5.4 - Human type + src SHALL require alt for accessibility
+  // @see Requirements: 5 AC 5 - Agent type SHALL ignore src entirely
+  // @see .kiro/specs/126-avatar-decorative-warn/design-outline.md § 4/5
+  //
+  // Together with the sentinel test above ('should warn when src is provided
+  // without alt'), this block forms the six-test matrix settled by Spec 126 § 5
+  // item 2. The sentinel is left unchanged (Spec 126 § 7 non-regression signal).
+  describe('Alt Text Warning — Decorative & Type-Scope Edge Semantics (Spec 126)', () => {
+    it('should NOT warn when alt="" is set via raw attribute (explicit empty, not "absent")', async () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const avatar = document.createElement('avatar-base') as AvatarBaseElement;
+      avatar.type = 'human';
+      avatar.src = 'https://example.com/profile.jpg';
+      // Raw attribute form is the only path that yields a genuine alt="" (getter
+      // returns '', not null) — the `alt` property setter collapses falsy values to
+      // removeAttribute, so this test must use setAttribute to exercise the real case.
+      avatar.setAttribute('alt', '');
+      document.body.appendChild(avatar);
+
+      await new Promise(resolve => setTimeout(resolve, 0));
+
+      expect(consoleSpy).not.toHaveBeenCalled();
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should warn when alt is set to empty string via the property (collapses to null via the setter)', async () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const avatar = document.createElement('avatar-base') as AvatarBaseElement;
+      avatar.type = 'human';
+      avatar.src = 'https://example.com/profile.jpg';
+      // Property-form empty string: the `alt` setter treats '' as falsy and calls
+      // removeAttribute('alt'), so this lands in the "alt absent" bucket and warns —
+      // pins the attribute-vs-property collapse explicitly (Spec 126 § 5 item 2).
+      avatar.alt = '';
+      document.body.appendChild(avatar);
+
+      await new Promise(resolve => setTimeout(resolve, 0));
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('alt')
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should NOT warn when decorative is true, even without alt (co-asserted with aria-hidden)', async () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const avatar = document.createElement('avatar-base') as AvatarBaseElement;
+      avatar.type = 'human';
+      avatar.src = 'https://example.com/profile.jpg';
+      avatar.decorative = true;
+      // No alt provided
+      document.body.appendChild(avatar);
+
+      await new Promise(resolve => setTimeout(resolve, 0));
+
+      expect(consoleSpy).not.toHaveBeenCalled();
+
+      // Co-assert the semantic linkage (Req 9.2): the warn is correctly suppressed
+      // because the avatar is genuinely hidden from screen readers, not incidentally.
+      const container = avatar.shadowRoot?.querySelector('.avatar');
+      expect(container?.getAttribute('aria-hidden')).toBe('true');
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should NOT warn for agent type with src and no alt (Req 5 AC 5 — agent ignores src entirely)', async () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const avatar = document.createElement('avatar-base') as AvatarBaseElement;
+      avatar.type = 'agent';
+      avatar.src = 'https://example.com/profile.jpg';
+      // No alt provided
+      document.body.appendChild(avatar);
+
+      await new Promise(resolve => setTimeout(resolve, 0));
+
+      expect(consoleSpy).not.toHaveBeenCalled();
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should NOT warn for agent type with src and alt both present (confirms silencing is type-driven, not alt-driven)', async () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const avatar = document.createElement('avatar-base') as AvatarBaseElement;
+      avatar.type = 'agent';
+      avatar.src = 'https://example.com/profile.jpg';
+      avatar.alt = 'Ignored for agent type';
+      document.body.appendChild(avatar);
+
+      await new Promise(resolve => setTimeout(resolve, 0));
+
+      expect(consoleSpy).not.toHaveBeenCalled();
+
       consoleSpy.mockRestore();
     });
   });

package/src/components/core/Avatar-Base/__tests__/Avatar.image.test.ts

@@ -287,6 +287,7 @@ describe('Avatar Component Image Handling', () => {
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
       avatar.type = 'agent';
       avatar.src = 'https://example.com/agent-image.jpg';
+      avatar.alt = 'Agent profile'; // honor the alt-with-src contract (Req 5.4)
       document.body.appendChild(avatar);
       
       await new Promise(resolve => setTimeout(resolve, 0));
@@ -299,6 +300,7 @@ describe('Avatar Component Image Handling', () => {
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
       avatar.type = 'agent';
       avatar.src = 'https://example.com/agent-image.jpg';
+      avatar.alt = 'Agent profile'; // honor the alt-with-src contract (Req 5.4)
       document.body.appendChild(avatar);
       
       await new Promise(resolve => setTimeout(resolve, 0));
@@ -311,6 +313,7 @@ describe('Avatar Component Image Handling', () => {
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
       avatar.type = 'agent';
       avatar.src = 'https://example.com/agent-image.jpg';
+      avatar.alt = 'Agent profile'; // honor the alt-with-src contract (Req 5.4)
       document.body.appendChild(avatar);
       
       await new Promise(resolve => setTimeout(resolve, 0));

package/src/components/core/Avatar-Base/__tests__/Avatar.test.ts

@@ -218,27 +218,33 @@ describe('Avatar Component Core API', () => {
   // ============================================================================
   
   describe('Src Prop', () => {
+    // Fixtures set `alt` alongside `src` so they honor the component's own a11y
+    // contract (Req 5.4: alt is required with src) — otherwise the component
+    // rightly warns, polluting CI logs. The assertions below are about src only.
     it('should accept src value', () => {
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
       avatar.src = 'https://example.com/image.jpg';
+      avatar.alt = 'Test avatar';
       document.body.appendChild(avatar);
-      
+
       expect(avatar.src).toBe('https://example.com/image.jpg');
       expect(avatar.getAttribute('src')).toBe('https://example.com/image.jpg');
     });
 
     it('should update src via attribute', () => {
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
+      avatar.alt = 'Test avatar';
       document.body.appendChild(avatar);
-      
+
       avatar.setAttribute('src', 'https://example.com/new-image.jpg');
       expect(avatar.src).toBe('https://example.com/new-image.jpg');
     });
 
     it('should update src via property', () => {
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
+      avatar.alt = 'Test avatar';
       document.body.appendChild(avatar);
-      
+
       avatar.src = 'https://example.com/profile.png';
       expect(avatar.getAttribute('src')).toBe('https://example.com/profile.png');
     });
@@ -246,8 +252,9 @@ describe('Avatar Component Core API', () => {
     it('should remove src attribute when set to null', () => {
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
       avatar.src = 'https://example.com/image.jpg';
+      avatar.alt = 'Test avatar';
       document.body.appendChild(avatar);
-      
+
       avatar.src = null;
       expect(avatar.src).toBeNull();
       expect(avatar.hasAttribute('src')).toBe(false);
@@ -566,8 +573,9 @@ describe('Avatar Component Core API', () => {
 
     it('should reflect src property to attribute', () => {
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
+      avatar.alt = 'Test avatar'; // honor the alt-with-src contract (Req 5.4)
       document.body.appendChild(avatar);
-      
+
       avatar.src = 'https://example.com/test.jpg';
       expect(avatar.getAttribute('src')).toBe('https://example.com/test.jpg');
     });
@@ -629,8 +637,9 @@ describe('Avatar Component Core API', () => {
     it('should read src attribute as property', () => {
       const avatar = document.createElement('avatar-base') as AvatarBaseElement;
       avatar.setAttribute('src', 'https://example.com/img.png');
+      avatar.setAttribute('alt', 'Test avatar'); // honor the alt-with-src contract (Req 5.4)
       document.body.appendChild(avatar);
-      
+
       expect(avatar.src).toBe('https://example.com/img.png');
     });
 

package/src/components/core/Avatar-Base/contracts.yaml

@@ -162,7 +162,17 @@ contracts:
       When not decorative, Avatar provides accessible name:
       - If alt prop provided: uses alt text
       - If no alt prop (iOS/Android): "User avatar" for human, "AI agent avatar" for agent
-      - Web requires alt prop when src is provided
+      - Web requires alt prop when src is provided, scoped to human type only
+        (agent type ignores src entirely — Req 5 AC 5) and only when decorative
+        is false (decorative is the component's own non-informative signal,
+        Req 9.2, and takes precedence over the alt requirement)
+      - Web edge semantics (settled Spec 126, O2, ratified 2026-07-09): the dev
+        warn fires iff `type === 'human' && src && alt == null && !decorative`.
+        A raw explicit empty alt (`setAttribute('alt', '')`) does not warn —
+        it is treated as the deliberate empty-alt signal. The `alt` property
+        setter collapses a falsy value (including '') to removeAttribute, so
+        setting `avatar.alt = ''` via the property lands in the "absent" bucket
+        and DOES warn — this is a setter-collapse detail, not a design gap.
     wcag: "1.1.1 Non-text Content"
     platforms: [web, ios, android]
     validation:

package/src/components/core/Avatar-Base/platforms/web/Avatar.web.ts

@@ -700,12 +700,31 @@ export class AvatarBaseElement extends HTMLElement {
     // @see Requirements: 9.2 - Apply aria-hidden="true" when decorative prop is true
     const ariaHiddenAttr = decorative ? ' aria-hidden="true"' : '';
     
-    // Warn in development if src is provided without alt
-    // @see Requirements: 5.4 - Require alt prop when src is provided
-    if (src && !alt && typeof console !== 'undefined') {
+    // Warn in development if a human-type avatar is missing alt text for its image.
+    // @see Requirements: 5.4 - Human type + src SHALL require alt for accessibility
+    // @see Requirements: 5 AC 5 - Agent type SHALL ignore src entirely (src not
+    //   rendered as an image), so agent-type avatars never warn regardless of alt.
+    //
+    // Settled edge semantics (Spec 126, O2, ratified 2026-07-09):
+    // - Scope is human-type only — Req 5.4 is human-type-scoped, and Req 5 AC 5
+    //   affirmatively establishes that agent-type SHALL ignore src, so a src+no-alt
+    //   agent avatar is not a violation of anything.
+    // - `alt == null` (loose equality — also excludes `undefined`), not `!alt`, is the
+    //   test. The `alt` attribute getter returns `getAttribute('alt')`. Raw
+    //   `setAttribute('alt', '')` yields `alt === ''`, which is the HTML-idiomatic
+    //   explicit-empty-alt signal and must NOT warn. The `alt` *property setter*
+    //   (see below) treats a falsy value as "remove the attribute," so
+    //   `avatar.alt = ''` collapses to `alt === null` — indistinguishable from
+    //   omitting alt entirely, and DOES warn under this condition.
+    // - `!decorative` is the operative fix for the confirmed false positive: a
+    //   `decorative` avatar is the component's official signal that the image is
+    //   non-informative (Req 9.2 applies `aria-hidden="true"`), so it must never warn
+    //   regardless of alt.
+    if (type === 'human' && src && alt == null && !decorative && typeof console !== 'undefined') {
       console.warn(
-        'AvatarBaseElement: "alt" prop is required when "src" is provided for accessibility. ' +
-        'Please add an alt attribute describing the image.'
+        'AvatarBaseElement: "alt" is required when "src" is provided. ' +
+        'Add an alt description of the image; or, if this avatar is purely decorative ' +
+        '(non-informative), set the "decorative" prop to hide it from screen readers.'
       );
     }
     

package/src/components/core/Badge-Count-Base/contracts.yaml

@@ -102,7 +102,7 @@ contracts:
       - No hover or press visual feedback
       - pointer-events: none (web)
       - No gesture handlers (native)
-    wcag: null
+    wcag: "N/A"  # legitimate-null: non-interactive negative guarantee, no positive WCAG SC (125-B 4.2)
     platforms: [web, ios, android]
     validation:
       - Badge cannot receive keyboard focus

package/src/components/core/Badge-Label-Base/contracts.yaml

@@ -77,7 +77,7 @@ contracts:
       - No hover or press visual feedback
       - pointer-events: none (web)
       - No gesture handlers (native)
-    wcag: null
+    wcag: "N/A"  # legitimate-null: non-interactive negative guarantee, no positive WCAG SC (125-B 4.2)
     platforms: [web, ios, android]
     validation:
       - Badge cannot receive keyboard focus

package/src/components/core/Button-CTA/Button-CTA.schema.yaml

@@ -90,20 +90,12 @@ properties:
       When true, text is truncated with ellipsis instead of wrapping.
       Default (false) allows text wrapping for accessibility and i18n support.
   
-  disabled:
-    type: boolean
-    required: false
-    default: false
-    description: |
-      When true, button is non-interactive with disabled visual styling.
-      Disabled buttons are not keyboard focusable and onPress is not called.
-  
   onPress:
     type: "() => void"
     required: true
     description: |
       Callback function invoked when button is clicked, tapped, or activated
-      via keyboard (Enter/Space). Not called when disabled.
+      via keyboard (Enter/Space).
   
   testID:
     type: string
@@ -153,7 +145,6 @@ tokens:
   blend:
     - blend.hoverDarker
     - blend.pressedDarker
-    - blend.disabledDesaturate
     - blend.iconLighter
   component:
     - buttonCTA.minWidth.small
@@ -247,11 +238,10 @@ accessibility:
     - "1.4.11 Non-text Contrast - Focus ring meets 3:1 contrast"
     - "2.1.1 Keyboard - Fully keyboard accessible (Tab, Enter, Space)"
     - "2.4.7 Focus Visible - Clear focus indicator with :focus-visible"
-    - "4.1.2 Name, Role, Value - Proper ARIA attributes and disabled state"
+    - "4.1.2 Name, Role, Value - Proper ARIA attributes"
     - "2.5.5 Target Size - Touch targets meet 44px minimum"
   aria_attributes:
     - role: button (implicit from semantic element)
-    - aria-disabled: true when disabled
     - aria-label: label prop value
   keyboard_navigation:
     - Tab: Move focus to/from button

package/src/components/core/Button-CTA/README.md

@@ -41,10 +41,11 @@ This component guarantees 7 behavioral contracts across all platforms:
 | `pressable` | Responds to press/click events | web, ios, android | 2.1.1 |
 | `hover_state` | Visual feedback on hover | web | 1.4.13 |
 | `pressed_state` | Visual feedback when pressed | web, ios, android | 2.4.7 |
-| `disabled_state` | Prevents interaction when disabled | web, ios, android | 4.1.2 |
 | `loading_state` | Shows loading indicator | web, ios, android | 4.1.3 |
 | `focus_ring` | WCAG 2.4.7 focus visible indicator | web, ios, android | 2.4.7 |
 
+**Excluded**: `state_disabled` — DesignerPunk does not support disabled states for usability and accessibility reasons. If an action is unavailable, the component should not be rendered (adjudicated 2026-07-15).
+
 ---
 
 ## Usage
@@ -62,7 +63,6 @@ This component guarantees 7 behavioral contracts across all platforms:
   variant="primary"
   icon="arrow-right"
   no-wrap="false"
-  disabled="false"
   test-id="submit-button"
 ></button-cta>
 ```
@@ -122,7 +122,6 @@ ButtonCTA(
 | `variant` | `'primary' \| 'secondary' \| 'tertiary'` | No | `'primary'` | Button visual variant |
 | `icon` | `IconName` | No | - | Optional leading icon |
 | `noWrap` | `boolean` | No | `false` | Prevent text wrapping |
-| `disabled` | `boolean` | No | `false` | Disable button interaction |
 | `onPress` | `() => void` | ✅ Yes | - | Press/click handler |
 | `testID` | `string` | No | - | Test identifier |
 
@@ -177,7 +176,6 @@ ButtonCTA(
 ### Blend
 - `blend.hoverDarker` - Hover state (8% darker)
 - `blend.pressedDarker` - Pressed state (12% darker)
-- `blend.disabledDesaturate` - Disabled state (12% less saturated)
 - `blend.iconLighter` - Icon optical balance (8% lighter)
 
 ### Accessibility
@@ -205,7 +203,7 @@ ButtonCTA(
 | 2.1.1 Keyboard | ✅ | Fully keyboard accessible (Tab, Enter, Space) |
 | 2.4.7 Focus Visible | ✅ | Clear focus indicator with :focus-visible |
 | 2.5.5 Target Size | ✅ | Touch targets meet 44px minimum |
-| 4.1.2 Name, Role, Value | ✅ | Proper ARIA attributes and disabled state |
+| 4.1.2 Name, Role, Value | ✅ | Proper ARIA attributes |
 
 ### Keyboard Navigation
 
@@ -219,7 +217,6 @@ ButtonCTA(
 
 - Semantic `<button>` element provides implicit role
 - `aria-label` set from label prop
-- `aria-disabled="true"` when disabled
 - State changes announced to assistive technology
 
 ---

package/src/components/core/Button-CTA/__tests__/ButtonCTA.test.ts

@@ -7,7 +7,7 @@
  * Unit tests for Button-CTA component rendering
  * 
  * Tests component rendering with various props, size variants, variant styles,
- * icon integration, text wrapping, and disabled state.
+ * icon integration, and text wrapping.
  * 
  * Stemma System Naming: [Family]-[Type] = Button-CTA
  * Component Type: Standalone (no behavioral variants)
@@ -66,7 +66,6 @@ describe('Button-CTA Component Rendering', () => {
     buttonVariant?: 'primary' | 'secondary' | 'tertiary';
     icon?: string;
     noWrap?: boolean;
-    disabled?: boolean;
     testID?: string;
   }): ButtonCTA {
     // Create element - constructor runs and attaches shadow DOM
@@ -78,7 +77,6 @@ describe('Button-CTA Component Rendering', () => {
     if (props.buttonVariant) button.buttonVariant = props.buttonVariant;
     if (props.icon) button.icon = props.icon;
     if (props.noWrap !== undefined) button.noWrap = props.noWrap;
-    if (props.disabled !== undefined) button.disabled = props.disabled;
     if (props.testID) button.testID = props.testID;
     
     // Append to container
@@ -287,40 +285,48 @@ describe('Button-CTA Component Rendering', () => {
     });
   });
   
-  describe('Disabled State', () => {
-    it('should render disabled button with correct attributes', () => {
-      // Requirement: Disabled prop prevents interaction
-      const button = createButton({ label: 'Disabled Button', disabled: true });
-      
-      const shadowButton = button.shadowRoot?.querySelector('button');
-      expect(shadowButton?.hasAttribute('disabled')).toBe(true);
-      expect(shadowButton?.getAttribute('aria-disabled')).toBe('true');
-      expect(shadowButton?.className).toContain('button-cta--disabled');
+  describe('No Disabled State (philosophy exclusion)', () => {
+    // DesignerPunk does not support disabled states: if an action is
+    // unavailable, the component should not be rendered. state_disabled was
+    // removed from Button-CTA per the 2026-07-15 adjudication; these tests
+    // guard against the disabled state resurfacing.
+
+    it('should declare state_disabled under excludes (not contracts) in contracts.yaml', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const contractsContent = fs.readFileSync(
+        path.join(__dirname, '../contracts.yaml'),
+        'utf-8'
+      );
+
+      const contractsSection = contractsContent.split(/^excludes:/m)[0];
+      const excludesSection = contractsContent.split(/^excludes:/m)[1] ?? '';
+      expect(contractsSection).not.toContain('state_disabled');
+      expect(excludesSection).toContain('state_disabled');
     });
-    
-    it('should not have disabled attributes when disabled is false', () => {
-      // Requirement: Enabled button is interactive
-      const button = createButton({ label: 'Enabled Button', disabled: false });
-      
-      const shadowButton = button.shadowRoot?.querySelector('button');
-      expect(shadowButton?.hasAttribute('disabled')).toBe(false);
-      expect(shadowButton?.getAttribute('aria-disabled')).toBe('false');
-      expect(shadowButton?.className).not.toContain('button-cta--disabled');
+
+    it('should not expose a disabled property or observe a disabled attribute', () => {
+      expect(ButtonCTA.observedAttributes).not.toContain('disabled');
+
+      const button = createButton({ label: 'Button' });
+      expect('disabled' in button).toBe(false);
     });
-    
-    it('should prevent press event when disabled', () => {
-      // Requirement: Disabled button doesn't trigger onPress
-      const button = createButton({ label: 'Disabled Button', disabled: true });
-      
+
+    it('should ignore a disabled attribute set by consumers', () => {
+      const button = createButton({ label: 'Button' });
+      button.setAttribute('disabled', '');
+
       let pressCount = 0;
       button.addEventListener('press', () => {
         pressCount++;
       });
-      
+
       const shadowButton = button.shadowRoot?.querySelector('button');
+      expect(shadowButton?.hasAttribute('disabled')).toBe(false);
+      expect(shadowButton?.className).not.toContain('button-cta--disabled');
+
       shadowButton?.click();
-      
-      expect(pressCount).toBe(0);
+      expect(pressCount).toBe(1);
     });
   });
   
@@ -409,21 +415,6 @@ describe('Button-CTA Component Rendering', () => {
       expect(pressCount).toBe(1);
     });
     
-    it('should NOT call onPress when button disabled', () => {
-      // Requirement 15.1: Disabled button doesn't trigger onPress
-      const button = createButton({ label: 'Disabled Button', disabled: true });
-      
-      let pressCount = 0;
-      button.addEventListener('press', () => {
-        pressCount++;
-      });
-      
-      const shadowButton = button.shadowRoot?.querySelector('button');
-      shadowButton?.click();
-      
-      expect(pressCount).toBe(0);
-    });
-    
     it('should receive focus via Tab key', () => {
       // Requirement 15.2: Button is keyboard focusable
       const button = createButton({ label: 'Focusable Button' });
@@ -647,19 +638,6 @@ describe('Button-CTA Component Rendering', () => {
       expect(shadowButton?.getAttribute('role')).toBe('button');
       expect(shadowButton?.getAttribute('aria-label')).toBe('Accessible Button');
       expect(shadowButton?.getAttribute('type')).toBe('button');
-      expect(shadowButton?.getAttribute('aria-disabled')).toBe('false');
-    });
-    
-    it('should have proper ARIA attributes when disabled', () => {
-      // Requirement 12.6: Disabled button has correct ARIA attributes
-      const button = createButton({ label: 'Disabled Button', disabled: true });
-      
-      const shadowButton = button.shadowRoot?.querySelector('button');
-      
-      // Verify disabled ARIA attributes
-      expect(shadowButton?.getAttribute('role')).toBe('button');
-      expect(shadowButton?.getAttribute('aria-disabled')).toBe('true');
-      expect(shadowButton?.hasAttribute('disabled')).toBe(true);
     });
     
     it('should support keyboard navigation with Enter key', () => {
@@ -716,37 +694,5 @@ describe('Button-CTA Component Rendering', () => {
       expect(pressCount).toBe(1);
     });
     
-    it('should not activate on keyboard when disabled', () => {
-      // Requirement 15.4: Disabled button doesn't respond to keyboard
-      const button = createButton({ label: 'Disabled Keyboard', disabled: true });
-      
-      let pressCount = 0;
-      button.addEventListener('press', () => {
-        pressCount++;
-      });
-      
-      const shadowButton = button.shadowRoot?.querySelector('button');
-      shadowButton?.focus();
-      
-      // Try Enter key
-      const enterEvent = new KeyboardEvent('keydown', {
-        key: 'Enter',
-        code: 'Enter',
-        bubbles: true,
-        cancelable: true
-      });
-      shadowButton?.dispatchEvent(enterEvent);
-      
-      // Try Space key
-      const spaceEvent = new KeyboardEvent('keydown', {
-        key: ' ',
-        code: 'Space',
-        bubbles: true,
-        cancelable: true
-      });
-      shadowButton?.dispatchEvent(spaceEvent);
-      
-      expect(pressCount).toBe(0);
-    });
   });
 });

package/src/components/core/Button-CTA/__tests__/setup.test.ts

@@ -123,7 +123,6 @@ describe('Button-CTA Test Infrastructure Setup', () => {
         buttonVariant: 'secondary',
         icon: 'arrow-right',
         noWrap: true,
-        disabled: false,
         testID: 'test-button'
       });
       
@@ -132,7 +131,6 @@ describe('Button-CTA Test Infrastructure Setup', () => {
       expect(button.buttonVariant).toBe('secondary');
       expect(button.icon).toBe('arrow-right');
       expect(button.noWrap).toBe(true);
-      expect(button.disabled).toBe(false);
       expect(button.testID).toBe('test-button');
     });
     

package/src/components/core/Button-CTA/__tests__/test-utils.ts

@@ -96,7 +96,6 @@ export async function createButtonCTA(props: {
   buttonVariant?: 'primary' | 'secondary' | 'tertiary';
   icon?: string;
   noWrap?: boolean;
-  disabled?: boolean;
   testID?: string;
 }): Promise<ButtonCTA> {
   registerButtonCTA();
@@ -109,7 +108,6 @@ export async function createButtonCTA(props: {
   if (props.buttonVariant) button.buttonVariant = props.buttonVariant;
   if (props.icon) button.icon = props.icon;
   if (props.noWrap !== undefined) button.noWrap = props.noWrap;
-  if (props.disabled !== undefined) button.disabled = props.disabled;
   if (props.testID) button.testID = props.testID;
   
   // Append to document to trigger rendering