tasks/v1/drawer.yaml

- id: drawer-antd-T01
  name: Open Help drawer
  canonical_type: drawer
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Help drawer. The task will finish automatically when done.
  ui_copy: Open the Help drawer. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered in the viewport with comfortable spacing.
    The card title is "Support". Inside the card there is a single primary Ant Design button labeled "Open Help drawer".

    Target component: AntD Drawer.
    - The drawer is CLOSED on page load.
    - When opened, it slides in from the right and shows a header title "Help".
    - The drawer uses the default close (X) icon in the top-right of the header and a semi-transparent mask over the page.

    Drawer contents (distractor-free):
    - A short paragraph of help text and a small list of links (non-interactive text in this task).
    No other drawers exist on the page.
    Feedback:
    - Opening animates the drawer in and dims the background with the mask.
  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: 1
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single large button opens one drawer with immediate visual feedback.
  success_trigger:
    human_readable:
    - The AntD Drawer instance is open (visible) with open state = true.
    - No confirmation step is required.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      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:
  - The drawer remains closed.
  - A different overlay (if any) is opened instead of the drawer.
  expected_interaction_path:
  - Click the "Open Help drawer" button.
  - Wait for the drawer to finish opening.
  notes:
  - 'Instrumentation: add data-testid=''open-help-drawer'' to the trigger button and data-testid=''drawer-help'' to the Drawer
    root.'
  - Checker should read canonical open/closed from the Drawer 'open' prop/state.
- id: drawer-antd-T02
  name: Close Help drawer with header X
  canonical_type: drawer
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Close the Help drawer using the close (X) button in the drawer header. The task will finish automatically
    when done.
  ui_copy: Close the Help drawer using the close (X) button in the drawer header. The task will finish automatically when
    done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing. The only interactive elements are the AntD Drawer and its built-in close control.

    Initial state:
    - The AntD Drawer titled "Help" is already OPEN on page load (slides in from the right).
    - The page behind it is dimmed by the mask.

    Target component details:
    - The drawer header contains the title "Help" and a small close (X) icon button on the far right.
    - Clicking the close icon closes the drawer and removes the mask.
    No other drawers are present.
    Feedback:
    - The drawer slides out and the background returns to normal when closed.
  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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Only one open drawer and one close icon; state change is immediate and obvious.
  success_trigger:
    human_readable:
    - The Help drawer is closed (open state = false).
    - No confirmation dialog is shown/required.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      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:
  - The drawer remains open.
  - The agent clicks outside the drawer but the drawer stays open (e.g., if mask click is ignored).
  expected_interaction_path:
  - Click the close (X) icon in the drawer header.
  - Wait for the drawer to finish closing.
  notes:
  - 'Instrumentation: data-testid=''drawer-help'' on Drawer root; ensure the close icon is an actual button with an accessible
    name like ''Close''.'
  - 'Checker: success when Drawer open prop/state becomes false.'
- id: drawer-antd-T03
  name: Dismiss drawer via mask click
  canonical_type: drawer
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Close the Help drawer by clicking on the shaded area outside the drawer. The task will finish automatically
    when done.
  ui_copy: Close the Help drawer by clicking on the shaded area outside the drawer. The task will finish automatically when
    done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    Initial state:
    - The AntD Drawer titled "Help" is OPEN on page load.
    - The drawer slides in from the right and a semi-transparent mask covers the rest of the page.

    Target component configuration:
    - maskClosable = true (default behavior): clicking the mask should close the drawer.
    - The header still contains a close (X) icon, but the intended interaction is to dismiss via the mask.

    Drawer content:
    - A short help paragraph only (no other required controls).

    Feedback:
    - When the drawer closes, the mask disappears and the underlying card becomes fully interactive again.
  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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires clicking outside the drawer on the mask, but otherwise a simple single-step dismissal.
  success_trigger:
    human_readable:
    - The Help drawer is closed (open state = false).
    - Closure occurs without any confirmation step.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      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:
  - The drawer remains open after clicking within the drawer content area.
  - The agent clicks a link or text inside the drawer instead of dismissing it.
  expected_interaction_path:
  - Click on the dimmed mask area outside the drawer panel.
  - Wait for the drawer to close.
  notes:
  - 'Instrumentation: ensure the mask/backdrop element is present and clickable (e.g., data-testid=''drawer-mask'').'
  - 'Checker: Drawer open prop/state becomes false.'
- id: drawer-antd-T04
  name: Open Order summary drawer (bottom-left placement)
  canonical_type: drawer
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Order summary drawer. The task will finish automatically when done.
  ui_copy: Open the Order summary drawer. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card anchored to the bottom-left of the viewport (the card is not centered). Spacing is comfortable and component scale is default.

    Card content:
    - A section header "Checkout".
    - One primary Ant Design button labeled "View order summary".

    Target component: AntD Drawer.
    - The drawer is CLOSED initially.
    - When opened, it slides in from the right with title "Order summary".
    - Standard close (X) icon is visible in the header; a mask dims the rest of the page.

    Distractors:
    - A single disabled button labeled "Place order" is shown below the trigger button but does nothing.

    Feedback:
    - The drawer animates open and shows a bold total amount line (read-only).
  scene_context:
    theme: light
    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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Same simple open interaction as baseline, but the trigger is anchored in the corner of the viewport.
  success_trigger:
    human_readable:
    - The Order summary drawer is open (open state = true).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      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:
  - No drawer opens.
  - A non-drawer overlay opens (should not exist in this scene).
  expected_interaction_path:
  - Click "View order summary".
  - Wait for the drawer to open.
  notes:
  - 'Robustness factor: placement != center (bottom_left).'
  - 'Instrumentation: data-testid=''open-order-summary'' for the trigger and data-testid=''drawer-order-summary'' for the
    Drawer root.'
