tasks/v1/combobox_editable_single.yaml

- id: combobox_editable_single-antd-T01
  name: Set favorite framework to React
  canonical_type: combobox_editable_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: AutoComplete'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the “Favorite framework” field, type to search and then select “React” from the suggestions. The task will finish automatically when done.
  ui_copy: |-
    Favorite framework: [ AutoComplete input ]
    Goal: Select React from the suggestions.
  setup_description: |
    A single isolated card titled “Developer Profile” is centered in the viewport. The card contains one editable combobox labeled “Favorite framework” implemented with Ant Design AutoComplete.

    - Scene: isolated_card layout, centered, light theme, comfortable spacing, default scale.
    - Component behavior: Clicking into the input opens a suggestion dropdown (popover) with framework options; typing filters the list. Selecting an option fills the input.
    - Options (single list, ~8 items): React, Angular, Vue, Svelte, SolidJS, Ember, Next.js, Remix.
    - Sub-controls: standard text caret; dropdown list items; no extra buttons besides the optional clear icon (not shown until a value exists).
    - Initial state: empty input (placeholder “Start typing…”).
    - Distractors: none (no other inputs or buttons in the card).
    - Feedback: the chosen value is shown as plain text in the input immediately after selection.
  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: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: A single, clearly labeled AutoComplete with a short option list; the only required interaction is typing and selecting the correct suggestion.
  success_trigger:
    human_readable:
    - The value of the “Favorite framework” combobox equals “React”.
    - The value is committed on the labeled instance “Favorite framework”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: React
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      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 different framework (e.g., “Vue”).
  - Typing “React” but leaving a different committed/selected option (if the component distinguishes typed text vs selected option).
  - Partial text like “Rea” with no final committed value.
  expected_interaction_path:
  - Click the “Favorite framework” input to focus it.
  - Type “Rea”.
  - Click “React” in the dropdown (or use arrow keys + Enter).
  notes: Checker should read the canonical combobox value (input text) and, if available, verify it corresponds to an option key/label equal to “React”.
- id: combobox_editable_single-antd-T02
  name: Open airport suggestions list
  canonical_type: combobox_editable_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: AutoComplete'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the suggestions dropdown for the “Airport” field. Do not select anything. The task will finish automatically when done.
  ui_copy: |-
    Airport: [ AutoComplete input ]
    Goal: Open the suggestions dropdown (no selection required).
  setup_description: |
    A single isolated card titled “Flight Search” is centered in the viewport. It contains one editable combobox labeled “Airport” implemented with Ant Design AutoComplete.

    - Scene: isolated_card, center placement, light theme, comfortable spacing, default scale.
    - Component behavior: Clicking the input (or its dropdown indicator) opens a popover list of suggested airports. The dropdown remains open while the input is focused.
    - Options (~10 items): Atlanta (ATL), Boston (BOS), Chicago (ORD), Dallas (DFW), Denver (DEN), Los Angeles (LAX), Miami (MIA), New York (JFK), Seattle (SEA), San Francisco (SFO).
    - Sub-controls: input text caret; dropdown popup list; no Apply/OK button.
    - Initial state: empty; placeholder “Type an airport”.
    - Distractors: none.
    - Feedback: open state is visible by the presence of the dropdown list under the input.
  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: This task only requires opening the combobox dropdown; no option selection or text entry is needed.
  success_trigger:
    human_readable:
    - The “Airport” combobox suggestion dropdown is open/expanded for the labeled instance “Airport”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        dropdown_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 dropdown is not open (input is unfocused or popup is closed).
  - Opening a different overlay (none exist in this scene).
  - Selecting an option is not required but should not be necessary for success (success should be based on open state only).
  expected_interaction_path:
  - Click inside the “Airport” input (or on its dropdown indicator) to open the list.
  notes: Instrument dropdown open state via aria-expanded/role=combobox or library popup visibility; do not require any particular highlighted option.
- id: combobox_editable_single-antd-T03
  name: Clear the City field
  canonical_type: combobox_editable_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: AutoComplete'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the value in the “City” field so the input becomes empty. The task will finish automatically when done.
  ui_copy: |-
    City: [ AutoComplete input prefilled with “Seattle” ]
    Goal: Clear the field.
  setup_description: |
    A single isolated card titled “Address” is centered in the viewport. It contains one editable combobox labeled “City” implemented with Ant Design AutoComplete.

    - Scene: isolated_card, center placement, light theme, comfortable spacing, default scale.
    - Component behavior: The AutoComplete input supports a clear (“×”) icon when a value is present. Clicking the clear icon empties the input.
    - Options (~12 cities): Seattle, San Diego, San Jose, San Francisco, Sacramento, Portland, Phoenix, Denver, Dallas, Austin, Chicago, Boston.
    - Sub-controls: clear icon appears in the right side of the input while it has a value; dropdown suggestions may appear when typing.
    - Initial state: input value is “Seattle”.
    - Distractors: none.
    - Feedback: after clearing, the placeholder text reappears and the input value becomes empty.
  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: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: The initial value is already set; the task is a straightforward clear/reset action with immediate visible feedback.
  success_trigger:
    human_readable:
    - The value of the “City” combobox is empty (no selected value and no remaining text).
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: ''
      tolerance:
        trim_whitespace: true
      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:
  - Replacing the value with a different city instead of clearing.
  - Leaving whitespace characters in the input (should be treated as not empty after trimming rules).
  - Clearing a different field (no other instances exist).
  expected_interaction_path:
  - Click the clear (×) icon in the “City” input.
  - Verify the input is empty.
  notes: If the implementation lacks a clear icon in a given variant, allow clearing via selecting all text and deleting; checker should look for empty canonical value.
- id: combobox_editable_single-antd-T04
  name: Choose Visa as payment method
  canonical_type: combobox_editable_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: AutoComplete'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the “Payment method” dropdown and select “Visa”. The task will finish automatically when done.
  ui_copy: |-
    Payment method: [ AutoComplete input ]
    Options include Visa, Mastercard, American Express, Discover.
  setup_description: |
    A single isolated card titled “Checkout” is centered in the viewport. It contains one editable combobox labeled “Payment method” implemented with Ant Design AutoComplete.

    - Scene: isolated_card, center placement, light theme, comfortable spacing, default scale.
    - Component behavior: The dropdown opens on focus/click. The user can either type to filter or directly click an option.
    - Options (4 items): Visa, Mastercard, American Express, Discover.
    - Sub-controls: dropdown list items; input caret; (optional) dropdown indicator icon.
    - Initial state: empty.
    - Distractors: a non-interactive order summary paragraph under the field (no buttons).
    - Feedback: chosen option appears as the input value immediately.
  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: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Very small option set with clear labels; opening the dropdown and clicking the target is sufficient.
  success_trigger:
    human_readable:
    - The “Payment method” combobox value equals “Visa”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Visa
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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 Mastercard/American Express/Discover.
  - Leaving the field empty.
  - Typing “Visa” but not committing any value (if the component distinguishes typed vs selected).
  expected_interaction_path:
  - Click the “Payment method” input to open the list.
  - Click “Visa”.
  notes: For robustness, allow either mouse selection or keyboard selection (arrow keys + Enter) as long as the final canonical value is “Visa”.
