tasks/v1/carousel.yaml

- id: carousel-antd-T01
  name: 'Promo carousel: show Summer Sale slide'
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the Promo Banners carousel, show the slide titled “Summer Sale”. The task will finish automatically when done.
  ui_copy: 'Promo Banners — Show: Summer Sale'
  setup_description: |
    A single Ant Design Carousel is shown inside an isolated card in the center of the page.
    The carousel contains 4 full-width banner slides with a large title text centered on each slide: “Spring Sale”, “Summer Sale”, “Fall Clearance”, and “Winter Deals”.
    By default, the carousel shows “Spring Sale” (slide id: promo-spring). Autoplay is off.
    Dots/indicators are visible below the carousel (default AntD dots at the bottom); arrows are not shown.
    There are no other interactive components on the page and no distractors.
    The slide title text is also present as accessible text within the active slide region.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Few options and clear labels; success is a single unambiguous active slide change.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `promo-summer`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: promo-summer
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Ending on any other promo slide (e.g., “Spring Sale” or “Fall Clearance”).
  - Carousel is between slides / mid-animation and does not settle on “Summer Sale”.
  - If multiple carousels existed, changing the wrong one (not applicable here).
  expected_interaction_path:
  - Locate the dots under the carousel.
  - Click the dot corresponding to the “Summer Sale” slide (or use next until the title reads “Summer Sale”).
  - Verify the banner title in the carousel reads “Summer Sale”.
  notes: 'Checker hint: read the carousel root data-active-slide-id or aria-current indicator to determine the active slide.'
- id: carousel-antd-T02
  name: Return carousel to first slide
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Reset the News Highlights carousel so it shows the first slide titled “Top Story”. The task will finish automatically when done.
  ui_copy: 'News Highlights — Reset to: Top Story'
  setup_description: |
    A single Ant Design Carousel appears in an isolated card (centered).
    It contains 5 slides with a headline and short subtext. Slide titles in order are:
    1) “Top Story”, 2) “Markets”, 3) “Sports”, 4) “Weather”, 5) “Arts”.
    The initial state is NOT the first slide: the carousel loads on “Sports” (slide id: news-sports) to simulate returning to a known start.
    Dots are shown at the bottom; arrows are disabled (not visible). Autoplay is off.
    A small helper text above the carousel says “Use the carousel to browse today’s sections.”
    No other components affect success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Clear objective to return to a known first slide using visible indicators.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `news-top`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: news-top
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on any slide other than “Top Story”.
  - Leaving the carousel on “Top Story” momentarily but ending on a different slide due to an extra click.
  - Changing any non-carousel UI (none are present).
  expected_interaction_path:
  - Use the dots (or repeated previous navigation) to move to the first slide.
  - Confirm the active slide headline is “Top Story”.
  notes: 'Instrumentation: each slide has stable ids: news-top, news-markets, news-sports, news-weather, news-arts.'
- id: carousel-antd-T03
  name: Use next arrow once
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: activate
  secondary_template: null
  browsergym_goal: 'In the Onboarding carousel, click Next so the active slide becomes “Step 2: Profile”. The task will finish automatically when done.'
  ui_copy: 'Onboarding — Go to: Step 2: Profile'
  setup_description: |
    The page uses a light theme with comfortable spacing, but the carousel card is anchored near the top-left of the viewport.
    An Ant Design Carousel is configured with `arrows=true`, so left/right arrow buttons are visible on hover and keyboard-focus.
    There are 3 slides with large step titles: “Step 1: Welcome”, “Step 2: Profile”, “Step 3: Finish”.
    The initial active slide is “Step 1: Welcome” (slide id: ob-welcome). Autoplay is off.
    Dots are also shown at the bottom, but the instruction is intended to be completed via the Next arrow.
    No other carousels are present.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single step change using a large, clearly labeled slide; arrows provide straightforward navigation.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `ob-profile`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: ob-profile
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - 'Clicking Next twice and landing on “Step 3: Finish”.'
  - 'Using the previous arrow and staying on “Step 1: Welcome”.'
  - Carousel mid-transition (animation not finished).
  expected_interaction_path:
  - Move pointer over the carousel to reveal the Next arrow (right arrow).
  - Click the Next arrow once.
  - 'Verify the slide title reads “Step 2: Profile”.'
  notes: AntD Carousel supports `arrows` and `afterChange`; checker can also read the active dot index.
- id: carousel-antd-T04
  name: 'Dark theme gallery: navigate to Forest photo'
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: navigate_to
  secondary_template: null
  browsergym_goal: In the Photo Gallery carousel, show the slide labeled “Forest”. The task will finish automatically when done.
  ui_copy: 'Photo Gallery — Show: Forest'
  setup_description: |
    The page is in dark theme (dark background, light text) with comfortable spacing.
    One Ant Design Carousel is centered in an isolated card titled “Photo Gallery”.
    Slides are image cards with an overlaid label at the bottom-left: “Beach”, “Forest”, “City”, “Desert”.
    The initial slide is “Beach” (slide id: photo-beach). Autoplay is off.
    Dots are shown below the carousel; arrows are hidden. Each image also has an alt text matching the label.
    No clutter besides the card title and a short caption below the carousel (“Use arrows or dots to browse.”).
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Dark theme slightly reduces visual contrast, but there are few slides and each has a clear label/alt text.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `photo-forest`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: photo-forest
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on “City” or “Desert” instead of “Forest”.
  - Carousel shows the correct image but the active slide is not committed (not applicable—no confirm).
  - Carousel mid-animation.
  expected_interaction_path:
  - Use dots (or next navigation) to advance to the “Forest” slide.
  - Confirm the slide label reads “Forest”.
  notes: For accessibility observability, ensure each slide's label is plain text and not only baked into the image.