- id: drawer-antd-T05
  name: Open Billing address drawer from form section
  canonical_type: drawer
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Billing address drawer. The task will finish automatically when done.
  ui_copy: Open the Billing address drawer. The task will finish automatically when done.
  setup_description: |-
    Layout: form_section in the center of the viewport (a short checkout form). Spacing is comfortable and component scale is default.
    Clutter (low): the page shows a few standard form fields (Name, Email) and two secondary buttons unrelated to the task ("Apply coupon", "Estimate shipping"). These controls are distractors only.

    Target drawer trigger:
    - In the "Billing address" subsection there is a small Ant Design link-style button labeled "Edit in drawer".
    - Clicking it opens the billing drawer.

    Target component: AntD Drawer.
    - Initial state: CLOSED.
    - Slides in from the right with header title "Billing address".
    - Header has a close (X) icon. Mask is enabled.

    Drawer contents (not required for success):
    - A read-only address preview and a disabled "Save" button (disabled to prevent the task from depending on form filling).

    Feedback:
    - The drawer open animation and the dimming mask provide immediate feedback.
  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: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 2
    justification: Requires locating a small link-style trigger within a form section that contains unrelated distractor controls.
  success_trigger:
    human_readable:
    - The Billing address drawer is open (open state = true).
    - No confirmation is required.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      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:
  - A different control is activated (e.g., Apply coupon) and the drawer stays closed.
  - The drawer opens but for a different section (should not exist; only one drawer in this scene).
  expected_interaction_path:
  - Find the "Billing address" subsection in the form section.
  - Click "Edit in drawer".
  - Wait for the drawer to open.
  notes:
  - 'Robustness factor: layout=form_section with low clutter distractors.'
  - 'Instrumentation: data-testid=''edit-billing-address'' for trigger; data-testid=''drawer-billing-address'' for Drawer
    root.'
- id: drawer-antd-T06
  name: Close Shipping address drawer via footer Cancel (compact/small)
  canonical_type: drawer
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Close the Shipping address drawer by clicking Cancel in the drawer footer. The task will finish automatically
    when done.
  ui_copy: Close the Shipping address drawer by clicking Cancel in the drawer footer. The task will finish automatically when
    done.
  setup_description: |-
    Layout: isolated_card centered, but with COMPACT spacing and SMALL component scale (buttons and padding are reduced).

    Initial state:
    - The AntD Drawer titled "Shipping address" is already OPEN on page load.
    - The drawer slides in from the right. A mask covers the page.

    Target component configuration:
    - closable = false (no header X icon).
    - maskClosable = false (clicking the mask does NOT close the drawer).
    - A footer is enabled with two buttons: "Cancel" (secondary) and "Save" (primary). Only "Cancel" closes the drawer; "Save" is disabled for this task.

    Distractors:
    - Inside the drawer there are two text fields rendered in read-only mode (not interactive) to avoid form dependencies.

    Feedback:
    - Clicking "Cancel" closes the drawer and removes the mask.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 2
    justification: Requires finding a smaller footer Cancel button; common easy exits (mask click, header X) are disabled.
  success_trigger:
    human_readable:
    - The Shipping address drawer is closed (open state = false).
    - No additional confirmation dialog is required.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      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:
  - The drawer stays open because the agent clicked the mask or header area (maskClosable is disabled).
  - The agent clicks the disabled "Save" button and the drawer remains open.
  expected_interaction_path:
  - Locate the drawer footer.
  - Click the "Cancel" button.
  - Wait for the drawer to close.
  notes:
  - 'Robustness factors: spacing=compact and scale=small (reduced target sizes).'
  - 'Instrumentation: data-testid=''drawer-shipping-address'', footer buttons data-testid=''drawer-cancel'' and ''drawer-save''.'
- id: drawer-antd-T07
  name: Discard changes when closing Profile editor (dark theme)
  canonical_type: drawer
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer + AntD: Modal.confirm (confirm dialog)'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Close the Profile editor drawer and discard changes when prompted. The task will finish automatically when
    done.
  ui_copy: Close the Profile editor drawer and discard changes when prompted. The task will finish automatically when done.
  setup_description: |-
    Theme: DARK mode (dark background and light text). Layout remains an isolated_card centered with comfortable spacing.

    Initial state:
    - An AntD Drawer titled "Profile editor" is OPEN on page load.
    - The drawer contains a small form with one text input that has already been modified (dirty state). A visible tag near the title reads "Unsaved changes".

    Close behavior:
    - Attempting to close the drawer (via the header X or the footer "Cancel" button) triggers an Ant Design confirmation dialog (modal) with:
      - Title: "Discard changes?"
      - Buttons: "Keep editing" (cancel) and "Discard" (confirm)

    Task requirement:
    - The drawer must end up CLOSED, and the confirm choice must be "Discard".

    Distractors:
    - The form fields are present but do not need to be edited for success.

    Feedback:
    - After clicking "Discard", the dialog disappears and the drawer closes.
  scene_context:
    theme: dark
    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: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Adds a second decision layer (confirm dialog) in dark theme; the agent must choose the correct confirmation
      option to close.
  success_trigger:
    human_readable:
    - The Profile editor drawer is closed (open state = false).
    - The discard confirmation has been accepted (the confirm control labeled "Discard" was used).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      tolerance: null
      require_confirm: true
      confirm_control: Discard
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The agent clicks "Keep editing" and the drawer remains open.
  - The drawer is still open because the confirmation dialog was dismissed without choosing "Discard".
  - The drawer closes without showing/accepting the discard confirmation (should not be possible in this configuration).
  expected_interaction_path:
  - Initiate closing the drawer (click the header X or footer Cancel).
  - In the confirmation dialog, click "Discard".
  - Verify the drawer closes.
  notes:
  - 'Robustness factor: theme=dark (lower contrast on close controls).'
  - 'Instrumentation: give the confirm dialog buttons stable selectors (e.g., data-testid=''discard-confirm'' and ''discard-cancel'').'
  - 'Checker: require_confirm=true should verify that the confirmed action was taken, not just that the drawer is closed.'
- id: drawer-antd-T08
  name: Open the drawer that matches a visual icon reference (3 instances)
  canonical_type: drawer
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Open the drawer whose header icon matches the Target preview card. The task will finish automatically when
    done.
  ui_copy: Open the drawer whose header icon matches the Target preview card. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing. Clutter: none beyond the preview and the three triggers; the card contains several similar-looking icon buttons.

    On the card:
    - A small "Target preview" tile shows a single icon (e.g., a bell) with no text label.
    - Below it are three icon-only buttons (same size and style) that open three different AntD Drawers:
      1) Drawer A: header icon = star, title text "Panel"
      2) Drawer B: header icon = bell, title text "Panel"
      3) Drawer C: header icon = gear, title text "Panel"
    All three drawers share the same visible title text to force reliance on the icon.

    Initial state:
    - All drawers are CLOSED.

    Target component(s):
    - Three separate AntD Drawer instances (same canonical type) with a mask and header close (X) icon.
    - Only one drawer should be open at a time; opening one closes any previously open drawer.

    Feedback:
    - Opening a drawer slides it in from the right and updates the header icon, which should match the target preview.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: Three near-identical triggers and identical titles force visual disambiguation using the header icon reference.
  success_trigger:
    human_readable:
    - The drawer instance whose header icon matches the Target preview is open (open state = true for the matching instance).
    - All other drawer instances are closed.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
        exclusive: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Drawer B (bell icon)
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The wrong drawer is opened (icon does not match the Target preview).
  - Multiple drawers are open at once (should be prevented; if possible, count as failure).
  - A drawer opens but the target preview is ignored (mismatch).
  expected_interaction_path:
  - Look at the Target preview icon.
  - Click the icon-only trigger that corresponds to the drawer with the matching header icon.
  - Verify the opened drawer's header icon matches the preview.
  notes:
  - 'Robustness factor: guidance=visual; the correct choice is specified primarily by an icon match.'
  - 'Instrumentation: assign stable ids to each drawer root (drawer-a, drawer-b, drawer-c) and to each trigger button (open-a/open-b/open-c).'
  - 'Checker: compare the opened drawer instance id to the target instance id derived from the preview.'