- id: combobox_editable_single-antd-T05
  name: Set Primary contact to Alice Johnson
  canonical_type: combobox_editable_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: AutoComplete'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the “Primary contact” field, search and select “Alice Johnson” from the suggestions. The task will finish automatically when done.
  ui_copy: |-
    Contacts
    Primary contact: [ AutoComplete ]
    Backup contact: [ AutoComplete ]
    Goal: Primary contact = Alice Johnson.
  setup_description: |
    A “Contacts” form section is centered in the viewport with two editable comboboxes (same canonical type) implemented using Ant Design AutoComplete.

    - Scene: form_section layout, center placement, light theme, comfortable spacing, default scale.
    - Instances: 2 AutoComplete fields stacked vertically:
      1) “Primary contact” (target)
      2) “Backup contact” (distractor)
    - Component behavior: Both fields open a suggestion dropdown on focus/typing. Selecting a suggestion fills the input.
    - Shared option dataset (~14 names): Alice Johnson, Alison Johnson, Alicia Jones, Alan Johnson, Bob Smith, Ben Wong, Becky Wu, Carlos Diaz, Chen Li, Dana Patel, Emily Nguyen, Fatima Hassan, George Kim, Hannah Lee.
    - Initial state:
      - Primary contact: empty.
      - Backup contact: prefilled with “Ben Wong”.
    - Distractors/clutter: the section also includes a non-target checkbox “Notify contacts by email” and a “Notes” textarea (not required for success).
    - Feedback: the selected name appears as plain text in the input.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 4
    justification: Two similar AutoComplete fields are present; the target name is confusable with similar spellings, increasing disambiguation and choice interference.
  success_trigger:
    human_readable:
    - The “Primary contact” combobox value equals “Alice Johnson”.
    - Success must be evaluated on the instance labeled “Primary contact”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Alice Johnson
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Primary contact
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting “Backup contact” to “Alice Johnson” while “Primary contact” remains empty or different.
  - Selecting a similar distractor like “Alison Johnson” or “Alicia Jones”.
  - Typing text without a final committed value (if applicable).
  expected_interaction_path:
  - Click the “Primary contact” input.
  - Type “Alice”.
  - Select “Alice Johnson” from the dropdown.
  notes: Add data-testid for each instance label (e.g., data-testid='contact-primary' / 'contact-backup') so the checker can bind the correct instance.
- id: combobox_editable_single-antd-T06
  name: Pick Pacific/Honolulu from a long time zone list
  canonical_type: combobox_editable_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: AutoComplete'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Open the “Time zone” list and choose “Pacific/Honolulu”. The task will finish automatically when done.
  ui_copy: |-
    Time zone: [ AutoComplete input ]
    Goal: Select Pacific/Honolulu.
  setup_description: |
    A single isolated card titled “Regional Settings” is anchored near the bottom-right of the viewport. It contains one editable combobox labeled “Time zone” implemented with Ant Design AutoComplete.

    - Scene: isolated_card layout, bottom_right placement, light theme, comfortable spacing, default scale.
    - Component behavior:
      - Clicking the input opens a tall dropdown list (max height ~240px) that is scrollable.
      - For this task, filtering is disabled: typing does NOT reduce the list (the dropdown always shows the full list).
    - Options (~60 IANA-like entries): Africa/Cairo, America/Chicago, America/Denver, America/Los_Angeles, America/New_York, Asia/Tokyo, Europe/London, Pacific/Auckland, Pacific/Honolulu, … (many more).
    - Sub-controls: scrollable dropdown panel; input caret.
    - Initial state: empty.
    - Distractors: none.
    - Feedback: after selection, the chosen time zone string appears in the input.
  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: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: A long scrollable dropdown increases search and motor demands; typing does not filter, so the agent must locate the item by scrolling.
  success_trigger:
    human_readable:
    - The “Time zone” combobox value equals “Pacific/Honolulu”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Pacific/Honolulu
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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 different time zone (e.g., “Pacific/Auckland”).
  - Scrolling the page instead of the dropdown so the option is never selected.
  - Leaving the field empty.
  expected_interaction_path:
  - Click the “Time zone” input to open the dropdown.
  - Scroll within the dropdown until “Pacific/Honolulu” is visible.
  - Click “Pacific/Honolulu”.
  notes: To enforce scroll_find, ensure the dropdown opens with the top of the list visible and “Pacific/Honolulu” initially off-screen within the dropdown panel.
- id: combobox_editable_single-antd-T07
  name: Match the Environment field to the reference badge
  canonical_type: combobox_editable_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: AutoComplete'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Environment” field to match the value shown in the Reference badge. The task will finish automatically when done.
  ui_copy: |-
    Environment settings
    Reference: [badge showing a target environment]
    Environment: [ AutoComplete input ]
  setup_description: |
    A settings panel is displayed in dark theme with a left sidebar (non-interactive for this task) and a main content area. In the main panel, there is one editable combobox labeled “Environment” implemented with Ant Design AutoComplete.

    - Scene: settings_panel layout, center placement, dark theme, comfortable spacing, default scale.
    - Guidance: A “Reference” badge is shown directly above the field (e.g., a colored pill). The agent must set the combobox to the same environment shown in that badge.
    - Component behavior: Focusing the input opens a dropdown of environment options; typing filters; clicking an option selects it.
    - Options (4 items): Development, Staging, Production, Sandbox.
    - Initial state: Environment input is empty.
    - Distractors/clutter: a couple of non-target toggles (“Enable logs”, “Verbose output”) and a “Save” button are present but are disabled and not required.
    - Feedback: once selected, the input shows the chosen environment; the Reference badge remains visible for comparison.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 2
    justification: The target is specified visually via an on-page reference badge rather than in the instruction text, increasing observability demands despite a small option set.
  success_trigger:
    human_readable:
    - The “Environment” combobox value matches the text shown in the Reference badge.
    - Matching is exact after trimming whitespace and applying Unicode NFC normalization.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_kind: badge
        reference_label: Reference
        reference_selector: '#env-reference'
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      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 any environment that does not match the Reference badge.
  - Typing a value that matches only partially (e.g., “Prod” for “Production”).
  - Changing a different control in the settings panel without setting the Environment combobox.
  expected_interaction_path:
  - Read the environment name from the Reference badge.
  - Click the “Environment” input.
  - Type a few letters (optional) and select the matching option.
  notes: Provide a stable selector for the reference badge text (e.g., id='env-reference') so the checker can compute the target reference value.