- id: carousel-antd-T05
  name: 'Compact carousel: set to slide 4'
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Mini Tips carousel to slide 4 titled “Shortcut Keys”. The task will finish automatically when done.
  ui_copy: 'Mini Tips — Go to slide 4: Shortcut Keys'
  setup_description: |
    The page uses light theme but is set to compact spacing and the carousel is rendered in a small size tier.
    A single Ant Design Carousel sits in the center of a small isolated card labeled “Mini Tips”.
    The carousel contains 6 short tip slides with titles: 1) “Getting Started”, 2) “Search”, 3) “Filters”, 4) “Shortcut Keys”, 5) “Exports”, 6) “Support”.
    The carousel starts on slide 2 “Search” (slide id: tip-search).
    Dots are visible but smaller due to compact mode; arrows are not shown. Autoplay is off.
    No other interactive elements are present.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Compact spacing makes indicators smaller, but the carousel is isolated and slide titles are explicit.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `tip-shortcuts`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: tip-shortcuts
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Landing on slide 3 “Filters” or slide 5 “Exports”.
  - Interacting with the card without changing the active slide to “Shortcut Keys”.
  - Leaving the carousel between slides.
  expected_interaction_path:
  - Use dots or repeated next navigation to reach slide 4.
  - Verify the slide title reads “Shortcut Keys”.
  notes: 'Checker: treat the active slide as the one with aria-hidden=false (or the active dot).'
- id: carousel-antd-T06
  name: 'Draggable product shots: drag to ''Side view'''
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: drag_operation
  secondary_template: null
  browsergym_goal: In the Product Shots carousel, drag the carousel until the active slide is “Side view”. The task will finish automatically when done.
  ui_copy: 'Product Shots — Show: Side view'
  setup_description: |
    A single Ant Design Carousel is displayed in an isolated card centered on the page.
    The carousel is configured with `draggable=true` (desktop drag/swipe is enabled) and `arrows=false` (no arrow buttons).
    There are 8 slides representing product photos. Each slide has a bold label beneath the image:
    “Front view”, “Side view”, “Back view”, “Detail”, “In hand”, “Packaging”, “Lifestyle”, “Size chart”.
    The carousel starts on “Front view” (slide id: shot-front). Autoplay is off.
    Dots are visible but the intended interaction is to drag horizontally within the carousel.
    The card footer shows a small hint: “Tip: you can click and drag the image.”
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires a continuous drag gesture and choosing among more slides; animation/settling can cause overshoot.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `shot-side`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: shot-side
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Dragging but stopping on “Back view” or another adjacent slide.
  - Leaving the carousel mid-drag so the active slide does not settle.
  - Using dots to reach the slide is allowed, but success still requires the active slide to be “Side view”.
  expected_interaction_path:
  - Click-and-drag (or swipe) the carousel content to move to the next slide.
  - Stop when the label beneath the image reads “Side view”.
  notes: AntD Carousel `draggable` is documented in the Ant Design Carousel API.
- id: carousel-antd-T07
  name: 'Reports carousel: find and stop on ''Q4 Summary'''
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the Monthly Reports carousel, browse until you find the slide titled “Q4 Summary” and make it the active slide. The task will finish automatically when done.
  ui_copy: 'Monthly Reports — Active slide should be: Q4 Summary'
  setup_description: |
    The page is a form_section layout titled “Analytics”.
    In the “Reports” section, there is one Ant Design Carousel titled “Monthly Reports”.
    The carousel shows 10 report cards with similar layouts (icon + title). Titles are:
    “January”, “February”, “March”, “April”, “May”, “June”, “July”, “August”, “September”, “Q4 Summary”.
    The carousel starts on “April” (slide id: rpt-apr). Autoplay is off. Dots are visible at the bottom; arrows are not shown.
    Other non-interactive clutter is present: two summary KPI tiles and a “Download CSV” button above the carousel, but they are distractors and not needed.
    The target slide “Q4 Summary” looks visually similar to the others except for the title, so the agent must read text to find it.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 2
    justification: Many similar options increase interference; the page has light clutter but the slide title is clearly observable.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `rpt-q4`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: rpt-q4
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on any month slide (e.g., “September”).
  - Scrolling within the page instead of changing the carousel slide.
  - Landing on “Q4 Summary” but immediately moving away due to an extra navigation step.
  expected_interaction_path:
  - Use dots or swipe/drag to advance through report cards.
  - Stop when the active slide title reads “Q4 Summary”.
  notes: 'Checker: match by slide id (rpt-q4) rather than visible title to avoid localization issues.'
- id: carousel-antd-T08
  name: Match reference banner in carousel
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the Brand Banners carousel to the slide that matches the reference banner preview shown to the right. The task will finish automatically when done.
  ui_copy: Brand Banners — Match the reference preview
  setup_description: |
    An isolated card contains an Ant Design Carousel titled “Brand Banners”.
    To the right of the carousel (still within the same card) there is a small “Reference preview” panel showing a miniature banner image with its label.
    The carousel contains 6 visually distinct banner slides, each with a short label in the bottom-right corner:
    “Blue Wave”, “Green Hills”, “Orange Burst”, “Purple Night”, “Red Sunset”, “Teal Grid”.
    The reference preview displays one of these banners (reference token: ref-banner-purple) and also prints the label in small text under the thumbnail.
    The carousel starts on “Blue Wave” (slide id: banner-blue). Dots are visible; arrows are hidden.
    No other components are required; the reference panel is read-only and exists only to specify the goal visually (guidance=mixed).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires interpreting a visual reference and mapping it to the correct slide among multiple banners.
  success_trigger:
    human_readable:
    - Target carousel shows the same slide as the reference card `ref-banner-purple` (reference resolves to slide `banner-purple`).
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_token: ref-banner-purple
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a slide with a similar color theme but not the exact matching banner.
  - Stopping on the correct slide label briefly but ending on a different banner.
  - Matching the text label in the reference but the active slide image does not correspond (if the label were misread).
  expected_interaction_path:
  - Look at the reference preview thumbnail and/or its label.
  - Use dots or next navigation to reach the matching banner slide.
  - Confirm the carousel shows the same banner (label and image) as the reference.
  notes: 'Implementation note: reference token maps to a slide id in config; checker resolves and compares active_slide_id.'