- id: drawer-antd-T09
  name: Scroll to bottom to close Terms drawer
  canonical_type: drawer
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Close the Terms and conditions drawer by scrolling to the bottom and clicking "I Understand". The task
    will finish automatically when done.
  ui_copy: Close the Terms and conditions drawer by scrolling to the bottom and clicking "I Understand". The task will finish
    automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    Initial state:
    - An AntD Drawer titled "Terms and conditions" is OPEN on page load.
    - The drawer slides in from the right and contains a long, scrollable block of text (multiple paragraphs) so that the bottom is not visible initially.

    Target component configuration:
    - closable = false (no header X icon).
    - maskClosable = false (clicking the mask does NOT close the drawer).
    - The ONLY way to close is a button labeled "I Understand" located at the very bottom of the drawer content (not sticky; requires scrolling within the drawer).

    Distractors:
    - The drawer text includes numbered headings and inline links (non-functional in this task) that can distract attention.

    Feedback:
    - Clicking "I Understand" closes the drawer and removes the mask.
  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: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Closing control is off-screen inside a scrollable drawer and common dismissal routes are disabled.
  success_trigger:
    human_readable:
    - The Terms and conditions drawer is closed (open state = false).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      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:
  - The drawer remains open because the agent did not scroll to reveal the "I Understand" button.
  - The agent scrolls the page behind the drawer instead of the drawer content area, leaving the button hidden.
  - The agent clicks inline text/links and the drawer remains open.
  expected_interaction_path:
  - Scroll within the drawer content until the bottom is visible.
  - Click the "I Understand" button.
  - Wait for the drawer to close.
  notes:
  - 'Template=scroll_find: requires scrolling inside the drawer (not the main page) to reach the closing control.'
  - 'Instrumentation: data-testid=''drawer-terms'', and data-testid=''terms-acknowledge'' for the bottom button.'
- id: drawer-antd-T10
  name: Open nested Audit log drawer from within another drawer
  canonical_type: drawer
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer (2 instances, nested)'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Audit log drawer (it opens from inside Advanced settings). The task will finish automatically
    when done.
  ui_copy: Open the Audit log drawer (it opens from inside Advanced settings). The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    On the card:
    - A primary button labeled "Open Advanced settings".

    Drawer flow:
    1) Clicking "Open Advanced settings" opens the first AntD Drawer titled "Advanced settings" (slides in from the right).
       - This drawer contains several read-only setting rows (distractors) and a button labeled "View audit log".
    2) Clicking "View audit log" opens a SECOND AntD Drawer titled "Audit log" on top of the first drawer (nested drawers).
       - The Audit log drawer has its own header with a close (X) icon and its own mask layer above the first drawer.

    Initial state:
    - Both drawers are CLOSED.

    Target:
    - The "Audit log" drawer must be OPEN at the end.

    Feedback:
    - Each drawer has an opening animation. When the nested Audit log drawer opens, the header title "Audit log" is visible on the topmost panel.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 3
    justification: Requires a two-step nested overlay flow and correct instance identification of the inner drawer.
  success_trigger:
    human_readable:
    - The nested "Audit log" drawer instance is open (open state = true for the Audit log drawer).
    - The correct drawer instance is the Audit log drawer (not just the outer Advanced settings drawer).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Audit log drawer
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Only the outer "Advanced settings" drawer is opened and the Audit log drawer is still closed.
  - The Audit log drawer opens briefly but is closed again before termination.
  - The wrong drawer is targeted when multiple drawers are present.
  expected_interaction_path:
  - Click "Open Advanced settings" to open the first drawer.
  - Inside the first drawer, click "View audit log".
  - Verify the second (topmost) drawer titled "Audit log" is open.
  notes:
  - Instances=2 counts both nested Drawer components.
  - 'Instrumentation: data-testid=''drawer-advanced'', data-testid=''drawer-audit-log'', and trigger buttons ''open-advanced''
    / ''open-audit-log''.'
  - Checker should identify which drawer instance is topmost/open if multiple are open.
- id: drawer-mui-T01
  name: Open Navigation drawer (temporary, left)
  canonical_type: drawer
  implementation_source: mui
  implementation_variant: temporary
  implementation_component: 'MUI: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Navigation drawer. The task will finish automatically when done.
  ui_copy: Open the Navigation drawer. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing. The card simulates a small app header.

    On the card:
    - A single MUI Button labeled "Open navigation".

    Target component: MUI Drawer (variant="temporary", anchor="left").
    - Initial state: CLOSED.
    - Opening it slides a panel in from the left and shows the header text "Navigation".
    - A backdrop (mask) appears over the rest of the page.

    Drawer contents (not required for success):
    - A short list of navigation items (List/ListItem) rendered as read-only text for this task.

    Feedback:
    - The drawer slide-in animation and backdrop make the open state obvious.
  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: 1
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single prominent trigger opens a single drawer with clear visual feedback.
  success_trigger:
    human_readable:
    - The MUI Navigation drawer is open (open state = true).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      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:
  - The drawer stays closed.
  - Another overlay (dialog/menu) opens instead of the drawer.
  expected_interaction_path:
  - Click the "Open navigation" button.
  - Wait for the drawer to open.
  notes:
  - 'Implementation: MUI Drawer (temporary) as documented in MUI Drawer demos.'
  - 'Instrumentation: data-testid=''open-nav-drawer'' for trigger; data-testid=''drawer-navigation'' for Drawer Paper element.'
