Initial ComponentBench data release: tasks v1+v2, cleaned human traces, difficulty audit, ontology metadata
360df42 verified | - id: inline_editable_text-antd-T01 | |
| name: Rename display name (single field) | |
| canonical_type: inline_editable_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Typography.Text (editable)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Change the Display name to “Ava Chen”. Click Save to commit the | |
| change. The task will finish automatically when done. | |
| ui_copy: Change the Display name to “Ava Chen”. Click Save to commit the change. | |
| The task will finish automatically when done. | |
| setup_description: 'A single centered card titled “Profile” contains one inline | |
| editable text row labeled “Display name”. | |
| The value is shown as Ant Design Typography.Text with a pencil edit icon on hover. | |
| Initial value: “Ava Li”. | |
| Clicking the text or the pencil icon turns it into a one-line input with two inline | |
| controls: “Save” (check icon) and “Cancel” (close icon). | |
| There are no other editable text components on the page and no extra distractors. | |
| Saving immediately commits the value back to the read-only Typography view.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: Single large target in a clean, centered card; only one short string | |
| to enter and a clear Save control to commit. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Display name' is the one that must be checked. | |
| - The committed (display) value equals 'Ava Chen' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Ava Chen | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Display name | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Editing a different field (there is only one; any other interaction does not count). | |
| - Typing “Ava Chen” but leaving the component in editing mode (input still visible). | |
| - Typing the value but clicking outside without committing, or pressing Cancel. | |
| - A near match such as “AvaChen”, “Ava Chen”, or “Ava Chen ” (extra/missing whitespace | |
| or characters). | |
| expected_interaction_path: | |
| - Click the Display name text (or pencil icon) to enter edit mode | |
| - Type Ava Chen | |
| - Click Save (check icon) to commit and return to display mode | |
| notes: 'Instrumentation: add data-testid on the editable root (e.g., editable-display-name), | |
| the input, and Save/Cancel controls so the checker can read committed value and | |
| mode.' | |
| - id: inline_editable_text-antd-T02 | |
| name: Enter edit mode (no text change) | |
| canonical_type: inline_editable_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Typography.Text (editable)' | |
| task_template: activate | |
| secondary_template: null | |
| browsergym_goal: Put the Project title text into edit mode (you do not need to change | |
| the text). The task will finish automatically when done. | |
| ui_copy: Put the Project title text into edit mode (you do not need to change the | |
| text). The task will finish automatically when done. | |
| setup_description: 'A centered card titled “Project” shows a single inline editable | |
| text labeled “Project title”. | |
| The value is displayed as “Launch Plan” in Ant Design Typography.Text with an | |
| edit (pencil) icon. | |
| Clicking the text (or the pencil icon) swaps the Typography view for a focused | |
| one-line input plus inline “Save” and “Cancel” controls. | |
| The task is purely about entering the editing state; committing or changing text | |
| is not required.' | |
| 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: Only one editable target and success is achieved as soon as the | |
| component visibly enters edit mode. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Project title' is the one that must be checked. | |
| - The component is in editing mode (mode='editing'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| mode: editing | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Project title | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Focusing a different control (there are no other editable text instances). | |
| - Changing the text and saving/canceling—these are unnecessary and not required | |
| for success. | |
| - Opening unrelated UI like tooltips; the inline editor must actually be in editing | |
| mode (input visible). | |
| expected_interaction_path: | |
| - Click the Project title text (or pencil icon) | |
| - Verify the inline input appears and is focused | |
| notes: Checker should detect mode by presence of the input element within the editable | |
| component subtree. | |
| - id: inline_editable_text-antd-T03 | |
| name: Clear a status note to empty | |
| canonical_type: inline_editable_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Typography.Text (editable)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the Status note so it becomes empty, then click Save. The | |
| task will finish automatically when done. | |
| ui_copy: Clear the Status note so it becomes empty, then click Save. The task will | |
| finish automatically when done. | |
| setup_description: 'A centered card titled “Status” contains one inline editable | |
| text row labeled “Status note”. | |
| Initial value: “Waiting for approval”. The text is shown as Typography.Text with | |
| an edit icon. | |
| When editing, the component shows a one-line input with a built-in clear (×) affordance | |
| inside the input, plus inline “Save” and “Cancel” controls. | |
| The page has no other inline editable text components and no extra clutter.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: Single field with obvious clear and Save controls; success is simply | |
| committing an empty string. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Status note' is the one that must be checked. | |
| - The committed (display) value equals '' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: '' | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Status note | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Leaving any characters behind (including a single space). | |
| - Clicking Cancel after clearing, which restores the original text. | |
| - Clearing the input but not committing (e.g., leaving it in edit mode). | |
| - Any non-empty value such as “ ”, “-”, or “None”. | |
| expected_interaction_path: | |
| - Click Status note to enter edit mode | |
| - Use the clear (×) control or delete all text | |
| - Click Save to commit the empty value | |
| notes: Checker should treat the committed value as empty only when it is exactly | |
| ''. Consider trimming only if the UI itself trims. | |
| - id: inline_editable_text-antd-T04 | |
| name: Set status label using mixed guidance | |
| canonical_type: inline_editable_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Typography.Text (editable)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Set the Status label to “READY” (it should match the green preview | |
| chip), then click Save. The task will finish automatically when done. | |
| ui_copy: Set the Status label to “READY” (it should match the green preview chip), | |
| then click Save. The task will finish automatically when done. | |
| setup_description: 'A centered card titled “Status Label” contains one inline editable | |
| text labeled “Status label”. | |
| The editable text currently shows “Idle”. To the right of it, a non-interactive | |
| green preview chip displays the desired label styling. | |
| Entering edit mode turns the Typography.Text into a one-line input with inline | |
| Save/Cancel controls. The chip remains visible while editing. | |
| The goal provides the target text explicitly (“READY”) but also includes the visual | |
| confirmation cue via the preview chip.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: mixed | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: The target value is explicitly stated and there is only one field; | |
| the preview chip is an extra confirmation cue rather than a disambiguation challenge. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Status label' is the one that must be checked. | |
| - The committed (display) value equals 'READY' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: READY | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Status label | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Entering a different casing like “Ready” or “ready”. | |
| - Committing the old value (“Idle”) or any other text. | |
| - Typing the correct text but not clicking Save to commit. | |
| - Leaving the component in edit mode (input still visible). | |
| expected_interaction_path: | |
| - Click Status label to enter edit mode | |
| - Type READY | |
| - Click Save to commit | |
| notes: The green preview chip is non-interactive and should not be used as the success | |
| signal; success is based only on the editable text state. | |
| - id: inline_editable_text-antd-T05 | |
| name: Enter a formatted ticket code | |
| canonical_type: inline_editable_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Typography.Text (editable)' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Change the Ticket code to “TKT-1042” and click Save. The task will | |
| finish automatically when done. | |
| ui_copy: Change the Ticket code to “TKT-1042” and click Save. The task will finish | |
| automatically when done. | |
| setup_description: 'A centered card titled “Support Ticket” contains one inline | |
| editable text labeled “Ticket code”. | |
| The current value is “TKT-1000”. Clicking the value opens an input with Save/Cancel | |
| controls. | |
| While editing, an inline validation hint appears under the input: “Format: TKT-####”. | |
| If the format is wrong (missing hyphen, wrong prefix, not four digits), the input | |
| shows an error state and the Save control is disabled until valid.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 4 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Requires exact formatted entry with validation and a disabled Save | |
| state on errors, but still a single, well-labeled field in a simple layout. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Ticket code' is the one that must be checked. | |
| - The committed (display) value equals 'TKT-1042' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: TKT-1042 | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Ticket code | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Wrong format such as “TKT1042”, “TK-1042”, or “TKT-142”. | |
| - Correct text typed but not committed via Save (still editing). | |
| - Leaving any trailing/leading characters (e.g., “TKT-1042 ”). | |
| - Canceling the edit so the value reverts to “TKT-1000”. | |
| expected_interaction_path: | |
| - Click Ticket code to enter edit mode | |
| - Type TKT-1042 | |
| - Click Save (enabled only when valid) | |
| notes: Checker should read the committed value (not the input draft) so partial/invalid | |
| drafts do not pass. | |
| - id: inline_editable_text-antd-T06 | |
| name: Save a tagline with asynchronous feedback | |
| canonical_type: inline_editable_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Typography.Text (editable)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Update the Team tagline to “Built to ship.” and click Save. The | |
| task will finish automatically when done. | |
| ui_copy: Update the Team tagline to “Built to ship.” and click Save. The task will | |
| finish automatically when done. | |
| setup_description: 'A centered card titled “Team” contains one inline editable text | |
| labeled “Team tagline”. | |
| The tagline is displayed as Typography.Text with an edit icon. Initial value: | |
| “Ship it”. | |
| When you click Save, the component shows a brief loading state (Save control disabled | |
| and a small spinner appears) before returning to the read-only view. | |
| A toast message “Saved” appears in the top-right of the page after the commit. | |
| If the text exceeds 20 characters, an inline error appears and the value is not | |
| committed.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 4 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Even with a single field, saving involves transient loading feedback | |
| and a constraint (max length) that can block committing if the entry is off | |
| by a character. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Team tagline' is the one that must be checked. | |
| - The committed (display) value equals 'Built to ship.' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Built to ship. | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Team tagline | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Typing the text but not committing it (e.g., leaving the input open). | |
| - A close match such as “Built to ship” (missing period) or “Built to ship.” (double | |
| space). | |
| - Text longer than allowed that leaves the component in an error state without committing. | |
| - Clicking Cancel after typing, which reverts to the original tagline. | |
| expected_interaction_path: | |
| - Click Team tagline to enter edit mode | |
| - Type Built to ship. | |
| - Click Save and wait for the component to return to display mode | |
| notes: Checker should use the committed value after save completes (not intermediate | |
| loading state). | |
| - id: inline_editable_text-antd-T07 | |
| name: Match badge text from a visual reference | |
| canonical_type: inline_editable_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Typography.Text (editable)' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the Badge text to match the example shown on the sample badge, | |
| then click Save. The task will finish automatically when done. | |
| ui_copy: Set the Badge text to match the example shown on the sample badge, then | |
| click Save. The task will finish automatically when done. | |
| setup_description: 'A centered card titled “Badge Designer” is split into two columns. | |
| Left column: one inline editable text labeled “Badge text”, currently “VISITOR”. | |
| Right column: a non-editable sample badge preview showing the desired text exactly | |
| as it should appear (including punctuation and spacing). | |
| The editable text uses Ant Design Typography.Text with an edit icon; editing shows | |
| an input with Save/Cancel controls. | |
| The target text is not written in the instructions; it must be read from the sample | |
| badge preview.' | |
| 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: 4 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Requires extracting an exact string from a visual reference (including | |
| special punctuation), but still a single component in a low-clutter scene. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Badge text' is the one that must be checked. | |
| - The committed (display) value equals 'STAFF — 2026' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: STAFF — 2026 | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Badge text | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Using a hyphen instead of an em dash, or missing spaces around the dash. | |
| - Matching only part of the reference (e.g., “STAFF” only). | |
| - Typing the correct string but not committing with Save. | |
| - Clicking Cancel, which restores “VISITOR”. | |
| expected_interaction_path: | |
| - Read the exact text shown on the sample badge preview | |
| - Click Badge text to enter edit mode | |
| - Type the reference text | |
| - Click Save to commit | |
| notes: For robustness, the sample badge preview should be clearly legible and have | |
| stable text content for the checker to use as the canonical target. | |
| - id: inline_editable_text-antd-T08 | |
| name: Edit the Billing note among two fields | |
| canonical_type: inline_editable_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Form + Typography.Text (editable)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: In the Notes section, change the Billing note to “Send invoice | |
| by email”, then click Save. The task will finish automatically when done. | |
| ui_copy: In the Notes section, change the Billing note to “Send invoice by email”, | |
| then click Save. The task will finish automatically when done. | |
| setup_description: "The page shows a centered “Checkout Settings” form section with\ | |
| \ several read-only fields (e.g., Company, Region) and a “Notes” subsection.\n\ | |
| Inside “Notes” there are two inline editable text rows of the same component type:\n\ | |
| \ • “Shipping note” (initial: “Leave at front desk”)\n • “Billing note” (initial:\ | |
| \ “Net 30”)\nEach row is displayed as Ant Design Typography.Text with a pencil\ | |
| \ icon and turns into an input with Save/Cancel controls when edited.\nThe surrounding\ | |
| \ form fields are distractors only; success depends solely on committing the correct\ | |
| \ text in the Billing note instance." | |
| 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: 3 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: Two similar inline editable fields in a small form section require | |
| careful instance selection, but the entry itself is a straightforward sentence. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Billing note' is the one that must be checked. | |
| - The committed (display) value equals 'Send invoice by email' exactly (case- | |
| and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Send invoice by email | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Billing note | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Editing the Shipping note instead of the Billing note. | |
| - Setting the Billing note correctly but not clicking Save to commit. | |
| - Leaving the component in edit mode (input visible). | |
| - A close but incorrect sentence such as “Send invoice via email”. | |
| expected_interaction_path: | |
| - Locate the Notes section | |
| - Click the Billing note row to enter edit mode | |
| - Type Send invoice by email | |
| - Click Save | |
| notes: Add stable labels/aria-labelledby so the checker can identify the Billing | |
| note instance even when both rows use the same underlying component. | |
| - id: inline_editable_text-antd-T09 | |
| name: Enter account code in dark theme | |
| canonical_type: inline_editable_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Typography.Text (editable)' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Set the Account code to “ACCT-2049” and click Save. The task will | |
| finish automatically when done. | |
| ui_copy: Set the Account code to “ACCT-2049” and click Save. The task will finish | |
| automatically when done. | |
| setup_description: 'A single card is centered on a dark-themed page (dark background, | |
| light text) titled “Account”. | |
| It contains one inline editable text labeled “Account code” with initial value | |
| “ACCT-1020”. | |
| Editing opens a one-line input with Save/Cancel controls. A small helper text | |
| under the input states: “Format: ACCT-#### (uppercase)”. | |
| If the entry does not match the format, the input shows an error state and Save | |
| is disabled. The darker theme makes the icon controls and helper text slightly | |
| harder to visually pick out.' | |
| scene_context: | |
| theme: dark | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 4 | |
| target_acquisition: 3 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Dark theme reduces contrast for small icon controls, and the value | |
| must match an exact formatted pattern with validation gating the Save action. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Account code' is the one that must be checked. | |
| - The committed (display) value equals 'ACCT-2049' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: ACCT-2049 | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Account code | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Wrong format such as “acct-2049”, “ACCT2049”, or “ACCT-249”. | |
| - Typing the correct code but not committing via Save. | |
| - Leaving the input open (still editing) even if the text matches. | |
| - Canceling the edit (reverts to “ACCT-1020”). | |
| expected_interaction_path: | |
| - Click Account code to enter edit mode | |
| - Type ACCT-2049 exactly | |
| - Click Save | |
| notes: For AX-tree agents, ensure the Save/Cancel icon buttons have aria-labels | |
| ('Save', 'Cancel') to keep observability comparable across modes. | |
| - id: inline_editable_text-antd-T10 | |
| name: Edit a specific table cell (compact, corner placement) | |
| canonical_type: inline_editable_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table + Typography.Text (editable)' | |
| task_template: table_operation | |
| secondary_template: null | |
| browsergym_goal: In the Orders table, edit the Owner cell for order “Gamma” to “M. | |
| Rivera”, then click Save. The task will finish automatically when done. | |
| ui_copy: In the Orders table, edit the Owner cell for order “Gamma” to “M. Rivera”, | |
| then click Save. The task will finish automatically when done. | |
| setup_description: 'A compact-density table card is anchored near the bottom-right | |
| of the viewport (you can see it without scrolling). | |
| The card title is “Orders”. The table has three rows (Alpha, Beta, Gamma) and | |
| columns: Order, Owner, Status. | |
| Only one cell uses the inline editable text component: the Owner cell in the Gamma | |
| row. That cell shows “Unassigned” as Typography.Text and reveals a small pencil | |
| icon when hovered. | |
| Clicking that cell enters inline edit mode inside the table cell, showing a one-line | |
| input and small Save/Cancel icon controls. | |
| Other rows and columns are non-editable and serve as realistic table clutter. | |
| Success depends only on the committed value in the Gamma/Owner inline editor.' | |
| scene_context: | |
| theme: light | |
| spacing: compact | |
| layout: table_cell | |
| placement: bottom_right | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 4 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: Small, dense table targets in a corner placement increase acquisition | |
| difficulty, and the user must correctly locate the one editable cell before | |
| entering and committing the exact value. | |
| success_trigger: | |
| human_readable: | |
| - The inline editable text instance inside the table cell (row='Gamma', column='Owner') | |
| is the one that must be checked. | |
| - The committed (display) value of that cell equals 'M. Rivera' exactly. | |
| - The cell is no longer in editing mode (input hidden). | |
| - The value is committed via the inline editor's Save control. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: M. Rivera | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: OrdersTable:Gamma/Owner | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Editing a different row or column (e.g., Alpha/Owner) if the UI mistakenly allows | |
| it. | |
| - Typing “M. Rivera” but not committing (still editing / input visible). | |
| - Committing a close value like “M Rivera” or “M. Rivera ” (missing punctuation | |
| or extra whitespace). | |
| - Clicking Cancel, which restores “Unassigned”. | |
| expected_interaction_path: | |
| - Locate the Gamma row and the Owner column | |
| - Click the editable cell to enter edit mode | |
| - Type M. Rivera | |
| - Click Save (check icon) to commit | |
| notes: 'Instrumentation: encode row/column identifiers in data-testid (e.g., editable-cell-gamma-owner) | |
| so the checker can disambiguate the target instance unambiguously.' | |
| - id: inline_editable_text-mui-T01 | |
| name: Rename display name (single field, MUI composite) | |
| canonical_type: inline_editable_text | |
| implementation_source: mui | |
| implementation_variant: composite | |
| implementation_component: 'MUI: Typography + TextField + IconButton (inline edit | |
| composite)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Change the Display name to “Jordan Lee”. Click Save to commit the | |
| change. The task will finish automatically when done. | |
| ui_copy: Change the Display name to “Jordan Lee”. Click Save to commit the change. | |
| The task will finish automatically when done. | |
| setup_description: 'A centered card titled “Profile” contains one inline editable | |
| text row labeled “Display name”. | |
| In read-only mode, the value is rendered as MUI Typography with a small pencil | |
| IconButton at the end of the row. Initial value: “Jordan L.” | |
| Clicking the pencil (or the text) swaps the Typography for a MUI TextField styled | |
| to look inline, plus two small buttons: “Save” and “Cancel”. | |
| Save commits the value and returns to the Typography view. There are no other | |
| inline editable text components on the page.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Single inline editor with clearly labeled Save/Cancel controls | |
| in a clean scene; only a short name string must be entered. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Display name' is the one that must be checked. | |
| - The committed (display) value equals 'Jordan Lee' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Jordan Lee | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Display name | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Typing the correct value but leaving the TextField open (not committed). | |
| - Clicking Cancel after typing, which restores the original value. | |
| - A near match such as “Jordan Lee” or “Jordan Lee ”. | |
| - Changing any other control (none exist of this canonical type). | |
| expected_interaction_path: | |
| - Click the pencil icon to enter edit mode | |
| - Type Jordan Lee | |
| - Click Save to commit | |
| notes: 'Composite implementation note: MUI does not ship a single dedicated ''inline | |
| editable text'' component; this uses a controlled toggle between Typography and | |
| TextField.' | |
| - id: inline_editable_text-mui-T02 | |
| name: Enter edit mode (MUI composite) | |
| canonical_type: inline_editable_text | |
| implementation_source: mui | |
| implementation_variant: composite | |
| implementation_component: 'MUI: Typography + TextField (inline edit composite)' | |
| task_template: activate | |
| secondary_template: null | |
| browsergym_goal: Put the Project nickname text into edit mode (no need to change | |
| it). The task will finish automatically when done. | |
| ui_copy: Put the Project nickname text into edit mode (no need to change it). The | |
| task will finish automatically when done. | |
| setup_description: 'A centered card titled “Project” has one inline editable text | |
| row labeled “Project nickname”. | |
| The read-only value is Typography showing “Apollo” with a trailing pencil IconButton. | |
| Clicking the pencil changes the row into a focused MUI TextField with Save and | |
| Cancel buttons. | |
| Success is defined as the component being in editing mode (TextField visible), | |
| regardless of what text is entered.' | |
| 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: Only one target and the success condition is a visible mode change | |
| (Typography → TextField). | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Project nickname' is the one that must be | |
| checked. | |
| - The component is in editing mode (mode='editing'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| mode: editing | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Project nickname | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Interacting with the card without opening the TextField (still in read-only Typography | |
| mode). | |
| - Opening a tooltip only; the TextField must appear. | |
| - Saving/canceling is unnecessary; the component must remain in editing mode for | |
| success. | |
| expected_interaction_path: | |
| - Click the pencil IconButton next to Project nickname | |
| - Confirm the TextField appears (editing mode) | |
| notes: Checker can detect editing mode by presence of the TextField element within | |
| the editable row container. | |
| - id: inline_editable_text-mui-T03 | |
| name: Clear status message to empty (MUI composite) | |
| canonical_type: inline_editable_text | |
| implementation_source: mui | |
| implementation_variant: composite | |
| implementation_component: 'MUI: Typography + TextField (inline edit composite)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the Status message so it is empty, then click Save. The task | |
| will finish automatically when done. | |
| ui_copy: Clear the Status message so it is empty, then click Save. The task will | |
| finish automatically when done. | |
| setup_description: 'A centered card titled “Status” contains one inline editable | |
| text row labeled “Status message”. | |
| The read-only Typography value is “In a meeting”. Clicking the pencil icon opens | |
| a one-line MUI TextField. | |
| While editing, a small clear (×) IconButton appears inside the TextField end-adornment; | |
| Save/Cancel buttons are displayed to the right. | |
| Saving commits the empty string back to read-only mode. No other inline editable | |
| text components are present.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Single field with an explicit clear affordance and clear Save/Cancel | |
| commit controls. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Status message' is the one that must be | |
| checked. | |
| - The committed (display) value equals '' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: '' | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Status message | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Leaving whitespace (e.g., a single space) instead of truly empty. | |
| - Clearing but clicking Cancel, which restores the original message. | |
| - Clearing but not saving (TextField still open). | |
| - Entering placeholder text like “-” or “n/a” (non-empty). | |
| expected_interaction_path: | |
| - Click Status message pencil to enter edit mode | |
| - Use the clear (×) control or delete all text | |
| - Click Save | |
| notes: If the UI trims whitespace on save, document it; otherwise the checker should | |
| treat whitespace as non-empty. | |
| - id: inline_editable_text-mui-T04 | |
| name: Enter formatted customer ID | |
| canonical_type: inline_editable_text | |
| implementation_source: mui | |
| implementation_variant: composite | |
| implementation_component: 'MUI: Typography + TextField (inline edit composite)' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Set the Customer ID to “CUS-00942” and click Save. The task will | |
| finish automatically when done. | |
| ui_copy: Set the Customer ID to “CUS-00942” and click Save. The task will finish | |
| automatically when done. | |
| setup_description: 'A centered card titled “Customer” contains one inline editable | |
| text labeled “Customer ID”. | |
| The current value is “CUS-00001” in Typography. Clicking edit opens a one-line | |
| TextField with helper text: “Format: CUS-#####”. | |
| The component validates the prefix and digit count; if invalid, the TextField | |
| shows an error and the Save button is disabled. | |
| Save commits the value and returns to Typography display mode.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 4 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Exact formatted input with validation gating Save increases precision | |
| and feedback complexity, but there is only one well-labeled field. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Customer ID' is the one that must be checked. | |
| - The committed (display) value equals 'CUS-00942' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: CUS-00942 | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Customer ID | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Wrong format like “CUS-942”, “CUS00942”, or “CUST-00942”. | |
| - Correct value typed but not committed with Save. | |
| - Leaving the editor in editing mode (TextField visible). | |
| - Canceling the edit so the original ID remains. | |
| expected_interaction_path: | |
| - Click Customer ID edit icon | |
| - Type CUS-00942 | |
| - Click Save | |
| notes: For checker robustness, read committed state variable rather than relying | |
| on DOM text which may include formatting or spacing. | |
| - id: inline_editable_text-mui-T05 | |
| name: Update meeting title (simple text) | |
| canonical_type: inline_editable_text | |
| implementation_source: mui | |
| implementation_variant: composite | |
| implementation_component: 'MUI: Typography + TextField (inline edit composite)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Change the Meeting title to “Weekly Sync” and click Save. The task | |
| will finish automatically when done. | |
| ui_copy: Change the Meeting title to “Weekly Sync” and click Save. The task will | |
| finish automatically when done. | |
| setup_description: 'A centered card titled “Calendar” includes a single inline editable | |
| text labeled “Meeting title”. | |
| Initial Typography value: “Sync”. Clicking the pencil icon opens a one-line TextField | |
| with Save/Cancel buttons. | |
| A small helper hint under the field says “Title is shown on the calendar”. No | |
| other inline editable text components appear on the page.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Still a single field, but requires an explicit Save action and | |
| exact string entry; overall remains low-interference. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Meeting title' is the one that must be checked. | |
| - The committed (display) value equals 'Weekly Sync' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Weekly Sync | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Meeting title | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Typing but not saving (TextField still open). | |
| - Saving a close value like “Weekly sync” (case mismatch) or “Weekly Sync” (extra | |
| space). | |
| - Canceling so the value stays “Sync”. | |
| expected_interaction_path: | |
| - Click Meeting title edit icon | |
| - Type Weekly Sync | |
| - Click Save | |
| notes: null | |
| - id: inline_editable_text-mui-T06 | |
| name: Commit release note with snackbar feedback | |
| canonical_type: inline_editable_text | |
| implementation_source: mui | |
| implementation_variant: composite | |
| implementation_component: 'MUI: Typography + TextField + Snackbar (inline edit composite)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Change the Release note to “Deploy at 5 PM ET” and click Save. | |
| The task will finish automatically when done. | |
| ui_copy: Change the Release note to “Deploy at 5 PM ET” and click Save. The task | |
| will finish automatically when done. | |
| setup_description: 'A centered card titled “Release” has one inline editable text | |
| labeled “Release note”. | |
| Initial value: “Deploy soon”. Clicking edit opens a TextField with Save/Cancel | |
| buttons. | |
| When Save is clicked, the Save button becomes disabled and a Snackbar appears | |
| saying “Saving…”, then updates to “Saved”. | |
| The TextField only returns to read-only mode after the save completes; this introduces | |
| a short feedback latency compared to immediate commit.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 4 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: The agent must handle delayed commit and transient UI states (disabled | |
| Save + snackbar) while still ensuring the final committed text matches exactly. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Release note' is the one that must be checked. | |
| - The committed (display) value equals 'Deploy at 5 PM ET' exactly (case- and | |
| punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Deploy at 5 PM ET | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Release note | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Saving before the full text is entered (partial commit). | |
| - Clicking Save but leaving the editor open in an intermediate state (still editing). | |
| - A near miss like “Deploy at 5PM ET” (missing space) or “Deploy at 5 PM” (missing | |
| suffix). | |
| - Clicking Cancel, which reverts to “Deploy soon”. | |
| expected_interaction_path: | |
| - Click Release note edit icon | |
| - Type Deploy at 5 PM ET | |
| - Click Save and wait for the component to return to read-only mode | |
| notes: Checker should ignore the snackbar text and rely on the committed value + | |
| display mode. | |
| - id: inline_editable_text-mui-T07 | |
| name: Match badge label from a preview chip | |
| canonical_type: inline_editable_text | |
| implementation_source: mui | |
| implementation_variant: composite | |
| implementation_component: 'MUI: Chip (preview) + Typography/TextField (inline edit | |
| composite)' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the Badge label to match the text shown in the blue preview | |
| chip, then click Save. The task will finish automatically when done. | |
| ui_copy: Set the Badge label to match the text shown in the blue preview chip, then | |
| click Save. The task will finish automatically when done. | |
| setup_description: "A centered card titled “Badge” shows:\n • Left: one inline\ | |
| \ editable text labeled “Badge label”, currently “OFF”.\n • Right: a non-editable\ | |
| \ MUI Chip preview (blue) that displays the desired label text exactly as it should\ | |
| \ be saved.\nThe editable label is rendered as Typography with an edit IconButton;\ | |
| \ edit mode uses a one-line TextField with Save/Cancel.\nThe goal requires reading\ | |
| \ the target string from the preview chip rather than from the instruction text." | |
| 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: 3 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Requires extracting the exact target from a visual reference, but | |
| interaction remains a simple single-field edit with a clear Save action. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Badge label' is the one that must be checked. | |
| - The committed (display) value equals 'ON-CALL' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: ON-CALL | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Badge label | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Typing “ON CALL” (missing hyphen) or “On-Call” (case mismatch). | |
| - Copying only part of the chip text. | |
| - Not saving after typing (still in edit mode). | |
| - Canceling the edit. | |
| expected_interaction_path: | |
| - Read the label shown in the blue chip preview | |
| - Click Badge label edit icon | |
| - Type the chip text | |
| - Click Save | |
| notes: Preview chip must be static and readable; checker should still use the canonical | |
| target in this task spec. | |
| - id: inline_editable_text-mui-T08 | |
| name: Edit secondary label among two fields | |
| canonical_type: inline_editable_text | |
| implementation_source: mui | |
| implementation_variant: composite | |
| implementation_component: 'MUI: Typography/TextField inline edit composite (two | |
| instances)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Change the Secondary label to “Archived”, then click Save. The | |
| task will finish automatically when done. | |
| ui_copy: Change the Secondary label to “Archived”, then click Save. The task will | |
| finish automatically when done. | |
| setup_description: "A centered card titled “Labels” contains two inline editable\ | |
| \ text rows stacked vertically:\n • “Primary label” (initial: “Active”)\n •\ | |
| \ “Secondary label” (initial: “Pending”)\nBoth rows use the same composite pattern:\ | |
| \ Typography in read-only mode with a pencil IconButton; TextField with Save/Cancel\ | |
| \ in edit mode.\nThere is no other clutter. The key difficulty is selecting the\ | |
| \ correct instance (“Secondary label”) before editing and committing." | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 2 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: Two same-type instances increase disambiguation load; otherwise | |
| the edit is straightforward with clear controls. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Secondary label' is the one that must be | |
| checked. | |
| - The committed (display) value equals 'Archived' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Archived | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Secondary label | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Editing the Primary label instead of the Secondary label. | |
| - Typing “Archived” but not clicking Save (still editing). | |
| - Committing a close value like “Archive” or “archived”. | |
| - Canceling after typing so the Secondary label remains “Pending”. | |
| expected_interaction_path: | |
| - Locate the Secondary label row | |
| - Click its edit icon to enter edit mode | |
| - Type Archived | |
| - Click Save | |
| notes: 'Instrumentation: each row should have a unique data-testid or aria-label | |
| so the checker can map committed values to instance labels.' | |
| - id: inline_editable_text-mui-T09 | |
| name: Enter tracking ID in dark theme | |
| canonical_type: inline_editable_text | |
| implementation_source: mui | |
| implementation_variant: composite | |
| implementation_component: 'MUI: Typography/TextField inline edit composite' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Set the Tracking ID to “ZX-2049-NA” and click Save. The task will | |
| finish automatically when done. | |
| ui_copy: Set the Tracking ID to “ZX-2049-NA” and click Save. The task will finish | |
| automatically when done. | |
| setup_description: 'The page is rendered in a dark theme. A centered card titled | |
| “Shipment” contains one inline editable text labeled “Tracking ID”. | |
| The initial value is “ZX-0000-NA”. Clicking edit opens a one-line TextField with | |
| helper text: “Use uppercase letters and digits: XX-####-XX”. | |
| Invalid entries show an error and disable Save until the format is correct. In | |
| dark mode, the outline, helper text, and icon buttons have reduced visual salience | |
| compared to light mode.' | |
| scene_context: | |
| theme: dark | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 4 | |
| target_acquisition: 3 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Exact formatted entry with validation plus dark-theme icon/button | |
| contrast makes acquisition and feedback handling more demanding. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Tracking ID' is the one that must be checked. | |
| - The committed (display) value equals 'ZX-2049-NA' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: ZX-2049-NA | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Tracking ID | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Wrong casing or format (e.g., “zx-2049-na”, “ZX2049NA”). | |
| - Saving without committing the final value (still editing). | |
| - Entering a close value like “ZX-2049-N A” (extra space). | |
| - Canceling the edit, leaving the original tracking ID. | |
| expected_interaction_path: | |
| - Click Tracking ID edit icon | |
| - Type ZX-2049-NA exactly | |
| - Click Save | |
| notes: null | |
| - id: inline_editable_text-mui-T10 | |
| name: Edit table status cell (compact, top-right) | |
| canonical_type: inline_editable_text | |
| implementation_source: mui | |
| implementation_variant: composite | |
| implementation_component: 'MUI: Table + Typography/TextField inline edit composite' | |
| task_template: table_operation | |
| secondary_template: null | |
| browsergym_goal: In the Inventory table, edit the Status cell for item “Widget B” | |
| to “In Stock”, then click Save. The task will finish automatically when done. | |
| ui_copy: In the Inventory table, edit the Status cell for item “Widget B” to “In | |
| Stock”, then click Save. The task will finish automatically when done. | |
| setup_description: 'A compact table card is positioned near the top-right of the | |
| viewport. | |
| The card title is “Inventory”. The table has three rows (Widget A, Widget B, Widget | |
| C) and columns: Item, Status, Qty. | |
| Only one cell is inline-editable: the Status cell in the Widget B row. It shows | |
| “Backorder” as Typography and reveals a small pencil IconButton when hovered. | |
| Clicking it turns the cell into a one-line TextField with small Save/Cancel buttons | |
| rendered inline. | |
| Other cells are read-only and act as realistic table context; the task succeeds | |
| only when the Widget B/Status editable cell is committed to the target text.' | |
| scene_context: | |
| theme: light | |
| spacing: compact | |
| layout: table_cell | |
| placement: top_right | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 4 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: A small editable affordance inside a dense table, placed in the | |
| corner of the viewport, increases acquisition difficulty and makes it easy to | |
| target the wrong cell. | |
| success_trigger: | |
| human_readable: | |
| - The inline editable text instance inside the table cell (row='Widget B', column='Status') | |
| is the one that must be checked. | |
| - The committed (display) value equals 'In Stock' exactly. | |
| - The cell has exited edit mode (TextField hidden). | |
| - The value is committed via the inline editor's Save control. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: In Stock | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: InventoryTable:Widget B/Status | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Editing Widget A or Widget C instead of Widget B. | |
| - Saving “In stock” (case mismatch) or “In Stock” (extra space). | |
| - Typing the correct value but not saving (still editing). | |
| - Canceling the edit so the cell remains “Backorder”. | |
| expected_interaction_path: | |
| - Locate the Inventory table and the Widget B row | |
| - Click the Status cell edit affordance | |
| - Type In Stock | |
| - Click Save | |
| notes: Ensure the editable cell and controls have stable identifiers; table virtualization | |
| is disabled for this task to keep the target visible. | |
| - id: inline_editable_text-mantine-T01 | |
| name: Rename workspace name (Mantine composite) | |
| canonical_type: inline_editable_text | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Text + TextInput + ActionIcon (inline edit composite)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Change the Workspace name to “Northwind Lab” and click Save. The | |
| task will finish automatically when done. | |
| ui_copy: Change the Workspace name to “Northwind Lab” and click Save. The task will | |
| finish automatically when done. | |
| setup_description: 'A centered card titled “Workspace” contains one inline editable | |
| text row labeled “Workspace name”. | |
| In view mode, the value is displayed as Mantine Text with a small pencil ActionIcon | |
| on the right. Initial value: “Northwind”. | |
| Clicking the pencil swaps the Text for a one-line Mantine TextInput styled to | |
| blend into the row, with inline ActionIcons for Save and Cancel. | |
| Clicking Save commits the value and returns to the view mode Text. No other inline | |
| editable text instances are present.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Single field with clear Save/Cancel ActionIcons in a clean scene; | |
| only a short string must be entered and committed. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Workspace name' is the one that must be | |
| checked. | |
| - The committed (display) value equals 'Northwind Lab' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Northwind Lab | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Workspace name | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Typing the correct value but leaving the TextInput open (not committed). | |
| - Clicking Cancel after typing, which restores the previous name. | |
| - A close variant like “NorthwindLab” or “Northwind Lab ”. | |
| - Interacting with other controls (none exist of this canonical type). | |
| expected_interaction_path: | |
| - Click the pencil ActionIcon next to Workspace name | |
| - Type Northwind Lab | |
| - Click Save | |
| notes: 'Composite note: Mantine does not provide a dedicated inline-edit text component; | |
| this pattern toggles between Text and TextInput.' | |
| - id: inline_editable_text-mantine-T02 | |
| name: Enter edit mode (Mantine composite) | |
| canonical_type: inline_editable_text | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Text + TextInput (inline edit composite)' | |
| task_template: activate | |
| secondary_template: null | |
| browsergym_goal: Put the Tagline text into edit mode (no need to change it). The | |
| task will finish automatically when done. | |
| ui_copy: Put the Tagline text into edit mode (no need to change it). The task will | |
| finish automatically when done. | |
| setup_description: 'A centered card titled “Branding” contains one inline editable | |
| text row labeled “Tagline”. | |
| The read-only value is Mantine Text showing “Fast & simple” with a pencil ActionIcon. | |
| Clicking the pencil turns the row into a focused one-line TextInput and shows | |
| Save/Cancel ActionIcons. | |
| Success is achieved once the component is in editing mode (TextInput visible), | |
| regardless of the value.' | |
| 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 target; success is just a mode switch to show the input | |
| field. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Tagline' is the one that must be checked. | |
| - The component is in editing mode (mode='editing'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| mode: editing | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Tagline | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Hovering without clicking so the input never appears. | |
| - Opening unrelated UI (none exists); the TextInput must be visible. | |
| - Saving/canceling is not required; the component must be in edit mode. | |
| expected_interaction_path: | |
| - Click the Tagline pencil ActionIcon | |
| - Confirm the TextInput is visible (editing mode) | |
| notes: null | |
| - id: inline_editable_text-mantine-T03 | |
| name: Clear note to empty (Mantine composite) | |
| canonical_type: inline_editable_text | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Text + TextInput (inline edit composite)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the Note text so it is empty, then click Save. The task will | |
| finish automatically when done. | |
| ui_copy: Clear the Note text so it is empty, then click Save. The task will finish | |
| automatically when done. | |
| setup_description: 'A centered card titled “Note” includes one inline editable text | |
| labeled “Note”. | |
| The current value is “Call me after lunch”. Clicking the edit ActionIcon opens | |
| a one-line TextInput. | |
| While editing, a clear (×) affordance appears inside the input rightSection and | |
| Save/Cancel ActionIcons appear beside it. | |
| Saving commits the empty string and returns to the Text view.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Single inline editor with an explicit clear affordance; committing | |
| an empty string is straightforward. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Note' is the one that must be checked. | |
| - The committed (display) value equals '' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: '' | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Note | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Leaving whitespace or any character behind (not truly empty). | |
| - Clearing but clicking Cancel, which restores the previous note. | |
| - Clearing but not committing (still editing). | |
| - Replacing with placeholder text like “-” instead of empty. | |
| expected_interaction_path: | |
| - Click Note edit icon | |
| - Clear all text (× or backspace) | |
| - Click Save | |
| notes: If the UI uses placeholder text when empty, ensure the checker reads the | |
| stored value, not placeholder rendering. | |
| - id: inline_editable_text-mantine-T04 | |
| name: Enter formatted team code | |
| canonical_type: inline_editable_text | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Text + TextInput (inline edit composite)' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Set the Team code to “TEAM-0042” and click Save. The task will | |
| finish automatically when done. | |
| ui_copy: Set the Team code to “TEAM-0042” and click Save. The task will finish automatically | |
| when done. | |
| setup_description: 'A centered card titled “Team” contains one inline editable text | |
| row labeled “Team code”. | |
| The initial value is “TEAM-0001”. Clicking the pencil ActionIcon opens a one-line | |
| TextInput with helper text under it: “Format: TEAM-####”. | |
| If the prefix/casing or digit count is wrong, the input shows an error message | |
| and the Save ActionIcon is disabled until valid. | |
| Save commits the value and returns to Text display mode.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 4 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Exact formatted input with validation gating the Save control, | |
| but otherwise a clean single-field interaction. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Team code' is the one that must be checked. | |
| - The committed (display) value equals 'TEAM-0042' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: TEAM-0042 | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Team code | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Wrong format like “TEAM-42”, “team-0042”, or “TEAM0042”. | |
| - Typing the correct code but not saving (still editing). | |
| - Canceling the edit so the old code remains. | |
| - Any extra character such as a trailing space. | |
| expected_interaction_path: | |
| - Click Team code edit icon | |
| - Type TEAM-0042 | |
| - Click Save (enabled only when valid) | |
| notes: null | |
| - id: inline_editable_text-mantine-T05 | |
| name: Update event title (simple text) | |
| canonical_type: inline_editable_text | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Text + TextInput (inline edit composite)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Change the Event title to “Open House” and click Save. The task | |
| will finish automatically when done. | |
| ui_copy: Change the Event title to “Open House” and click Save. The task will finish | |
| automatically when done. | |
| setup_description: 'A centered card titled “Event” shows one inline editable text | |
| row labeled “Event title”. | |
| The current value is “Launch”. Clicking the edit ActionIcon opens a one-line TextInput | |
| with Save/Cancel. | |
| A small description below the row says “Shown on the public event page”. There | |
| are no other inline editable text rows on the page.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: A standard single-field inline edit requiring an explicit Save | |
| commit, with minimal distraction. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Event title' is the one that must be checked. | |
| - The committed (display) value equals 'Open House' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Open House | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Event title | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Not saving after typing (still editing). | |
| - Saving a close value like “Open house” (case mismatch) or “OpenHouse” (missing | |
| space). | |
| - Canceling, leaving the title unchanged. | |
| expected_interaction_path: | |
| - Click Event title edit icon | |
| - Type Open House | |
| - Click Save | |
| notes: null | |
| - id: inline_editable_text-mantine-T06 | |
| name: Commit short description with toast feedback | |
| canonical_type: inline_editable_text | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: TextInput + Notifications (inline edit composite)' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Change the Short description to “New orders ship Monday.” and click | |
| Save. The task will finish automatically when done. | |
| ui_copy: Change the Short description to “New orders ship Monday.” and click Save. | |
| The task will finish automatically when done. | |
| setup_description: 'A centered card titled “Description” contains one inline editable | |
| text row labeled “Short description”. | |
| The initial value is “Ships soon”. Clicking the pencil ActionIcon opens a one-line | |
| TextInput with Save/Cancel. | |
| On Save, the component shows a brief loading indicator on the Save icon and then | |
| displays a toast notification “Saved”. | |
| If the description exceeds 24 characters, an inline error appears and the value | |
| is not committed.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 4 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Delayed commit with transient loading/toast feedback and a character-limit | |
| constraint increases the chance of partial or invalid saves. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Short description' is the one that must | |
| be checked. | |
| - The committed (display) value equals 'New orders ship Monday.' exactly (case- | |
| and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: New orders ship Monday. | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Short description | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Missing the period or committing a close variant like “New orders ship Monday” | |
| (no punctuation). | |
| - Entering a too-long string that triggers an error and prevents commit. | |
| - Typing correctly but not saving (still editing). | |
| - Canceling, leaving the original value. | |
| expected_interaction_path: | |
| - Click Short description edit icon | |
| - Type New orders ship Monday. | |
| - Click Save and wait for return to display mode | |
| notes: Checker should ignore the toast and rely on committed value + display mode. | |
| - id: inline_editable_text-mantine-T07 | |
| name: Match internal label from reference card (two instances) | |
| canonical_type: inline_editable_text | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Text/TextInput inline edit composite (two instances) | |
| + Reference card' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the Internal label to match the bold text shown in the reference | |
| card, then click Save. The task will finish automatically when done. | |
| ui_copy: Set the Internal label to match the bold text shown in the reference card, | |
| then click Save. The task will finish automatically when done. | |
| setup_description: "A centered card titled “Labels” has two inline editable text\ | |
| \ rows:\n • “Public label” (initial: “Customer”)\n • “Internal label” (initial:\ | |
| \ “Ops”)\nTo the right, a reference card titled “Reference” shows the desired\ | |
| \ internal label in bold text.\nEach label row uses the same inline edit composite:\ | |
| \ Text view + pencil ActionIcon, then TextInput with Save/Cancel ActionIcons.\n\ | |
| The target string is not included in the instruction; it must be read from the\ | |
| \ reference card. The main challenge is choosing the correct instance (Internal\ | |
| \ label) and matching the reference exactly." | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 2 | |
| guidance: visual | |
| 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: 4 | |
| justification: Combines visual reference extraction with instance disambiguation | |
| across two same-type fields, while keeping the overall scene low clutter. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Internal label' is the one that must be | |
| checked. | |
| - The committed (display) value equals 'Back Office' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Back Office | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Internal label | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Editing the Public label instead of the Internal label. | |
| - Using a close value like “BackOffice” (missing space) or “Back office” (case mismatch). | |
| - Typing correctly but not saving (still editing). | |
| - Canceling after typing so the Internal label stays “Ops”. | |
| expected_interaction_path: | |
| - Read the bold text in the Reference card | |
| - Click the Internal label edit icon | |
| - Type the reference text | |
| - Click Save | |
| notes: Reference card content should be static for the task; checker uses the canonical | |
| target specified here. | |
| - id: inline_editable_text-mantine-T08 | |
| name: Scroll to find footer line and edit it | |
| canonical_type: inline_editable_text | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: ScrollArea + Text/TextInput inline edit composite' | |
| task_template: scroll_find | |
| secondary_template: null | |
| browsergym_goal: In the settings list, scroll until you find “Footer line”. Change | |
| it to “Powered by Mantine” and click Save. The task will finish automatically | |
| when done. | |
| ui_copy: In the settings list, scroll until you find “Footer line”. Change it to | |
| “Powered by Mantine” and click Save. The task will finish automatically when done. | |
| setup_description: 'The page shows a settings panel with a scrollable list of settings | |
| groups (inside a Mantine ScrollArea). | |
| Near the top are several distractor rows (toggles, selects, and read-only text) | |
| such as “Email alerts”, “Theme”, and “Timezone”. | |
| The target inline editable text row labeled “Footer line” is further down and | |
| is not visible at initial load without scrolling. | |
| “Footer line” displays a Text value (initial: “© 2026”) with a pencil ActionIcon; | |
| editing opens a one-line TextInput with Save/Cancel ActionIcons. | |
| Success depends only on committing the new Footer line value; the other settings | |
| are present only as clutter and do not affect completion.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: settings_panel | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 3 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: Requires scrolling within a settings panel to locate the correct | |
| row amid distractors, then performing an exact inline edit and commit. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Footer line' is the one that must be checked. | |
| - The committed (display) value equals 'Powered by Mantine' exactly (case- and | |
| punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Powered by Mantine | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Footer line | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Editing a different nearby setting row (e.g., changing some other text value). | |
| - Typing the value but not saving (still editing). | |
| - Entering a close value like “Powered by Mantine” (double space) or “Powered by | |
| mantine” (case mismatch). | |
| - Scrolling the page but never actually changing the Footer line value. | |
| expected_interaction_path: | |
| - Scroll the settings list until the Footer line row is visible | |
| - Click the Footer line edit icon | |
| - Type Powered by Mantine | |
| - Click Save | |
| notes: Checker should locate the target by its label and read committed value; avoid | |
| relying on scroll position. | |
| - id: inline_editable_text-mantine-T09 | |
| name: Enter team slug in dark theme | |
| canonical_type: inline_editable_text | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Text/TextInput inline edit composite' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Set the Team slug to “team-ops-42” and click Save. The task will | |
| finish automatically when done. | |
| ui_copy: Set the Team slug to “team-ops-42” and click Save. The task will finish | |
| automatically when done. | |
| setup_description: 'A centered card titled “Team” is displayed on a dark-themed | |
| page. | |
| It contains one inline editable text labeled “Team slug” with initial value “team-ops-01”. | |
| Editing opens a one-line TextInput with helper text: “Lowercase letters, digits, | |
| and hyphens only”. | |
| If uppercase letters or spaces are used, the input shows an error and the Save | |
| ActionIcon is disabled until the slug is valid. | |
| The dark theme reduces contrast for small helper text and icon controls compared | |
| to light mode.' | |
| scene_context: | |
| theme: dark | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 4 | |
| target_acquisition: 3 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Strict formatting constraints combined with reduced contrast in | |
| dark theme raise both precision and target acquisition difficulty. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Team slug' is the one that must be checked. | |
| - The committed (display) value equals 'team-ops-42' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: team-ops-42 | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Team slug | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Wrong casing like “Team-ops-42” or “TEAM-OPS-42”. | |
| - Using underscores or spaces (e.g., “team_ops_42” or “team ops 42”). | |
| - Typing correctly but not saving (still editing). | |
| - Canceling and leaving the original slug unchanged. | |
| expected_interaction_path: | |
| - Click Team slug edit icon | |
| - Type team-ops-42 | |
| - Click Save | |
| notes: null | |
| - id: inline_editable_text-mantine-T10 | |
| name: Edit display name inside a drawer (two fields, small scale) | |
| canonical_type: inline_editable_text | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Drawer + Text/TextInput inline edit composite' | |
| task_template: enter_text | |
| secondary_template: null | |
| browsergym_goal: Open the Edit profile drawer. Change the Display name to “Riley | |
| Quinn”, then click Save. The task will finish automatically when done. | |
| ui_copy: Open the Edit profile drawer. Change the Display name to “Riley Quinn”, | |
| then click Save. The task will finish automatically when done. | |
| setup_description: "The main page shows a small “Edit profile” button. Clicking\ | |
| \ it opens a Mantine Drawer that slides in from the left.\nInside the drawer is\ | |
| \ a compact profile form with two inline editable text rows of the same canonical\ | |
| \ type:\n • “Display name” (initial: “Riley Q.”)\n • “Username” (initial: “rileyq”)\n\ | |
| Both rows use the inline edit composite: Text view with pencil ActionIcon → small-size\ | |
| \ TextInput with Save/Cancel ActionIcons.\nThe drawer also contains a few non-editable\ | |
| \ lines (e.g., “Account created: 2024”) as low clutter, but they do not affect\ | |
| \ success.\nThe task requires editing the Display name (not Username) and committing\ | |
| \ the change via Save, all within the drawer overlay context." | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: drawer_flow | |
| placement: top_left | |
| scale: small | |
| instances: 2 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 3 | |
| density_choice_interference: 1 | |
| depth_layering: 3 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 4 | |
| justification: Adds an overlay layer (drawer) plus two same-type instances in | |
| a smaller scale UI, increasing layering and disambiguation demands alongside | |
| normal text entry and commit. | |
| success_trigger: | |
| human_readable: | |
| - The editable text instance labeled 'Display name' is the one that must be checked. | |
| - The committed (display) value equals 'Riley Quinn' exactly (case- and punctuation-sensitive). | |
| - The component is not in editing mode (mode='display'). | |
| - The value is committed via the component's confirm control ('Save'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| text: Riley Quinn | |
| mode: display | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Save | |
| require_correct_instance: true | |
| target_instance_label_or_id: Display name | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Editing the Username field instead of Display name. | |
| - Typing the correct name but not saving (still editing). | |
| - Closing the drawer without committing the change. | |
| - Committing a close value like “Riley Quinn ” (trailing space) or “Riley Quin” | |
| (missing letter). | |
| expected_interaction_path: | |
| - Click Edit profile to open the drawer | |
| - In the drawer, click Display name edit icon | |
| - Type Riley Quinn | |
| - Click Save | |
| notes: Checker should ensure it reads the committed value associated with the Display | |
| name instance, independent of whether the drawer remains open. | |