- id: carousel-antd-T09
  name: 'Modal gallery: open and show ''City at night'''
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: navigate_to
  secondary_template: open_overlay
  browsergym_goal: Open the Image Gallery modal, then in its carousel show the slide titled “City at night”. The task will finish automatically when done.
  ui_copy: 'Button: Open Image Gallery • Goal in modal: City at night'
  setup_description: |
    The main page shows an isolated card with a primary button labeled “Open Image Gallery”.
    Clicking the button opens an Ant Design Modal (modal_flow layout) containing a single Ant Design Carousel.
    The carousel inside the modal has 5 photo slides with captions under each image: “Sunrise”, “Forest trail”, “City at night”, “Snow peaks”, “Desert road”.
    The modal opens with the carousel on “Sunrise” (slide id: gal-sunrise). Autoplay is off.
    Dots are shown within the modal under the carousel; arrows are disabled.
    The rest of the modal contains a short paragraph of descriptive text (distractor) but does not affect success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires opening a modal before interacting with the carousel; slide choice is still clear once visible.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `gal-city`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: gal-city
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Not opening the modal, or opening it but leaving the carousel on a different photo.
  - Closing the modal after selecting the correct slide (selection would be lost in this setup).
  - Carousel mid-transition at evaluation time.
  expected_interaction_path:
  - Click “Open Image Gallery” to open the modal.
  - Use dots/next to navigate to “City at night”.
  - Verify the caption under the image reads “City at night”.
  notes: 'Secondary template open_overlay: modal must be opened, but success is purely the carousel''s active slide.'
- id: carousel-antd-T10
  name: 'Two carousels: set Testimonials to ''Customer Story 2'''
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Testimonials” carousel (not the “Hero Banners” carousel), show the slide titled “Customer Story 2”. The task will finish automatically when done.
  ui_copy: Hero Banners • Testimonials — set Testimonials to Customer Story 2
  setup_description: |
    The page is a small dashboard-like section with two Ant Design Carousels stacked vertically, anchored near the top-right of the viewport.
    The first card is labeled “Hero Banners” and contains a carousel of 3 marketing banners.
    The second card is labeled “Testimonials” and contains a carousel of 4 testimonial slides titled:
    “Customer Story 1”, “Customer Story 2”, “Customer Story 3”, “Customer Story 4”.
    Both carousels show dots; neither shows arrows. Autoplay is off for both.
    Initial state: Hero Banners is on its first slide (hero-1). Testimonials starts on “Customer Story 4” (test-4) to force navigation.
    Only the Testimonials carousel is checked for success; the Hero Banners carousel is a distractor and must remain unchanged.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: top_right
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 4
    justification: Two similar carousels increase disambiguation load; labels help but the agent must select the correct instance.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `test-2`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: test-2
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Testimonials
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Changing the Hero Banners carousel instead of Testimonials.
  - Testimonials ends on Story 1, 3, or 4 instead of Story 2.
  - Both carousels changed (even if Testimonials is correct).
  expected_interaction_path:
  - Locate the “Testimonials” card (second carousel).
  - Use its dots/next to move from “Customer Story 4” to “Customer Story 2”.
  - Ensure the “Hero Banners” carousel is untouched.
  notes: Checker must scope to the carousel instance labeled 'Testimonials' (e.g., nearest heading or data-instance-id).
- id: carousel-antd-T11
  name: 'Three carousels: match the partner logo reference'
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the “Partner Logos” carousel, show the logo that matches the reference tile. The task will finish automatically when done.
  ui_copy: 'Reference tile • Carousels: Featured Articles, Partner Logos, Testimonials'
  setup_description: |
    The page is a settings_panel layout titled “Homepage content”.
    At the top of the panel there is a small, read-only “Reference” tile that shows a single partner logo image (reference token: ref-logo-zenith).
    Below it are three Ant Design Carousels with similar sizing and dot indicators:
      1) “Featured Articles” (image + headline slides),
      2) “Partner Logos” (logo-only slides),
      3) “Testimonials” (quote cards).
    Only the “Partner Logos” carousel is the target component instance for this task.
    The Partner Logos carousel contains 9 logo-only slides (no large textual titles on the slides). Each logo image has an accessible alt text like “Zenith”, “Northwind”, etc.
    Initial state: Partner Logos starts on a different logo (logo-northwind). Autoplay is off; arrows are hidden; dots are small.
    Medium clutter is present in the settings panel: a few checkboxes and “Save”/“Cancel” buttons exist but are not required and should not be used.
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 3
    guidance: visual
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 5
    justification: Multiple carousel instances plus logo-only slides make target identification and state observability difficult; the goal is specified visually.
  success_trigger:
    human_readable:
    - Target carousel shows the same slide as the reference card `ref-logo-zenith` (reference resolves to slide `logo-zenith`).
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_token: ref-logo-zenith
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Partner Logos
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Changing Featured Articles or Testimonials instead of Partner Logos.
  - Selecting a visually similar logo (wrong brand) that does not match the reference tile.
  - Landing on the right logo but in the wrong carousel instance.
  - Carousel between slides where no single active logo is selected.
  expected_interaction_path:
  - Look at the reference logo tile.
  - Find the carousel labeled “Partner Logos”.
  - Use dots or repeated next navigation to cycle logos until the visible logo matches the reference.
  - Verify the Partner Logos active slide is the matching logo.
  notes: Checker should scope to instance 'Partner Logos' and resolve reference token to expected slide id.