- id: drawer-mui-T02
  name: Open the drawer that matches a mixed (icon+text) reference
  canonical_type: drawer
  implementation_source: mui
  implementation_variant: temporary
  implementation_component: 'MUI: Drawer (2 instances)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Open the drawer that matches the Target preview (icon and title). The task will finish automatically when
    done.
  ui_copy: Open the drawer that matches the Target preview (icon and title). The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing. No unrelated controls are shown.

    At the top of the card:
    - A "Target preview" chip shows BOTH:
      - an icon (shopping cart), and
      - the text label "Cart"

    Below the preview are two similar icon buttons (same size/shape):
    1) Icon button with a shopping cart icon (opens Drawer instance "Cart")
    2) Icon button with a bookmark icon (opens Drawer instance "Saved")

    Target components:
    - Two separate MUI Drawer instances (variant="temporary", anchor="right").
    - Each drawer has a header with the same icon as its trigger and a title ("Cart" or "Saved").

    Initial state:
    - Both drawers are CLOSED.

    Feedback:
    - Opening the correct drawer shows the matching icon + title in the drawer header.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two similar icon triggers require light disambiguation using the provided preview, but the choices are
      few and feedback is clear.
  success_trigger:
    human_readable:
    - The drawer instance that matches the Target preview is open (open state = true for the matching instance).
    - The non-target drawer instance remains closed.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
        exclusive: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Cart drawer
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The Saved drawer opens instead of the Cart drawer.
  - Both drawers become open at once.
  - No drawer opens.
  expected_interaction_path:
  - Compare the Target preview (icon + title) to the two triggers.
  - Click the trigger matching the cart icon.
  - Verify the opened drawer header reads "Cart".
  notes:
  - 'Robustness factor: guidance=mixed; correct instance is specified by a small icon + text preview.'
  - 'Instrumentation: data-testid=''target-preview'', triggers ''open-cart''/''open-saved'', drawers ''drawer-cart''/''drawer-saved''.'
- id: drawer-mui-T03
  name: Close Navigation drawer with Escape
  canonical_type: drawer
  implementation_source: mui
  implementation_variant: temporary
  implementation_component: 'MUI: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Close the Navigation drawer by pressing the Escape key. The task will finish automatically when done.
  ui_copy: Close the Navigation drawer by pressing the Escape key. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    Initial state:
    - The MUI Drawer titled "Navigation" is OPEN on page load (temporary drawer with a backdrop).
    - The drawer is anchored on the left and covers part of the page.
    - The backdrop is visible behind the drawer.

    Close behavior:
    - The drawer listens for the Escape key and should close when Escape is pressed.
    - The header includes a close icon, but keyboard dismissal is expected.

    Drawer content:
    - A short list of navigation items (not required).

    Feedback:
    - On successful dismissal, the drawer slides out and the backdrop disappears.
  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: 1
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Simple one-step dismissal with obvious state change.
  success_trigger:
    human_readable:
    - The Navigation drawer is closed (open state = false).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      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:
  - The drawer stays open after keyboard input.
  - Focus remains outside the drawer and Escape does not close it (should not happen if properly wired).
  expected_interaction_path:
  - Ensure the page is focused (click inside the page if needed).
  - Press the Escape key.
  - Verify the drawer closes.
  notes:
  - 'Instrumentation: ensure the Drawer is mounted in the DOM and handles onClose for Escape/backdrop.'
  - 'Checker: drawer open prop/state becomes false.'
- id: drawer-mui-T04
  name: Open Notifications drawer from a corner-anchored header icon
  canonical_type: drawer
  implementation_source: mui
  implementation_variant: temporary
  implementation_component: 'MUI: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Notifications drawer. The task will finish automatically when done.
  ui_copy: Open the Notifications drawer. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card anchored to the bottom-right of the viewport (not centered). Spacing is comfortable; scale is default.

    Within the card is a compact app-bar row:
    - Left: text label "Dashboard"
    - Right: a small MUI IconButton with a bell icon and aria-label "Open notifications"

    Target component: MUI Drawer (variant="temporary", anchor="right").
    - Initial state: CLOSED.
    - When opened, it slides in from the right with a header title "Notifications".
    - Backdrop is enabled.

    Distractors:
    - Next to the bell icon is a disabled IconButton (settings gear) that does nothing.

    Feedback:
    - Drawer opening animation and backdrop indicate success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: bottom_right
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 2
    justification: Smaller icon-only trigger placed in a corner adds acquisition difficulty and a nearby distractor icon.
  success_trigger:
    human_readable:
    - The Notifications drawer is open (open state = true).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      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:
  - The drawer stays closed.
  - The wrong icon button is clicked (settings) and no drawer opens.
  expected_interaction_path:
  - Locate the bell IconButton in the card header.
  - Click it to open the drawer.
  - Wait for the drawer to open.
  notes:
  - 'Robustness factor: placement=bottom_right (trigger in a corner region).'
  - 'Instrumentation: data-testid=''open-notifications'' and data-testid=''drawer-notifications''.'
- id: drawer-mui-T05
  name: Pin a persistent Navigation drawer open (dark theme)
  canonical_type: drawer
  implementation_source: mui
  implementation_variant: persistent
  implementation_component: 'MUI: Drawer (persistent)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Pin the Navigation drawer open (persistent). The task will finish automatically when done.
  ui_copy: Pin the Navigation drawer open (persistent). The task will finish automatically when done.
  setup_description: |-
    Theme: DARK mode. Layout: isolated_card centered with comfortable spacing.

    This page demonstrates a persistent navigation drawer:
    - There is a labeled control row with:
      - Text label "Pinned navigation"
      - A MUI Switch (off by default)

    Target component: MUI Drawer (variant="persistent", anchor="left").
    - Initial state: CLOSED (not visible).
    - When "Pinned navigation" is turned on, the drawer becomes visible and stays open without a backdrop.

    Drawer header:
    - Shows the title "Navigation (pinned)".

    Distractors:
    - A secondary button labeled "Open temporary drawer" is present but disabled in this task.

    Feedback:
    - When pinned open, the drawer pushes content slightly to the right (persistent behavior) and remains visible.
  scene_context:
    theme: dark
    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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires toggling a persistent drawer state in dark theme; feedback is slightly subtler than a temporary
      drawer with backdrop.
  success_trigger:
    human_readable:
    - The persistent Navigation drawer is open/visible (open state = true).
    - No confirmation step is required.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      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:
  - The drawer remains closed (pinned switch not enabled).
  - A different drawer variant is opened (should not happen; temporary button is disabled).
  expected_interaction_path:
  - Locate the "Pinned navigation" switch.
  - Toggle it on.
  - Verify the persistent drawer appears and stays open.
  notes:
  - 'Robustness factor: theme=dark.'
  - 'Implementation: MUI Drawer with variant=''persistent''.'
  - 'Instrumentation: data-testid=''pinned-switch'' and data-testid=''drawer-navigation-persistent''.'