- id: combobox_editable_single-antd-T08
  name: Set Billing city to San José (diacritics + two fields)
  canonical_type: combobox_editable_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: AutoComplete'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the “Billing city” field, search and select “San José”. The task will finish automatically when done.
  ui_copy: |-
    Address dashboard
    Shipping city: [ AutoComplete ]
    Billing city: [ AutoComplete ]
    Goal: Billing city = San José.
  setup_description: |
    A compact “Address dashboard” panel is shown with two editable comboboxes (same canonical type) implemented with Ant Design AutoComplete.

    - Scene: dashboard layout with a top toolbar and side nav (not required), center placement, light theme, compact spacing, default scale.
    - Instances: 2 AutoComplete fields in a two-column layout:
      - Left: “Shipping city” (distractor)
      - Right: “Billing city” (target)
    - Component behavior: Typing filters suggestions; selecting fills the input immediately.
    - Options dataset (~16 cities), including confusable variants:
      - San Jose (no accent)
      - San José (accented é)
      - San Juan
      - Santa Rosa
      - San Diego
      - San Mateo
      - San Marcos
      - … plus other common cities (Austin, Boston, Denver, etc.)
    - Initial state:
      - Shipping city: “San Jose”
      - Billing city: empty
    - Distractors/clutter: the dashboard also contains non-target widgets (a small map thumbnail, two buttons “Refresh” and “Export”) that do nothing.
    - Feedback: selected city appears in the input; the accent mark is visible in the rendered text.
  scene_context:
    theme: light
    spacing: compact
    layout: dashboard
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: The target differs from a common distractor only by a diacritic and must be set on the correct instance in a denser dashboard layout.
  success_trigger:
    human_readable:
    - The combobox instance labeled “Billing city” has value exactly “San José” (Unicode-normalized).
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: San José
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Billing city
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting “Shipping city” to “San José” instead of “Billing city”.
  - Selecting “San Jose” (missing the accent) or another similar option like “San Juan”.
  - Entering “San José” with a different Unicode form that does not normalize to the same NFC string (checker should normalize, but raw mismatches should not count if normalization is disabled).
  expected_interaction_path:
  - Click the “Billing city” input.
  - Type “San”.
  - Choose the accented “San José” option from the dropdown.
  notes: Checker should bind to the instance by its visible label text (“Billing city”) or a stable data-testid.
- id: combobox_editable_single-antd-T09
  name: Select Newark (EWR) in a modal flight editor
  canonical_type: combobox_editable_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: AutoComplete'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the “Edit flight” dialog, then set the “Departure airport” field to “Newark (EWR)”. The task will finish automatically when done.
  ui_copy: |-
    Button: Edit flight
    Dialog: Flight details
    Departure airport: [ AutoComplete ]
    Goal: Departure airport = Newark (EWR).
  setup_description: |
    The page shows a small “Flight details” summary card with a primary button labeled “Edit flight”. Clicking it opens a modal dialog (Ant Design Modal) that contains the target combobox.

    - Scene: modal_flow layout, center placement, light theme, comfortable spacing, default scale.
    - Component location: inside the modal dialog, in the first form row.
    - Target component: an editable combobox labeled “Departure airport” implemented with Ant Design AutoComplete.
    - Component behavior: typing filters options; selecting an option fills the input immediately.
    - Options (~18 airports), with several “New…” distractors:
      - Newark (EWR)  [target]
      - New Orleans (MSY)
      - New York (JFK)
      - New York (LGA)
      - Newport News (PHF)
      - plus others (BOS, LAX, SFO, SEA, DEN, DFW, ORD, MIA, ATL…)
    - Initial state: empty.
    - Distractors in the modal: a non-target Date field, a Seat preference dropdown, and “Cancel” / “Close” buttons. None of these are required for success.
    - Feedback: after selection, the exact label “Newark (EWR)” is displayed in the input.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: The combobox is behind a modal layer and the option set contains multiple visually similar “New…” airports, increasing layering and choice interference.
  success_trigger:
    human_readable:
    - The “Departure airport” combobox value equals “Newark (EWR)”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Newark (EWR)
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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:
  - Opening the dialog but leaving the field empty.
  - Selecting a different “New…” airport (e.g., “New York (JFK)”).
  - Typing “Newark” without selecting an option if the component requires selection to commit (checker should enforce option membership if available).
  expected_interaction_path:
  - Click “Edit flight” to open the modal dialog.
  - Click the “Departure airport” input.
  - Type “Newa” and select “Newark (EWR)”.
  notes: If the modal traps focus, ensure the test harness exposes stable selectors for the modal root and the “Departure airport” label.
- id: combobox_editable_single-antd-T10
  name: Enter a formatted custom tag Road-trip
  canonical_type: combobox_editable_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: AutoComplete'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: In the “Custom tag” field, enter exactly “Road-trip” (capital R, hyphen). The task will finish automatically when done.
  ui_copy: |-
    Custom tag: [ AutoComplete input ]
    Goal: Road-trip
  setup_description: |
    A small “Tags” card is placed near the top-right of the viewport. It contains one editable combobox labeled “Custom tag” implemented with Ant Design AutoComplete.

    - Scene: isolated_card layout, top_right placement, light theme, comfortable spacing, SMALL scale (reduced input height and smaller icons).
    - Component behavior: The AutoComplete shows suggestions while typing, but it allows free text values that are not necessarily one of the suggestions.
    - Suggestions (shown in dropdown as you type): Road trip, road-trip, Road-trip, Roadtrip, Weekend-trip, Work-trip.
    - Initial state: empty.
    - Distractors: none.
    - Feedback: the input displays the exact entered text. No additional “Save” action is required.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_right
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 5
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: The required value is a strictly formatted string and the suggestion list contains near-duplicates that differ only by case or punctuation, increasing precision and interference.
  success_trigger:
    human_readable:
    - The “Custom tag” combobox value equals the exact string “Road-trip”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Road-trip
        value_source: free_text
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      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:
  - Any variant such as “Road trip” (space), “road-trip” (lowercase r), or “Roadtrip” (missing hyphen).
  - Leaving the input empty.
  - Entering additional trailing/leading characters (e.g., “Road-trip ”).
  expected_interaction_path:
  - Click the “Custom tag” input.
  - Type “Road-trip”.
  - Optionally press Enter or click outside to commit (implementation-dependent).
  notes: Checker should treat the input text as the canonical value. If the component emits a separate selected option, ignore it for free_text tasks.
- id: combobox_editable_single-mui-T01
  name: Select English as the UI language
  canonical_type: combobox_editable_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the “Language” field and select “English”. The task will finish automatically when done.
  ui_copy: |-
    Language: [ Autocomplete ]
    Options: English, Spanish, French, German.
  setup_description: |
    A single isolated card titled “Preferences” is centered in the viewport. It contains one editable combobox labeled “Language” implemented with MUI Autocomplete (Material UI).

    - Scene: isolated_card layout, center placement, light theme, comfortable spacing, default scale.
    - Component behavior: Clicking the input opens a popup list; selecting an option sets the input value.
    - Options (4): English, Spanish, French, German.
    - Sub-controls: input caret; popup indicator; listbox options.
    - Initial state: empty.
    - Distractors: none.
    - Feedback: selected language appears in the input immediately.
  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: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Small, unambiguous option list with a single Autocomplete instance.
  success_trigger:
    human_readable:
    - The “Language” combobox value equals “English”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: English
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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 Spanish/French/German.
  - Leaving the field empty.
  - Typing “English” without selecting it (if option membership is enforced).
  expected_interaction_path:
  - Click the “Language” input to open the list.
  - Click “English”.
  notes: Bind to the Autocomplete input via its label (e.g., aria-labelledby) for robust instance identification.