- id: carousel-antd-T12
  name: 'Compact vertical dots: go to slide 11'
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Release Notes carousel to slide 11 titled “v2.11”. The task will finish automatically when done.
  ui_copy: 'Release Notes — Go to: v2.11'
  setup_description: |
    The page is light theme but uses compact spacing and renders the carousel at a small scale tier.
    A single Ant Design Carousel titled “Release Notes” is centered in an isolated card.
    The carousel is configured with dots placed on the start side (using AntD dotPlacement/start), so the indicators appear as a vertical stack on the left of the slides.
    There are 12 nearly identical slides titled “v2.01” through “v2.12”. Each slide has the version title in small text at the top.
    Initial state: the carousel starts on “v2.04” (slide id: rel-204). Autoplay is off; arrows are hidden; draggable is false.
    Because the dots are small and numerous in compact mode, selecting the correct slide index requires careful targeting.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 5
      density_choice_interference: 5
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Many highly similar slides and a dense vertical dot stack in compact/small mode create high acquisition and interference difficulty.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `rel-211`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: rel-211
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on v2.10 or v2.12 (adjacent versions).
  - Clicking the wrong dot due to dense indicators.
  - Carousel mid-animation (not settled).
  expected_interaction_path:
  - Use the left-side dot stack to jump close to the end of the carousel.
  - Fine-tune by clicking adjacent dots until the slide title is “v2.11”.
  notes: AntD supports dot placement options via dotPlacement.
- id: carousel-antd-T13
  name: 'Vertical carousel: drag to Day 5 itinerary'
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: drag_operation
  secondary_template: null
  browsergym_goal: In the Trip Itinerary carousel, scroll vertically until the active slide is “Day 5”. The task will finish automatically when done.
  ui_copy: 'Trip Itinerary — Active: Day 5'
  setup_description: |
    A single Ant Design Carousel is displayed in an isolated card in the center of the viewport.
    The carousel is configured as a vertical carousel (react-slick vertical mode) and is draggable, so the user can drag up/down within the slide area.
    There are 7 slides labeled “Day 1” through “Day 7”; each slide shows a day number badge and a short itinerary paragraph.
    The initial slide is “Day 2” (slide id: trip-day2). Autoplay is off.
    Dots are displayed on the end side as a vertical column; arrows are not shown.
    Because the interaction is vertical, page scroll can be confused with carousel drag; the agent must drag inside the carousel region.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Vertical drag gestures can be confounded with page scrolling; the carousel must settle on the exact target day slide.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `trip-day5`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: trip-day5
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Scrolling the page instead of moving the carousel, leaving the active slide unchanged.
  - Stopping on Day 4 or Day 6 instead of Day 5.
  - Carousel is between slides / not snapped to a day.
  expected_interaction_path:
  - Click and drag within the carousel content vertically (not the page).
  - Continue until the active slide label shows “Day 5”.
  notes: 'Implementation note: AntD Carousel forwards many props to react-slick; vertical mode should be documented via react-slick API link in AntD docs.'
- id: carousel-antd-T14
  name: 'Table cell carousel: set Listing B to image 3'
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the listings table, find the carousel in the row labeled “Listing B” and set it to “Image 3”. The task will finish automatically when done.
  ui_copy: 'Listings table — Listing B image carousel: Image 3'
  setup_description: |
    The page uses a table_cell layout: a compact listings table is shown near the bottom-right of the viewport.
    Two rows (“Listing A” and “Listing B”) each contain a small Ant Design Carousel inside the “Photos” column.
    Each row’s carousel contains 4 slides labeled “Image 1”–“Image 4” (small overlay label in the bottom-left of the image).
    The carousels are small (scale=small) but the page spacing remains comfortable; dots are shown under each tiny carousel.
    Initial state: Listing A is on Image 1 (listA-img1) and Listing B is on Image 4 (listB-img4).
    The rest of the table includes non-interactive columns (Price, Status) and a “View” link per row (distractor). Only Listing B’s carousel is checked.
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: bottom_right
    scale: small
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 5
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 5
    justification: Small carousels inside a dense table increase acquisition difficulty and the risk of editing the wrong row's carousel.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `listB-img3`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: listB-img3
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Listing B / Photos Carousel
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting Listing A to Image 3 instead of Listing B.
  - Listing B ends on Image 2 or Image 4.
  - Clicking the “View” link or other table elements without changing the carousel.
  expected_interaction_path:
  - Scroll attention to the table row labeled “Listing B”.
  - Use the dots under Listing B’s small carousel to move from Image 4 to Image 3.
  - Confirm the overlay label reads “Image 3” within Listing B’s carousel.
  notes: 'Checker: identify the target carousel by row label ''Listing B'' and column ''Photos'' (e.g., DOM containment).'
- id: carousel-antd-T15
  name: 'Customize drawer: set Header banners to ''Minimal'''
  canonical_type: carousel
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Carousel'
  task_template: navigate_to
  secondary_template: open_overlay
  browsergym_goal: Open the “Customize homepage” drawer and set the “Header Banners” carousel to the slide titled “Minimal”. The task will finish automatically when done.
  ui_copy: 'Button: Customize homepage • Drawer: Header Banners carousel → Minimal'
  setup_description: |
    The main page shows a settings overview with a button labeled “Customize homepage”.
    Clicking it opens a right-side Ant Design Drawer (drawer_flow layout).
    Inside the drawer there are two carousels:
      - “Header Banners” (5 slides: “Bold”, “Minimal”, “Photo”, “Split”, “Text-only”)
      - “Footer Promotions” (3 slides: “Coupon”, “Newsletter”, “App download”)
    Both carousels show dots; arrows are hidden. The drawer also contains multiple toggles, dropdowns, and a sticky footer with “Save changes” and “Cancel” buttons (high clutter).
    Initial state: Header Banners starts on “Bold” (hdr-bold) and Footer Promotions starts on “Newsletter” (ftr-news).
    Only the Header Banners carousel active slide is used for success; do not change Footer Promotions.
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 5
    justification: Requires opening a drawer, finding the correct carousel among multiple similar sections, and avoiding many distracting controls.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `hdr-minimal`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: hdr-minimal
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Header Banners
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Not opening the drawer, or closing it before setting the slide.
  - Setting Footer Promotions instead of Header Banners.
  - Ending on “Text-only” or “Photo” instead of “Minimal”.
  - Clicking “Save changes” without actually setting the correct active slide (save does not affect success).
  expected_interaction_path:
  - Click “Customize homepage” to open the drawer.
  - In the drawer, locate the “Header Banners” carousel.
  - Use its dots/next navigation to reach “Minimal”.
  - Ensure the “Footer Promotions” carousel is unchanged.
  notes: 'Secondary template open_overlay: drawer must be opened. Success ignores Save/Cancel; it only checks active slide id.'