- id: drawer-mui-T06
  name: Open drawer from within a table cell context
  canonical_type: drawer
  implementation_source: mui
  implementation_variant: temporary
  implementation_component: 'MUI: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Invoice details drawer. The task will finish automatically when done.
  ui_copy: Open the Invoice details drawer. The task will finish automatically when done.
  setup_description: |-
    Layout: table_cell. The drawer trigger is embedded in a small table in the center of the viewport.
    Clutter (low): the table has 3 columns (Invoice, Amount, Action) and 2 rows.

    Action column:
    - Row 1 has an enabled MUI Button labeled "View details" (this is the ONLY enabled action).
    - Row 2 has a disabled "View details" button (distractor).

    Target component: MUI Drawer (variant="temporary", anchor="right").
    - Initial state: CLOSED.
    - When opened (via the enabled "View details" button), it shows the header title "Invoice details".
    - Backdrop is enabled.

    Drawer contents:
    - A short read-only summary (no further interaction required).

    Feedback:
    - Drawer slides in from the right and the backdrop appears.
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 2
    justification: The trigger is embedded in a table with a disabled distractor action, increasing acquisition and attention
      demands.
  success_trigger:
    human_readable:
    - The Invoice details drawer is open (open state = true).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      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:
  - The drawer stays closed because the agent clicked the disabled action in the second row.
  - The drawer stays closed because a non-action cell was clicked.
  expected_interaction_path:
  - Locate the enabled "View details" button in the first row of the table.
  - Click it.
  - Wait for the drawer to open.
  notes:
  - 'Robustness factor: layout=table_cell with low clutter.'
  - 'Instrumentation: data-testid=''invoice-table'', enabled action data-testid=''view-details-enabled'', drawer data-testid=''drawer-invoice-details''.'
- id: drawer-mui-T07
  name: Close a small bottom-anchored drawer via header close icon (compact/small)
  canonical_type: drawer
  implementation_source: mui
  implementation_variant: temporary
  implementation_component: 'MUI: Drawer (bottom anchor)'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Close the Quick add drawer using the close (X) icon in the drawer header. The task will finish automatically
    when done.
  ui_copy: Close the Quick add drawer using the close (X) icon in the drawer header. The task will finish automatically when
    done.
  setup_description: |-
    Layout: isolated_card centered, with COMPACT spacing and SMALL component scale.

    Initial state:
    - A MUI Drawer titled "Quick add" is OPEN on page load.
    - Drawer is anchored at the bottom (bottom sheet style) and covers roughly the lower half of the card area.
    - Backdrop is visible, but backdrop-click dismissal is disabled (onClose ignores reason='backdropClick').

    Target close control:
    - A small IconButton with an X icon is located in the top-right of the drawer header.

    Drawer contents:
    - A short list of suggested items (read-only chips) to create visual clutter inside the drawer but not required for success.

    Feedback:
    - Clicking the close icon dismisses the drawer with a slide-down animation and removes the backdrop.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Small-scale header close control is harder to acquire, and backdrop click does not help, increasing interaction
      precision demands.
  success_trigger:
    human_readable:
    - The Quick add drawer is closed (open state = false).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      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:
  - The drawer remains open because the agent clicked the backdrop (backdrop click is disabled).
  - The agent clicks inside drawer content but does not activate the close icon.
  expected_interaction_path:
  - Locate the small close (X) icon in the drawer header.
  - Click it.
  - Wait for the drawer to close.
  notes:
  - 'Robustness factors: spacing=compact, scale=small.'
  - 'Implementation detail: ignore backdropClick in onClose to force use of the header close control.'
  - 'Instrumentation: data-testid=''drawer-quick-add'' and data-testid=''drawer-quick-add-close''.'
- id: drawer-mui-T08
  name: Open a SwipeableDrawer by dragging (bottom anchor)
  canonical_type: drawer
  implementation_source: mui
  implementation_variant: swipeable
  implementation_component: 'MUI: SwipeableDrawer'
  task_template: drag_operation
  secondary_template: null
  browsergym_goal: Open the Filters bottom drawer by dragging it up until it is fully open. The task will finish automatically
    when done.
  ui_copy: Open the Filters bottom drawer by dragging it up until it is fully open. The task will finish automatically when
    done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    This scene uses a swipeable drawer (mobile-style bottom sheet) implemented with MUI SwipeableDrawer (anchor="bottom").

    Initial state:
    - The swipeable drawer is CLOSED.
    - A visible grab handle (a short horizontal bar) is shown at the very bottom edge of the card with the label "Filters".

    Interaction affordance:
    - There is NO separate "Open" button; the intended way to open is to drag (swipe) upward from the handle area.
    - The drawer follows the pointer while dragging and snaps open when dragged far enough.

    Drawer content (not required for success):
    - A few filter chips and a header "Filters" once fully opened.

    Feedback:
    - During drag, the drawer partially reveals; when fully open it settles into place and the content becomes fully visible.
  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: 4
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: Requires a continuous drag gesture with a threshold/snap behavior; partial states and motion feedback increase
      dynamics difficulty.
  success_trigger:
    human_readable:
    - The SwipeableDrawer is fully open (open state = true).
    - The open state must be the fully-open snapped state (not a partially dragged position).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      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:
  - The drawer is only partially dragged and then released without snapping open.
  - The drawer remains closed.
  - The agent drags the page content instead of the drawer handle area.
  expected_interaction_path:
  - Locate the bottom grab handle labeled "Filters".
  - Click-and-drag upward until the drawer snaps fully open.
  - Release and verify the drawer is open.
  notes:
  - 'Implementation variant: MUI SwipeableDrawer (anchor=''bottom'').'
  - 'Instrumentation: data-testid=''drawer-filters-swipeable'' and data-testid=''drawer-filters-handle''.'
  - 'Checker: use the component''s open state (not pixel position) to determine fully open.'
