Initial ComponentBench data release: tasks v1+v2, cleaned human traces, difficulty audit, ontology metadata
360df42 verified | - id: date_input_text-antd-T01 | |
| name: AntD basic typed date in ISO format | |
| canonical_type: date_input_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker (date) with manual typing enabled' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: In the Date entry card, set the “Invoice date” field to 2026-02-14 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Goal: Set Invoice date to 2026-02-14 (YYYY-MM-DD).' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport (single card on an otherwise blank page). | |
| Component: One Ant Design DatePicker rendered inline inside the card with label “Invoice date”. | |
| The input shows a placeholder “YYYY-MM-DD”, a calendar icon on the right, and a clear (✕) icon that appears when a value is present. | |
| Initial state: the field is empty (no date selected) and no popup is open. | |
| Sub-controls/behavior: typing a date and pressing Enter (or blurring the field) commits the value; clicking the calendar icon would open a calendar popover but is not required. | |
| Distractors: none (no other inputs/buttons in the card). | |
| Feedback: once committed, the formatted date text is visible in the input. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Single, large date input with an explicit placeholder and immediate visible feedback after typing. | |
| success_trigger: | |
| human_readable: | |
| - The DatePicker value (canonical date) equals 2026-02-14. | |
| - No confirmation button is required; the committed field value is sufficient. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-02-14' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Any other date is entered (including 2026-02-13 or 2026-02-15). | |
| - The text is typed but not committed (value remains empty / invalid). | |
| - The date is entered into a non-existent or wrong field (not applicable here, but still invalid). | |
| expected_interaction_path: Click the input → type 2026-02-14 → press Enter or click outside to commit. | |
| notes: 'Instrumentation: expose the DatePicker input as data-testid=''invoice-date''. Checker should read the component value and normalize to ISO YYYY-MM-DD.' | |
| - id: date_input_text-antd-T02 | |
| name: AntD overwrite an existing date | |
| canonical_type: date_input_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker (date) with manual typing enabled' | |
| task_template: set_scalar | |
| secondary_template: null | |
| browsergym_goal: Change the “Shipping date” field to 2026-02-20 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Goal: Shipping date should be 2026-02-20.' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: One Ant Design DatePicker labeled “Shipping date”. | |
| Initial state: the field is pre-filled with 2026-02-01 (YYYY-MM-DD). The clear icon is available because a value is set. | |
| Sub-controls/behavior: the date can be edited by focusing the input and typing over the existing value; calendar popover is available but optional. | |
| Distractors: a non-interactive summary line under the field (“Orders ship within 2 business days.”) to look realistic. | |
| Feedback: the input text updates to the new date when committed. | |
| 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: Requires replacing an existing value, but the field is still isolated with clear visual confirmation. | |
| success_trigger: | |
| human_readable: | |
| - The DatePicker value (canonical date) equals 2026-02-20. | |
| - No additional Save/Apply action is required. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-02-20' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Leaving the original date (2026-02-01) unchanged. | |
| - Entering 2026-02-02 or any other off-by-one date. | |
| - Typing the date but leaving the field in an invalid/uncommitted state (checker still reads old value). | |
| expected_interaction_path: Click the input → select all (or clear) → type 2026-02-20 → commit by Enter/blur. | |
| notes: 'Instrumentation: data-testid=''shipping-date''. Consider normalizing value via onChange-emitted Dayjs/Date object to ISO.' | |
| - id: date_input_text-antd-T03 | |
| name: AntD clear a pre-filled date | |
| canonical_type: date_input_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker (date) with allowClear' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the “Reminder date” field so it becomes empty. The task will finish automatically when done. | |
| ui_copy: 'Goal: Reminder date should be cleared (empty).' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: One Ant Design DatePicker labeled “Reminder date”. | |
| Initial state: the field contains 2026-03-10 (YYYY-MM-DD). | |
| Sub-controls/behavior: a small clear (✕) icon becomes available in the input when it has a value (typical AntD allowClear behavior). Clearing removes the value and restores the placeholder. | |
| Distractors: none. | |
| Feedback: after clearing, the input shows the placeholder text again and the value becomes null/empty. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 1 | |
| target_acquisition: 3 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: The main challenge is acquiring the small clear control; otherwise the task is straightforward with immediate feedback. | |
| success_trigger: | |
| human_readable: | |
| - The DatePicker value is empty/null (no date selected). | |
| - The field shows the empty state (placeholder visible) and no date is committed. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: null | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| empty_ok: true | |
| negative_cases: | |
| - A date value remains set (including the original 2026-03-10). | |
| - The user types and leaves an invalid string that does not clear the underlying value. | |
| - Clearing is attempted but the value is not actually removed (e.g., only selects text). | |
| expected_interaction_path: Hover/focus the input if needed → click the clear (✕) icon (or delete the value and commit) → verify placeholder returns. | |
| notes: 'Instrumentation: data-testid=''reminder-date''. Checker should treat null/undefined/empty as cleared.' | |
| - id: date_input_text-antd-T04 | |
| name: AntD typed date in US format | |
| canonical_type: date_input_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker (date) with format MM/DD/YYYY' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Set the “Event date” field to 03/03/2026 (MM/DD/YYYY). The task will finish automatically when done. | |
| ui_copy: 'Goal: Event date = 03/03/2026.' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: One Ant Design DatePicker labeled “Event date”. | |
| Configuration: display/parse format is set to MM/DD/YYYY, and the placeholder shows “MM/DD/YYYY”. | |
| Initial state: empty. | |
| Sub-controls/behavior: typing is supported; the calendar popover exists but is optional. | |
| Distractors: none. | |
| Feedback: after commit, the input shows “03/03/2026”. | |
| 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: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Single field with an explicit format hint; success is an exact semantic date match. | |
| success_trigger: | |
| human_readable: | |
| - The DatePicker value (canonical date) equals 2026-03-03. | |
| - The displayed text corresponds to MM/DD/YYYY for that date. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-03-03' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| expected_display_format: MM/DD/YYYY | |
| negative_cases: | |
| - Entering 03/02/2026 or 02/03/2026 (month/day swapped). | |
| - Entering a malformed date that does not parse (field remains empty/invalid). | |
| - Leaving the field empty. | |
| expected_interaction_path: Click input → type 03/03/2026 → press Enter or blur. | |
| notes: 'Instrumentation: data-testid=''event-date''. Checker should compare parsed date, not raw text.' | |
| - id: date_input_text-antd-T05 | |
| name: AntD pick the correct field among two instances | |
| canonical_type: date_input_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker (date) x2 in a form section' | |
| task_template: set_scalar | |
| secondary_template: null | |
| browsergym_goal: In the Booking form, set the “End date” field to 2026-05-20 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Booking form: Set End date to 2026-05-20.' | |
| setup_description: |- | |
| Layout: form_section centered in the viewport, resembling a typical booking form. | |
| Components: Two Ant Design DatePicker inputs shown inline in the same section: | |
| 1) “Start date” (pre-filled with 2026-05-10) | |
| 2) “End date” (empty) | |
| Both fields use the same YYYY-MM-DD format and both allow manual typing. | |
| Sub-controls: each input has its own calendar icon and clear behavior. | |
| Distractors (clutter=low): there is also a “Guests” numeric input and a disabled “Promo code” text box, but they do not affect success. | |
| Feedback: the “End date” field shows the selected/typed date once committed. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: form_section | |
| placement: center | |
| scale: default | |
| instances: 2 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: Two identical date inputs require disambiguation by label; otherwise the interaction is direct typing with immediate feedback. | |
| success_trigger: | |
| human_readable: | |
| - The “End date” DatePicker value equals 2026-05-20. | |
| - The “Start date” field may be unchanged; only the targeted instance is checked. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-05-20' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: End date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Setting the “Start date” to 2026-05-20 while leaving “End date” empty. | |
| - Entering 2026-05-02 or any other date (wrong day/month). | |
| - Typing into the field but not committing (checker still reads empty). | |
| expected_interaction_path: Locate “End date” → focus input → type 2026-05-20 → commit by Enter/blur. | |
| notes: 'Instrumentation: data-testid=''start-date'' and ''end-date''. Checker must ensure correct instance by associated label.' | |
| - id: date_input_text-antd-T06 | |
| name: AntD match a date from a visual reference badge | |
| canonical_type: date_input_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker (date) with manual typing enabled' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the “Report date” field to match the date shown on the “Reference stamp” on the page. The task will finish automatically when done. | |
| ui_copy: 'Goal: Report date must match the Reference stamp.' | |
| setup_description: |- | |
| Layout: dashboard-style card with two columns, centered in the viewport. | |
| Left column: an Ant Design DatePicker labeled “Report date” (format YYYY-MM-DD) with placeholder “YYYY-MM-DD”. | |
| Right column: a prominent “Reference stamp” badge styled like a rubber stamp. It visually displays the target date as: | |
| “JUN 01 2026” | |
| Initial state: “Report date” is empty. | |
| Distractors (clutter=low): a small “Report title” text field is present but disabled and does not affect success. | |
| Feedback: after entering a valid date, the DatePicker shows the formatted date text in the input. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: visual | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 3 | |
| disambiguation_load: 2 | |
| justification: The target date is not provided in the instruction and must be read from an on-screen reference, increasing observability demand. | |
| success_trigger: | |
| human_readable: | |
| - The “Report date” DatePicker value equals the reference date 2026-06-01. | |
| - No additional confirmation action is required. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| date_iso: '2026-06-01' | |
| reference_id: reference-stamp | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Report date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Entering any other date that does not match the Reference stamp. | |
| - Leaving the field empty. | |
| - Typing an invalid string that fails to parse (value remains null). | |
| expected_interaction_path: Read the date from the Reference stamp → focus “Report date” → type the equivalent YYYY-MM-DD value → commit. | |
| notes: 'Instrumentation: reference badge data-testid=''reference-stamp'' (for dataset generation) and input data-testid=''report-date''. Checker uses the fixed target date encoded in the task instance.' | |
| - id: date_input_text-antd-T07 | |
| name: AntD date input inside a modal with Save/Cancel | |
| canonical_type: date_input_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Modal + DatePicker (date) in a form' | |
| task_template: confirm_cancel | |
| secondary_template: null | |
| browsergym_goal: Open the “Edit reservation” dialog, set “Check-in date” to 2026-07-04 (YYYY-MM-DD), then click “Save reservation”. The task will finish automatically when done. | |
| ui_copy: Edit reservation → set Check-in date to 2026-07-04 → Save reservation. | |
| setup_description: |- | |
| Layout: modal_flow. The base page shows a small reservation summary card and a primary button “Edit reservation”. | |
| When “Edit reservation” is clicked, an Ant Design Modal opens in the center of the screen. | |
| Inside the modal is a short form with: | |
| - “Guest name” (prefilled text input; not required) | |
| - “Check-in date” (Ant Design DatePicker; format YYYY-MM-DD; manual typing enabled) | |
| Initial state: modal is closed; “Check-in date” is empty once the modal opens. | |
| Actions: modal footer has two buttons: “Cancel” (secondary) and “Save reservation” (primary). | |
| Feedback: clicking “Save reservation” closes the modal and shows a small inline success message under the reservation summary (“Saved”). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: modal_flow | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 3 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 2 | |
| justification: Requires opening a modal layer and committing via an explicit Save button; success depends on both the entered date and confirmation. | |
| success_trigger: | |
| human_readable: | |
| - The “Check-in date” value in the modal form equals 2026-07-04. | |
| - The user has clicked “Save reservation” (confirmation required) and the saved value is persisted. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-07-04' | |
| tolerance: | |
| days: 0 | |
| require_confirm: true | |
| confirm_control: Save reservation | |
| require_correct_instance: true | |
| target_instance_label_or_id: Check-in date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| persisted_state_id: reservation.checkin | |
| negative_cases: | |
| - Correct date is entered but “Save reservation” is not clicked (modal left open). | |
| - Clicking “Cancel” after entering the date (should not count). | |
| - Saving with any date other than 2026-07-04. | |
| - Entering text that looks right but does not parse to a valid date value. | |
| expected_interaction_path: Click “Edit reservation” → focus Check-in date → type 2026-07-04 → commit → click “Save reservation”. | |
| notes: 'Instrumentation: modal root data-testid=''edit-reservation-modal''; input data-testid=''checkin-date''; save button data-testid=''save-reservation''. Checker should verify a persisted state update, not just transient text.' | |
| - id: date_input_text-antd-T08 | |
| name: AntD masked date input in dark compact small card | |
| canonical_type: date_input_text | |
| implementation_source: antd | |
| implementation_variant: mask_format | |
| implementation_component: 'AntD: DatePicker (date) using Mask Format demo-style input' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: In the Cutoff card, enter 2026-12-31 into the “Cutoff date” field. The task will finish automatically when done. | |
| ui_copy: 'Cutoff card: Cutoff date should be 2026-12-31.' | |
| setup_description: |- | |
| Layout: isolated_card anchored at the top-right of the viewport (not centered). | |
| Theme/spacing: dark theme with compact spacing; the component uses the small size variant. | |
| Component: one Ant Design DatePicker labeled “Cutoff date”. | |
| Configuration: the field uses a mask-like date format (YYYY-MM-DD) where the caret advances by segments; the placeholder shows a partially formatted mask (e.g., “YYYY-MM-DD” with guides). | |
| Initial state: empty. No popup is open. | |
| Sub-controls/behavior: the input attempts to align to the last valid date on blur if the typed text is close but incomplete; arrow keys can move between segments; the calendar icon is present but small. | |
| Distractors: none. | |
| Feedback: once a valid date is committed, the masked field displays the fully formatted date. | |
| scene_context: | |
| theme: dark | |
| spacing: compact | |
| layout: isolated_card | |
| placement: top_right | |
| scale: small | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 3 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: Small, compact masked input in a corner placement increases target acquisition difficulty and requires precise formatted entry/segment editing. | |
| success_trigger: | |
| human_readable: | |
| - The “Cutoff date” value equals 2026-12-31 after the input is committed. | |
| - No Save/Apply button is required. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-12-31' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Cutoff date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| input_mode: mask | |
| negative_cases: | |
| - Entering 2026-12-13 or 2026-11-31 (wrong day/month). | |
| - Leaving the input partially filled so the underlying date value is still null/invalid. | |
| - Relying on auto-alignment to a different date than the target. | |
| expected_interaction_path: Focus the small masked field → type 2026-12-31 (or fill segments) → blur/Enter to commit. | |
| notes: 'Implementation hint: use AntD DatePicker Mask Format example configuration. Instrument input as data-testid=''cutoff-date''.' | |
| - id: date_input_text-antd-T09 | |
| name: AntD edit a date field inside a dense table row | |
| canonical_type: date_input_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table + DatePicker (date) in table cells' | |
| task_template: table_operation | |
| secondary_template: null | |
| browsergym_goal: In the Milestones table, set the “Milestone date” for the “Beta” row to 2026-04-01 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Milestones table: Beta → Milestone date = 2026-04-01.' | |
| setup_description: |- | |
| Layout: table_cell scene with the table centered in the viewport. | |
| Component instances: three Ant Design DatePicker inputs rendered directly inside the “Milestone date” column cells (one per row). | |
| Rows: “Alpha”, “Beta”, “Gamma”. | |
| Each cell shows a small DatePicker input (size=small, format YYYY-MM-DD) with a calendar icon; manual typing is enabled. | |
| Initial state: | |
| - Alpha milestone date: 2026-03-15 | |
| - Beta milestone date: empty | |
| - Gamma milestone date: 2026-05-10 | |
| Clutter (high): table also includes an “Owner” dropdown and a “Status” tag column; these are distractors and not required. | |
| Feedback: the edited cell updates immediately after commit and the table highlights the changed cell briefly (1s). | |
| scene_context: | |
| theme: light | |
| spacing: compact | |
| layout: table_cell | |
| placement: center | |
| scale: small | |
| instances: 3 | |
| guidance: text | |
| clutter: high | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 4 | |
| density_choice_interference: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 4 | |
| justification: Multiple small, similar date inputs inside a dense table require precise target acquisition and correct row disambiguation. | |
| success_trigger: | |
| human_readable: | |
| - In the “Beta” row, the “Milestone date” cell’s DatePicker value equals 2026-04-01. | |
| - Other rows’ milestone dates may remain unchanged. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-04-01' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Milestone date (Beta) | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| table_row_key: Beta | |
| table_column_key: milestone_date | |
| negative_cases: | |
| - Setting the Alpha or Gamma row’s date to 2026-04-01 instead of Beta. | |
| - Entering 2026-01-04 (month/day swapped) or any other incorrect date. | |
| - Leaving Beta empty or in an invalid state. | |
| expected_interaction_path: Find the Beta row → focus its Milestone date input → type 2026-04-01 → commit by Enter/blur. | |
| notes: 'Instrumentation: add data-row-key attributes for each row and data-testid for each cell input (e.g., milestone-date-beta). Checker should resolve the correct row via stable row key, not screen position.' | |
| - id: date_input_text-antd-T10 | |
| name: AntD match reference date with Apply in a cluttered dashboard | |
| canonical_type: date_input_text | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker (date) x2 + sticky Apply bar' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the “Backup deadline” field to match the date shown on the “Reference calendar” tile, then click “Apply changes”. The task will finish automatically when done. | |
| ui_copy: 'Dashboard: Backup deadline must match Reference calendar, then Apply changes.' | |
| setup_description: |- | |
| Layout: dashboard scene anchored at the bottom-right of the viewport (not centered). | |
| Components: Two Ant Design DatePicker inputs in a “Deadlines” panel: | |
| - “Primary deadline” (pre-filled with 2026-04-01) | |
| - “Backup deadline” (empty) | |
| Both use YYYY-MM-DD format and allow manual typing. | |
| Visual reference: a separate tile labeled “Reference calendar” shows the target date prominently as “APR 09 2026”. | |
| Clutter (medium): the dashboard also contains a small activity feed and two filter chips; they are irrelevant. | |
| Confirmation: a sticky footer bar contains “Discard” and a primary “Apply changes” button. Changes are not persisted until “Apply changes” is clicked. | |
| Feedback: clicking “Apply changes” shows a toast “Changes applied” and the sticky bar disappears. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: bottom_right | |
| scale: default | |
| instances: 2 | |
| guidance: visual | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 3 | |
| semantic_observability: 3 | |
| disambiguation_load: 3 | |
| justification: Requires reading a visual reference, editing the correct field among two similar instances, and committing via an explicit Apply action. | |
| success_trigger: | |
| human_readable: | |
| - The “Backup deadline” DatePicker value equals the reference date 2026-04-09. | |
| - The user has clicked “Apply changes” (confirmation required) so the value is persisted. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| date_iso: '2026-04-09' | |
| reference_id: reference-calendar-tile | |
| tolerance: | |
| days: 0 | |
| require_confirm: true | |
| confirm_control: Apply changes | |
| require_correct_instance: true | |
| target_instance_label_or_id: Backup deadline | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| persisted_state_id: deadlines.backup | |
| negative_cases: | |
| - Setting “Primary deadline” instead of “Backup deadline”. | |
| - Entering the correct date but not clicking “Apply changes”. | |
| - Clicking “Discard”. | |
| - Choosing a date that is off by one day (e.g., 2026-04-08 or 2026-04-10). | |
| expected_interaction_path: Read date on Reference calendar tile → focus Backup deadline → type corresponding YYYY-MM-DD → commit → click Apply changes. | |
| notes: 'Instrumentation: data-testid=''primary-deadline'', ''backup-deadline'', ''apply-changes'', ''reference-calendar-tile''. Checker should verify persisted state updated after Apply.' | |
| - id: date_input_text-mui-T01 | |
| name: MUI DateField basic typed date (MM/DD/YYYY) | |
| canonical_type: date_input_text | |
| implementation_source: mui | |
| implementation_variant: DateField | |
| implementation_component: 'MUI X: DateField' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Set the “Birthday” field to 03/15/2026 (MM/DD/YYYY). The task will finish automatically when done. | |
| ui_copy: 'Goal: Birthday = 03/15/2026.' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: One MUI X DateField labeled “Birthday”. | |
| Visuals/behavior: the field shows a placeholder like “MM/DD/YYYY” and uses a sectioned input (month/day/year sections) typical of MUI X fields. | |
| Initial state: empty; no popover is open (field-only). | |
| Sub-controls: a calendar icon is not shown (DateField only); the user edits directly in the field. | |
| Distractors: none. | |
| Feedback: once a valid date is entered, the field displays it in MM/DD/YYYY and the internal value becomes a valid date object. | |
| 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: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Single date field with a clear placeholder; no overlays or extra confirmations. | |
| success_trigger: | |
| human_readable: | |
| - The DateField value (canonical date) equals 2026-03-15. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-03-15' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Entering 03/05/2026 or 05/03/2026 (swapped day/month). | |
| - Leaving the field incomplete so it does not parse to a valid date value. | |
| - Leaving it empty. | |
| expected_interaction_path: Focus the DateField → type 03/15/2026 (or fill sections) → blur/Enter to commit. | |
| notes: 'Instrumentation: data-testid=''birthday-datefield''. Checker should normalize the Date value to ISO.' | |
| - id: date_input_text-mui-T02 | |
| name: MUI DateField overwrite an existing date | |
| canonical_type: date_input_text | |
| implementation_source: mui | |
| implementation_variant: DateField | |
| implementation_component: 'MUI X: DateField' | |
| task_template: set_scalar | |
| secondary_template: null | |
| browsergym_goal: Change the “Start date” field to 02/28/2026 (MM/DD/YYYY). The task will finish automatically when done. | |
| ui_copy: 'Goal: Start date should be 02/28/2026.' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: One MUI X DateField labeled “Start date”. | |
| Initial state: pre-filled with 02/10/2026. | |
| Behavior: the DateField uses month/day/year sections; user can edit by selecting sections and typing. | |
| Distractors: a read-only “Project name” text line above the field. | |
| Feedback: the value updates in place when the edit is committed (blur/Enter). | |
| 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: Overwriting a pre-filled value adds a small edit step, but the field is isolated with clear feedback. | |
| success_trigger: | |
| human_readable: | |
| - The “Start date” DateField value equals 2026-02-28. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-02-28' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Start date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Leaving the original date (02/10/2026). | |
| - Entering 02/18/2026 or any other incorrect date. | |
| - Typing but not committing (checker still reads old value). | |
| expected_interaction_path: Focus Start date field → select/overwrite sections → type 02/28/2026 → commit. | |
| notes: 'Instrumentation: data-testid=''start-date''. For sectioned fields, checker should read the component value rather than DOM text only.' | |
| - id: date_input_text-mui-T03 | |
| name: MUI DateField clear using clearable control | |
| canonical_type: date_input_text | |
| implementation_source: mui | |
| implementation_variant: DateField | |
| implementation_component: 'MUI X: DateField (clearable)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the “Due date” field so it becomes empty. The task will finish automatically when done. | |
| ui_copy: 'Goal: Due date should be cleared (empty).' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: One MUI X DateField labeled “Due date” with clearable behavior enabled. | |
| Initial state: pre-filled with 04/05/2026. | |
| Sub-controls: a small clear icon button appears inside the field when it has a value (standard MUI X clearable behavior). | |
| Distractors: none. | |
| Feedback: after clearing, the field shows the placeholder “MM/DD/YYYY” again and the value becomes null. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 1 | |
| target_acquisition: 3 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Clearing requires acquiring a small clear icon (or deleting all sections), but the page is otherwise minimal. | |
| success_trigger: | |
| human_readable: | |
| - The “Due date” DateField value is empty/null (no date selected). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: null | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Due date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| empty_ok: true | |
| negative_cases: | |
| - A date value remains set (including 04/05/2026). | |
| - Only selecting text/sections without clearing the underlying value. | |
| - Leaving an invalid partial date that does not clear to null. | |
| expected_interaction_path: Focus Due date field → click clear icon (or delete content) → ensure placeholder returns. | |
| notes: 'Instrumentation: data-testid=''due-date''. If using MUI X clearable prop, also tag clear button data-testid=''due-date-clear''.' | |
| - id: date_input_text-mui-T04 | |
| name: MUI two DateFields in a form section (disambiguate by label) | |
| canonical_type: date_input_text | |
| implementation_source: mui | |
| implementation_variant: DateField | |
| implementation_component: 'MUI X: DateField x2' | |
| task_template: set_scalar | |
| secondary_template: null | |
| browsergym_goal: In the Schedule form, set the “End date” field to 05/20/2026 (MM/DD/YYYY). The task will finish automatically when done. | |
| ui_copy: 'Schedule form: End date = 05/20/2026.' | |
| setup_description: |- | |
| Layout: form_section centered in the viewport with a header “Schedule”. | |
| Components: two MUI X DateField inputs stacked with labels: | |
| - “Start date” (pre-filled with 05/10/2026) | |
| - “End date” (empty) | |
| Both fields use MM/DD/YYYY and sectioned editing. | |
| Distractors (clutter=low): a “Timezone” select (disabled) and a “Notes” multiline field (optional) are visible. | |
| Feedback: entering a valid date updates the field’s displayed value and removes any placeholder sections. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: form_section | |
| placement: center | |
| scale: default | |
| instances: 2 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: Two similar fields require selecting the correct instance; otherwise the interaction is simple sectioned typing. | |
| success_trigger: | |
| human_readable: | |
| - The “End date” DateField value equals 2026-05-20. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-05-20' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: End date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Setting “Start date” to 05/20/2026 instead of “End date”. | |
| - Entering 05/02/2026 or any other incorrect date. | |
| - Leaving End date empty. | |
| expected_interaction_path: Find End date field → focus → type 05/20/2026 → commit. | |
| notes: 'Instrumentation: data-testid=''start-date'' and ''end-date''. Ensure labels are programmatically associated with inputs for accessibility-based agents.' | |
| - id: date_input_text-mui-T05 | |
| name: MUI DateField with dash separator custom format | |
| canonical_type: date_input_text | |
| implementation_source: mui | |
| implementation_variant: DateField | |
| implementation_component: 'MUI X: DateField (custom format YYYY-MM-DD)' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Set the “Archive date” field to 2026-06-30 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Goal: Archive date = 2026-06-30.' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: one MUI X DateField labeled “Archive date”. | |
| Configuration: the field uses a dash-separated display/parse format (YYYY-MM-DD) and shows a placeholder like “YYYY-MM-DD”. | |
| Initial state: empty. | |
| Behavior: sectioned input still applies, but separators are dashes; users can type the full string or edit sections. | |
| Distractors: none. | |
| Feedback: the value becomes valid only when all sections form a real calendar date. | |
| 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: 3 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Custom formatting increases precision requirements and can trip agents that assume the default MM/DD/YYYY layout. | |
| success_trigger: | |
| human_readable: | |
| - The “Archive date” DateField value equals 2026-06-30. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-06-30' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Archive date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| expected_display_format: YYYY-MM-DD | |
| negative_cases: | |
| - Entering 06/30/2026 (slashes) if it does not parse under the configured format. | |
| - Entering 2026-30-06 (swapped month/day). | |
| - Leaving the field partially filled so it remains invalid. | |
| expected_interaction_path: Focus Archive date → type 2026-06-30 → commit by blur/Enter. | |
| notes: 'Instrumentation: data-testid=''archive-date''. Configure MUI X format explicitly so the UI is deterministic.' | |
| - id: date_input_text-mui-T06 | |
| name: MUI scroll to find a date field in settings panel | |
| canonical_type: date_input_text | |
| implementation_source: mui | |
| implementation_variant: DateField | |
| implementation_component: 'MUI X: DateField inside a scrollable Settings panel' | |
| task_template: scroll_find | |
| secondary_template: null | |
| browsergym_goal: In Settings, scroll to the “Data retention start date” field and set it to 08/01/2026 (MM/DD/YYYY). The task will finish automatically when done. | |
| ui_copy: 'Settings: Data retention start date = 08/01/2026.' | |
| setup_description: |- | |
| Layout: settings_panel. The page has a left navigation rail (non-interactive for this task) and a main scrollable settings pane. | |
| Target component: a MUI X DateField labeled “Data retention start date” located in the “Retention” section near the bottom of the scrollable pane (initially below the fold). | |
| Initial state: the field is empty. | |
| Other content (clutter=medium): multiple toggles, helper text paragraphs, and a numeric input appear above it; none affect success. | |
| Behavior: standard sectioned MM/DD/YYYY input; no popovers. | |
| Feedback: after entry, the field displays “08/01/2026” and the section header shows a small “Unsaved changes” dot (cosmetic). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: settings_panel | |
| placement: bottom_left | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 2 | |
| justification: Requires scrolling within a settings pane to locate the correct labeled field amid moderate clutter before performing the usual date entry. | |
| success_trigger: | |
| human_readable: | |
| - The “Data retention start date” DateField value equals 2026-08-01. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-08-01' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Data retention start date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| scroll_required: true | |
| negative_cases: | |
| - Entering the date in a different setting field. | |
| - Entering any date other than 08/01/2026. | |
| - Leaving the field empty because it was not found. | |
| expected_interaction_path: Scroll the settings pane until the Retention section → focus Data retention start date → type 08/01/2026 → commit. | |
| notes: 'Instrumentation: data-testid=''retention-start-date''. Include a stable section container id for scroll targeting.' | |
| - id: date_input_text-mui-T07 | |
| name: MUI match a date from a shipping label preview | |
| canonical_type: date_input_text | |
| implementation_source: mui | |
| implementation_variant: DateField | |
| implementation_component: 'MUI X: DateField' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the “Ship date” field to match the date shown on the “Shipping label preview”. The task will finish automatically when done. | |
| ui_copy: 'Goal: Ship date must match the Shipping label preview.' | |
| setup_description: |- | |
| Layout: dashboard-style card centered in the viewport. | |
| Left side: a MUI X DateField labeled “Ship date” (MM/DD/YYYY). | |
| Right side: a “Shipping label preview” panel that visually prints the target date in bold, uppercase stamp style: | |
| “SEP 09 2026” | |
| Initial state: Ship date field is empty. | |
| Clutter (low): a disabled “Carrier” dropdown is visible under the preview (not required). | |
| Feedback: when a valid date is entered, the date field updates; the preview’s “Ship date” line also updates (cosmetic). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: visual | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 3 | |
| disambiguation_load: 2 | |
| justification: The instruction omits the exact date, requiring the agent to extract it from a visual preview before entering it. | |
| success_trigger: | |
| human_readable: | |
| - The “Ship date” value equals the reference date 2026-09-09. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| date_iso: '2026-09-09' | |
| reference_id: shipping-label-preview | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Ship date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Entering a different date than shown in the preview. | |
| - Leaving the field empty or invalid. | |
| - Entering the correct date into a non-target field (if any). | |
| expected_interaction_path: Read the stamped date on the preview → enter that date into Ship date → commit. | |
| notes: 'Instrumentation: data-testid=''ship-date'' and ''shipping-label-preview''.' | |
| - id: date_input_text-mui-T08 | |
| name: MUI DatePicker field inside dark themed modal with Save | |
| canonical_type: date_input_text | |
| implementation_source: mui | |
| implementation_variant: DatePicker | |
| implementation_component: 'MUI X: DatePicker (keyboard input) inside a Dialog' | |
| task_template: confirm_cancel | |
| secondary_template: null | |
| browsergym_goal: Open the “New appointment” dialog, set “Appointment date” to 10/12/2026 (MM/DD/YYYY), then click “Save appointment”. The task will finish automatically when done. | |
| ui_copy: New appointment → Appointment date = 10/12/2026 → Save appointment. | |
| setup_description: |- | |
| Layout: modal_flow with dark theme. | |
| Base page: a small toolbar with a primary button “New appointment”. | |
| Clicking it opens a MUI Dialog in the center containing a short form: | |
| - “Title” text field (prefilled; not required) | |
| - “Appointment date” using MUI X DatePicker input field (manual typing supported; calendar popover can be opened from the field but is optional) | |
| Footer buttons: “Cancel” and “Save appointment”. | |
| Initial state: Appointment date is empty when the dialog opens. | |
| Feedback: after clicking “Save appointment”, the dialog closes and an inline confirmation text appears (“Appointment saved”). | |
| scene_context: | |
| theme: dark | |
| spacing: comfortable | |
| layout: modal_flow | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 3 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 2 | |
| justification: Multiple-layer interaction (open dialog, edit date, then explicitly save) with dark theme reduces contrast and increases layering/feedback demands. | |
| success_trigger: | |
| human_readable: | |
| - The “Appointment date” value equals 2026-10-12. | |
| - The user clicked “Save appointment” and the saved value is persisted. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-10-12' | |
| tolerance: | |
| days: 0 | |
| require_confirm: true | |
| confirm_control: Save appointment | |
| require_correct_instance: true | |
| target_instance_label_or_id: Appointment date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| persisted_state_id: appointment.date | |
| negative_cases: | |
| - Entering the correct date but closing the dialog without saving. | |
| - Clicking “Cancel”. | |
| - Saving a different date. | |
| - Leaving the field invalid/empty. | |
| expected_interaction_path: Click New appointment → focus Appointment date field → type 10/12/2026 → commit → click Save appointment. | |
| notes: 'Instrumentation: data-testid=''new-appointment'', dialog data-testid=''appointment-dialog'', date field data-testid=''appointment-date'', save button data-testid=''save-appointment''.' | |
| - id: date_input_text-mui-T09 | |
| name: MUI edit a date field inside a compact table | |
| canonical_type: date_input_text | |
| implementation_source: mui | |
| implementation_variant: DateField | |
| implementation_component: 'MUI X: DateField in DataGrid/Table cells' | |
| task_template: table_operation | |
| secondary_template: null | |
| browsergym_goal: In the Release plan table, set the “Release date” for the “v2.0” row to 11/01/2026 (MM/DD/YYYY). The task will finish automatically when done. | |
| ui_copy: 'Release plan: v2.0 → Release date = 11/01/2026.' | |
| setup_description: |- | |
| Layout: table_cell anchored near the top-left of the viewport. | |
| Theme/spacing: light theme with compact spacing; small component scale. | |
| Table: a compact release plan table with three rows: “v1.0”, “v2.0”, “v3.0”. | |
| Component instances: each row contains an inline editable MUI X DateField in the “Release date” column (MM/DD/YYYY). | |
| Initial state: | |
| - v1.0: 09/01/2026 | |
| - v2.0: empty | |
| - v3.0: 12/15/2026 | |
| Clutter (high): additional columns (“Owner”, “Risk”) include chips and icons; not required. | |
| Feedback: after a valid date is entered in the v2.0 row, the cell shows the formatted date and briefly displays a small “Edited” indicator on that row. | |
| scene_context: | |
| theme: light | |
| spacing: compact | |
| layout: table_cell | |
| placement: top_left | |
| scale: small | |
| instances: 3 | |
| guidance: text | |
| clutter: high | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 4 | |
| density_choice_interference: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 4 | |
| justification: Dense table layout with multiple small, similar date fields creates high disambiguation load and target acquisition difficulty. | |
| success_trigger: | |
| human_readable: | |
| - In the “v2.0” row, the “Release date” field value equals 2026-11-01. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-11-01' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Release date (v2.0) | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| table_row_key: v2.0 | |
| table_column_key: release_date | |
| negative_cases: | |
| - Editing v1.0 or v3.0 instead of v2.0. | |
| - Entering 01/11/2026 (day/month swapped) or any other incorrect date. | |
| - Leaving the v2.0 cell empty or invalid. | |
| expected_interaction_path: Locate v2.0 row → focus Release date cell → type 11/01/2026 → commit. | |
| notes: 'Instrumentation: stable row keys; data-testid=''release-date-v2''. Checker should match by row key, not visual order.' | |
| - id: date_input_text-mui-T10 | |
| name: MUI fix a validation error and set an in-range date | |
| canonical_type: date_input_text | |
| implementation_source: mui | |
| implementation_variant: DatePicker | |
| implementation_component: 'MUI X: DatePicker (keyboard input) with min/max validation' | |
| task_template: set_scalar | |
| secondary_template: null | |
| browsergym_goal: Set the “Compliance date” field to 07/01/2026 (MM/DD/YYYY). The task will finish automatically when done. | |
| ui_copy: 'Compliance: Compliance date must be 07/01/2026.' | |
| setup_description: |- | |
| Layout: form_section anchored near the bottom-left of the viewport. | |
| Component: a single MUI X DatePicker input labeled “Compliance date” (manual typing supported). | |
| Validation configuration: the field enforces an allowed range (minDate=01/01/2026, maxDate=12/31/2026) and shows an error helper text when out of range. | |
| Initial state: the field is pre-filled with 01/01/2027 and is currently in an error state (red underline + helper text “Date must be within 2026”). | |
| Clutter (medium): there are two non-required controls nearby: a checkbox “Send reminder email” and a disabled text field “Compliance owner”. | |
| Feedback: when a valid in-range date is entered, the error state disappears and the helper text changes to “Looks good”. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: form_section | |
| placement: bottom_left | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 2 | |
| feedback_dynamics: 4 | |
| semantic_observability: 2 | |
| disambiguation_load: 2 | |
| justification: The field starts in an error state with range validation, requiring the agent to correct the value and observe error feedback clearing. | |
| success_trigger: | |
| human_readable: | |
| - The “Compliance date” value equals 2026-07-01. | |
| - The field is not in an error/invalid state after commit. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-07-01' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Compliance date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| require_valid: true | |
| negative_cases: | |
| - Entering a date outside 2026 (error remains). | |
| - Entering 01/07/2026 (month/day swapped). | |
| - Leaving the invalid initial value (01/01/2027). | |
| - Typing without committing so the component value does not update. | |
| expected_interaction_path: Focus Compliance date → replace with 07/01/2026 → commit → verify error cleared. | |
| notes: 'Instrumentation: data-testid=''compliance-date''. Checker should verify both value equality and validity flag (no error).' | |
| - id: date_input_text-mantine-T01 | |
| name: Mantine DateInput basic typed ISO date | |
| canonical_type: date_input_text | |
| implementation_source: mantine | |
| implementation_variant: null | |
| implementation_component: 'Mantine: DateInput' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: In the Date input card, set the “Invoice date” field to 2026-02-14 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Goal: Invoice date = 2026-02-14.' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: one Mantine DateInput labeled “Invoice date”. | |
| Configuration: the input displays/accepts YYYY-MM-DD (valueFormat set accordingly) and shows placeholder “YYYY-MM-DD”. | |
| Initial state: empty; dropdown calendar is closed. | |
| Sub-controls: a calendar icon is shown inside the input; a clear button appears only when a value exists (if clearable is enabled, but not needed here). | |
| Distractors: none. | |
| Feedback: after committing a valid date, the input displays the formatted value and keeps it as the canonical date state. | |
| 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: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Single Mantine DateInput with explicit placeholder and immediate visible value after typing. | |
| success_trigger: | |
| human_readable: | |
| - The DateInput value (canonical date) equals 2026-02-14. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-02-14' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Entering 2026-02-41 or another invalid date string (should not parse). | |
| - Entering any other date. | |
| - Leaving the field empty. | |
| expected_interaction_path: Click input → type 2026-02-14 → blur/Enter to commit. | |
| notes: 'Instrumentation: data-testid=''invoice-date''. Checker reads Date value and normalizes to ISO.' | |
| - id: date_input_text-mantine-T02 | |
| name: Mantine overwrite an existing date value | |
| canonical_type: date_input_text | |
| implementation_source: mantine | |
| implementation_variant: null | |
| implementation_component: 'Mantine: DateInput' | |
| task_template: set_scalar | |
| secondary_template: null | |
| browsergym_goal: Change the “Renewal date” field to 2026-03-31 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Goal: Renewal date should be 2026-03-31.' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: one Mantine DateInput labeled “Renewal date” with valueFormat YYYY-MM-DD. | |
| Initial state: pre-filled with 2026-03-01. | |
| Sub-controls: calendar icon is present but optional; editing can be done via typing. | |
| Distractors: none. | |
| Feedback: once a valid date is committed, the input displays the new value and any internal error state remains clear. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Requires replacing an existing value but remains a single isolated date input with clear feedback. | |
| success_trigger: | |
| human_readable: | |
| - The “Renewal date” DateInput value equals 2026-03-31. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-03-31' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Renewal date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Leaving the original date (2026-03-01). | |
| - Entering 2026-03-13 or any other incorrect date. | |
| - Typing without committing so the value doesn't update. | |
| expected_interaction_path: Focus Renewal date → select/overwrite → type 2026-03-31 → commit. | |
| notes: 'Instrumentation: data-testid=''renewal-date''.' | |
| - id: date_input_text-mantine-T03 | |
| name: Mantine clear a date with clearable button | |
| canonical_type: date_input_text | |
| implementation_source: mantine | |
| implementation_variant: null | |
| implementation_component: 'Mantine: DateInput (clearable)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the “Reminder date” field so it becomes empty. The task will finish automatically when done. | |
| ui_copy: 'Goal: Reminder date should be cleared (empty).' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: one Mantine DateInput labeled “Reminder date” with clearable enabled (clear button appears in the right section when a value exists). | |
| Initial state: pre-filled with 2026-04-10. | |
| Sub-controls: calendar icon + clear (✕) button within the input’s right section. | |
| Distractors: none. | |
| Feedback: clearing removes the value and restores the placeholder “YYYY-MM-DD”. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 1 | |
| target_acquisition: 3 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Clearing relies on a small right-section control, but the rest of the scene is minimal and the cleared state is obvious. | |
| success_trigger: | |
| human_readable: | |
| - The “Reminder date” DateInput value is empty/null (no date selected). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: null | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Reminder date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| empty_ok: true | |
| negative_cases: | |
| - Any date remains set (including 2026-04-10). | |
| - Selecting text without clearing the underlying value. | |
| - Leaving an invalid partial string that does not clear to null. | |
| expected_interaction_path: Focus Reminder date → click the clear (✕) button (or delete all text) → commit/blur. | |
| notes: 'Instrumentation: data-testid=''reminder-date'' and data-testid=''reminder-date-clear'' for the clear button.' | |
| - id: date_input_text-mantine-T04 | |
| name: Mantine two DateInputs in a form section | |
| canonical_type: date_input_text | |
| implementation_source: mantine | |
| implementation_variant: null | |
| implementation_component: 'Mantine: DateInput x2' | |
| task_template: set_scalar | |
| secondary_template: null | |
| browsergym_goal: In the Booking form, set the “End date” field to 2026-05-20 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Booking form: End date = 2026-05-20.' | |
| setup_description: |- | |
| Layout: form_section centered in the viewport with header “Booking”. | |
| Components: two Mantine DateInput fields side-by-side: | |
| - “Start date” (pre-filled with 2026-05-10) | |
| - “End date” (empty) | |
| Both use valueFormat YYYY-MM-DD and allow free-form typing; calendar dropdown is available but optional. | |
| Distractors (clutter=low): a “Guests” number input and a “Room type” select are shown but not required. | |
| Feedback: after committing a valid date, the End date input shows the new value. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: form_section | |
| placement: center | |
| scale: default | |
| instances: 2 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: Requires choosing the correct date field among two similar instances within a realistic form layout. | |
| success_trigger: | |
| human_readable: | |
| - The “End date” DateInput value equals 2026-05-20. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-05-20' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: End date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Setting “Start date” instead of “End date”. | |
| - Entering 2026-05-02 or any other incorrect date. | |
| - Leaving End date empty/invalid. | |
| expected_interaction_path: Focus End date → type 2026-05-20 → blur/Enter. | |
| notes: 'Instrumentation: data-testid=''start-date'' and ''end-date''.' | |
| - id: date_input_text-mantine-T05 | |
| name: Mantine match a date from a packing slip preview | |
| canonical_type: date_input_text | |
| implementation_source: mantine | |
| implementation_variant: null | |
| implementation_component: 'Mantine: DateInput' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the “Delivery date” field to match the date shown on the “Packing slip preview”. The task will finish automatically when done. | |
| ui_copy: 'Goal: Delivery date must match the Packing slip preview.' | |
| setup_description: |- | |
| Layout: dashboard scene centered in the viewport. | |
| Left pane: Mantine DateInput labeled “Delivery date” (valueFormat YYYY-MM-DD). | |
| Right pane: “Packing slip preview” card with a large printed date line in a stylized header: | |
| “JUN 10 2026” | |
| Initial state: Delivery date input is empty. | |
| Clutter (low): the preview also shows a fake order number and address lines (non-interactive). | |
| Feedback: once a valid date is entered, the Delivery date field displays it; the preview updates a small “Delivery date” line (cosmetic). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: visual | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 3 | |
| disambiguation_load: 2 | |
| justification: The date must be extracted from an on-screen preview rather than being provided directly in text instructions. | |
| success_trigger: | |
| human_readable: | |
| - The “Delivery date” DateInput value equals the reference date 2026-06-10. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| date_iso: '2026-06-10' | |
| reference_id: packing-slip-preview | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Delivery date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| negative_cases: | |
| - Entering a different date than shown on the preview. | |
| - Leaving the input empty or invalid. | |
| - Typing the date into a non-target field (if any). | |
| expected_interaction_path: Read date from Packing slip preview → type equivalent YYYY-MM-DD into Delivery date → commit. | |
| notes: 'Instrumentation: data-testid=''delivery-date'' and data-testid=''packing-slip-preview''.' | |
| - id: date_input_text-mantine-T06 | |
| name: Mantine scroll to locate a DateInput in settings panel | |
| canonical_type: date_input_text | |
| implementation_source: mantine | |
| implementation_variant: null | |
| implementation_component: 'Mantine: DateInput in a scrollable Settings panel' | |
| task_template: scroll_find | |
| secondary_template: null | |
| browsergym_goal: In Settings, scroll to the “Maintenance date” field and set it to 2026-07-15 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Settings: Maintenance date = 2026-07-15.' | |
| setup_description: |- | |
| Layout: settings_panel with a scrollable main content area. | |
| Target component: a Mantine DateInput labeled “Maintenance date” in the “System maintenance” section located near the bottom of the settings content (initially below the fold). | |
| Configuration: valueFormat YYYY-MM-DD; free-form typing enabled. | |
| Initial state: empty. | |
| Clutter (medium): several switches, sliders, and informational callouts appear above; they are distractors. | |
| Feedback: after entering a valid date, the input shows the formatted date and a small helper text appears (“Next maintenance scheduled”). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: settings_panel | |
| placement: bottom_right | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 2 | |
| justification: The agent must scroll within a settings panel to find the correct labeled DateInput amid moderate clutter before entering the target date. | |
| success_trigger: | |
| human_readable: | |
| - The “Maintenance date” DateInput value equals 2026-07-15. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-07-15' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Maintenance date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| scroll_required: true | |
| negative_cases: | |
| - Entering the date in a different field in Settings. | |
| - Entering any date other than 2026-07-15. | |
| - Leaving the Maintenance date field empty because it was not found. | |
| expected_interaction_path: Scroll to System maintenance section → focus Maintenance date → type 2026-07-15 → commit. | |
| notes: 'Instrumentation: data-testid=''maintenance-date''. Provide stable section anchors for automated scrolling.' | |
| - id: date_input_text-mantine-T07 | |
| name: Mantine DateInput with min/max and weekdays-only validation | |
| canonical_type: date_input_text | |
| implementation_source: mantine | |
| implementation_variant: null | |
| implementation_component: 'Mantine: DateInput with minDate/maxDate + exclude weekends' | |
| task_template: set_scalar | |
| secondary_template: null | |
| browsergym_goal: Set the “Payroll date” field to 2026-02-25 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Goal: Payroll date = 2026-02-25.' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport. | |
| Component: one Mantine DateInput labeled “Payroll date” (valueFormat YYYY-MM-DD). | |
| Validation configuration: | |
| - minDate = 2026-02-01 | |
| - maxDate = 2026-02-28 | |
| - weekends are disabled (only weekdays are allowed) | |
| A helper hint under the input reads: “Weekdays only. Allowed range: 2026-02-01 to 2026-02-28.” | |
| Initial state: pre-filled with 2026-02-10 (a valid weekday). | |
| Behavior: if the user types a date outside the allowed range or on a weekend, the input is considered invalid and reverts to the last known valid date when blurred/committed (Mantine DateInput validation behavior). | |
| Distractors: none. | |
| Feedback: invalid entry shows a brief inline error message (“Invalid date”) before reverting; valid entry clears the error and keeps the new value. | |
| scene_context: | |
| theme: light | |
| spacing: compact | |
| 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: 3 | |
| disambiguation_load: 1 | |
| justification: Strict validity constraints with automatic revert on invalid input increase feedback dynamics and require careful formatted entry. | |
| success_trigger: | |
| human_readable: | |
| - The “Payroll date” DateInput value equals 2026-02-25. | |
| - The value is valid under the configured constraints (within range and not a weekend). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-02-25' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Payroll date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| require_valid: true | |
| constraints: | |
| min: '2026-02-01' | |
| max: '2026-02-28' | |
| weekdays_only: true | |
| negative_cases: | |
| - Entering a weekend date (e.g., 2026-02-28) so the input reverts. | |
| - Entering a date outside the allowed range so the input reverts. | |
| - Leaving the original date (2026-02-10). | |
| - Typing without committing (checker still reads old value). | |
| expected_interaction_path: Focus Payroll date → replace with 2026-02-25 → blur/Enter to commit → ensure it stays (no revert). | |
| notes: 'Instrumentation: data-testid=''payroll-date''. Checker should verify component value and that error state is false.' | |
| - id: date_input_text-mantine-T08 | |
| name: Mantine edit a date input inside a dense table | |
| canonical_type: date_input_text | |
| implementation_source: mantine | |
| implementation_variant: null | |
| implementation_component: 'Mantine: DateInput in table cells (multiple instances)' | |
| task_template: table_operation | |
| secondary_template: null | |
| browsergym_goal: In the Maintenance table, set the “Maintenance date” for the “Server B” row to 2026-09-01 (YYYY-MM-DD). The task will finish automatically when done. | |
| ui_copy: 'Maintenance table: Server B → Maintenance date = 2026-09-01.' | |
| setup_description: |- | |
| Layout: table_cell scene anchored at the bottom-right of the viewport. | |
| Theme/spacing: light theme with compact spacing; small component scale. | |
| Table: three rows labeled “Server A”, “Server B”, “Server C”. | |
| Component instances: each row has an inline Mantine DateInput in the “Maintenance date” column (valueFormat YYYY-MM-DD). | |
| Initial state: | |
| - Server A: 2026-08-15 | |
| - Server B: empty | |
| - Server C: 2026-10-20 | |
| Clutter (high): additional columns show status pills and action icons; these do not affect success. | |
| Feedback: the edited cell updates after the input is committed and briefly shows a subtle background highlight. | |
| scene_context: | |
| theme: light | |
| spacing: compact | |
| layout: table_cell | |
| placement: bottom_right | |
| scale: small | |
| instances: 3 | |
| guidance: text | |
| clutter: high | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 4 | |
| density_choice_interference: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 4 | |
| justification: Small inputs embedded in a compact table increase pointing precision needs and disambiguation across multiple similar instances. | |
| success_trigger: | |
| human_readable: | |
| - In the “Server B” row, the “Maintenance date” DateInput value equals 2026-09-01. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-09-01' | |
| tolerance: | |
| days: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Maintenance date (Server B) | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| table_row_key: Server B | |
| table_column_key: maintenance_date | |
| negative_cases: | |
| - Editing Server A or Server C instead of Server B. | |
| - Entering 2026-01-09 or any other incorrect date. | |
| - Leaving Server B empty or invalid. | |
| expected_interaction_path: Find Server B row → focus its Maintenance date input → type 2026-09-01 → commit. | |
| notes: 'Instrumentation: stable row keys; data-testid=''maintenance-date-server-b''.' | |
| - id: date_input_text-mantine-T09 | |
| name: Mantine match reference date among three inputs and apply | |
| canonical_type: date_input_text | |
| implementation_source: mantine | |
| implementation_variant: null | |
| implementation_component: 'Mantine: DateInput x3 + Apply action bar' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the “Secondary window” date to match the date shown on the “Reference banner”, then click “Apply schedule”. The task will finish automatically when done. | |
| ui_copy: 'Schedule dashboard: Secondary window must match Reference banner → Apply schedule.' | |
| setup_description: |- | |
| Layout: dashboard scene anchored at the top-right of the viewport. | |
| Theme: dark. | |
| Components: three Mantine DateInput fields in a panel titled “Maintenance windows”: | |
| - “Primary window” (pre-filled with 2026-10-01) | |
| - “Secondary window” (empty) | |
| - “Fallback window” (pre-filled with 2026-10-15) | |
| Visual reference: a prominent “Reference banner” above the panel shows the target date in large type: | |
| “OCT 05 2026” | |
| Clutter (medium): the dashboard includes a small status chart placeholder and two filter chips; not required. | |
| Confirmation: a sticky action bar at the bottom of the panel has “Reset” and a primary button “Apply schedule”. Changes are only persisted after “Apply schedule”. | |
| Feedback: after Apply, a toast “Schedule applied” appears and the sticky bar collapses. | |
| scene_context: | |
| theme: dark | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: top_right | |
| scale: default | |
| instances: 3 | |
| guidance: visual | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 3 | |
| semantic_observability: 3 | |
| disambiguation_load: 4 | |
| justification: Dark theme plus three similar inputs requires careful disambiguation, extracting the date from a reference banner, and committing via Apply. | |
| success_trigger: | |
| human_readable: | |
| - The “Secondary window” DateInput value equals the reference date 2026-10-05. | |
| - The user clicked “Apply schedule” and the value is persisted. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| date_iso: '2026-10-05' | |
| reference_id: reference-banner | |
| tolerance: | |
| days: 0 | |
| require_confirm: true | |
| confirm_control: Apply schedule | |
| require_correct_instance: true | |
| target_instance_label_or_id: Secondary window | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| persisted_state_id: maintenance.secondary_window | |
| negative_cases: | |
| - Setting Primary or Fallback window instead of Secondary window. | |
| - Entering the correct date but not clicking Apply schedule. | |
| - Clicking Reset (should not count). | |
| - Entering any date other than the reference date. | |
| expected_interaction_path: Read date on Reference banner → edit Secondary window input → commit → click Apply schedule. | |
| notes: 'Instrumentation: data-testid=''primary-window'', ''secondary-window'', ''fallback-window'', ''apply-schedule'', ''reference-banner''. Checker verifies persisted state updated after Apply.' | |
| - id: date_input_text-mantine-T10 | |
| name: Mantine DateInput inside a drawer with Save/Cancel | |
| canonical_type: date_input_text | |
| implementation_source: mantine | |
| implementation_variant: null | |
| implementation_component: 'Mantine: Drawer + DateInput' | |
| task_template: confirm_cancel | |
| secondary_template: null | |
| browsergym_goal: Open the “Edit subscription” drawer, set “Next billing date” to 2026-11-15 (YYYY-MM-DD), then click “Save changes”. The task will finish automatically when done. | |
| ui_copy: Edit subscription → Next billing date = 2026-11-15 → Save changes. | |
| setup_description: |- | |
| Layout: drawer_flow. The base page shows a subscription summary and a button “Edit subscription”. | |
| Clicking it opens a right-side Drawer that slides in from the edge. | |
| Inside the drawer is a small form with: | |
| - “Plan” select (disabled; not required) | |
| - “Next billing date” (Mantine DateInput, valueFormat YYYY-MM-DD, manual typing enabled) | |
| Initial state: drawer is closed; when opened, Next billing date is empty. | |
| Drawer footer: “Cancel” and primary “Save changes”. | |
| Clutter (low): a short paragraph explaining billing (non-interactive). | |
| Feedback: after clicking “Save changes”, the drawer closes and the summary updates the displayed next billing date. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: drawer_flow | |
| placement: top_right | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 3 | |
| feedback_dynamics: 3 | |
| semantic_observability: 2 | |
| disambiguation_load: 2 | |
| justification: Requires handling a drawer overlay and explicitly saving; the date input is straightforward once located. | |
| success_trigger: | |
| human_readable: | |
| - The “Next billing date” value equals 2026-11-15. | |
| - The user clicked “Save changes” and the saved value is persisted to the summary. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| date_iso: '2026-11-15' | |
| tolerance: | |
| days: 0 | |
| require_confirm: true | |
| confirm_control: Save changes | |
| require_correct_instance: true | |
| target_instance_label_or_id: Next billing date | |
| terminal_condition: task_ends_when_predicate_holds | |
| canonical_type: date_input_text | |
| persisted_state_id: subscription.next_billing_date | |
| negative_cases: | |
| - Entering the correct date but clicking Cancel or closing the drawer without saving. | |
| - Saving a different date. | |
| - Leaving the field empty/invalid. | |
| expected_interaction_path: Click Edit subscription → in drawer, focus Next billing date → type 2026-11-15 → commit → click Save changes. | |
| notes: 'Instrumentation: data-testid=''edit-subscription'', drawer data-testid=''subscription-drawer'', input data-testid=''next-billing-date'', save button data-testid=''save-changes''.' | |