- id: carousel-mantine-T01
  name: 'Featured cards: select ''Starter Pack'''
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the Featured Cards carousel, show the slide titled “Starter Pack”. The task will finish automatically when done.
  ui_copy: 'Featured Cards — Show: Starter Pack'
  setup_description: |
    A single Mantine Carousel (from @mantine/carousel) is shown inside a centered isolated card.
    The carousel is horizontal, withControls enabled and withIndicators enabled (default-style controls).
    It contains 4 card slides with large titles: “New Arrivals”, “Starter Pack”, “Team Picks”, “Last Chance”.
    The carousel starts on “New Arrivals” (slide id: feat-new). Loop is disabled; drag is enabled (Embla default).
    Clicking an indicator dot or the next/previous controls changes the active slide immediately with a short animation.
    No other interactive components are present.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Few slides with clear titles and visible controls/indicators make navigation straightforward.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `feat-starter`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: feat-starter
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on “Team Picks” or another slide instead of “Starter Pack”.
  - Carousel mid-transition at evaluation time.
  expected_interaction_path:
  - Click the indicator dot for the second slide or click Next once.
  - Verify the active slide title is “Starter Pack”.
  notes: Mantine Carousel supports withIndicators/withControls as shown in Mantine docs.
- id: carousel-mantine-T02
  name: Reset testimonials to first card
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Reset the Testimonials carousel so it shows “Testimonial 1”. The task will finish automatically when done.
  ui_copy: Testimonials — Reset to Testimonial 1
  setup_description: |
    One Mantine Carousel is displayed in a centered isolated card titled “Testimonials”.
    The carousel has withIndicators enabled but withControls disabled; users navigate primarily via indicator dots or drag.
    There are 5 slides labeled “Testimonial 1” through “Testimonial 5”.
    Initial state: the carousel opens on “Testimonial 4” (slide id: testi-4).
    Each slide contains a quote block with the label rendered as visible text at the top.
    No other components affect success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Simple reset-to-first-slide goal with clear labeling and minimal clutter.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `testi-1`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: testi-1
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving the carousel on Testimonial 2–5.
  - Dragging partially so the carousel does not settle on a slide.
  expected_interaction_path:
  - Use indicator dots to jump back to the first slide (or drag to the start).
  - Confirm the label reads “Testimonial 1”.
  notes: 'Checker: use Embla selectedScrollSnap index or data-active-slide-id.'
- id: carousel-mantine-T03
  name: 'Swipe gallery: drag to ''Card 3'''
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: drag_operation
  secondary_template: null
  browsergym_goal: In the Swipe Gallery carousel, drag until the active slide is “Card 3”. The task will finish automatically when done.
  ui_copy: 'Swipe Gallery — Active: Card 3'
  setup_description: |
    A Mantine Carousel withIndicators=false and withControls=false is displayed in an isolated card.
    The carousel is intended to be used via drag/swipe (Embla drag interaction).
    There are 6 slides labeled “Card 1”–“Card 6”, each with a large centered label.
    Initial state: “Card 1” (slide id: swipe-1) is active.
    The page has no other interactive elements; the carousel occupies most of the card width.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Requires a simple drag gesture to move a couple slides; slide labels are prominent.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `swipe-3`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: swipe-3
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Dragging too far and stopping on Card 4 or later.
  - Not completing the drag so the carousel stays on Card 2.
  - Carousel mid-animation without settling.
  expected_interaction_path:
  - Click and drag the carousel content leftward until Card 3 becomes active.
  - Release and let the carousel snap to Card 3.
  notes: Mantine Carousel is based on Embla carousel.
- id: carousel-mantine-T04
  name: 'Corner placement: show ''Overview'' slide'
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: navigate_to
  secondary_template: null
  browsergym_goal: In the Getting Started carousel, show the slide titled “Overview”. The task will finish automatically when done.
  ui_copy: Getting Started — Overview
  setup_description: |
    The page uses a dark theme and comfortable spacing, but the carousel card is anchored near the bottom-left of the viewport.
    A Mantine Carousel withControls enabled is shown with 3 slides: “Overview”, “Install”, “Next steps”.
    The carousel starts on “Install” (slide id: gs-install). Indicators are off; navigation is via Previous/Next controls or drag.
    Each slide title is rendered as large text at the top of the slide.
    No other components are present.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: bottom_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Only three slides and clear controls; non-center placement is the main robustness variation.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `gs-overview`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: gs-overview
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on “Install” or “Next steps”.
  - Dragging but not reaching the Overview slide.
  expected_interaction_path:
  - Click Previous once (or drag) to move from “Install” to “Overview”.
  - Confirm the title reads “Overview”.
  notes: null