- id: drawer-mui-T09
  name: Discard changes when closing a form drawer (MUI dialog confirm)
  canonical_type: drawer
  implementation_source: mui
  implementation_variant: temporary
  implementation_component: 'MUI: Drawer + MUI: Dialog'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Close the Address editor drawer and discard changes when prompted. The task will finish automatically when
    done.
  ui_copy: Close the Address editor drawer and discard changes when prompted. The task will finish automatically when done.
  setup_description: |-
    Layout: form_section (a small profile/settings form) in the center of the viewport with low clutter.

    Initial state:
    - A MUI Drawer titled "Address editor" is OPEN on page load (variant="temporary", anchor="right").
    - Inside the drawer is a form with one field already modified, and a small inline message "You have unsaved changes".

    Close behavior:
    - Clicking the drawer header close icon (X) triggers a MUI Dialog confirmation:
      - Title: "Discard unsaved changes?"
      - Actions: "Keep editing" and "Discard"
    - Selecting "Discard" closes the dialog and then closes the drawer.

    Distractors:
    - The underlying page shows a few unrelated text fields (read-only) to simulate a form section, but they are not part of the task.

    Feedback:
    - The dialog appears centered above the drawer; after confirming discard, both dialog and drawer disappear.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Adds a layered confirm dialog and requires selecting the correct option to reach the closed state.
  success_trigger:
    human_readable:
    - The Address editor drawer is closed (open state = false).
    - The discard confirmation is accepted (clicked "Discard").
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      tolerance: null
      require_confirm: true
      confirm_control: Discard
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The agent chooses "Keep editing" and the drawer remains open.
  - The dialog is dismissed without choosing "Discard" and the drawer stays open.
  - The drawer stays open because the close attempt never happened.
  expected_interaction_path:
  - Click the drawer header close (X) icon.
  - In the confirmation dialog, click "Discard".
  - Verify the drawer closes.
  notes:
  - 'Robustness factors: layout=form_section with low clutter.'
  - 'Instrumentation: data-testid for drawer close icon and for dialog actions (discard/keep-editing).'
  - 'Checker: require_confirm=true should verify the dialog choice, not just final open state.'
- id: drawer-mui-T10
  name: Close multiple drawers to reach a clean page state
  canonical_type: drawer
  implementation_source: mui
  implementation_variant: mixed (persistent+temporary)
  implementation_component: 'MUI: Drawer (3 instances)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Close all open drawers so that no drawer is visible. The task will finish automatically when done.
  ui_copy: Close all open drawers so that no drawer is visible. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing. Clutter is LOW: only controls related to the three drawers are shown.

    There are THREE MUI drawer instances on the page:
    1) Navigation drawer (variant="persistent", anchor="left")
    2) Details drawer (variant="temporary", anchor="right")
    3) Help drawer (variant="temporary", anchor="bottom")

    Initial state:
    - Navigation drawer is OPEN (pinned, no backdrop).
    - Details drawer is OPEN (with backdrop).
    - Help drawer is CLOSED.

    Controls:
    - Navigation drawer has a toggle button labeled "Unpin navigation" inside its header area.
    - Details drawer has a header close (X) icon and also supports Escape/backdrop click.
    - Help drawer has a trigger button "Open help" (not needed) and a close icon when open.

    Task requirement:
    - End state must have ALL drawers closed (none visible).

    Feedback:
    - When each drawer closes, its panel disappears; for the temporary Details drawer, the backdrop disappears as well.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 4
    justification: Requires coordinating multiple drawer variants and ensuring the final global drawer state is fully reset.
  success_trigger:
    human_readable:
    - 'All drawer instances are closed: Navigation (persistent), Details (temporary), and Help (temporary).'
    - No drawer panel is visible on the page.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open_drawers: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: ALL drawers (Navigation, Details, Help)
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Any drawer remains open (even if others are closed).
  - The agent opens the Help drawer and leaves it open.
  - Only the temporary drawer is closed but the persistent navigation drawer remains pinned open.
  expected_interaction_path:
  - Close the temporary Details drawer (close icon, Escape, or backdrop click).
  - Unpin/close the persistent Navigation drawer using its "Unpin navigation" control.
  - Confirm that no drawer panels are visible.
  notes:
  - 'Template=clear_reset: goal is a neutral state with no open drawers.'
  - 'Instrumentation: each drawer root should have a stable id and open state; checker should verify all are closed.'
  - 'Suggested testids: drawer-nav, drawer-details, drawer-help; plus unpin button testid=''unpin-nav''.'
- id: drawer-mantine-T01
  name: Open Settings drawer
  canonical_type: drawer
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Settings drawer. The task will finish automatically when done.
  ui_copy: Open the Settings drawer. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    On the card:
    - A Mantine Button labeled "Open settings".

    Target component: Mantine Drawer.
    - Initial state: CLOSED.
    - When opened, it slides in from the right and shows the title "Settings" in the header.
    - An overlay dims the rest of the page; a close (X) button is present in the header.

    Drawer contents (not required for success):
    - A short list of settings descriptions rendered as plain text.

    Feedback:
    - Drawer opening animation and overlay make the open state clear.
  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: 1
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single clear trigger with one drawer instance and immediate feedback.
  success_trigger:
    human_readable:
    - The Settings drawer is open (open state = true).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      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:
  - The drawer remains closed.
  - A different overlay opens instead of the drawer.
  expected_interaction_path:
  - Click "Open settings".
  - Wait for the drawer to open.
  notes:
  - 'Instrumentation: data-testid=''open-settings-drawer'' and data-testid=''drawer-settings''.'
  - 'Implementation: Mantine Drawer supports positions (left/right/top/bottom); this task uses the default position.'
- id: drawer-mantine-T02
  name: Close Settings drawer with header X
  canonical_type: drawer
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Close the Settings drawer using the close (X) button in the drawer header. The task will finish automatically
    when done.
  ui_copy: Close the Settings drawer using the close (X) button in the drawer header. The task will finish automatically when
    done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    Initial state:
    - A Mantine Drawer titled "Settings" is OPEN on page load.
    - The drawer overlay is visible behind the panel.

    Close control:
    - The drawer header includes an X icon button on the right side.
    - Clicking the X closes the drawer.

    Drawer content:
    - Simple read-only text blocks (no additional required actions).

    Feedback:
    - Closing animates the drawer out and removes the overlay.
  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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Only one open drawer and a single close control; minimal ambiguity.
  success_trigger:
    human_readable:
    - The Settings drawer is closed (open state = false).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      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:
  - The drawer remains open.
  - The agent clicks the overlay but the drawer stays open (if overlay-click is disabled in config, this should not count).
  expected_interaction_path:
  - Click the header close (X) button.
  - Wait for the drawer to close.
  notes:
  - 'Instrumentation: data-testid=''drawer-settings'' and data-testid=''drawer-settings-close''.'
  - 'Checker: Drawer opened/open state becomes false.'