- id: combobox_editable_single-mui-T02
  name: Open the Country dropdown
  canonical_type: combobox_editable_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the options list for the “Country” field. Do not select anything. The task will finish automatically when done.
  ui_copy: |-
    Country: [ Autocomplete ]
    Goal: Open options list (no selection).
  setup_description: |
    A single isolated card titled “Shipping” is centered in the viewport. It contains one editable combobox labeled “Country” implemented with MUI Autocomplete.

    - Scene: isolated_card, center placement, light theme, comfortable spacing, default scale.
    - Component behavior: Clicking the input or the popup indicator opens the listbox. The listbox stays open while focused.
    - Options (~12): Canada, United States, Mexico, Brazil, United Kingdom, France, Germany, Spain, Italy, Japan, India, Australia.
    - Initial state: empty.
    - Distractors: none.
    - Feedback: open state is visible by the listbox rendered under the input.
  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: Only requires opening the Autocomplete listbox; no selection or typing.
  success_trigger:
    human_readable:
    - The “Country” combobox listbox is open/expanded.
    canonical_predicate:
      predicate_type: equals
      target_state:
        dropdown_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:
  - Listbox remains closed.
  - Focusing a different element without opening the Country list.
  expected_interaction_path:
  - Click the “Country” input or its popup indicator to open the list.
  notes: Use aria-expanded on the input (role=combobox) or presence of the listbox element to detect open state.
- id: combobox_editable_single-mui-T03
  name: Clear the selected Country
  canonical_type: combobox_editable_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the value in the “Country” field so it becomes empty. The task will finish automatically when done.
  ui_copy: |-
    Country: [ Autocomplete prefilled with “Canada” ]
    Goal: Clear the field.
  setup_description: |
    A single isolated card titled “Address” is centered in the viewport. It contains one editable combobox labeled “Country” implemented with MUI Autocomplete.

    - Scene: isolated_card, center placement, light theme, comfortable spacing, default scale.
    - Component behavior: The Autocomplete shows a clear (×) icon when a value is selected (clearable by default). Clicking the clear icon removes the selection and empties the input.
    - Options: Canada, United States, Mexico, United Kingdom, France, Germany.
    - Initial state: selected value “Canada”.
    - Distractors: none.
    - Feedback: after clearing, the input becomes empty and the clear icon 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: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: A single clear action with immediate feedback; no searching or disambiguation.
  success_trigger:
    human_readable:
    - The “Country” combobox has no selected value and the input text is empty.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: ''
      tolerance:
        trim_whitespace: true
      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:
  - Replacing “Canada” with another country instead of clearing.
  - Leaving any non-empty text in the input.
  - Clearing a different control (none exist).
  expected_interaction_path:
  - Click the clear (×) icon in the Country field.
  - Verify the field is empty.
  notes: If the UI uses a dedicated clear button with aria-label like “Clear”, the checker can also verify the selection is null in component state.
- id: combobox_editable_single-mui-T04
  name: Search and select San Francisco
  canonical_type: combobox_editable_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the “City” field, search and select “San Francisco”. The task will finish automatically when done.
  ui_copy: |-
    Shipping form
    City: [ Autocomplete ]
    Goal: San Francisco.
  setup_description: |
    A shipping form section is shown with several standard inputs. The “City” field is an editable combobox implemented with MUI Autocomplete.

    - Scene: form_section layout, center placement, light theme, comfortable spacing, default scale.
    - Target component: “City” Autocomplete.
    - Component behavior: typing filters options; selecting an option commits the value.
    - Options (~20), including similar “San …” entries: San Francisco, San Jose, San Diego, San Mateo, Santa Cruz, Santa Rosa, Sacramento, Seattle, Portland, Phoenix, Denver, Dallas, Austin, Chicago, Boston, Miami, Atlanta, Nashville, Orlando, Tampa.
    - Initial state: empty.
    - Distractors/clutter (not required): text inputs for Name and Street, a checkbox “Use as default address”, and a disabled “Continue” button.
    - Feedback: selected city appears in the input immediately.
  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: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Moderate option density with multiple similar city names; the component is embedded in a realistic form with light clutter.
  success_trigger:
    human_readable:
    - The “City” combobox value equals “San Francisco”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: San Francisco
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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 another “San …” city (e.g., “San Jose”).
  - Leaving the field empty.
  - Typing only partial text without committing a value.
  expected_interaction_path:
  - Click the City input.
  - Type “San f”.
  - Select “San Francisco” from the listbox.
  notes: If MUI renders listbox in a portal, ensure the checker can still locate the active listbox for this instance (e.g., by aria-controls linkage).
- id: combobox_editable_single-mui-T05
  name: Scroll to find America/New_York time zone
  canonical_type: combobox_editable_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Open the “Time zone” options and select “America/New_York”. The task will finish automatically when done.
  ui_copy: |-
    Time zone: [ Autocomplete ]
    Goal: America/New_York.
  setup_description: |
    A single isolated card titled “Time zone” is placed near the top-right of the viewport. The card contains one MUI Autocomplete combobox labeled “Time zone”.

    - Scene: isolated_card layout, top_right placement, light theme, comfortable spacing, default scale.
    - Component behavior:
      - The listbox opens on focus.
      - The listbox is scrollable (max height ~240px).
      - Filtering is intentionally disabled for this task (typing does not reduce the list) to emphasize scrolling.
    - Options (~80): a long list of IANA-like time zones including Africa/Johannesburg, America/Chicago, America/Los_Angeles, America/New_York, Asia/Seoul, Asia/Tokyo, Europe/Berlin, Europe/London, Pacific/Auckland, etc.
    - Initial state: empty.
    - Distractors: none.
    - Feedback: the selected option label is shown in the input.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_right
    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: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: The target is inside a long scrollable listbox; finding it requires scrolling and accurate clicking in the dropdown.
  success_trigger:
    human_readable:
    - The “Time zone” combobox value equals “America/New_York”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: America/New_York
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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 “America/Chicago” or any other zone.
  - Scrolling the page instead of the listbox and failing to select the target.
  - Leaving the field empty.
  expected_interaction_path:
  - Click the Time zone input to open the listbox.
  - Scroll within the listbox until “America/New_York” is visible.
  - Click “America/New_York”.
  notes: Ensure the target option is not initially visible in the listbox viewport to make scrolling necessary.