- id: carousel-mantine-T05
  name: 'Small carousel: go to slide 5 ''FAQ'''
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Help Topics carousel to slide 5 titled “FAQ”. The task will finish automatically when done.
  ui_copy: 'Help Topics — Go to: FAQ'
  setup_description: |
    A single Mantine Carousel is rendered at a small scale tier in the center of an isolated card.
    Spacing is comfortable, but controls and indicator dots appear smaller because the component is compact.
    The carousel has withIndicators enabled and contains 6 slides titled:
    “Contact”, “Billing”, “Shipping”, “Returns”, “FAQ”, “Troubleshooting”.
    Initial state: the carousel starts on “Returns” (slide id: help-returns).
    Controls are visible; loop is off.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Small scale increases acquisition difficulty slightly, but the goal slide is clearly labeled.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `help-faq`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: help-faq
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on “Returns” or “Troubleshooting”.
  - Not letting the carousel settle after clicking an indicator.
  expected_interaction_path:
  - Use the indicator dots or Next control to move to the “FAQ” slide.
  - Confirm the slide title reads “FAQ”.
  notes: Use slide ids (help-contact, help-billing, ..., help-faq) for stable checking.
- id: carousel-mantine-T06
  name: 'Changelog carousel: find ''Breaking changes'''
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the Changelog carousel, find the slide titled “Breaking changes” and make it active. The task will finish automatically when done.
  ui_copy: 'Changelog — Active: Breaking changes'
  setup_description: |
    The page is a form_section titled “Release center” with light clutter (a couple of read-only stats and a “Subscribe” button).
    Within the section there is one Mantine Carousel configured with withIndicators=true and withControls=true.
    The carousel contains 8 slides that all look similar (same icon and layout). Titles are:
    “Highlights”, “Improvements”, “Bug fixes”, “Performance”, “Security”, “Deprecated”, “Breaking changes”, “Thanks”.
    Initial state: the carousel starts on “Bug fixes” (slide id: ch-bugfix).
    Slide titles are rendered as text headers, so the only reliable way to identify the target is to read the title.
    Loop is disabled; drag is enabled.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 2
    justification: Many similar slides increase interference; light page clutter adds minor distraction.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `ch-breaking`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: ch-breaking
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on “Deprecated” or “Thanks” instead of “Breaking changes”.
  - Navigating the page (scrolling/clicking Subscribe) without changing the carousel slide.
  - Ending mid-transition.
  expected_interaction_path:
  - Use Next/Previous controls or indicator dots to move through slides.
  - Stop when the slide title reads “Breaking changes”.
  notes: null
- id: carousel-mantine-T07
  name: Match the reference product photo
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the Product Gallery carousel to the slide that matches the reference photo shown below it. The task will finish automatically when done.
  ui_copy: Product Gallery — Match reference photo
  setup_description: |
    An isolated card contains a Mantine Carousel titled “Product Gallery”.
    The carousel uses withControls=true and withIndicators=true. Each slide shows a product photo and a short caption like “Angle A”, “Angle B”, etc.
    Directly below the carousel is a read-only “Reference photo” strip (reference token: ref-angle-d) showing the exact photo that should be displayed.
    The reference strip also shows a tiny caption under the thumbnail, but the primary cue is visual (guidance=mixed).
    The carousel contains 7 photo slides: “Angle A”, “Angle B”, “Angle C”, “Angle D”, “Angle E”, “Angle F”, “Angle G”.
    Initial state: the carousel starts on “Angle B” (slide id: angle-b). Loop is off.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: Requires matching a visual reference among several similar photo angles; state is less observable than text-only slides.
  success_trigger:
    human_readable:
    - Target carousel shows the same slide as the reference card `ref-angle-d` (reference resolves to slide `angle-d`).
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_token: ref-angle-d
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a similar-looking angle (C or E) instead of the exact match.
  - Matching the caption text but the visible photo is not the same as the reference.
  - Carousel does not settle on a single slide.
  expected_interaction_path:
  - Inspect the reference photo strip to identify the target angle.
  - Use indicators/controls to navigate until the carousel shows the same photo.
  - Confirm the active slide is the matching one.
  notes: 'Checker: resolve reference token to slide id; compare to Embla selected snap.'
- id: carousel-mantine-T08
  name: 'Two carousels in a form: set ''Shipping options'' to Express'
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Shipping options” carousel (not the “Payment methods” carousel), show the slide titled “Express”. The task will finish automatically when done.
  ui_copy: Checkout settings — Shipping options carousel → Express
  setup_description: |
    The page is a form_section layout anchored near the top-right of the viewport.
    Two Mantine Carousels appear as horizontally scrollable option pickers:
      - “Payment methods” carousel with slides: “Card”, “PayPal”, “Bank transfer”.
      - “Shipping options” carousel with slides: “Standard”, “Express”, “Overnight”.
    Both carousels use slideSize around 70% so only one card is prominent at a time; withIndicators are enabled.
    Initial state: Payment methods is on “Card” (pay-card). Shipping options starts on “Overnight” (ship-overnight).
    The surrounding form includes text inputs for address (distractors) but they do not affect success.
    Only the Shipping options carousel is checked; Payment methods must remain unchanged.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: top_right
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 4
    justification: Two similar carousel pickers in one form require careful instance selection and avoidance of distractor inputs.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `ship-express`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: ship-express
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Shipping options
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Changing Payment methods instead of Shipping options.
  - Shipping options ends on Standard or Overnight instead of Express.
  - Editing address inputs (irrelevant) without setting the carousel correctly.
  expected_interaction_path:
  - Locate the carousel labeled “Shipping options”.
  - Use its indicators or drag to move from Overnight to Express.
  - Ensure the Payment methods carousel remains on Card.
  notes: null
