Initial ComponentBench data release: tasks v1+v2, cleaned human traces, difficulty audit, ontology metadata
360df42 verified | - id: datetime_picker_range-antd-T01 | |
| name: 'Support window: set same-day morning range' | |
| canonical_type: datetime_picker_range | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker.RangePicker (showTime, 24h, HH:mm)' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Support window” date-time range to 2026-02-14 09:30 through 2026-02-14 11:00, then click OK to | |
| apply. The task will finish automatically when done. | |
| ui_copy: |- | |
| Support window | |
| Please choose a start and end date/time. | |
| Target format: YYYY-MM-DD HH:mm | |
| Target chip: “2026-02-14 09:30 – 2026-02-14 11:00” | |
| [ Start – End ] (RangePicker with time) | |
| OK / Cancel buttons appear in the picker panel. | |
| setup_description: 'Layout: isolated_card centered in the viewport with a single labeled field “Support window”. Theme is | |
| light with comfortable spacing and default component scale. The component is an Ant Design DatePicker.RangePicker configured | |
| with showTime enabled (24-hour, hour+minute). A small ‘Target’ chip on the card repeats the requested range as a visual | |
| reference (mixed guidance). Clicking either input opens a popover panel showing a calendar and a time selector; the panel | |
| includes “OK” and “Cancel” actions. Initial state: empty (no start/end selected). There are no other interactive elements | |
| on the card.' | |
| 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: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Single, clearly labeled RangePicker with time; target is fully specified and the chosen range is within | |
| the currently visible month. Requires a straightforward OK confirmation. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-02-14T09:30:00 (local time). | |
| - Target range end equals 2026-02-14T11:00:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-02-14T09:30:00' | |
| end: '2026-02-14T11:00:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Only the start is set (end still empty) when the checker evaluates. | |
| - Start or end date/time does not exactly match the target values. | |
| - Correct start/end are selected in the panel but OK is not clicked (value not committed). | |
| - Range is applied to a different component (not applicable here because instances=1). | |
| expected_interaction_path: Click the Support window input → pick start date → pick start time → pick end date → pick end | |
| time → click OK. | |
| notes: 'Instrumentation: wrap the RangePicker with data-cb-instance=''Support window''. Checker should read the committed | |
| value (after OK) from the RangePicker value prop and normalize to local ISO timestamps.' | |
| - id: datetime_picker_range-antd-T02 | |
| name: 'Pickup window: set afternoon range (small control, corner placement)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker.RangePicker (showTime, minuteStep=30)' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Pickup window” date-time range to 2026-03-03 13:00 through 2026-03-03 17:30, then click OK to | |
| apply. The task will finish automatically when done. | |
| ui_copy: |- | |
| Pickup window (small) | |
| Choose a date/time range. | |
| Format: YYYY-MM-DD HH:mm | |
| [ Start – End ] | |
| OK / Cancel | |
| setup_description: 'Layout: isolated_card anchored near the top-left of the viewport. Theme is light with comfortable spacing, | |
| but the RangePicker is rendered in the library’s small size variant. The Ant Design RangePicker has showTime enabled and | |
| the time list uses 30-minute steps (e.g., 13:00, 13:30, 14:00, …). Clicking the field opens a popover with a calendar | |
| and time selector, plus OK/Cancel actions. Initial state: empty. No distractors are present.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: top_left | |
| scale: small | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Target is explicit and time choices are on coarse 30-minute steps; the main added challenge is smaller | |
| hit targets due to small scale and corner placement. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-03-03T13:00:00 (local time). | |
| - Target range end equals 2026-03-03T17:30:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-03-03T13:00:00' | |
| end: '2026-03-03T17:30:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Start or end differs from the requested time (e.g., 17:00 instead of 17:30). | |
| - Only a date is selected but time remains at a default that does not match the target. | |
| - OK is not clicked after selecting the range. | |
| - Overlay is left open with an uncommitted draft selection. | |
| expected_interaction_path: Click Pickup window → select 2026-03-03 as start → pick 13:00 → select end on same day → pick | |
| 17:30 → click OK. | |
| notes: 'Checker: enforce exact minute-level match. Confirm required via OK.' | |
| - id: datetime_picker_range-antd-T03 | |
| name: 'Outage window: clear the prefilled range' | |
| canonical_type: datetime_picker_range | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker.RangePicker (showTime, allowClear)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the “Outage window” date-time range so it becomes empty (no start and no end). The task will finish | |
| automatically when done. | |
| ui_copy: |- | |
| Outage window | |
| Current value: 2026-02-05 01:00 – 2026-02-05 03:00 | |
| (There is an × clear icon when you hover/focus the field.) | |
| setup_description: 'Layout: isolated_card centered in the viewport with a single RangePicker labeled “Outage window”. Theme | |
| is light, spacing comfortable, scale default. The RangePicker has showTime enabled but is configured to commit changes | |
| immediately when cleared (no confirmation required for clearing). Initial state: pre-filled with start=2026-02-05 01:00 | |
| and end=2026-02-05 03:00. A clear (×) control appears in the input when hovered/focused. No other UI elements 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: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 5 | |
| disambiguation_load: 1 | |
| justification: Single prefilled field with a standard clear affordance; success is simply the empty state with immediate | |
| visual feedback. | |
| success_trigger: | |
| human_readable: | |
| - Start value is empty (null). | |
| - End value is empty (null). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: null | |
| end: null | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Only one side of the range is cleared (start cleared but end still present, or vice versa). | |
| - Text is deleted in the input but the underlying value is still non-null (stale value). | |
| - A partial draft selection remains (e.g., start selected but end missing). | |
| expected_interaction_path: Focus/hover the Outage window field → click the × clear icon (or use the built-in clear action) | |
| → verify the field is empty. | |
| notes: Checker reads RangePicker value; must be null/empty for both start and end. | |
| - id: datetime_picker_range-antd-T04 | |
| name: 'Report window: open the date-time range popover' | |
| canonical_type: datetime_picker_range | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker.RangePicker (showTime)' | |
| task_template: open_overlay | |
| secondary_template: null | |
| browsergym_goal: Open the “Report window” date-time range picker so the calendar/time popover is visible. Do not change | |
| any values. The task will finish automatically when done. | |
| ui_copy: |- | |
| Report window | |
| [ Start – End ] (empty) | |
| Clicking the field opens a popover calendar with time selection. | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing, default scale. A single AntD RangePicker | |
| labeled “Report window” starts empty. The picker uses a popover overlay that contains a calendar view and a time selection | |
| panel. No other controls exist on the page; the intent is to test reliably opening the overlay without modifying 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: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: Requires only locating the correct field and opening its popover; no value setting or confirmation is involved. | |
| success_trigger: | |
| human_readable: | |
| - The date-time range picker overlay is open (calendar/time UI visible). | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| overlay_open: true | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Popover does not open (overlay remains closed). | |
| - A date/time is accidentally selected and the component value changes. | |
| - Wrong overlay is opened (not applicable here because instances=1). | |
| expected_interaction_path: Click the Report window input (or its picker icon) → ensure the popover panel is open. | |
| notes: Checker should detect overlay open state via DOM (e.g., popup element present and anchored to this RangePicker). | |
| - id: datetime_picker_range-antd-T05 | |
| name: 'Backup window: set range in a form with two pickers' | |
| canonical_type: datetime_picker_range | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker.RangePicker (showTime) ×2 instances' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: In the form, set the “Backup window” date-time range to 2026-02-20 14:00 through 2026-02-20 15:15, then | |
| click OK to apply. The task will finish automatically when done. | |
| ui_copy: |- | |
| Schedule settings | |
| Primary window: 2026-02-18 09:00 – 2026-02-18 10:00 | |
| Backup window: [ Start – End ] | |
| (Other fields: Job name, Notify on failure toggle) | |
| setup_description: 'Layout: form_section centered with a short ‘Schedule settings’ form. Light theme, comfortable spacing, | |
| default scale. Two AntD RangePickers with showTime are present and visually similar: “Primary window” (pre-filled) and | |
| “Backup window” (empty). Each RangePicker opens a popover calendar+time panel and requires clicking “OK” to commit the | |
| selection. Clutter: low—there is a text input labeled “Job name” and a toggle “Notify on failure”, but they do not affect | |
| success.' | |
| 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: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 3 | |
| justification: Two visually similar RangePickers require selecting the correct labeled instance in a small form; otherwise | |
| the range itself is straightforward and same-day. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-02-20T14:00:00 (local time). | |
| - Target range end equals 2026-02-20T15:15:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-02-20T14:00:00' | |
| end: '2026-02-20T15:15:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: true | |
| target_instance_label_or_id: Backup window | |
| terminal_condition: true | |
| negative_cases: | |
| - The Primary window is changed instead of the Backup window. | |
| - Backup window start/end do not exactly match the target. | |
| - Dates/times are selected but OK is not clicked to commit. | |
| - Only start is set (end missing) when the checker evaluates. | |
| expected_interaction_path: Locate Backup window field → open its popover → choose start date/time → choose end date/time | |
| → click OK. | |
| notes: 'Instrumentation: assign data-cb-instance labels ''Primary window'' and ''Backup window'' to disambiguate in checker.' | |
| - id: datetime_picker_range-antd-T06 | |
| name: 'Edit by typing: enter a formatted date-time range' | |
| canonical_type: datetime_picker_range | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker.RangePicker (showTime, format=YYYY-MM-DD HH:mm)' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Enter the “Editing window” range as 2026-04-10 08:15 through 2026-04-10 09:45 by typing into the inputs, | |
| then click OK to apply. The task will finish automatically when done. | |
| ui_copy: |- | |
| Editing window | |
| Format hint: YYYY-MM-DD HH:mm | |
| [ Start – End ] (empty) | |
| (You can type directly into the fields.) | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing, default scale. A single AntD RangePicker | |
| labeled “Editing window” is configured with showTime and an explicit display/parse format of ''YYYY-MM-DD HH:mm''. The | |
| inputs accept keyboard entry for both start and end. When the panel is open, an “OK” button must be clicked to commit | |
| the typed values. Initial state: empty. No distractors.' | |
| 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: 2 | |
| feedback_dynamics: 3 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Requires correct formatted typing for both endpoints and confirming with OK; small formatting errors or | |
| partial entry are common failure modes. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-04-10T08:15:00 (local time). | |
| - Target range end equals 2026-04-10T09:45:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-04-10T08:15:00' | |
| end: '2026-04-10T09:45:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Wrong format entered (e.g., missing leading zeros) and the value is rejected or parsed differently. | |
| - Only one side is typed/committed (start set but end missing). | |
| - Values are typed but not committed via OK (draft remains). | |
| - Start/end swapped. | |
| expected_interaction_path: Click start input → type '2026-04-10 08:15' → move to end input → type '2026-04-10 09:45' → click | |
| OK. | |
| notes: Checker should read parsed Dayjs values, not raw input text; reject partial/draft values if OK not pressed. | |
| - id: datetime_picker_range-antd-T07 | |
| name: 'Service window: match the reference range card' | |
| canonical_type: datetime_picker_range | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker.RangePicker (showTime) + reference display' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the “Service window” date-time range to match the range shown in the “Reference” card on the page, | |
| then click OK to apply. The task will finish automatically when done. | |
| ui_copy: |- | |
| Reference | |
| Target range (shown on the card): 2026-06-01 10:00 – 2026-06-01 12:30 | |
| Service window | |
| [ Start – End ] | |
| OK / Cancel | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing, default scale. The card contains a | |
| small ‘Reference’ panel above the picker that displays the target start/end as plain text. Below it is a single AntD RangePicker | |
| labeled “Service window” with showTime enabled; it opens a popover calendar and time selector and requires OK to commit. | |
| Initial state: empty. No other distractors.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: visual | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Goal is specified via an on-page reference (visual read) rather than directly in the instruction, but the | |
| picker interaction remains standard with an OK commit. | |
| success_trigger: | |
| human_readable: | |
| - Selected range matches the range displayed in the reference element labeled 'Reference'. | |
| - Reference resolves to start=2026-06-01T10:00:00, end=2026-06-01T12:30:00 (local time). | |
| - If confirmation is required, the selection must be confirmed using the specified confirm control. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| reference_label: Reference | |
| start: '2026-06-01T10:00:00' | |
| end: '2026-06-01T12:30:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Service window does not match the reference exactly. | |
| - A different day/time is selected due to misreading the reference. | |
| - Correct values selected but OK not clicked to apply. | |
| expected_interaction_path: Read the Reference card → open Service window picker → select matching start/end date+time → | |
| click OK. | |
| notes: Checker can either resolve reference text to canonical datetimes or use pre-known target values (recommended for | |
| determinism). | |
| - id: datetime_picker_range-antd-T08 | |
| name: 'Cutover window: set cross-midnight range with seconds (dark theme)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker.RangePicker (showTime with seconds, format=YYYY-MM-DD HH:mm:ss)' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Cutover window” date-time range to 2026-11-07 23:30:15 through 2026-11-08 01:15:45, then click | |
| OK to apply. The task will finish automatically when done. | |
| ui_copy: |- | |
| Cutover window (dark mode) | |
| Format: YYYY-MM-DD HH:mm:ss | |
| [ Start – End ] | |
| OK / Cancel | |
| setup_description: 'Layout: isolated_card centered in the viewport, rendered in a dark theme. Spacing is comfortable and | |
| scale is default. A single AntD RangePicker labeled “Cutover window” has showTime enabled with seconds visible and an | |
| explicit format ''YYYY-MM-DD HH:mm:ss''. The popover includes calendar selection and time columns for hours, minutes, | |
| and seconds; an “OK” button is required to confirm the final value. Initial state: empty. No other UI elements.' | |
| 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: 5 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 3 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Requires precise second-level time selection and a cross-midnight date boundary; dark theme can reduce | |
| contrast for small time-column targets. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-11-07T23:30:15 (local time). | |
| - Target range end equals 2026-11-08T01:15:45 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-11-07T23:30:15' | |
| end: '2026-11-08T01:15:45' | |
| timezone: local | |
| tolerance: | |
| unit: second | |
| value: 0 | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Seconds are left at a default (e.g., :00) instead of the specified values. | |
| - End date is set on the wrong day (e.g., still 2026-11-07). | |
| - Values are selected but OK is not clicked to commit. | |
| - Range is reversed (end earlier than start) or only partially selected. | |
| expected_interaction_path: Open Cutover window → pick start date 2026-11-07 → set time to 23:30:15 → pick end date 2026-11-08 | |
| → set time to 01:15:45 → click OK. | |
| notes: Checker tolerance is 0 seconds; read committed value after OK. Consider instrumenting time panel columns with stable | |
| testids for hour/minute/second. | |
| - id: datetime_picker_range-antd-T09 | |
| name: 'Billing window: set an open-ended range (end left empty)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker.RangePicker (showTime, allowEmpty end)' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Billing window” start to 2026-05-01 00:00 and leave the end of the range empty, then click OK | |
| to apply. The task will finish automatically when done. | |
| ui_copy: |- | |
| Billing window | |
| Start is required; End is optional (open interval) | |
| Format: YYYY-MM-DD HH:mm | |
| [ Start – End ] | |
| OK / Cancel | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing, default scale. A single AntD RangePicker | |
| labeled “Billing window” is configured to allow an open-ended range: the start is required but the end may be empty (allowEmpty=[false,true]). | |
| showTime is enabled (hour+minute). The popover has OK/Cancel; OK commits the current start/end (including a null end). | |
| Initial state: empty. No other interactive elements.' | |
| 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: 2 | |
| depth_layering: 3 | |
| feedback_dynamics: 4 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: 'Open-ended ranges are error-prone: the agent must set only the start, ensure the end remains truly empty, | |
| and still confirm with OK.' | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-05-01T00:00:00 (local time). | |
| - End value is empty (null). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-05-01T00:00:00' | |
| end: null | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - End date/time is set (non-empty) when it should be empty. | |
| - End is cleared visually but underlying value remains set. | |
| - Start is correct but OK not clicked to commit. | |
| - Only a date (without correct time) is set for start. | |
| expected_interaction_path: Open Billing window → select start date 2026-05-01 and time 00:00 → ensure end input is blank | |
| → click OK. | |
| notes: Checker must accept end=null and start set. Ensure adapter exposes allowEmpty configuration so leaving end empty | |
| is a valid committed state. | |
| - id: datetime_picker_range-antd-T10 | |
| name: 'Deployments table: scroll and set the Staging window (cross-year)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: DatePicker.RangePicker (showTime) in table rows (3 instances)' | |
| task_template: scroll_find | |
| secondary_template: null | |
| browsergym_goal: Scroll to the “Deployment windows” section and set the date-time range in the “Staging” row to 2026-12-28 | |
| 18:00 through 2027-01-02 09:00, then click OK to apply. The task will finish automatically when done. | |
| ui_copy: |- | |
| Settings | |
| (Several sections...) | |
| Deployment windows (table) | |
| Rows: Dev | Staging | Prod | |
| Each row has a date-time range field. | |
| Set the Staging row to: 2026-12-28 18:00 – 2027-01-02 09:00 | |
| setup_description: 'Layout: settings_panel with multiple collapsible sections and form controls (medium clutter). Light | |
| theme, comfortable spacing, default scale. The page initially shows the top of the settings panel; the “Deployment windows” | |
| section is further down and requires scrolling to reach. Inside “Deployment windows” is a compact table with three AntD | |
| RangePickers (showTime) in separate rows labeled “Dev”, “Staging”, and “Prod”. All three pickers look identical and each | |
| opens a popover that requires clicking OK to commit. Initial state: Dev and Prod rows are pre-filled with other ranges; | |
| Staging starts empty.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: settings_panel | |
| placement: center | |
| scale: default | |
| instances: 3 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 3 | |
| semantic_observability: 4 | |
| disambiguation_load: 5 | |
| justification: Requires scrolling to locate the correct table section and disambiguating among multiple identical RangePickers. | |
| The target range spans across months/years, increasing navigation steps before confirming with OK. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-12-28T18:00:00 (local time). | |
| - Target range end equals 2027-01-02T09:00:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-12-28T18:00:00' | |
| end: '2027-01-02T09:00:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: true | |
| target_instance_label_or_id: Deployment windows > Staging | |
| terminal_condition: true | |
| negative_cases: | |
| - The Dev or Prod row is modified instead of Staging. | |
| - Staging is set to a nearby but incorrect date (off by day/month/year). | |
| - Correct values chosen but OK not clicked to commit. | |
| - Only one endpoint is set (partial range). | |
| expected_interaction_path: Scroll down to Deployment windows → locate Staging row → open its RangePicker → navigate calendar | |
| to Dec 2026/Jan 2027 → set start 2026-12-28 18:00 → set end 2027-01-02 09:00 → click OK. | |
| notes: 'Instrumentation: each row wrapper should expose a stable identifier (e.g., data-cb-instance=''Deployment windows | |
| > Staging''). Checker should ignore changes to other rows and only evaluate the Staging instance.' | |
| - id: datetime_picker_range-mui-T01 | |
| name: 'Booking window: set same-day range (MUI DateTimeRangePicker)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mui | |
| implementation_variant: mui_x_pro | |
| implementation_component: 'MUI X Pro: DateTimeRangePicker (SingleInputDateTimeRangeField)' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Booking window” date-time range to 02/14/2026 09:30 AM – 02/14/2026 11:00 AM. The task will finish | |
| automatically when done. | |
| ui_copy: |- | |
| Booking window | |
| MM/DD/YYYY hh:mm aa – MM/DD/YYYY hh:mm aa | |
| [single input field with start–end] | |
| (Open picker icon on the right.) | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing, default scale. The target component | |
| is the MUI X Pro DateTimeRangePicker using the default single-input field (start–end displayed in one TextField). Activating | |
| the field opens a desktop popper with a date-range calendar and a digital clock view for time selection. This instance | |
| is configured to commit on selection completion (no separate OK button is shown on desktop). Initial state: empty. No | |
| distractors.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Single clearly labeled picker with default desktop behavior; same-day range avoids calendar navigation | |
| and the value is visible in the input field. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-02-14T09:30:00 (local time). | |
| - Target range end equals 2026-02-14T11:00:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-02-14T09:30:00' | |
| end: '2026-02-14T11:00:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - End time/date is not set (partial range). | |
| - Start/end do not exactly match the requested values. | |
| - A different picker instance is changed (not applicable here). | |
| - Range is selected but the field displays a different parsed value (e.g., wrong AM/PM). | |
| expected_interaction_path: Open Booking window picker → select start date/time → select end date/time → ensure the field | |
| shows the requested range. | |
| notes: Uses MUI X Pro DateTimeRangePicker. Checker should read the picker value (e.g., Day.js objects) and normalize to | |
| local ISO timestamps. | |
| - id: datetime_picker_range-mui-T02 | |
| name: 'Filters: clear a prefilled date-time range' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mui | |
| implementation_variant: mui_x_pro | |
| implementation_component: 'MUI X Pro: DateTimeRangePicker (single input, clear button enabled)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the “Created between” date-time range so the field is empty. The task will finish automatically when | |
| done. | |
| ui_copy: |- | |
| Created between | |
| 04/17/2026 03:30 PM – 04/21/2026 06:30 PM | |
| (An ✕ clear icon appears at the end of the field.) | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing, default scale. A single MUI X Pro | |
| DateTimeRangePicker labeled “Created between” is pre-filled with a range. The field is configured with a clear button | |
| (✕) inside the input (clearButton/clearIcon slot). Initial state: start=04/17/2026 03:30 PM, end=04/21/2026 06:30 PM. | |
| No other controls.' | |
| 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: 2 | |
| semantic_observability: 5 | |
| disambiguation_load: 1 | |
| justification: A single field with an explicit clear icon; success is the empty value with immediate feedback. | |
| success_trigger: | |
| human_readable: | |
| - Start value is empty (null). | |
| - End value is empty (null). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: null | |
| end: null | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Only one endpoint is cleared (start null but end still set, or vice versa). | |
| - Text is edited but the value remains non-null (controlled value not cleared). | |
| - Field shows an error state rather than a clean empty state. | |
| expected_interaction_path: Click the clear (✕) icon in the field (or use the picker clear action) → confirm the field becomes | |
| empty. | |
| notes: Checker reads picker value; must be [null, null]. | |
| - id: datetime_picker_range-mui-T03 | |
| name: 'Audit window: open the picker popper' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mui | |
| implementation_variant: mui_x_pro | |
| implementation_component: 'MUI X Pro: DateTimeRangePicker (desktop popper)' | |
| task_template: open_overlay | |
| secondary_template: null | |
| browsergym_goal: Open the “Audit window” date-time range picker so the popper with the calendar/time UI is visible. Do not | |
| set any dates. The task will finish automatically when done. | |
| ui_copy: |- | |
| Audit window | |
| MM/DD/YYYY hh:mm aa – MM/DD/YYYY hh:mm aa | |
| [empty] | |
| (Calendar icon button opens the popper.) | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing. A single DateTimeRangePicker labeled | |
| “Audit window” starts empty. The field has an opening icon button; activating it opens a popper that contains the date-range | |
| calendar and time selection views. No other interactive elements 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: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: Only requires opening the popper overlay; no selection or confirmation is needed. | |
| success_trigger: | |
| human_readable: | |
| - The date-time range picker overlay is open (calendar/time UI visible). | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| overlay_open: true | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Popper does not open (calendar/time UI not visible). | |
| - A value is accidentally selected and the field becomes non-empty. | |
| expected_interaction_path: Click the field or open-picker icon → verify the popper is displayed. | |
| notes: 'Checker: overlay_open can be detected by the presence of the picker popper anchored to this field.' | |
| - id: datetime_picker_range-mui-T04 | |
| name: 'Approval required: set range and press OK' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mui | |
| implementation_variant: mui_x_pro | |
| implementation_component: 'MUI X Pro: DateTimeRangePicker (action bar with Cancel/OK enabled)' | |
| task_template: confirm_cancel | |
| secondary_template: null | |
| browsergym_goal: Set the “Approval window” to 03/05/2026 01:15 PM – 03/05/2026 02:45 PM, then click OK in the picker to | |
| apply. The task will finish automatically when done. | |
| ui_copy: |- | |
| Approval window | |
| [empty] | |
| (When the picker is open, an action bar shows Cancel and OK.) | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing. A single MUI X Pro DateTimeRangePicker | |
| labeled “Approval window” starts empty. Unlike the default desktop behavior, this instance is configured to always show | |
| the action bar with “Cancel” and “OK” (accept) buttons. Selections made in the popper are considered draft until OK is | |
| clicked. No other UI elements are present.' | |
| 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: 2 | |
| depth_layering: 3 | |
| feedback_dynamics: 4 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: 'Adds a commit step: the agent must recognize that OK is required to apply the draft range; otherwise the | |
| interaction is standard.' | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-03-05T13:15:00 (local time). | |
| - Target range end equals 2026-03-05T14:45:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-03-05T13:15:00' | |
| end: '2026-03-05T14:45:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Correct draft selection is made but OK is not clicked (value not committed). | |
| - Cancel is clicked (value remains empty). | |
| - AM/PM mismatch (e.g., 01:15 AM instead of PM). | |
| - Only one endpoint selected. | |
| expected_interaction_path: Open Approval window → choose start date/time → choose end date/time → click OK in the action | |
| bar. | |
| notes: Checker should verify committed value only after OK/accept action is taken. | |
| - id: datetime_picker_range-mui-T05 | |
| name: 'Delivery window: match the on-page reference (corner placement)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mui | |
| implementation_variant: mui_x_pro | |
| implementation_component: 'MUI X Pro: DateTimeRangePicker + reference card' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the “Delivery window” to match the date-time range shown in the “Reference” card. The task will finish | |
| automatically when done. | |
| ui_copy: |- | |
| Reference | |
| 05/12/2026 10:00 AM – 05/12/2026 12:00 PM | |
| Delivery window | |
| [empty single input range field] | |
| setup_description: 'Layout: isolated_card anchored near the bottom-right of the viewport. Light theme, comfortable spacing, | |
| default scale. A small ‘Reference’ card above the picker displays the target range as formatted text. The DateTimeRangePicker | |
| labeled “Delivery window” uses the single-input field and commits on completion (no OK button). Initial state: empty. | |
| No other UI elements.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: bottom_right | |
| scale: default | |
| instances: 1 | |
| guidance: visual | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Target must be read from an on-page reference and the component is placed in a corner, slightly increasing | |
| acquisition difficulty. | |
| success_trigger: | |
| human_readable: | |
| - Selected range matches the range displayed in the reference element labeled 'Reference'. | |
| - Reference resolves to start=2026-05-12T10:00:00, end=2026-05-12T12:00:00 (local time). | |
| - If confirmation is required, the selection must be confirmed using the specified confirm control. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| reference_label: Reference | |
| start: '2026-05-12T10:00:00' | |
| end: '2026-05-12T12:00:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Delivery window does not match the reference exactly. | |
| - AM/PM is incorrect due to misreading. | |
| - Only start is set (end missing). | |
| expected_interaction_path: Read reference → open Delivery window picker → select the matching start/end date+time → ensure | |
| field displays the same range. | |
| notes: Reference values are fixed (not relative). Checker should normalize to local time. | |
| - id: datetime_picker_range-mui-T06 | |
| name: 'Shipping window: set range with two pickers in a form' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mui | |
| implementation_variant: mui_x_pro | |
| implementation_component: 'MUI X Pro: DateTimeRangePicker ×2 instances (single input fields)' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: In the checkout form, set the “Shipping window” to 06/01/2026 09:00 AM – 06/01/2026 10:30 AM. The task | |
| will finish automatically when done. | |
| ui_copy: |- | |
| Checkout options | |
| Billing window: 06/01/2026 08:00 AM – 06/01/2026 09:00 AM | |
| Shipping window: [empty] | |
| (Other fields: Carrier select, Notes text area) | |
| setup_description: 'Layout: form_section centered. Light theme, comfortable spacing, default scale. Two visually similar | |
| DateTimeRangePickers are present, each using a single input field: “Billing window” (pre-filled) and “Shipping window” | |
| (empty). Both commit on selection completion (no OK button). Clutter: low—there is a Carrier dropdown and a Notes multiline | |
| field that are not required for success.' | |
| 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: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 3 | |
| justification: Two identical range pickers in a form require correct instance selection; otherwise the range is simple | |
| and same-day. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-06-01T09:00:00 (local time). | |
| - Target range end equals 2026-06-01T10:30:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-06-01T09:00:00' | |
| end: '2026-06-01T10:30:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Shipping window | |
| terminal_condition: true | |
| negative_cases: | |
| - Billing window is changed instead of Shipping window. | |
| - Only one endpoint is set. | |
| - Start/end are off by one hour due to AM/PM confusion. | |
| expected_interaction_path: Locate Shipping window field → open picker → set start date/time → set end date/time → verify | |
| the Shipping field shows the correct range. | |
| notes: 'Instrumentation: data-cb-instance=''Billing window'' and ''Shipping window'' on the two pickers.' | |
| - id: datetime_picker_range-mui-T07 | |
| name: 'Keyboard edit: type a full date-time range in one field' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mui | |
| implementation_variant: mui_x_pro | |
| implementation_component: 'MUI X Pro: DateTimeRangePicker (SingleInputDateTimeRangeField, keyboard editing)' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Type the “Editing range” as 04/10/2026 08:15 AM – 04/10/2026 09:45 AM in the field (keyboard entry), then | |
| finish editing so the value is applied. The task will finish automatically when done. | |
| ui_copy: |- | |
| Editing range | |
| MM/DD/YYYY hh:mm aa – MM/DD/YYYY hh:mm aa | |
| Hint under the field: “Press Enter to start editing” | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing, default scale. A single MUI X Pro | |
| DateTimeRangePicker labeled “Editing range” is configured to emphasize keyboard editing. Under the field, helper text | |
| reads “Press Enter to start editing”. The single input uses the range field format and supports direct typing of the complete | |
| range string. There is no action bar; once the field parses a valid range, the underlying value updates immediately. Initial | |
| state: empty.' | |
| 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: 2 | |
| feedback_dynamics: 3 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Requires precise formatted keyboard entry and successful parsing of both endpoints; small format mistakes | |
| can leave the component in an invalid/partial state. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-04-10T08:15:00 (local time). | |
| - Target range end equals 2026-04-10T09:45:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-04-10T08:15:00' | |
| end: '2026-04-10T09:45:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Only part of the range is entered and parsed (partial value). | |
| - AM/PM mis-typed leading to wrong time. | |
| - Field contains text but value is invalid (error state) and underlying range is not updated. | |
| expected_interaction_path: Focus field → press Enter (start editing) → type the full range string → press Enter/blur to | |
| commit editing → verify value updates. | |
| notes: Checker should evaluate parsed value, not raw string; treat invalid text as failure even if it visually resembles | |
| the target. | |
| - id: datetime_picker_range-mui-T08 | |
| name: 'Night shift: cross-month range with OK confirmation (dark theme)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mui | |
| implementation_variant: mui_x_pro | |
| implementation_component: 'MUI X Pro: DateTimeRangePicker (action bar enabled, dark theme)' | |
| task_template: confirm_cancel | |
| secondary_template: null | |
| browsergym_goal: Set the “Night shift” range to 11/30/2026 10:00 PM – 12/01/2026 01:30 AM, then click OK to apply. The task | |
| will finish automatically when done. | |
| ui_copy: |- | |
| Night shift (dark mode) | |
| [empty] | |
| (When open: date-range calendar + digital clock + Cancel/OK action bar.) | |
| setup_description: 'Layout: isolated_card centered in dark theme; spacing comfortable, scale default. A single DateTimeRangePicker | |
| labeled “Night shift” starts empty. The popper uses a date-range calendar; after selecting dates, the time view uses a | |
| digital clock. An action bar with Cancel and OK is always present; the range is not committed until OK is clicked. Target | |
| spans a month boundary (Nov 30 → Dec 1), requiring calendar navigation between months.' | |
| 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: 3 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 4 | |
| feedback_dynamics: 4 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Cross-month navigation plus a required OK commit step; dark theme can reduce visibility of small calendar | |
| and clock targets. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-11-30T22:00:00 (local time). | |
| - Target range end equals 2026-12-01T01:30:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-11-30T22:00:00' | |
| end: '2026-12-01T01:30:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - End date stays in November (wrong day/month). | |
| - Time selected in AM instead of PM (or vice versa). | |
| - Draft selection made but OK not clicked. | |
| - Only start is selected. | |
| expected_interaction_path: Open Night shift → navigate calendar to Nov 2026 → select 11/30 as start → navigate/choose 12/01 | |
| as end → set start time 10:00 PM and end time 01:30 AM → click OK. | |
| notes: Checker should read committed value post-OK; ensure dark theme does not change formatting used by the adapter. | |
| - id: datetime_picker_range-mui-T09 | |
| name: 'Compact mode: set a tight-minute range using multi-input field' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mui | |
| implementation_variant: mui_x_pro | |
| implementation_component: 'MUI X Pro: DateTimeRangePicker (MultiInputDateTimeRangeField, minute step=1)' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Blackout window” to 07/04/2026 09:07 AM – 07/04/2026 09:59 AM. The task will finish automatically | |
| when done. | |
| ui_copy: |- | |
| Blackout window | |
| Start: MM/DD/YYYY hh:mm aa | |
| End: MM/DD/YYYY hh:mm aa | |
| (Compact spacing; minute options include every minute.) | |
| setup_description: 'Layout: isolated_card centered. Light theme but compact spacing mode. Scale default. The DateTimeRangePicker | |
| is configured to use the MultiInputDateTimeRangeField (separate Start and End text fields). The time selection uses a | |
| digital clock with 1-minute granularity (dense minute list). No action bar is shown; values update as soon as valid selections | |
| are made. Initial state: empty.' | |
| 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: 4 | |
| target_acquisition: 3 | |
| density_choice_interference: 4 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Compact spacing reduces target sizes and the 1-minute time granularity creates a dense list of nearly identical | |
| minute options, increasing selection error risk. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-07-04T09:07:00 (local time). | |
| - Target range end equals 2026-07-04T09:59:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-07-04T09:07:00' | |
| end: '2026-07-04T09:59:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Minute selection is off by 1–2 minutes (e.g., 09:05 instead of 09:07). | |
| - Start and end times are swapped. | |
| - Only Start is filled and End remains empty. | |
| - End time is earlier than start (invalid range). | |
| expected_interaction_path: Open picker → set Start date/time → set End date/time using the dense minute list → confirm both | |
| fields display the exact requested times. | |
| notes: If the implementation uses timeSteps/minuteStep config, expose it in notes for reproducibility. Checker uses exact | |
| minutes. | |
| - id: datetime_picker_range-mui-T10 | |
| name: 'Dashboard filters: scroll to ‘Resolved between’ and set range' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mui | |
| implementation_variant: mui_x_pro | |
| implementation_component: 'MUI X Pro: DateTimeRangePicker in a scrollable filter sidebar (2 instances)' | |
| task_template: scroll_find | |
| secondary_template: null | |
| browsergym_goal: In the dashboard Filters panel, scroll to the “Resolved between” field and set it to 10/15/2026 06:00 AM | |
| – 10/15/2026 06:00 PM. The task will finish automatically when done. | |
| ui_copy: |- | |
| Analytics dashboard | |
| Left sidebar: Filters (scrollable) | |
| Includes many controls (Status, Assignee, Tags, …) | |
| Date-time ranges: | |
| - Created between (pre-filled) | |
| - Resolved between (below fold, empty) | |
| setup_description: 'Layout: dashboard with a left-hand Filters sidebar that is vertically scrollable (high clutter). Light | |
| theme, comfortable spacing, default scale. Inside the sidebar are many common filter widgets (selects, chips, toggles). | |
| There are two DateTimeRangePicker instances with identical styling: “Created between” (pre-filled, near the top) and “Resolved | |
| between” (empty, located further down and not visible until you scroll). Both pickers use the single-input field and commit | |
| on selection completion (no OK). Only the “Resolved between” value is checked for success.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: center | |
| scale: default | |
| instances: 2 | |
| guidance: text | |
| clutter: high | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 5 | |
| justification: High visual clutter and a scrollable sidebar increase the chance of interacting with the wrong control; | |
| two similar range pickers require careful disambiguation. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-10-15T06:00:00 (local time). | |
| - Target range end equals 2026-10-15T18:00:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-10-15T06:00:00' | |
| end: '2026-10-15T18:00:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Resolved between | |
| terminal_condition: true | |
| negative_cases: | |
| - Created between is modified instead of Resolved between. | |
| - Resolved between is partially set (only start). | |
| - Resolved between times are incorrect (AM/PM mix-up). | |
| - A nearby but incorrect date is selected due to scrolling or calendar navigation. | |
| expected_interaction_path: Scroll the Filters sidebar → locate Resolved between → open its picker → set start 10/15/2026 | |
| 06:00 AM → set end 10/15/2026 06:00 PM → verify the field value. | |
| notes: 'Instrumentation: use data-cb-instance=''Created between'' and ''Resolved between'' for the two pickers to support | |
| correct-instance checking.' | |
| - id: datetime_picker_range-mantine-T01 | |
| name: 'Reservation window: set start and end (composite)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: DateTimePicker ×2 (Start/End) grouped as one range component' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Reservation window” start to 2026-02-14 09:30 and end to 2026-02-14 11:00. The task will finish | |
| automatically when done. | |
| ui_copy: |- | |
| Reservation window | |
| Start: [Pick date and time] | |
| End: [Pick date and time] | |
| Display format: YYYY-MM-DD HH:mm | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing, default scale. Mantine does not provide | |
| a single native date-time range picker; this implementation is a composite range group: two Mantine DateTimePicker inputs | |
| labeled “Start” and “End” under the section title “Reservation window”. Each DateTimePicker opens a popover with a calendar | |
| and a time picker. Time selection is configured with dropdowns for hour/minute (easier than free-form). Initial state: | |
| both Start and End are empty. No other UI elements.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Clear labeled Start/End inputs with straightforward same-day values; composite structure is simple and | |
| state is visible in both fields. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-02-14T09:30:00 (local time). | |
| - Target range end equals 2026-02-14T11:00:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-02-14T09:30:00' | |
| end: '2026-02-14T11:00:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Only Start is set and End remains empty. | |
| - End is earlier than Start (invalid ordering). | |
| - Start/End times do not match exactly. | |
| - Values are entered into the wrong composite group (not applicable here). | |
| expected_interaction_path: Open Start picker → choose date/time → open End picker → choose date/time → verify both fields | |
| show the target values. | |
| notes: 'Composite note: Treat the pair (Start DateTimePicker, End DateTimePicker) as one canonical datetime range component. | |
| Instrumentation: wrap group with data-cb-instance=''Reservation window'' and expose child testids for start/end fields.' | |
| - id: datetime_picker_range-mantine-T02 | |
| name: Clear a prefilled composite range | |
| canonical_type: datetime_picker_range | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: DateTimePicker ×2 (clearable) as composite range' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the “Maintenance window” so both Start and End become empty. The task will finish automatically when | |
| done. | |
| ui_copy: |- | |
| Maintenance window | |
| Start: 2026-03-10 01:00 | |
| End: 2026-03-10 03:00 | |
| (Clear ✕ buttons are shown in each field.) | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing. Composite range group “Maintenance | |
| window” contains two Mantine DateTimePicker inputs (Start and End), both configured with clearable=true so each field | |
| shows a clear (✕) control when it has a value. Initial state: Start=2026-03-10 01:00 and End=2026-03-10 03:00. No other | |
| interactive elements.' | |
| 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: 2 | |
| semantic_observability: 5 | |
| disambiguation_load: 1 | |
| justification: Clearing is a direct action with visible clear buttons; success is the empty state for both fields. | |
| success_trigger: | |
| human_readable: | |
| - Start value is empty (null). | |
| - End value is empty (null). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: null | |
| end: null | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Only one field is cleared (Start cleared but End still set, or vice versa). | |
| - Text appears empty but underlying value remains (controlled value not cleared). | |
| - Field enters an error state instead of being cleanly empty. | |
| expected_interaction_path: Click clear on Start → click clear on End → ensure both show placeholders. | |
| notes: 'Checker evaluates composite: both underlying DateTimePicker values must be null.' | |
| - id: datetime_picker_range-mantine-T03 | |
| name: Open the Start picker popover (composite) | |
| canonical_type: datetime_picker_range | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: DateTimePicker ×2 (popover) as composite range' | |
| task_template: open_overlay | |
| secondary_template: null | |
| browsergym_goal: Open the “Event window” Start date/time picker so its calendar/time popover is visible. Do not change any | |
| values. The task will finish automatically when done. | |
| ui_copy: |- | |
| Event window | |
| Start: [Pick date and time] | |
| End: [Pick date and time] | |
| (Clicking a field opens a popover.) | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing. Composite range group “Event window” | |
| contains two empty Mantine DateTimePicker fields labeled Start and End. Each field opens its own popover with the calendar | |
| and time picker when clicked. No other UI elements; intent is to test opening the Start field overlay without setting | |
| values.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: Only requires opening the Start field popover; no range values need to be set. | |
| success_trigger: | |
| human_readable: | |
| - The Start DateTimePicker popover for the Event window group is open (calendar/time UI visible). | |
| - The composite range value remains empty (no start/end selected). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| overlay_open: true | |
| active_part: start | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - End field popover is opened instead of Start (active_part mismatch). | |
| - Any date/time is selected, making Start or End non-empty. | |
| - No popover is visible. | |
| expected_interaction_path: Click the Start field in Event window → verify popover opens. | |
| notes: Checker should detect which child popover is open (start vs end) and ensure value is still empty. | |
| - id: datetime_picker_range-mantine-T04 | |
| name: 'Secondary schedule: set range among two composite groups' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: DateTimePicker ×2 per group, two groups on page (instances=2)' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: In the form, set the “Secondary schedule” start to 2026-04-01 13:00 and end to 2026-04-01 16:30. The task | |
| will finish automatically when done. | |
| ui_copy: |- | |
| Schedules | |
| Primary schedule: (pre-filled) | |
| Secondary schedule: (empty) | |
| Other fields: Name, Timezone select | |
| setup_description: 'Layout: form_section centered with low clutter. Light theme, comfortable spacing, default scale. There | |
| are two composite date-time range groups that look alike: “Primary schedule” (Start/End pre-filled) and “Secondary schedule” | |
| (Start/End empty). Each group is composed of two Mantine DateTimePicker fields (Start and End). Other controls (a Name | |
| text input and a Timezone select) are present but irrelevant to success.' | |
| 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: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 4 | |
| justification: 'Disambiguation is the main challenge: two similar composite groups require selecting the correct Start/End | |
| fields under the right label.' | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-04-01T13:00:00 (local time). | |
| - Target range end equals 2026-04-01T16:30:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-04-01T13:00:00' | |
| end: '2026-04-01T16:30:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Secondary schedule | |
| terminal_condition: true | |
| negative_cases: | |
| - Primary schedule is modified instead of Secondary schedule. | |
| - Only Start or only End is set in Secondary schedule. | |
| - Start/end values are correct but entered in different groups (mixed fields). | |
| expected_interaction_path: Locate Secondary schedule → set Start date/time → set End date/time → verify both fields show | |
| correct values. | |
| notes: 'Instrumentation: each composite group should have a stable instance id; checker reads start/end from that group | |
| only.' | |
| - id: datetime_picker_range-mantine-T05 | |
| name: 'Service window: match reference card (composite)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: DateTimePicker ×2 + reference display' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Set the “Service window” Start and End to match the range shown in the “Reference” card. The task will | |
| finish automatically when done. | |
| ui_copy: |- | |
| Reference | |
| 2026-08-09 10:00 → 2026-08-09 12:30 | |
| Service window | |
| Start: [empty] | |
| End: [empty] | |
| setup_description: 'Layout: isolated_card centered, light theme, comfortable spacing. A ‘Reference’ block above the composite | |
| range group shows the target start/end as text (visual guidance). The “Service window” composite group contains Start | |
| and End Mantine DateTimePicker fields (popover dropdowns for time). Initial state: both fields empty. No other UI.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: visual | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Target is provided via an on-page reference rather than in the instruction; otherwise interaction is standard | |
| with two clear fields. | |
| success_trigger: | |
| human_readable: | |
| - Selected range matches the range displayed in the reference element labeled 'Reference'. | |
| - Reference resolves to start=2026-08-09T10:00:00, end=2026-08-09T12:30:00 (local time). | |
| - If confirmation is required, the selection must be confirmed using the specified confirm control. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| reference_label: Reference | |
| start: '2026-08-09T10:00:00' | |
| end: '2026-08-09T12:30:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Reference is misread and values differ from target. | |
| - Only Start is set. | |
| - Start/End are set in the wrong order. | |
| expected_interaction_path: Read Reference → set Start → set End → verify displayed values match Reference. | |
| notes: Checker may parse reference text or use pre-known target values for determinism. | |
| - id: datetime_picker_range-mantine-T06 | |
| name: 'Inspection window: set range with pickers opening in modals' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: DateTimePicker ×2 (dropdownType=''modal'') as composite range' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Inspection window” start to 2026-09-15 07:00 and end to 2026-09-15 09:00. The task will finish | |
| automatically when done. | |
| ui_copy: |- | |
| Inspection window | |
| Start: [Pick date and time] (opens in a modal) | |
| End: [Pick date and time] (opens in a modal) | |
| setup_description: 'Layout: modal_flow anchored near the top-right of the viewport. Light theme, comfortable spacing, default | |
| scale. Composite range group “Inspection window” has two Mantine DateTimePicker fields (Start/End) configured with dropdownType=''modal'', | |
| so clicking either field opens a full modal dialog containing the calendar and time picker. Initial state: empty. No extra | |
| form fields or buttons; once both Start and End are set, success is achieved.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: modal_flow | |
| placement: top_right | |
| 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: 2 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Modal-based pickers add an extra layer and larger context switches (Start modal then End modal), while | |
| the target values remain straightforward. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-09-15T07:00:00 (local time). | |
| - Target range end equals 2026-09-15T09:00:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-09-15T07:00:00' | |
| end: '2026-09-15T09:00:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Only Start is set and End remains empty. | |
| - Start/End values are off by an hour due to mis-selection in modal. | |
| - End is earlier than Start (invalid range). | |
| expected_interaction_path: Click Start → set date/time in modal → close modal → click End → set date/time in modal → verify | |
| values. | |
| notes: Checker reads the two DateTimePicker values from the composite group. Instrument modals with stable roles/labels | |
| for overlay detection. | |
| - id: datetime_picker_range-mantine-T07 | |
| name: 'Year-end window: cross-year range (dark theme, composite)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: DateTimePicker ×2 (dark theme) as composite range' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Year-end window” start to 2026-12-31 23:00 and end to 2027-01-01 01:00. The task will finish automatically | |
| when done. | |
| ui_copy: |- | |
| Year-end window (dark mode) | |
| Start: [empty] | |
| End: [empty] | |
| (Each field opens a calendar + time picker.) | |
| setup_description: 'Layout: isolated_card centered in dark theme; comfortable spacing, default scale. Composite range group | |
| “Year-end window” contains Start and End Mantine DateTimePicker fields. Target spans a year boundary (Dec 31 → Jan 1), | |
| requiring navigation between months/years in the calendar view for at least one of the fields. Initial state: empty. No | |
| other UI elements.' | |
| 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: 3 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Cross-year navigation requires careful month/year changes in the calendar for Start and End, and dark theme | |
| can reduce contrast for small navigation controls. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-12-31T23:00:00 (local time). | |
| - Target range end equals 2027-01-01T01:00:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-12-31T23:00:00' | |
| end: '2027-01-01T01:00:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - End date is set to the wrong year (2026 instead of 2027). | |
| - Times are correct but dates are off by one day due to midnight boundary. | |
| - Only one of Start/End is set. | |
| expected_interaction_path: Set Start to Dec 31, 2026 23:00 → set End to Jan 1, 2027 01:00 → verify both fields. | |
| notes: Checker must treat local time; ensure adapter uses consistent time zone when converting Date objects. | |
| - id: datetime_picker_range-mantine-T08 | |
| name: 'Precise timing: set range with seconds enabled (composite)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: DateTimePicker ×2 (withSeconds) as composite range' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Recorder window” start to 2026-10-10 08:15:30 and end to 2026-10-10 09:45:10. The task will finish | |
| automatically when done. | |
| ui_copy: |- | |
| Recorder window | |
| Start: [HH:MM:SS] | |
| End: [HH:MM:SS] | |
| (Seconds inputs are enabled.) | |
| setup_description: 'Layout: isolated_card centered. Light theme, comfortable spacing, default scale. Composite range group | |
| “Recorder window” uses two Mantine DateTimePicker fields with withSeconds enabled, so time selection includes hours, minutes, | |
| and seconds. Initial state: empty. No other UI elements.' | |
| 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: 5 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 3 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Second-level precision increases the likelihood of small errors; the agent must correctly set hours, minutes, | |
| and seconds for both Start and End. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-10-10T08:15:30 (local time). | |
| - Target range end equals 2026-10-10T09:45:10 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-10-10T08:15:30' | |
| end: '2026-10-10T09:45:10' | |
| timezone: local | |
| tolerance: | |
| unit: second | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Seconds are left at default values (e.g., :00). | |
| - Only hours/minutes are set correctly but seconds are wrong. | |
| - Start/End are swapped or partially set. | |
| expected_interaction_path: Open Start → set date 2026-10-10 and time 08:15:30 → open End → set time 09:45:10 → verify values. | |
| notes: Ensure adapter reads seconds from the underlying Date value; checker uses 0-second tolerance. | |
| - id: datetime_picker_range-mantine-T09 | |
| name: 'Compact + small: set tight-minute range in composite inputs' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: DateTimePicker ×2 (compact spacing, small size) as composite range' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Set the “Blackout window” start to 2026-07-04 09:07 and end to 2026-07-04 09:59. The task will finish automatically | |
| when done. | |
| ui_copy: |- | |
| Blackout window (compact) | |
| Start (small): [Pick date and time] | |
| End (small): [Pick date and time] | |
| setup_description: 'Layout: isolated_card centered. Light theme, but compact spacing mode and small-sized inputs. Composite | |
| range group “Blackout window” contains Start and End Mantine DateTimePicker fields rendered in small size. Time selection | |
| uses fine-grained minutes (no coarse stepping), making it easy to pick a nearby but incorrect minute. Initial state: empty.' | |
| scene_context: | |
| theme: light | |
| spacing: compact | |
| layout: isolated_card | |
| placement: center | |
| scale: small | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 4 | |
| target_acquisition: 4 | |
| density_choice_interference: 4 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Small, tightly spaced controls raise acquisition difficulty and selecting uncommon minutes (09:07, 09:59) | |
| increases the chance of near-miss errors. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-07-04T09:07:00 (local time). | |
| - Target range end equals 2026-07-04T09:59:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-07-04T09:07:00' | |
| end: '2026-07-04T09:59:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: true | |
| negative_cases: | |
| - Start or End minute is off (e.g., 09:05 or 10:00). | |
| - Only one endpoint is set. | |
| - End earlier than Start. | |
| expected_interaction_path: Set Start to 2026-07-04 09:07 → set End to 2026-07-04 09:59 → verify both fields. | |
| notes: If minute stepping is configurable in the underlying TimePicker, set it to 1-minute steps for reproducibility. | |
| - id: datetime_picker_range-mantine-T10 | |
| name: 'SLA table: edit the Silver row window (composite)' | |
| canonical_type: datetime_picker_range | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: DateTimePicker ×2 per table row (2 rows = 2 instances)' | |
| task_template: table_operation | |
| secondary_template: null | |
| browsergym_goal: In the SLA table, set the “Silver” row response window start to 2026-06-15 14:00 and end to 2026-06-15 | |
| 16:00. The task will finish automatically when done. | |
| ui_copy: |- | |
| SLA table | |
| Rows: Gold | Silver | |
| Columns include: Response window (Start, End) | |
| Gold row is pre-filled; Silver row is empty. | |
| setup_description: 'Layout: table_cell view centered in the viewport (a small admin table). Light theme, comfortable spacing, | |
| default scale. There are two rows (“Gold” and “Silver”). Each row contains a composite date-time range editor embedded | |
| in the table: a Start DateTimePicker cell and an End DateTimePicker cell (together treated as one canonical datetime range | |
| instance per row). The Gold row is pre-filled with a different range; the Silver row Start/End are empty. Medium clutter | |
| comes from other non-interactive columns (SLA name, description) and a couple of action icons per row, but they do not | |
| affect success.' | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: table_cell | |
| placement: center | |
| scale: default | |
| instances: 2 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 4 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 5 | |
| justification: Table cell embedding makes click targets smaller and increases the risk of editing the wrong row; two similar | |
| row instances require careful disambiguation. | |
| success_trigger: | |
| human_readable: | |
| - Target range start equals 2026-06-15T14:00:00 (local time). | |
| - Target range end equals 2026-06-15T16:00:00 (local time). | |
| - If confirmation is required, the selection is not considered final until the specified confirm control is activated. | |
| - If multiple instances are present, only the labeled target instance is evaluated. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| start: '2026-06-15T14:00:00' | |
| end: '2026-06-15T16:00:00' | |
| timezone: local | |
| tolerance: | |
| unit: minute | |
| value: 0 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: SLA table > Silver | |
| terminal_condition: true | |
| negative_cases: | |
| - Gold row is modified instead of Silver. | |
| - Only Start or End is set in Silver row. | |
| - Values are set but in the wrong row/cells due to table focus behavior. | |
| expected_interaction_path: Locate Silver row → set Start cell DateTimePicker → set End cell DateTimePicker → verify the | |
| Silver row shows the correct times. | |
| notes: 'Instrumentation: each row should expose a stable instance id (e.g., data-cb-instance=''SLA table > Silver'') to | |
| support correct-instance checking.' | |