- id: combobox_editable_single-mui-T06
  name: Match Snack selection to the sample chip
  canonical_type: combobox_editable_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Snack” field to match the value shown in the Sample chip. The task will finish automatically when done.
  ui_copy: |-
    Snack picker
    Sample: [chip]
    Snack: [ Autocomplete ]
  setup_description: |
    A centered isolated card titled “Snack picker” contains one editable MUI Autocomplete combobox labeled “Snack” and a visual reference element.

    - Scene: isolated_card layout, center placement, light theme, comfortable spacing, default scale.
    - Guidance: To the right of the label, a “Sample” chip is displayed (e.g., a rounded pill UI element). The target snack is shown on that chip; the instruction does not spell the value out.
    - Component behavior: opening the listbox shows snack options; typing filters; selecting commits.
    - Options (6): Apple, Banana, Granola bar, Yogurt, Trail mix, Pretzels.
    - Initial state: empty.
    - Distractors: none.
    - Feedback: the selected snack appears in the input; the Sample chip remains visible to compare.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: The target must be read from an on-page visual chip rather than from the prompt, increasing observability requirements.
  success_trigger:
    human_readable:
    - The “Snack” combobox value matches the text shown in the Sample chip.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_kind: chip
        reference_label: Sample
        reference_selector: '#snack-sample-chip'
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      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 any snack that does not match the Sample chip.
  - Typing partial text that does not resolve to the exact option.
  - Leaving the field empty.
  expected_interaction_path:
  - Read the snack name from the Sample chip.
  - Open the Snack Autocomplete.
  - Select the matching option.
  notes: Expose the sample chip’s text via a stable selector so the checker can compute the reference value.
- id: combobox_editable_single-mui-T07
  name: Enter invoice ID INV-2048 in free text mode
  canonical_type: combobox_editable_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (freeSolo)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: In the “Invoice ID” field, enter exactly “INV-2048”. The task will finish automatically when done.
  ui_copy: |-
    Billing settings
    Invoice ID: [ Autocomplete input with suggestions ]
    Goal: INV-2048
  setup_description: |
    A billing settings panel contains one editable combobox labeled “Invoice ID” implemented with MUI Autocomplete configured in free text mode (freeSolo).

    - Scene: settings_panel layout, center placement, light theme, COMPACT spacing, default scale.
    - Component behavior: As you type, past invoice IDs appear as suggestions, but the field accepts any text even if it is not an option.
    - Suggestions (examples): INV-2045, INV-2046, INV-2047, INV-2049, INV-2148, INV-3048.
    - Initial state: empty.
    - Distractors/clutter: a “Currency” select and a toggle “Email receipts” are present but irrelevant.
    - Feedback: the input shows the entered text immediately. No separate submit/save is required.
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: The target is a strictly formatted identifier and nearby suggestions are confusable; however, the scene contains only one relevant instance.
  success_trigger:
    human_readable:
    - The “Invoice ID” combobox value equals “INV-2048” exactly.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: INV-2048
        value_source: free_text
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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:
  - Entering “inv-2048” (wrong case).
  - Selecting a nearby suggestion like “INV-2047” or “INV-2148”.
  - Leaving trailing spaces or extra characters.
  expected_interaction_path:
  - Click the Invoice ID field.
  - Type “INV-2048”.
  - Press Enter or blur the field if needed to commit.
  notes: Checker should read the input’s current value as the canonical value for free_text tasks.
- id: combobox_editable_single-mui-T08
  name: 'Set Assignee in a table row (Bug #1842 → Alex Kim)'
  canonical_type: combobox_editable_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (in DataGrid cell)'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: 'In the issues table, set the Assignee for “Bug #1842” to “Alex Kim”. The task will finish automatically when done.'
  ui_copy: |-
    Issues table
    Row: Bug #1842 | Assignee: [editable Autocomplete]
    Goal: Assignee = Alex Kim.
  setup_description: |
    A small issues table is shown (table_cell layout). Each row has an editable “Assignee” cell implemented with MUI Autocomplete that appears when the cell is activated.

    - Scene: table_cell layout, center placement, light theme, COMPACT spacing, SMALL scale (tight row height and small text).
    - Instances: 3 Autocomplete instances exist (one per row’s Assignee cell):
      - Bug #1839 → Assignee
      - Bug #1842 → Assignee  (target row)
      - Bug #1847 → Assignee
    - Component behavior: Clicking the Assignee cell activates an inline Autocomplete input within the cell. Typing filters names; selecting commits.
    - Options (~10 assignees): Alex Kim, Alexa King, Alice Johnson, Ben Wong, Carlos Diaz, Dana Patel, Emma Stone, George Kim, Hannah Lee, Priya Singh.
    - Initial state: all three Assignee cells show “Unassigned”.
    - Distractors/clutter: table has other non-editable columns (Status, Priority) and a toolbar with filters (not required).
    - Feedback: after selection, the cell shows the chosen assignee name and the inline editor collapses.
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: center
    scale: small
    instances: 3
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 5
    justification: The target is an inline table cell editor with small hit targets and multiple identical instances across rows, making correct row/column disambiguation difficult.
  success_trigger:
    human_readable:
    - 'In the issues table, the Assignee combobox in row “Bug #1842” equals “Alex Kim”.'
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Alex Kim
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: 'Bug #1842 → Assignee'
      terminal_condition: task ends when predicate holds
  negative_cases:
  - 'Setting the Assignee in a different row (e.g., Bug #1839) to “Alex Kim”.'
  - Selecting a confusable name like “Alexa King”.
  - Typing “Alex Kim” but not committing the selection so the cell still reads “Unassigned”.
  expected_interaction_path:
  - 'Locate the row labeled “Bug #1842”.'
  - Click its Assignee cell to activate editing.
  - Type “Alex” and select “Alex Kim”.
  notes: Checker should identify the target instance by row key + column (e.g., data-rowid='1842' and data-col='assignee') rather than screen position.
- id: combobox_editable_single-mui-T09
  name: Choose Paris, France over Paris, Texas (dark dashboard)
  canonical_type: combobox_editable_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the “Destination” field, search and select “Paris, France”. The task will finish automatically when done.
  ui_copy: |-
    Travel dashboard
    Destination: [ Autocomplete ]
    Goal: Paris, France.
  setup_description: |
    A travel planning dashboard is displayed in dark theme with multiple widgets. The target editable combobox is labeled “Destination” and is implemented with MUI Autocomplete.

    - Scene: dashboard layout, bottom_left placement (the destination card is anchored lower-left), dark theme, comfortable spacing, default scale.
    - Component behavior: typing filters destination options; selecting commits.
    - Options (~14), including confusable entries:
      - Paris, France  [target]
      - Paris, Texas
      - Paris, Ontario
      - London, UK
      - London, Ontario
      - Rome, Italy
      - Berlin, Germany
      - Barcelona, Spain
      - Porto, Portugal
      - etc.
    - Initial state: empty.
    - Distractors/clutter: a date range widget, a price slider, a sidebar navigation menu, and a “Search” button are visible but irrelevant to success.
    - Feedback: selected destination appears as input value immediately.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: dashboard
    placement: bottom_left
    scale: default
    instances: 1
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 3
    justification: A cluttered dark-themed dashboard and multiple nearly identical city names increase acquisition and choice interference.
  success_trigger:
    human_readable:
    - The “Destination” combobox value equals “Paris, France”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Paris, France
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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 “Paris, Texas” or another non-France Paris.
  - Entering “Paris” without selecting the full intended option label (if options include multiple Parises).
  - Changing other dashboard controls without setting Destination.
  expected_interaction_path:
  - Click the Destination field.
  - Type “Paris”.
  - Select “Paris, France”.
  notes: If the UI renders secondary text (country/state) in each option, the checker should compare the committed value string, not the partial input.