- id: drawer-mantine-T03
  name: Open the drawer that matches a visual color reference (2 instances)
  canonical_type: drawer
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer (2 instances)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Open the drawer whose header accent color matches the Target swatch. The task will finish automatically
    when done.
  ui_copy: Open the drawer whose header accent color matches the Target swatch. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    At the top of the card:
    - A "Target swatch" is shown as a small colored rectangle (no text), e.g., a teal accent.

    Below are two identical Mantine Buttons labeled "Open panel":
    - Button 1 opens Drawer A, which has a teal accent line under the header.
    - Button 2 opens Drawer B, which has a purple accent line under the header.

    Both drawers:
    - Have the same visible title text "Panel".
    - Open from the right with an overlay and a header close (X) button.

    Initial state:
    - Both drawers are CLOSED.

    Feedback:
    - The opened drawer shows its header accent color clearly, allowing visual confirmation against the Target swatch.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 3
    justification: Two similar options require simple visual matching, but the choice set is small and feedback is immediate.
  success_trigger:
    human_readable:
    - The drawer with the header accent color matching the Target swatch is open (open state = true for the matching instance).
    - The other drawer instance remains closed.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
        exclusive: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Drawer A (teal accent)
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The wrong drawer is opened (accent color does not match the Target swatch).
  - Both drawers become open at the same time.
  expected_interaction_path:
  - Compare the Target swatch color to the two drawers' accent colors (via their triggers or by opening).
  - Open the matching drawer.
  notes:
  - 'Robustness factor: guidance=visual; the target is specified by a color swatch rather than text.'
  - 'Instrumentation: testids drawer-a/drawer-b and open-a/open-b; include the target swatch value in a data attribute for
    checker mapping.'
- id: drawer-mantine-T04
  name: Open a top-position drawer in dark theme
  canonical_type: drawer
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer (position=top)'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Shortcuts drawer (it slides down from the top). The task will finish automatically when done.
  ui_copy: Open the Shortcuts drawer (it slides down from the top). The task will finish automatically when done.
  setup_description: |-
    Theme: DARK mode. Layout: isolated_card anchored to the top-left of the viewport (not centered) with comfortable spacing.

    On the card:
    - A Mantine Button labeled "Open shortcuts".

    Target component: Mantine Drawer configured with position="top".
    - Initial state: CLOSED.
    - When opened, it slides down from the top edge and shows the title "Shortcuts".
    - An overlay dims the rest of the page; the header includes a close (X) button.

    Distractors:
    - A second button labeled "Open help" is disabled (visual distractor only).

    Feedback:
    - The top-down slide animation and overlay indicate the drawer is open.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: top_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Dark theme plus a less-common top-position drawer can make targets and boundaries slightly harder to perceive.
  success_trigger:
    human_readable:
    - The Shortcuts drawer is open (open state = true).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      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:
  - The drawer stays closed.
  - A different overlay opens (should not happen; help button disabled).
  expected_interaction_path:
  - Click "Open shortcuts".
  - Wait for the top drawer to open.
  notes:
  - 'Robustness factor: theme=dark.'
  - 'Implementation: Mantine Drawer supports position prop (left/right/top/bottom).'
  - 'Instrumentation: data-testid=''open-shortcuts'' and data-testid=''drawer-shortcuts''.'
- id: drawer-mantine-T05
  name: Open the correct drawer among three labeled options
  canonical_type: drawer
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer (3 instances)'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Shipping drawer. The task will finish automatically when done.
  ui_copy: Open the Shipping drawer. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    On the card are three similar Mantine Buttons stacked vertically:
    - "Open Billing"
    - "Open Shipping"
    - "Open Returns"

    Each button opens a separate Mantine Drawer instance (all position="right") with matching titles:
    - Billing drawer title "Billing"
    - Shipping drawer title "Shipping"
    - Returns drawer title "Returns"

    Initial state:
    - All drawers are CLOSED.

    Distractors:
    - The three buttons are similar in size/style, and all open drawers with the same animation and overlay, increasing the chance of choosing the wrong one.

    Feedback:
    - The opened drawer shows its title in the header, allowing verification.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 4
    justification: Multiple similar triggers increase disambiguation even though titles are textually clear once opened.
  success_trigger:
    human_readable:
    - The Shipping drawer instance is open (open state = true for Shipping).
    - The Billing and Returns drawers remain closed.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
        exclusive: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Shipping drawer
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Billing drawer is opened instead of Shipping.
  - Returns drawer is opened instead of Shipping.
  - Multiple drawers are open at once.
  expected_interaction_path:
  - Click the "Open Shipping" button.
  - Verify the drawer title reads "Shipping".
  notes:
  - Instances=3; ensure each drawer has a unique id for checker (billing/shipping/returns).
  - 'Instrumentation: triggers open-billing/open-shipping/open-returns; drawers drawer-billing/drawer-shipping/drawer-returns.'
- id: drawer-mantine-T06
  name: Close a compact-spacing drawer via header close button
  canonical_type: drawer
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Close the Account drawer using the close (X) button in the drawer header. The task will finish automatically
    when done.
  ui_copy: Close the Account drawer using the close (X) button in the drawer header. The task will finish automatically when
    done.
  setup_description: |-
    Layout: isolated_card centered, but with COMPACT spacing (reduced padding and tighter spacing).

    Initial state:
    - A Mantine Drawer titled "Account" is OPEN on page load.
    - The overlay behind the drawer is visible.

    Target component configuration:
    - closeOnClickOutside = false (clicking the overlay does NOT close the drawer).
    - closeOnEscape = true (Escape could close, but the prompt asks for the header close button).
    - Header includes a small close (X) button on the right.

    Drawer contents:
    - A compact list of account options as read-only text (not required).

    Feedback:
    - Clicking the close icon closes the drawer and removes the overlay.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Compact spacing makes the close button smaller and disables overlay dismissal, increasing target acquisition
      demands.
  success_trigger:
    human_readable:
    - The Account drawer is closed (open state = false).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      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:
  - The drawer remains open because the agent clicked outside on the overlay (overlay-click close is disabled).
  - The agent interacts with drawer content but does not close it.
  expected_interaction_path:
  - Locate the header close (X) button.
  - Click it.
  - Wait for the drawer to close.
  notes:
  - 'Robustness factor: spacing=compact.'
  - 'Instrumentation: data-testid=''drawer-account'' and data-testid=''drawer-account-close''.'