- id: carousel-mantine-T09
  name: 'Multi-item carousel: jump to ''Item 7'''
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: In the Trending Items carousel, make “Item 7” the active slide. The task will finish automatically when done.
  ui_copy: 'Trending Items — Active: Item 7'
  setup_description: |
    A Mantine Carousel is displayed in an isolated card with withControls=true and withIndicators=true.
    The carousel is configured to show multiple items per view: slideSize is approximately one-third width and slideGap is medium.
    Embla options include `slidesToScroll: 3` and `align: 'start'` (as in Mantine docs examples), so the Next/Previous controls move by groups of three items.
    There are 9 item slides labeled “Item 1” through “Item 9”. Initial state is “Item 1” (trend-1).
    Because multiple items are visible at once, the agent must ensure “Item 7” is the selected/active slide (not merely visible).
    The active slide has a subtle outline and `aria-current="true"` on its indicator.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 1
    justification: Grouped scrolling and multiple visible items make it harder to confirm which slide is truly active.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `trend-7`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: trend-7
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Item 7 is visible but Item 6 or Item 8 is the active slide.
  - Scrolling to the wrong group and ending on Item 9.
  - Carousel mid-transition.
  expected_interaction_path:
  - Use Next control to advance by groups until Item 7 is reachable.
  - Click/tap Item 7 card to make it the active slide if needed.
  - Verify the active indicator corresponds to Item 7.
  notes: Mantine docs show Embla options such as slidesToScroll via emblaOptions.
- id: carousel-mantine-T10
  name: 'Open modal and navigate to ''Gallery: Mountains'''
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: navigate_to
  secondary_template: open_overlay
  browsergym_goal: Open the Gallery modal and set its carousel to the slide titled “Mountains”. The task will finish automatically when done.
  ui_copy: 'Open Gallery • In modal: Mountains'
  setup_description: |
    The main page shows a button labeled “Open Gallery”.
    Clicking it opens a modal dialog containing a Mantine Carousel (modal_flow layout).
    The carousel has withControls=true and withIndicators=true and contains 5 photo slides with captions:
    “Beach”, “Forest”, “Mountains”, “City”, “Desert”.
    The modal opens with “Beach” active (slide id: mgal-beach). Loop is off.
    Outside the modal, the page is dimmed; clicking outside closes the modal (distractor risk), but closing is not required.
    Success is based only on the active slide inside the modal carousel.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires opening and staying within a modal overlay before setting the carousel to the target slide.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `mgal-mountains`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: mgal-mountains
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Not opening the modal or closing it before setting the target slide.
  - Stopping on Forest or City instead of Mountains.
  - Clicking outside the modal, dismissing it, and losing state.
  expected_interaction_path:
  - Click “Open Gallery” to open the modal.
  - Use Next/indicators to navigate to “Mountains”.
  - Confirm the caption reads “Mountains”.
  notes: null
- id: carousel-mantine-T11
  name: 'Vertical carousel in compact mode: drag to ''Chapter 6'''
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: drag_operation
  secondary_template: null
  browsergym_goal: In the Chapters carousel, scroll vertically until the active slide is “Chapter 6”. The task will finish automatically when done.
  ui_copy: 'Chapters — Active: Chapter 6'
  setup_description: |
    The page is light theme but uses compact spacing and renders the carousel at a small scale tier.
    A single Mantine Carousel is configured with `orientation="vertical"` and a fixed height (required for vertical orientation).
    withControls is disabled; withIndicators is enabled as a vertical dot list alongside the carousel.
    The carousel contains 8 slides labeled “Chapter 1” through “Chapter 8”, each a small card with a chapter title.
    Initial state: Chapter 3 (chap-3) is active. Loop is off. Drag interaction is enabled.
    Because the carousel is vertical, dragging inside it can be confused with scrolling the page; the agent must drag within the carousel region or use the vertical indicators.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Vertical orientation increases gesture ambiguity and requires careful control to settle on the correct chapter in compact/small mode.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `chap-6`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: chap-6
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Scrolling the page instead of moving the carousel (active chapter stays unchanged).
  - Stopping on Chapter 5 or Chapter 7 instead of Chapter 6.
  - Leaving the carousel between chapters (no clear active slide).
  expected_interaction_path:
  - Drag upward/downward inside the carousel (or click the vertical indicator) to reach Chapter 6.
  - Release and wait for the carousel to settle.
  - Verify the active slide title reads “Chapter 6”.
  notes: Mantine docs note that vertical orientation requires setting height.
- id: carousel-mantine-T12
  name: 'Dark dashboard: match the reference hero image in the correct carousel'
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the “Hero Images” carousel, show the slide that matches the reference image tile. The task will finish automatically when done.
  ui_copy: Reference tile • Hero Images carousel (target) • Other carousels
  setup_description: |
    The page is in dark theme and uses a dashboard layout with medium clutter (stats cards and action buttons).
    A small “Reference image” tile at the top shows the target hero image (reference token: ref-hero-lighthouse).
    Below it are three Mantine Carousels side by side:
      - “Hero Images” (target)
      - “Customer Logos” (distractor)
      - “Team Photos” (distractor)
    Each carousel uses withControls=true and withIndicators=true. Slides are image-heavy and have minimal text; alt text exists but is small.
    Initial state: Hero Images starts on a different image (hero-forest). Loop is enabled for all three carousels (emblaOptions.loop=true).
    The agent must pick the correct carousel instance and match the reference image under dark theme conditions.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 3
    guidance: visual
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 5
    justification: Dark theme plus image-dominant slides and three adjacent carousels create high disambiguation and low observability; goal is visual.
  success_trigger:
    human_readable:
    - Target carousel shows the same slide as the reference card `ref-hero-lighthouse` (reference resolves to slide `hero-lighthouse`).
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_token: ref-hero-lighthouse
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Hero Images
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Matching an image in Customer Logos or Team Photos instead of Hero Images.
  - Selecting a similar image (e.g., a coastline) that is not the exact reference image.
  - Leaving Hero Images on the correct image briefly but cycling past it due to loop navigation.
  expected_interaction_path:
  - Inspect the reference image tile.
  - Locate the “Hero Images” carousel (left-most of the three).
  - Use its controls/indicators to cycle until the visible image matches the reference.
  - Confirm the active slide is the matching image.
  notes: If loop is enabled, checker should still rely on slide ids (hero-lighthouse) rather than index, because indices can wrap.