- id: combobox_editable_single-mui-T10
  name: Select Zürich from async-loading Autocomplete
  canonical_type: combobox_editable_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (async options)'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: Open the “Add stop” dialog, then in the “City” field search and select “Zürich”. The task will finish automatically when done.
  ui_copy: |-
    Button: Add stop
    Dialog: Add stop
    City: [ Autocomplete with loading spinner ]
    Goal: Zürich.
  setup_description: |
    The page has a button labeled “Add stop”. Clicking it opens a modal dialog that contains a MUI Autocomplete combobox labeled “City”.

    - Scene: modal_flow layout, center placement, light theme, comfortable spacing, default scale.
    - Component behavior:
      - The Autocomplete fetches options asynchronously based on the typed query.
      - After typing at least 2 characters, a small loading spinner appears in the input for ~600–900ms, then options populate.
    - Options returned for the query “Zu” include: Zürich (target, with umlaut), Zurich (no umlaut), Zwickau, Zunyi.
    - Initial state: empty.
    - Distractors: a Notes textarea and a “Cancel” button exist in the modal but are irrelevant.
    - Feedback: loading spinner (transient), then dropdown options; selected city shown in input.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 2
    justification: Async loading introduces latency and transient feedback, and the target includes a diacritic that must be selected correctly within a modal layer.
  success_trigger:
    human_readable:
    - The “City” combobox value equals “Zürich” (Unicode-normalized).
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Zürich
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      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 “Zurich” (missing umlaut).
  - Typing “Zürich” but not selecting/committing a value before the dropdown loads.
  - Selecting any other “Zu…” option.
  expected_interaction_path:
  - Click “Add stop” to open the modal.
  - Click the City field and type “Zu”.
  - Wait for options to load (spinner disappears).
  - Select “Zürich”.
  notes: Checker should wait for the component’s committed value, not transient input text during loading; tie the listbox to the input via aria-controls to avoid cross-instance confusion.
- id: combobox_editable_single-mantine-T01
  name: Pick Svelte from Autocomplete suggestions
  canonical_type: combobox_editable_single
  implementation_source: mantine
  implementation_variant: Autocomplete
  implementation_component: 'Mantine: Autocomplete'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the “Favorite library” field, search and select “Svelte” from the suggestions. The task will finish automatically when done.
  ui_copy: |-
    Favorite library: [ Autocomplete ]
    Goal: Svelte.
  setup_description: |
    A centered isolated card titled “Profile” contains one editable combobox labeled “Favorite library” implemented with Mantine Autocomplete.

    - Scene: isolated_card layout, center placement, light theme, comfortable spacing, default scale.
    - Component behavior: Typing opens a dropdown with suggestions; clicking a suggestion fills the input. The input also allows free text, but for this task the target is one of the suggestions.
    - Suggestions: React, Angular, Vue, Svelte, Solid, Ember.
    - Initial state: empty.
    - Distractors: none.
    - Feedback: selected value appears in the input immediately.
  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: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single Autocomplete with a short list of distinct options; straightforward type-and-select interaction.
  success_trigger:
    human_readable:
    - The “Favorite library” combobox value equals “Svelte”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Svelte
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      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 different library (e.g., “Vue”).
  - Leaving the input empty.
  - Typing partial text without committing a value.
  expected_interaction_path:
  - Click the input.
  - Type “Sve”.
  - Select “Svelte” from the dropdown.
  notes: Mantine Autocomplete allows values outside suggestions; for this task, checker should still accept success if the final input value equals “Svelte” even if selection source is ambiguous.
- id: combobox_editable_single-mantine-T02
  name: Choose Bananas in a Mantine Combobox picker
  canonical_type: combobox_editable_single
  implementation_source: mantine
  implementation_variant: Combobox
  implementation_component: 'Mantine: Combobox (InputBase target)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the “Grocery item” field and select “Bananas”. The task will finish automatically when done.
  ui_copy: |-
    Grocery item: [ Combobox input ]
    Options include Apples, Bananas, Broccoli, Carrots, Chocolate.
  setup_description: |
    A centered isolated card titled “Grocery picker” contains one editable combobox built with Mantine Combobox primitives (InputBase as the target).

    - Scene: isolated_card, center placement, light theme, comfortable spacing, default scale.
    - Component behavior: Clicking the input opens a dropdown. Selecting an item sets the input value and closes the dropdown.
    - Options (5): Apples, Bananas, Broccoli, Carrots, Chocolate.
    - Sub-controls: input caret; dropdown list; no extra clear button for this easy variant.
    - Initial state: empty.
    - Distractors: none.
    - Feedback: selected item text appears in the input.
  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: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Simple dropdown selection with a very small option list and no clutter or disambiguation.
  success_trigger:
    human_readable:
    - The “Grocery item” combobox value equals “Bananas”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Bananas
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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 any option other than “Bananas”.
  - Leaving the field empty.
  - Typing “Bananas” but not committing if this variant requires selection (checker should rely on committed value).
  expected_interaction_path:
  - Click the Grocery item input to open the dropdown.
  - Click “Bananas”.
  notes: Combobox list is typically rendered in a dropdown; expose aria roles or testids on options for reliable checking.
- id: combobox_editable_single-mantine-T03
  name: Clear a Mantine Autocomplete field
  canonical_type: combobox_editable_single
  implementation_source: mantine
  implementation_variant: Autocomplete
  implementation_component: 'Mantine: Autocomplete (clearable)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the value in the “Framework” field so the input becomes empty. The task will finish automatically when done.
  ui_copy: |-
    Framework: [ Autocomplete prefilled with “Angular” ]
    Goal: Clear the field.
  setup_description: |
    A centered isolated card titled “Tech stack” contains one Mantine Autocomplete input labeled “Framework”. The Autocomplete is configured with a clear button.

    - Scene: isolated_card, center placement, light theme, comfortable spacing, default scale.
    - Component behavior: When the field has a value, a clear (×) button appears in the right section. Clicking it clears the value.
    - Suggestions: React, Angular, Vue, Svelte.
    - Initial state: value is “Angular”.
    - Distractors: none.
    - Feedback: after clearing, the input becomes empty and the clear button 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: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single clear action with visible affordance and immediate state change.
  success_trigger:
    human_readable:
    - The “Framework” combobox value is empty.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: ''
      tolerance:
        trim_whitespace: true
      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:
  - Replacing the value with another framework instead of clearing.
  - Leaving any non-empty text in the input after clearing.
  - Clearing a different component (none exist).
  expected_interaction_path:
  - Click the clear button in the Framework input.
  - Verify the input is empty.
  notes: Mantine clear button may be an ActionIcon in the right section; tag it with aria-label='Clear' for accessibility and checking.