- id: drawer-mantine-T07
  name: Open the drawer that matches an avatar+label reference (2 instances)
  canonical_type: drawer
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer (2 instances)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Open the drawer that matches the Target preview (avatar and label). The task will finish automatically
    when done.
  ui_copy: Open the drawer that matches the Target preview (avatar and label). The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    At the top of the card:
    - A "Target preview" tile shows:
      - a small circular avatar image (e.g., initials in a circle), and
      - a text label (e.g., "Team")

    Below the preview are two small Mantine ActionIcon triggers (icon-only, same size):
    1) Trigger A opens Drawer A with header avatar+label "Team"
    2) Trigger B opens Drawer B with header avatar+label "Project"

    Both drawers:
    - Open from the right with an overlay.
    - Use the same base title text "Panel", but the header includes the avatar and label as the primary identifier.

    Initial state:
    - Both drawers are CLOSED.

    Feedback:
    - When a drawer opens, its header shows the avatar + label, which should be compared to the Target preview.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: Icon-only triggers and subtle avatar cues require careful matching between the preview and the drawer header.
  success_trigger:
    human_readable:
    - The drawer whose header avatar+label matches the Target preview is open (open state = true for the matching instance).
    - The other drawer instance remains closed.
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
        exclusive: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Drawer A (Team)
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The Project drawer opens instead of the Team drawer.
  - Both drawers are open at once.
  - A drawer opens but does not match the Target preview content.
  expected_interaction_path:
  - Inspect the Target preview avatar and label.
  - Click the ActionIcon trigger that corresponds to the matching drawer.
  - Verify the opened drawer header matches the preview.
  notes:
  - 'Robustness factor: guidance=mixed (visual avatar + text label).'
  - 'Instrumentation: data-testid=''target-preview'', triggers ''open-team''/''open-project'', drawers ''drawer-team''/''drawer-project''.'
- id: drawer-mantine-T08
  name: Scroll to bottom action to close a Mantine drawer (privacy notice)
  canonical_type: drawer
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Close the Privacy notice drawer by scrolling to the bottom and clicking "Accept & close". The task will
    finish automatically when done.
  ui_copy: Close the Privacy notice drawer by scrolling to the bottom and clicking "Accept & close". The task will finish
    automatically when done.
  setup_description: |-
    Layout: form_section in the center of the viewport. Clutter is LOW: the page shows a few read-only profile fields behind the drawer.

    Initial state:
    - A Mantine Drawer titled "Privacy notice" is OPEN on page load.
    - The drawer contains a long scrollable notice (multiple paragraphs) so the bottom action is not initially visible.

    Target component configuration:
    - withCloseButton = false (no header X icon).
    - closeOnEscape = false.
    - closeOnClickOutside = false.
    - The ONLY closing control is a button labeled "Accept & close" located at the bottom of the drawer content (not sticky).

    Interaction requirement:
    - The agent must scroll inside the drawer content area to reveal the bottom button.

    Feedback:
    - Clicking "Accept & close" closes the drawer and removes the overlay.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: All quick dismissal routes are disabled and the close action is off-screen, forcing precise scrolling within
      the drawer.
  success_trigger:
    human_readable:
    - The Privacy notice drawer is closed (open state = false).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      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:
  - The drawer remains open because the agent did not scroll to the bottom.
  - The agent scrolls the underlying page instead of the drawer content area.
  - The agent clicks within the text but never activates the bottom "Accept & close" button.
  expected_interaction_path:
  - Scroll within the drawer content until the bottom action area is visible.
  - Click "Accept & close".
  - Wait for the drawer to close.
  notes:
  - 'Robustness factor: layout=form_section with low clutter.'
  - 'Instrumentation: data-testid=''drawer-privacy-notice'' and data-testid=''privacy-accept-close''.'
- id: drawer-mantine-T09
  name: Discard changes when closing a Mantine editor drawer (confirm modal)
  canonical_type: drawer
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer + Mantine: Modal'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Close the Note editor drawer and discard changes when prompted. The task will finish automatically when
    done.
  ui_copy: Close the Note editor drawer and discard changes when prompted. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    Initial state:
    - A Mantine Drawer titled "Note editor" is OPEN on page load.
    - Inside the drawer is a text area that already contains unsaved edits; an inline status text reads "Unsaved changes".

    Close behavior:
    - Clicking the header close (X) button opens a confirmation modal (Mantine Modal) with:
      - Title: "Discard changes?"
      - Buttons: "Keep editing" and "Discard"
    - Clicking "Discard" closes the modal and then closes the drawer.

    Distractors:
    - The drawer also shows a disabled "Save" button to simulate an editor UI without requiring saving.

    Feedback:
    - The modal appears above the drawer; after discarding, both modal and drawer are gone.
  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: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Nested confirm modal adds depth and requires correct option selection to reach the closed state.
  success_trigger:
    human_readable:
    - The Note editor drawer is closed (open state = false).
    - The discard confirmation is accepted (clicked "Discard").
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
      tolerance: null
      require_confirm: true
      confirm_control: Discard
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The agent clicks "Keep editing" and the drawer remains open.
  - The confirmation modal is dismissed without choosing "Discard".
  - The drawer remains open because the close action was never initiated.
  expected_interaction_path:
  - Click the drawer header close (X) button.
  - In the confirmation modal, click "Discard".
  - Verify the drawer closes.
  notes:
  - 'Instrumentation: data-testid for close icon and for modal actions discard/keep.'
  - 'Checker: require_confirm=true should verify the correct modal button was chosen.'
- id: drawer-mantine-T10
  name: Open nested Invite members drawer from within Team settings
  canonical_type: drawer
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer (2 instances, nested)'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Invite members drawer (it opens from inside Team settings). The task will finish automatically
    when done.
  ui_copy: Open the Invite members drawer (it opens from inside Team settings). The task will finish automatically when done.
  setup_description: |-
    Layout: isolated_card centered with comfortable spacing.

    On the card:
    - A primary Mantine Button labeled "Open Team settings".

    Drawer flow (nested):
    1) Clicking "Open Team settings" opens the first Mantine Drawer titled "Team settings" (position="right").
       - Inside it are several read-only setting rows and a button labeled "Invite members".
    2) Clicking "Invite members" opens a second Mantine Drawer titled "Invite members" on top of the first drawer.
       - The nested drawer has its own overlay layer and its own header close button.

    Initial state:
    - Both drawers are CLOSED.

    Target:
    - The nested "Invite members" drawer must be OPEN at the end.

    Feedback:
    - The topmost drawer's header clearly shows "Invite members" when successful.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two-step nested drawer flow increases depth and requires correct instance tracking.
  success_trigger:
    human_readable:
    - The nested "Invite members" drawer instance is open (open state = true for Invite members).
    - 'Correct instance requirement: opening only the outer Team settings drawer is insufficient.'
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Invite members drawer
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Only the outer "Team settings" drawer is open.
  - The Invite members drawer opens and is immediately closed again.
  - The wrong drawer instance is targeted in a multi-drawer scene.
  expected_interaction_path:
  - Click "Open Team settings" to open the first drawer.
  - Inside it, click "Invite members".
  - Verify the second drawer titled "Invite members" is open.
  notes:
  - Instances=2 (nested drawers).
  - 'Instrumentation: data-testid=''drawer-team-settings'', data-testid=''drawer-invite-members'', and triggers ''open-team-settings''/''open-invite''.'
  - 'Checker: should check open state of the correct drawer instance (invite).'