- id: carousel-mantine-T13
  name: 'Looping carousel: find and stop on ''Slide 12: Credits'''
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the Storyboard carousel, find the slide titled “Credits” and make it active. The task will finish automatically when done.
  ui_copy: 'Storyboard — Active: Credits'
  setup_description: |
    A single Mantine Carousel is displayed in an isolated card with comfortable spacing.
    The carousel has withIndicators=true but indicators are rendered as small dots because the card is narrow.
    emblaOptions.loop=true is enabled, so navigating past the end wraps around.
    There are 12 slides with short titles: “Intro”, “Scene 1”, “Scene 2”, ... “Scene 10”, “Epilogue”, “Credits”.
    Many slides share similar typography; only the title text distinguishes them.
    Initial state: the carousel starts on “Scene 6” (sb-scene6). The target “Credits” slide id is sb-credits.
    No other components are present.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 5
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: A large number of similar slides combined with looping behavior and small indicators increases interference and overshoot risk.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `sb-credits`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: sb-credits
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on “Epilogue” instead of “Credits”.
  - Looping around and ending on a different scene after passing Credits.
  - Carousel mid-transition.
  expected_interaction_path:
  - Use Next/indicators to move forward through the storyboard.
  - If you overshoot due to looping, navigate back until “Credits” is active.
  notes: 'Checker: rely on slide id sb-credits, not index (loop can wrap).'
- id: carousel-mantine-T14
  name: 'Dashboard tiles: set the ''Announcements'' carousel to ''Maintenance'''
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: In the “Announcements” carousel, make the slide titled “Maintenance” active. The task will finish automatically when done.
  ui_copy: Dashboard — Announcements carousel → Maintenance
  setup_description: |
    The page uses a dashboard layout anchored near the bottom-right of the viewport.
    Two Mantine Carousels appear as small tiles in a grid:
      - “Announcements” (target) with 6 short message slides.
      - “Tips” (distractor) with 6 short tip slides.
    Both tiles are small (scale=small) and display indicator dots; controls are hidden to save space (navigation via dots/drag).
    The Announcements slides are: “Welcome”, “Pricing”, “Maintenance”, “New feature”, “Survey”, “Status”.
    Initial state: Announcements starts on “Survey” (ann-survey); Tips starts on “Tip 1”.
    Several other dashboard widgets (charts, buttons) are present as medium clutter, but they are not required for success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: bottom_right
    scale: small
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 5
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 5
    justification: Small tile carousels in a cluttered dashboard make it hard to acquire the right controls and avoid modifying the wrong carousel.
  success_trigger:
    human_readable:
    - Target carousel's active slide id equals `ann-maintenance`.
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        active_slide_id: ann-maintenance
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Announcements
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting the Tips carousel instead of Announcements.
  - Stopping on Pricing or New feature instead of Maintenance.
  - Announcing carousel mid-transition.
  expected_interaction_path:
  - Locate the Announcements tile.
  - Use its dots or drag to move from Survey to Maintenance.
  - Verify the Announcements title area shows “Maintenance”.
  notes: null
- id: carousel-mantine-T15
  name: 'Drawer gallery picker: choose the referenced banner for ''Header carousel'''
  canonical_type: carousel
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: @mantine/carousel Carousel'
  task_template: navigate_to
  secondary_template: open_overlay
  browsergym_goal: Open the “Choose banners” drawer, then set the “Header carousel” to the banner that matches the reference preview. The task will finish automatically when done.
  ui_copy: 'Button: Choose banners • Drawer: Header carousel → match reference'
  setup_description: |
    The main page has a button labeled “Choose banners”.
    Clicking it opens a left-side drawer (drawer_flow layout) that contains two Mantine Carousels:
      - “Header carousel” (target) with 7 banner slides
      - “Sidebar carousel” (distractor) with 7 banner slides
    At the top of the drawer there is a small “Reference preview” thumbnail and label (reference token: ref-banner-teal-grid).
    Both carousels have withIndicators=true and withControls=true. Slides are banner images with small corner labels.
    Initial state: Header carousel starts on “Blue Wave” (hdr-blue); Sidebar carousel starts on “Teal Grid” (side-teal) to create a tempting distractor.
    The drawer also contains several unrelated settings toggles and buttons (high clutter), but none affect success.
    The goal is specified in mixed form: the reference preview provides the visual target, and the banner label is also printed in small text under the preview.
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: center
    scale: default
    instances: 2
    guidance: mixed
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 5
    justification: Drawer layering plus two similar carousels and many distractors create high disambiguation; the target is specified via a reference preview.
  success_trigger:
    human_readable:
    - Target carousel shows the same slide as the reference card `ref-banner-teal-grid` (reference resolves to slide `hdr-teal-grid`).
    - No other carousel instance is modified (when multiple instances are present).
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_token: ref-banner-teal-grid
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Header carousel
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting the Sidebar carousel to the reference banner instead of Header carousel.
  - Leaving Header carousel on a different banner (e.g., Blue Wave).
  - Closing the drawer before completing the selection (state resets in this setup).
  expected_interaction_path:
  - Click “Choose banners” to open the drawer.
  - Read the reference preview label / image at the top.
  - In the Header carousel, navigate until the Teal Grid banner is active.
  - Do not change the Sidebar carousel (even though it already shows Teal Grid).
  notes: To reduce ambiguity, give each carousel a data-instance-id (header-carousel, sidebar-carousel) for checker scoping.