- id: combobox_editable_single-mantine-T04
  name: Enter a custom dessert name (free text)
  canonical_type: combobox_editable_single
  implementation_source: mantine
  implementation_variant: Autocomplete
  implementation_component: 'Mantine: Autocomplete'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: In the “Dessert” field, type “Tiramisu”. The task will finish automatically when done.
  ui_copy: |-
    Dessert: [ Autocomplete ]
    Goal: Tiramisu
  setup_description: |
    A small isolated card titled “Order note” is anchored near the bottom-left of the viewport. It contains one Mantine Autocomplete input labeled “Dessert”.

    - Scene: isolated_card layout, bottom_left placement, light theme, comfortable spacing, default scale.
    - Component behavior: The Autocomplete shows suggestions while typing, but it accepts any text value (the final value does not have to be one of the suggestions).
    - Suggestions: Brownie, Cheesecake, Ice cream, Pudding, Tarte tatin (no Tiramisu in suggestions).
    - Initial state: empty.
    - Distractors: none.
    - Feedback: the input shows the typed value. No extra confirmation button is present.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: bottom_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires entering a specific free-text value that is not available as a suggestion, but the UI is otherwise simple and uncluttered.
  success_trigger:
    human_readable:
    - The “Dessert” combobox value equals “Tiramisu”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Tiramisu
        value_source: free_text
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      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 different dessert suggestion (e.g., “Cheesecake”).
  - Leaving the input empty.
  - Entering misspellings like “Tiramisu!” (extra punctuation).
  expected_interaction_path:
  - Click the Dessert input.
  - Type “Tiramisu”.
  - Blur the field or press Enter if needed.
  notes: For free_text tasks, treat the input’s text as the canonical value regardless of dropdown selection state.
- id: combobox_editable_single-mantine-T05
  name: Match Team field to reference badge (dark theme)
  canonical_type: combobox_editable_single
  implementation_source: mantine
  implementation_variant: Autocomplete
  implementation_component: 'Mantine: Autocomplete'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Team” field to match the value shown in the Reference badge. The task will finish automatically when done.
  ui_copy: |-
    Team assignment
    Reference: [badge]
    Team: [ Autocomplete ]
  setup_description: |
    A dark-themed settings panel titled “Team assignment” contains one Mantine Autocomplete input labeled “Team” and a visual reference badge.

    - Scene: settings_panel layout, center placement, dark theme, comfortable spacing, default scale.
    - Guidance: A “Reference” badge is shown above the Team field. The target team is displayed on that badge; the instruction does not specify the team name.
    - Component behavior: Typing opens suggestions; selecting fills the input.
    - Options (6): Support, Sales, Marketing, Engineering, Finance, People Ops.
    - Initial state: empty.
    - Distractors/clutter: a non-target toggle “Auto-assign on signup” and a read-only text line “Last updated: today” are visible but irrelevant.
    - Feedback: chosen team appears in the input and can be compared with the reference badge.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 2
    justification: The target is provided via a visual reference element and must be transferred to the Autocomplete field; otherwise the choice set is small.
  success_trigger:
    human_readable:
    - The “Team” combobox value matches the text in the Reference badge.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_kind: badge
        reference_label: Reference
        reference_selector: '#team-reference'
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      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 different team than the badge shows.
  - Leaving the Team field empty.
  - Changing other settings without setting Team.
  expected_interaction_path:
  - Read the team name from the Reference badge.
  - Click the Team input and select the matching option.
  notes: Provide stable selector for badge text; in dark theme, ensure adequate contrast so the value is still readable.
- id: combobox_editable_single-mantine-T06
  name: Scroll to select Norway inside a drawer
  canonical_type: combobox_editable_single
  implementation_source: mantine
  implementation_variant: Combobox
  implementation_component: 'Mantine: Combobox (searchable dropdown)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Open the “Advanced settings” drawer, then in the “Country” field select “Norway”. The task will finish automatically when done.
  ui_copy: |-
    Button: Advanced settings
    Drawer: Advanced settings
    Country: [ Combobox ]
    Goal: Norway.
  setup_description: |
    The page shows a compact header with a button labeled “Advanced settings”. Clicking it opens a right-side drawer. Inside the drawer is an editable combobox labeled “Country”, implemented using Mantine Combobox primitives (a searchable dropdown pattern).

    - Scene: drawer_flow layout, right-side drawer anchored, light theme, comfortable spacing, default scale.
    - Component behavior:
      - Clicking the Country input opens a scrollable dropdown list.
      - A small search input exists at the top of the dropdown, but the user may also scroll to find an option.
    - Options (~40 countries): Argentina, Australia, Austria, Belgium, Brazil, Canada, Denmark, Finland, France, Germany, Iceland, India, Italy, Japan, Mexico, Netherlands, New Zealand, Norway, Portugal, Spain, Sweden, Switzerland, United Kingdom, United States, … etc.
    - Initial state: empty.
    - Distractors/clutter: the drawer also contains two toggles and a “Close” icon in the header; none are required beyond opening the drawer to access the field.
    - Feedback: selecting a country fills the input and closes the dropdown.
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_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: 3
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires interacting through an additional drawer layer and locating the target in a moderately long scrollable list.
  success_trigger:
    human_readable:
    - The “Country” combobox value equals “Norway”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Norway
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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 different country.
  - Opening the drawer but never setting the Country field.
  - Scrolling the page instead of the dropdown list and failing to select Norway.
  expected_interaction_path:
  - Click “Advanced settings” to open the drawer.
  - Click the Country field to open dropdown.
  - Scroll the dropdown until “Norway” appears, then select it.
  notes: Ensure Norway is initially off-screen in the dropdown list viewport to make scroll_find meaningful.
- id: combobox_editable_single-mantine-T07
  name: Set CC recipient to alex.kim@acme.com (two fields)
  canonical_type: combobox_editable_single
  implementation_source: mantine
  implementation_variant: Autocomplete
  implementation_component: 'Mantine: Autocomplete'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the “CC” field, search and select “alex.kim@acme.com”. The task will finish automatically when done.
  ui_copy: |-
    Compose message
    To: [ Autocomplete ]
    CC: [ Autocomplete ]
    Goal: CC = alex.kim@acme.com.
  setup_description: |
    A compact “Compose message” form section contains two Mantine Autocomplete inputs with identical styling.

    - Scene: form_section layout, center placement, light theme, COMPACT spacing, default scale.
    - Instances: 2 Autocomplete fields:
      - “To” (distractor)
      - “CC” (target)
    - Component behavior: typing opens a dropdown with suggested email addresses; selecting one fills the input.
    - Suggestion dataset (~12), with confusable variants:
      - alex.kim@acme.com  [target]
      - alex.kim2@acme.com
      - alex.king@acme.com
      - alice.kim@acme.com
      - ben.wong@acme.com
      - dana.patel@acme.com
      - emily.nguyen@acme.com
      - … etc.
    - Initial state:
      - To: prefilled with “hannah.lee@acme.com”
      - CC: empty
    - Distractors/clutter: a Subject text input and a large Message textarea are present but irrelevant.
    - Feedback: the selected email is shown in the CC input immediately.
  scene_context:
    theme: light
    spacing: compact
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Two nearly identical Autocomplete fields and multiple confusable email suggestions require careful instance targeting and exact string matching.
  success_trigger:
    human_readable:
    - The Autocomplete instance labeled “CC” has value exactly “alex.kim@acme.com”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: alex.kim@acme.com
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: CC
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting the “To” field to alex.kim@acme.com instead of “CC”.
  - Selecting a confusable address like alex.kim2@acme.com or alex.king@acme.com.
  - Typing the address but not committing a selection if required by this configuration.
  expected_interaction_path:
  - Click the CC field.
  - Type “alex.kim”.
  - Select “alex.kim@acme.com” from suggestions.
  notes: Use data-testid per field (to/cc) and ensure the checker verifies the CC instance specifically.
