Datasets:

TianchenGuan
/

ComponentBench

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