- 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.