- id: combobox_editable_single-mantine-T08
  name: Select Chocolate (not chips) inside a modal combobox
  canonical_type: combobox_editable_single
  implementation_source: mantine
  implementation_variant: Combobox
  implementation_component: 'Mantine: Combobox (modal picker)'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: Open the “Add ingredient” dialog, then in the “Ingredient” field search and select “Chocolate”. The task will finish automatically when done.
  ui_copy: |-
    Button: Add ingredient
    Dialog: Add ingredient
    Ingredient: [ Combobox ]
    Goal: Chocolate.
  setup_description: |
    The page has a button labeled “Add ingredient” that opens a modal dialog. Inside the modal is a custom editable combobox built with Mantine Combobox primitives.

    - Scene: modal_flow layout, center placement, light theme, comfortable spacing, default scale.
    - Target component: “Ingredient” combobox (editable input with dropdown suggestions).
    - Component behavior: typing filters dropdown items; selecting an item commits and closes the dropdown.
    - Options (~25), with confusable chocolate-related entries close together:
      - Chocolate  [target]
      - Chocolate (dark)
      - Chocolate chips
      - Cocoa powder
      - Carob
      - plus other ingredients (Butter, Flour, Sugar, Salt, Vanilla, Eggs, Milk, etc.)
    - Initial state: empty.
    - Distractors: modal also includes a Quantity numeric input and a Cancel button; they are irrelevant.
    - Feedback: selected ingredient appears in the input; modal remains open but does not need to be closed for success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: The field is behind a modal layer and includes multiple very similar options (Chocolate vs Chocolate chips), increasing layering and choice interference.
  success_trigger:
    human_readable:
    - The “Ingredient” combobox value equals “Chocolate”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: Chocolate
        value_source: option
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      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 “Chocolate chips” or “Chocolate (dark)” instead of “Chocolate”.
  - Leaving the Ingredient field empty.
  - Typing “Chocolate” but committing a different option due to highlighted selection.
  expected_interaction_path:
  - Click “Add ingredient” to open the modal.
  - Click the Ingredient input.
  - Type “choc” and choose “Chocolate” (exact) from dropdown.
  notes: If the Combobox renders options with additional description text, ensure the committed value used for checking is the primary label (“Chocolate”).
- id: combobox_editable_single-mantine-T09
  name: Match Segment filter to reference chip (3 filters on dashboard)
  canonical_type: combobox_editable_single
  implementation_source: mantine
  implementation_variant: Autocomplete
  implementation_component: 'Mantine: Autocomplete'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: On the dashboard, set the “Segment” filter to match the value shown in the Reference chip. The task will finish automatically when done.
  ui_copy: |-
    Analytics dashboard
    Reference chip: [Segment target]
    Filters: Region [Autocomplete], Segment [Autocomplete], Metric [Autocomplete]
  setup_description: |
    An analytics dashboard is shown with a row of filter controls at the top and several charts below (non-interactive for this task). The filters are implemented as Mantine Autocomplete inputs.

    - Scene: dashboard layout, center placement, light theme, comfortable spacing, default scale.
    - Instances: 3 Autocomplete combobox filters in a horizontal row:
      - “Region” (distractor)
      - “Segment” (TARGET)
      - “Metric” (distractor)
    - Guidance: A “Reference” chip above the filter row shows the desired Segment value (e.g., a pill labeled with the segment). The prompt does not name the segment explicitly.
    - Options:
      - Region: North America, South America, Europe, Asia Pacific.
      - Segment: SMB, Mid-market, Enterprise, Consumer.
      - Metric: Revenue, Active users, Churn, NPS.
    - Initial state: all three filters are empty.
    - Distractors/clutter: charts, a left nav, and a toolbar with buttons (Export, Refresh) are visible; none are required.
    - Feedback: the chosen Segment appears in the Segment input; the Reference chip remains visible for comparison.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 3
    guidance: visual
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 5
    justification: The target is specified via a visual reference and must be applied to the correct filter among multiple similar Autocomplete instances in a cluttered dashboard.
  success_trigger:
    human_readable:
    - The Autocomplete instance labeled “Segment” matches the value shown in the Reference chip.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_kind: chip
        reference_label: Reference
        reference_selector: '#segment-reference'
      tolerance:
        case_sensitive: true
        trim_whitespace: true
        unicode_normalization: NFC
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Segment
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting Region or Metric to the reference value while Segment remains unset.
  - Choosing a Segment that does not match the Reference chip.
  - Interacting with dashboard buttons without setting the Segment filter.
  expected_interaction_path:
  - Read the Segment value from the Reference chip.
  - Click the Segment filter input.
  - Select the matching segment option.
  notes: Expose stable selectors for each filter input and the reference chip so the checker can bind and compare values reliably.
- id: combobox_editable_single-mantine-T10
  name: Set Build standard to C++17 (special characters, small control)
  canonical_type: combobox_editable_single
  implementation_source: mantine
  implementation_variant: Autocomplete
  implementation_component: 'Mantine: Autocomplete'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: In the “Build standard” field, enter exactly “C++17”. The task will finish automatically when done.
  ui_copy: |-
    Build standard: [ Autocomplete ]
    Goal: C++17
  setup_description: |
    A small settings card titled “Compiler” is anchored near the bottom-right of the viewport. It contains one Mantine Autocomplete input labeled “Build standard”.

    - Scene: isolated_card layout, bottom_right placement, light theme, COMPACT spacing, SMALL scale (short input height, smaller icons).
    - Component behavior: The field shows suggestions as you type, but it also accepts free text.
    - Suggestions: C, C++, C++14, C++17, C++20, C#.
    - Initial state: empty.
    - Distractors: none.
    - Feedback: the input displays the entered value exactly; no additional confirmation is required.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: bottom_right
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 5
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires an exact formatted string containing special characters (+) on a small-scale control, with nearby confusable suggestions like C++14/C++20.
  success_trigger:
    human_readable:
    - The “Build standard” combobox value equals the exact string “C++17”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: C++17
        value_source: free_text
      tolerance:
        case_sensitive: true
        trim_whitespace: true
      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/entering C++14 or C++20 instead of C++17.
  - Entering “C++ 17” with an extra space.
  - Leaving the field empty.
  expected_interaction_path:
  - Click the Build standard field.
  - Type “C++17” (or type “C++” and select “C++17”).
  - Commit by pressing Enter or blurring if needed.
  notes: For checking, compare the final input value string; do not accept approximate matches.