Initial ComponentBench data release: tasks v1+v2, cleaned human traces, difficulty audit, ontology metadata
360df42 verified | - id: data_table_paginated-antd-T01 | |
| name: 'Orders table: go to page 3' | |
| canonical_type: data_table_paginated | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table (pagination enabled)' | |
| task_template: navigate_to | |
| secondary_template: null | |
| browsergym_goal: In the Orders table, go to page 3. The task will finish automatically when done. | |
| ui_copy: In the Orders table, go to page 3. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: an isolated card centered in the viewport titled **Orders**. | |
| Component: an Ant Design Table with built-in pagination in the footer. The table shows 5 columns: Order ID, Customer, Status (colored Tag), Total, and Order Date. The dataset contains 120 orders (IDs A-1001…A-1120), so pagination shows 12 pages at 10 rows per page. | |
| Initial state: the table is on page 1, sorted by Order Date (newest first) **is NOT** enabled; no filters are active; no rows are selected. | |
| Controls: pagination footer shows page numbers and next/previous arrows. Clicking a page number changes pages immediately (no Apply/OK confirmation). | |
| Distractors: none beyond the standard table header and pagination 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: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Single table with visible page numbers; one direct click updates the page immediately. | |
| success_trigger: | |
| human_readable: | |
| - Orders table pagination current page is 3 (1-based). | |
| - No confirmation click is required. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page: 3 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Landing on page 2 or page 4 (off-by-one page). | |
| - Changing rows-per-page without reaching page 3. | |
| - Scrolling the table body without changing the pagination page. | |
| expected_interaction_path: Click page number **3** in the pagination footer (or use next twice). | |
| notes: |- | |
| Checker hint: read AntD Table pagination state from the rendered Pagination control (current page) or from the table adapter state. | |
| Instrumentation: add data-testid on the Orders table root (e.g., data-testid='orders-table') and on its pagination container. | |
| - id: data_table_paginated-antd-T02 | |
| name: 'Orders table: set rows per page to 20' | |
| canonical_type: data_table_paginated | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table (pagination + pageSize changer)' | |
| task_template: open_and_select | |
| secondary_template: null | |
| browsergym_goal: Set the Orders table to show 20 rows per page. The task will finish automatically when done. | |
| ui_copy: Set the Orders table to show 20 rows per page. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered, titled **Orders**. | |
| Component: Ant Design Table with pagination configured with **page size changer** enabled. Footer pagination includes a "Rows per page" (pageSize) dropdown with options 10, 20, 50. | |
| Initial state: page 1, page size 10 rows per page; no filters; no selected rows. | |
| Controls: selecting a new page size applies immediately (no extra Apply button). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Requires opening a single dropdown in the pagination footer and choosing a clearly labeled option. | |
| success_trigger: | |
| human_readable: | |
| - Orders table page size is 20 rows per page. | |
| - Change is applied (no pending/unsaved state). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page_size: 20 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Page size remains 10 or becomes 50. | |
| - Changing to 20 in a different table (if any appears due to responsive layout) — not applicable here but should be guarded | |
| by testid scoping. | |
| - Typing 20 into any unrelated input on the page. | |
| expected_interaction_path: Open the page-size dropdown in the pagination footer → click **20 / page**. | |
| notes: |- | |
| Checker hint: normalize page-size across libraries to integer page_size. | |
| Instrumentation: page size selector should have stable aria-label (e.g., 'Rows per page') or data-testid. | |
| - id: data_table_paginated-antd-T03 | |
| name: 'Orders table: sort by Order Date (newest first)' | |
| canonical_type: data_table_paginated | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table (pagination + column sorter)' | |
| task_template: table_operation | |
| secondary_template: null | |
| browsergym_goal: Sort the Orders table by Order Date from newest to oldest. The task will finish automatically when done. | |
| ui_copy: Sort the Orders table by Order Date from newest to oldest. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered, titled **Orders**. | |
| Component: Ant Design Table with sortable columns. The **Order Date** column header shows the standard sort caret indicators on hover. | |
| Initial state: page 1, page size 10; no filters; sorting is **not set** (neutral) on all columns. | |
| Controls: clicking a sortable header cycles sorting states (neutral → ascending → descending). Sorting is applied immediately. | |
| Distractors: other columns (Customer, Status, Total) are also sortable but are irrelevant. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: Single click target in the header; feedback is visible via sort indicator and row order changes. | |
| success_trigger: | |
| human_readable: | |
| - Orders table active sort is set to Order Date descending (newest → oldest). | |
| - No column filters are required. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| sort: | |
| column_id: order_date | |
| direction: desc | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Order Date sorted ascending (oldest → newest). | |
| - A different column is sorted instead of Order Date. | |
| - Table is left in neutral (unsorted) state. | |
| expected_interaction_path: Click the **Order Date** header until the descending sort indicator is active. | |
| notes: 'Checker hint: map AntD sorter state to canonical {column_id, direction}.' | |
| - id: data_table_paginated-antd-T04 | |
| name: 'Orders table: select one row by Order ID' | |
| canonical_type: data_table_paginated | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table (pagination + rowSelection)' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: Select the row with Order ID A-1007 in the Orders table. The task will finish automatically when done. | |
| ui_copy: Select the row with Order ID A-1007 in the Orders table. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered, titled **Orders**. | |
| Component: Ant Design Table with a leading checkbox selection column (rowSelection enabled). Each row has a stable `rowKey` equal to the Order ID (e.g., A-1007). | |
| Initial state: page 1, page size 10, sorted by Order ID ascending so A-1007 is visible on page 1. No rows are selected. | |
| Controls: click the checkbox at the start of the A-1007 row (or click the row if the checkbox is configured as row click). Selection updates immediately. | |
| Distractors: other rows have similar IDs (A-1006, A-1008). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Row checkboxes are small and adjacent rows have similar IDs, but the target row is visible on the first | |
| page. | |
| success_trigger: | |
| human_readable: | |
| - 'Exactly one row is selected: Order ID A-1007.' | |
| - Selection is in the Orders table (single instance on page). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| selection: | |
| mode: single | |
| selected_row_ids: | |
| - A-1007 | |
| tolerance: | |
| set_mode: exact | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Selecting A-1006 or A-1008 (neighbor rows). | |
| - Selecting multiple rows (more than one checkbox checked). | |
| - Row is focused/highlighted but not actually selected (if selection is checkbox-only). | |
| expected_interaction_path: Locate row A-1007 on page 1 → click its checkbox. | |
| notes: 'Instrumentation: ensure each row exposes its canonical row_id (Order ID) for the checker (e.g., data-row-key).' | |
| - id: data_table_paginated-antd-T05 | |
| name: 'Orders table: filter Status to Pending' | |
| canonical_type: data_table_paginated | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table (pagination + column filters)' | |
| task_template: open_and_select | |
| secondary_template: null | |
| browsergym_goal: Filter the Orders table so it shows only rows with Status = Pending. Click OK in the filter menu if needed. | |
| The task will finish automatically when done. | |
| ui_copy: Filter the Orders table so it shows only rows with Status = Pending. Click OK in the filter menu if needed. The | |
| task will finish automatically when done. | |
| setup_description: |- | |
| Layout: **form_section** — a "Manage Orders" page with a left-aligned form section (date range inputs and a "Create order" button) above the table. The Orders table sits below the form inputs inside the same page section. | |
| Component: Ant Design Table with column filters enabled on the **Status** column. The Status header has a funnel/filter icon that opens a dropdown menu. The filter menu lists 5 statuses with single-select behavior (radio-style): Pending, Shipped, Delivered, Cancelled, Refunded. | |
| Initial state: no filters are applied; page 1; page size 10. | |
| Controls: open the Status filter dropdown → choose **Pending** → click **OK** to apply. After applying, the filter icon becomes highlighted and the table rows update. | |
| Distractors: the page contains unrelated form inputs (date range, customer search) but they do not affect the success checker. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: form_section | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 3 | |
| semantic_observability: 3 | |
| disambiguation_load: 2 | |
| justification: Requires opening a small header control, choosing among similar options, and confirming in the dropdown | |
| menu. | |
| success_trigger: | |
| human_readable: | |
| - Status column filter is active with value 'Pending'. | |
| - If the AntD filter menu requires confirmation, the filter has been applied (OK clicked). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| filters: | |
| - column_id: status | |
| operator: equals | |
| value: Pending | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Filter dropdown shows Pending selected but OK was not clicked (filter not applied). | |
| - Filtering to a different status (e.g., Shipped). | |
| - Using the unrelated form inputs above the table without setting the table's Status filter. | |
| expected_interaction_path: Click Status column filter icon → select Pending → click OK. | |
| notes: 'Checker hint: read table filter state from adapter (e.g., filteredInfo) rather than from visible rows alone.' | |
| - id: data_table_paginated-antd-T06 | |
| name: 'Orders table: select the row matching a reference card' | |
| canonical_type: data_table_paginated | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table (pagination + rowSelection + reference panel)' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Select the order in the Orders table that matches the reference card shown on the right. The task will | |
| finish automatically when done. | |
| ui_copy: Select the order in the Orders table that matches the reference card shown on the right. The task will finish automatically | |
| when done. | |
| setup_description: |- | |
| Layout: isolated card centered. The card is split into two columns: | |
| • Left: the **Orders** Ant Design Table with pagination and row selection (checkboxes). | |
| • Right: a **Reference Order** mini-card that visually summarizes one target order. | |
| Reference card details (mixed guidance): shows a customer avatar, a colored Status Tag, and a text badge reading **Order ID A-1042**. | |
| Table details: 120 orders total, 10 rows per page. The target order A-1042 is not on page 1; it appears on page 2. | |
| Initial state: page 1; no filters; no rows selected. | |
| Distractors: neighboring Order IDs on page 2 include A-1041 and A-1043, and multiple rows share the same Status color. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: mixed | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 4 | |
| disambiguation_load: 2 | |
| justification: Requires using a visual/text reference, navigating pages, and selecting the correct row among similar IDs. | |
| success_trigger: | |
| human_readable: | |
| - The selected row in the Orders table matches the Reference Order card (Order ID A-1042). | |
| - Exactly that row is selected (no extra selected rows). | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| reference_id: ref-order-card-1 | |
| resolved_row_id: A-1042 | |
| selection: | |
| mode: single | |
| selected_row_ids: | |
| - A-1042 | |
| tolerance: | |
| set_mode: exact | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Selecting a row that matches only part of the reference (e.g., same Status color but different Order ID). | |
| - Selecting A-1041 or A-1043 (adjacent IDs). | |
| - Leaving multiple rows selected. | |
| expected_interaction_path: Read Order ID from the reference card → go to page 2 → select row A-1042. | |
| notes: 'Checker hint: reference card should have stable reference_id; checker resolves to a canonical row_id and validates | |
| selection.' | |
| - id: data_table_paginated-antd-T07 | |
| name: 'Orders table: clear the active Status filter' | |
| canonical_type: data_table_paginated | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table (pagination + column filters, pre-filtered)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the active Status filter in the Orders table so all statuses are shown again. If the filter menu | |
| has Reset/OK buttons, use them. The task will finish automatically when done. | |
| ui_copy: Clear the active Status filter in the Orders table so all statuses are shown again. If the filter menu has Reset/OK | |
| buttons, use them. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Orders**. | |
| Component: Ant Design Table with a Status column filter dropdown. | |
| Initial state (important): the Status filter is already active with value **Pending**. The filter icon in the Status column header appears highlighted, and only Pending rows are visible. | |
| Controls: opening the Status filter dropdown shows Pending selected and provides **Reset** and **OK** buttons at the bottom. | |
| Distractors: other columns are sortable and can change row order but do not affect filter clearing. | |
| 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: 3 | |
| density_choice_interference: 2 | |
| depth_layering: 3 | |
| feedback_dynamics: 3 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: Requires recognizing an already-filtered state and using the correct control sequence to remove the filter. | |
| success_trigger: | |
| human_readable: | |
| - No column filters are active (filters list is empty). | |
| - If the filter UI requires confirmation, the cleared state is applied. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| filters: [] | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Filter menu shows Reset clicked but OK not clicked (cleared state not applied). | |
| - Switching the filter to a different status instead of clearing it. | |
| - Clearing sorting only (filter remains active). | |
| expected_interaction_path: Open Status filter dropdown → click Reset → click OK. | |
| notes: 'Checker hint: verify canonical filters model is empty, not just that more rows appear (avoid false positives).' | |
| - id: data_table_paginated-antd-T08 | |
| name: 'Orders table: select three specific orders across pages' | |
| canonical_type: data_table_paginated | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table (pagination + multi-row selection, preserveSelectedRowKeys)' | |
| task_template: select_many | |
| secondary_template: null | |
| browsergym_goal: Select the rows with Order IDs A-1088, A-1091, and A-1120 in the Orders table. You may need to change pages; | |
| selected rows should stay selected when you paginate. The task will finish automatically when done. | |
| ui_copy: Select the rows with Order IDs A-1088, A-1091, and A-1120 in the Orders table. You may need to change pages; selected | |
| rows should stay selected when you paginate. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Orders** in **dark theme** with **compact spacing** (reduced padding in rows and pagination). | |
| Component: Ant Design Table with pagination (10 rows per page) and multi-row selection (checkboxes). `rowSelection.preserveSelectedRowKeys` is enabled so selections persist when moving between pages. | |
| Dataset: 120 orders (A-1001…A-1120). The three target Order IDs are spread across multiple pages: | |
| • A-1088 (page 9) | |
| • A-1091 (page 10) | |
| • A-1120 (page 12) | |
| Initial state: page 1; no rows selected. | |
| Distractors: many IDs differ by only 1 digit; compact spacing makes the checkboxes and row text tighter. | |
| scene_context: | |
| theme: dark | |
| spacing: compact | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 4 | |
| density_choice_interference: 4 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 2 | |
| justification: Requires accurate multi-selection across several pagination changes in a dense, compact/dark presentation. | |
| success_trigger: | |
| human_readable: | |
| - Selected row IDs are exactly {A-1088, A-1091, A-1120}. | |
| - Selection persists across pagination (no need to return to page 1). | |
| canonical_predicate: | |
| predicate_type: set_membership | |
| target_state: | |
| selection: | |
| mode: multi | |
| selected_row_ids: | |
| - A-1088 | |
| - A-1091 | |
| - A-1120 | |
| tolerance: | |
| set_mode: exact | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Selecting only a subset (e.g., A-1088 and A-1091 but missing A-1120). | |
| - Selecting extra rows beyond the three targets. | |
| - Selecting rows in the right pages but with wrong IDs (e.g., A-1089 instead of A-1088). | |
| expected_interaction_path: Go to page 9 → select A-1088 → page 10 → select A-1091 → page 12 → select A-1120. | |
| notes: 'Checker hint: enforce exact set equality on selected_row_ids; ignore ordering.' | |
| - id: data_table_paginated-antd-T09 | |
| name: 'Dashboard: navigate Archived Orders table to page 4' | |
| canonical_type: data_table_paginated | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table (dashboard with 2 instances, each paginated)' | |
| task_template: navigate_to | |
| secondary_template: null | |
| browsergym_goal: In the Archived Orders table (not Recent Orders), go to page 4. The task will finish automatically when | |
| done. | |
| ui_copy: In the Archived Orders table (not Recent Orders), go to page 4. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: **dashboard** layout anchored toward the **top-left** of the viewport. | |
| Scene contains TWO Ant Design tables of the same canonical type (instances=2): | |
| 1) **Recent Orders** (top card) — small table with pagination. | |
| 2) **Archived Orders** (bottom card) — larger table with pagination. | |
| Both tables have the same columns and similar pagination controls, but each card has a clear title. | |
| Initial state: both tables start on page 1 with 10 rows per page. | |
| Task target: only the **Archived Orders** table should end on page 4. Changing the page on Recent Orders does not count. | |
| Clutter/distractors: dashboard also includes a right-side summary panel (KPIs and a small chart), but it is non-interactive. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: top_left | |
| scale: default | |
| instances: 2 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 4 | |
| disambiguation_load: 4 | |
| justification: Two visually similar table instances require careful disambiguation before using pagination controls. | |
| success_trigger: | |
| human_readable: | |
| - Archived Orders table current page is 4. | |
| - Recent Orders table state is ignored by the checker. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page: 4 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Archived Orders | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Changing page to 4 in the Recent Orders table instead of Archived Orders. | |
| - Archived Orders ends on page 3 or 5. | |
| - Changing rows-per-page without reaching page 4. | |
| expected_interaction_path: Locate the 'Archived Orders' card → use its pagination to select page 4. | |
| notes: 'Instrumentation: each table instance should have a stable instance label/testid (e.g., data-testid=''table-archived-orders'').' | |
| - id: data_table_paginated-antd-T10 | |
| name: 'Orders table: jump to page 9 via quick jumper' | |
| canonical_type: data_table_paginated | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Table (pagination + quick jumper)' | |
| task_template: enter_formatted | |
| secondary_template: null | |
| browsergym_goal: Use the page jumper in the Orders table pagination to go to page 9. Press Enter if needed. The task will | |
| finish automatically when done. | |
| ui_copy: Use the page jumper in the Orders table pagination to go to page 9. Press Enter if needed. The task will finish | |
| automatically when done. | |
| setup_description: |- | |
| Layout: isolated card positioned near the **bottom-right** of the viewport. | |
| Component: Ant Design Table with pagination configured with `showQuickJumper` enabled. The pagination footer includes a small numeric text field labeled "Jump to" (or similar) that lets the user type a page number. | |
| Dataset: 300 orders (30 pages at 10 rows per page). | |
| Initial state: page 1; page size 10; no filters; no selection. | |
| Controls: focus the quick-jump input → type **9** → confirm by pressing Enter (or the input's built-in confirm behavior). Page changes immediately when the jump is accepted. | |
| Density: compact spacing and **small scale** make the jumper input and pagination buttons tighter. | |
| Distractors: the pagination footer also contains a page-size selector, but changing it is not required. | |
| scene_context: | |
| theme: light | |
| spacing: compact | |
| layout: isolated_card | |
| placement: bottom_right | |
| scale: small | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 4 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 3 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Requires acquiring a small numeric input and entering a correctly formatted page number with explicit submission. | |
| success_trigger: | |
| human_readable: | |
| - Orders table pagination current page is 9. | |
| - The page jump has been accepted (not just typed but unapplied). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page: 9 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Typing 9 but not submitting (page remains 1). | |
| - Landing on page 8 or 10 due to mis-entry. | |
| - Changing rows per page (page size) without reaching page 9. | |
| expected_interaction_path: Click the quick jumper input → type 9 → press Enter → verify current page shows 9. | |
| notes: 'Instrumentation: expose current page in a data attribute; ensure the quick-jumper input has a stable label/aria-label | |
| for accessibility.' | |
| - id: data_table_paginated-mui-T01 | |
| name: 'Users grid: go to page 2' | |
| canonical_type: data_table_paginated | |
| implementation_source: mui | |
| implementation_variant: x-data-grid | |
| implementation_component: 'MUI X: DataGrid' | |
| task_template: navigate_to | |
| secondary_template: null | |
| browsergym_goal: In the Users table, go to page 2. The task will finish automatically when done. | |
| ui_copy: In the Users table, go to page 2. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Users**. | |
| Component: MUI X **DataGrid** with client-side pagination enabled. The footer shows the displayed-rows label (e.g., "1–25 of 250"), a Rows-per-page selector, and Next/Previous page arrow buttons. | |
| Dataset: 250 users (User IDs U-0001…U-0250). Page size is 25 rows per page (10 pages total). | |
| Initial state: page 1 (showing rows 1–25), no sorting, no filters, no selected rows. | |
| Controls: click the Next page arrow once to reach page 2; changes apply immediately. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: Simple single-instance footer navigation (Next page) with immediate feedback in the displayed-rows label. | |
| success_trigger: | |
| human_readable: | |
| - Users grid current page is 2 (1-based in canonical state). | |
| - No confirmation click is required. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page: 2 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Remaining on page 1. | |
| - Jumping past page 2 (e.g., to page 3). | |
| - Changing rows per page instead of changing the page. | |
| expected_interaction_path: Use the footer Next page arrow once. | |
| notes: 'Checker hint: normalize MUI DataGrid paginationModel.page (0-based) to canonical page (1-based).' | |
| - id: data_table_paginated-mui-T02 | |
| name: 'Users grid: set rows per page to 50' | |
| canonical_type: data_table_paginated | |
| implementation_source: mui | |
| implementation_variant: x-data-grid | |
| implementation_component: 'MUI X: DataGrid' | |
| task_template: open_and_select | |
| secondary_template: null | |
| browsergym_goal: Set the Users table to show 50 rows per page. The task will finish automatically when done. | |
| ui_copy: Set the Users table to show 50 rows per page. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Users**. | |
| Component: MUI X DataGrid with pagination. Footer includes a **Rows per page** select with options 25, 50, 100. | |
| Initial state: page 1, rows per page = 25. | |
| Controls: open the Rows per page select in the footer and choose **50**. The grid refreshes immediately. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: One dropdown selection in a standard footer control with clear numeric options. | |
| success_trigger: | |
| human_readable: | |
| - Users grid page size is 50 rows per page. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page_size: 50 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Setting page size to 25 or 100. | |
| - Changing page number without setting page size. | |
| - Selecting 50 in any unrelated dropdown outside the grid (should not exist in this isolated scene). | |
| expected_interaction_path: Open footer Rows per page select → choose 50. | |
| notes: 'Checker hint: use DataGrid paginationModel.pageSize (or equivalent) for canonical page_size.' | |
| - id: data_table_paginated-mui-T03 | |
| name: 'Users grid: sort by Last seen (most recent first)' | |
| canonical_type: data_table_paginated | |
| implementation_source: mui | |
| implementation_variant: x-data-grid | |
| implementation_component: 'MUI X: DataGrid' | |
| task_template: table_operation | |
| secondary_template: null | |
| browsergym_goal: Sort the Users table by Last seen so the most recent activity is first. The task will finish automatically | |
| when done. | |
| ui_copy: Sort the Users table by Last seen so the most recent activity is first. The task will finish automatically when | |
| done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Users**. | |
| Component: MUI X DataGrid with sortable columns. | |
| Columns: User ID, Name, Role, Status, and **Last seen** (date-time). | |
| Initial state: no active sort model (neutral). | |
| Controls: click the **Last seen** column header to toggle sorting. Sorting applies immediately and the header shows a sort arrow. | |
| Distractors: other column headers are also clickable for sorting. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: Single header interaction with visible sort indicator; only one column needs to be set correctly. | |
| success_trigger: | |
| human_readable: | |
| - Active sort model is Last seen descending (most recent first). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| sort: | |
| column_id: last_seen | |
| direction: desc | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Last seen sorted ascending (oldest first). | |
| - Sorting a different column. | |
| - Leaving the grid unsorted. | |
| expected_interaction_path: Click Last seen header until descending sort arrow is active. | |
| notes: 'Checker hint: map DataGrid sortModel (field, sort) into canonical sort state.' | |
| - id: data_table_paginated-mui-T04 | |
| name: 'Users grid: search and select the user from a reference chip' | |
| canonical_type: data_table_paginated | |
| implementation_source: mui | |
| implementation_variant: x-data-grid | |
| implementation_component: 'MUI X: DataGrid (with toolbar quick filter)' | |
| task_template: search_and_select | |
| secondary_template: null | |
| browsergym_goal: Use the search box in the Users table to find the user shown in the reference chip, then select that user's | |
| row. The task will finish automatically when done. | |
| ui_copy: Use the search box in the Users table to find the user shown in the reference chip, then select that user's row. | |
| The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Users** with a small right-side panel. | |
| Component: MUI X DataGrid with toolbar enabled (includes a quick search/quick filter text field). The grid supports checkbox row selection. | |
| Reference (mixed guidance): to the right of the grid is a **Target user** chip showing an avatar and the text **Maria Chen**. | |
| Dataset: 250 users. Maria Chen appears exactly once in the Name column and is not on the first page. | |
| Initial state: page 1; no filters; no selected rows. | |
| Controls: type into the toolbar search box to filter rows; after filtering, select the matching row via its checkbox. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: mixed | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 3 | |
| disambiguation_load: 2 | |
| justification: Requires using a toolbar search control and then selecting the correct row; the target is not visible initially. | |
| success_trigger: | |
| human_readable: | |
| - The selected row matches the reference chip user (resolved to User ID U-0137). | |
| - Exactly that one row is selected. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| reference_id: ref-user-chip-1 | |
| resolved_row_id: U-0137 | |
| selection: | |
| mode: single | |
| selected_row_ids: | |
| - U-0137 | |
| tolerance: | |
| set_mode: exact | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Filtering for Maria but selecting a different row. | |
| - Selecting multiple rows. | |
| - Typing in the search box but not selecting the row (no selection state). | |
| expected_interaction_path: Type 'Maria Chen' in quick filter → find remaining row → click its checkbox. | |
| notes: 'Checker hint: selection should be validated by canonical row_id; do not depend on filtered row count.' | |
| - id: data_table_paginated-mui-T05 | |
| name: 'Users grid: select user U-0062 (page 3)' | |
| canonical_type: data_table_paginated | |
| implementation_source: mui | |
| implementation_variant: x-data-grid | |
| implementation_component: 'MUI X: DataGrid (checkbox selection)' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: Select the row with User ID U-0062 in the Users table. The task will finish automatically when done. | |
| ui_copy: Select the row with User ID U-0062 in the Users table. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card anchored near the **bottom-left** of the viewport titled **Users**. | |
| Component: MUI X DataGrid with pagination (25 rows per page) and checkbox selection. | |
| Dataset: 250 users with sequential IDs. User **U-0062** appears on page 3 (rows 51–75). | |
| Initial state: page 1; no rows selected. | |
| Controls: use the footer pagination next/previous controls to reach page 3, then click the checkbox for the U-0062 row. | |
| Distractors: nearby IDs include U-0061 and U-0063. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: bottom_left | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 4 | |
| density_choice_interference: 3 | |
| depth_layering: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Requires pagination plus a small checkbox target among similar row IDs. | |
| success_trigger: | |
| human_readable: | |
| - 'Exactly one selected row: U-0062.' | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| selection: | |
| mode: single | |
| selected_row_ids: | |
| - U-0062 | |
| tolerance: | |
| set_mode: exact | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Selecting U-0061 or U-0063. | |
| - Selecting multiple rows. | |
| - Navigating to page 3 but not selecting the row. | |
| expected_interaction_path: Go to page 3 via next controls → locate U-0062 → click its checkbox. | |
| notes: 'Checker hint: validate selected row IDs against canonical row_id field (User ID).' | |
| - id: data_table_paginated-mui-T06 | |
| name: 'Users grid: filter Status to Active via filter panel' | |
| canonical_type: data_table_paginated | |
| implementation_source: mui | |
| implementation_variant: x-data-grid | |
| implementation_component: 'MUI X: DataGrid (toolbar filter panel)' | |
| task_template: open_and_select | |
| secondary_template: null | |
| browsergym_goal: Filter the Users table so only Status = Active rows are shown. The task will finish automatically when | |
| done. | |
| ui_copy: Filter the Users table so only Status = Active rows are shown. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: **dashboard** page with a top bar (non-interactive) and the **Users** grid in the main content area. | |
| Component: MUI X DataGrid with the built-in toolbar enabled, including a **Filters** button that opens the filter panel. The Status column supports a single filter rule. | |
| Initial state: no filters; page 1. | |
| Controls: click the toolbar Filters button → in the filter panel, set: | |
| • Column: Status | |
| • Operator: equals | |
| • Value: Active | |
| Filtering applies immediately. | |
| Clutter: dashboard shows a small stats strip (cards like "Active", "Pending") above the grid, but they are not interactive. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 3 | |
| disambiguation_load: 2 | |
| justification: Requires opening a secondary panel and setting a multi-field filter rule (column/operator/value). | |
| success_trigger: | |
| human_readable: | |
| - 'Users grid has an active filter rule: Status equals Active.' | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| filters: | |
| - column_id: status | |
| operator: equals | |
| value: Active | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Filtering to Inactive or a different status. | |
| - Setting the filter UI but leaving it empty (no active filter model). | |
| - Sorting instead of filtering. | |
| expected_interaction_path: Open Filters panel → set column Status → operator equals → value Active. | |
| notes: 'Checker hint: map DataGrid filterModel.items into canonical filters list.' | |
| - id: data_table_paginated-mui-T07 | |
| name: 'Users grid: reset filters and sorting to default view' | |
| canonical_type: data_table_paginated | |
| implementation_source: mui | |
| implementation_variant: x-data-grid | |
| implementation_component: 'MUI X: DataGrid (custom toolbar reset)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: 'Reset the Users table to its default view: no filters, no sorting, and back to page 1. The task will finish | |
| automatically when done.' | |
| ui_copy: 'Reset the Users table to its default view: no filters, no sorting, and back to page 1. The task will finish automatically | |
| when done.' | |
| setup_description: |- | |
| Layout: **settings_panel** for "User Directory". The Users grid is the main element, with a compact toolbar at the top. | |
| Component: MUI X DataGrid with a custom toolbar that includes a **Reset view** button. | |
| Initial state (important): the grid starts in a non-default state: | |
| • Filter active: Status equals Inactive | |
| • Sort active: Last seen descending | |
| • Current page: 4 | |
| Controls: clicking **Reset view** clears the filter model, clears the sort model, and returns pagination to page 1. | |
| Distractors: the settings panel also includes toggles ("Show avatars", "Show emails") above the grid; they do not affect the checker. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: settings_panel | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 3 | |
| disambiguation_load: 2 | |
| justification: Multiple table states must be cleared; a dedicated Reset control reduces interaction depth but still requires | |
| correct discovery. | |
| success_trigger: | |
| human_readable: | |
| - Pagination is on page 1. | |
| - No filters are active. | |
| - No sorting is active. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page: 1 | |
| filters: [] | |
| sort: null | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Clearing only filters but leaving sorting active (or vice versa). | |
| - Returning to page 1 but leaving a filter active. | |
| - Clicking unrelated settings toggles instead of resetting the grid state. | |
| expected_interaction_path: Locate the toolbar Reset view button → click it once → verify page 1 and neutral sort/filter. | |
| notes: 'Checker hint: allow canonical sort to be null/None when sortModel is empty.' | |
| - id: data_table_paginated-mui-T08 | |
| name: 'Users grid: multi-select three users across distant pages' | |
| canonical_type: data_table_paginated | |
| implementation_source: mui | |
| implementation_variant: x-data-grid | |
| implementation_component: 'MUI X: DataGrid (dark theme, persistent selection)' | |
| task_template: select_many | |
| secondary_template: null | |
| browsergym_goal: Select the rows for User IDs U-0020, U-0077, and U-0199 in the Users table. You will need to change pages; | |
| selected rows should remain selected when you paginate. The task will finish automatically when done. | |
| ui_copy: Select the rows for User IDs U-0020, U-0077, and U-0199 in the Users table. You will need to change pages; selected | |
| rows should remain selected when you paginate. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Users** in **dark theme**. | |
| Component: MUI X DataGrid with checkboxSelection and pagination (25 rows per page). Selection model is configured to persist across pagination (selected IDs stay selected even when not on the current page). | |
| Target IDs are on different pages: | |
| • U-0020 (page 1) | |
| • U-0077 (page 4) | |
| • U-0199 (page 8) | |
| Initial state: page 1; no rows selected. | |
| Distractors: each page contains many similar IDs; the footer navigation arrows are small in dark mode. | |
| scene_context: | |
| theme: dark | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 4 | |
| density_choice_interference: 4 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 2 | |
| justification: Cross-page exact multi-selection with small checkbox targets; dark theme reduces contrast for subtle selection | |
| states. | |
| success_trigger: | |
| human_readable: | |
| - Selected row IDs are exactly {U-0020, U-0077, U-0199}. | |
| canonical_predicate: | |
| predicate_type: set_membership | |
| target_state: | |
| selection: | |
| mode: multi | |
| selected_row_ids: | |
| - U-0020 | |
| - U-0077 | |
| - U-0199 | |
| tolerance: | |
| set_mode: exact | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Missing one of the three IDs. | |
| - Selecting additional rows beyond the three targets. | |
| - Selecting the wrong neighbor ID (e.g., U-0078 instead of U-0077). | |
| expected_interaction_path: On page 1 select U-0020 → go to page 4 select U-0077 → go to page 8 select U-0199. | |
| notes: 'Checker hint: exact set equality over selectionModel; ignore current page.' | |
| - id: data_table_paginated-mui-T09 | |
| name: 'Invite Manager dialog: configure Invited users pagination' | |
| canonical_type: data_table_paginated | |
| implementation_source: mui | |
| implementation_variant: x-data-grid | |
| implementation_component: 'MUI X: DataGrid (2 instances in modal)' | |
| task_template: table_operation | |
| secondary_template: open_overlay | |
| browsergym_goal: Open the Invite Manager dialog. In the Invited users table (not Active users), set rows per page to 10 | |
| and go to page 2. The task will finish automatically when done. | |
| ui_copy: Open the Invite Manager dialog. In the Invited users table (not Active users), set rows per page to 10 and go to | |
| page 2. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: **modal_flow**. | |
| Outside the modal: a settings page with a single button labeled **Invite Manager**. | |
| Inside the modal (after opening): there are TWO paginated tables (instances=2), stacked vertically: | |
| 1) **Active users** (top) — MUI X DataGrid with pagination. | |
| 2) **Invited users** (bottom) — MUI X DataGrid with pagination. | |
| Both grids use the same footer UI: Rows per page select and next/previous arrows. | |
| Initial state inside modal: | |
| • Active users: page 1, page size 25 | |
| • Invited users: page 1, page size 25 | |
| Task target: only the **Invited users** grid should end with page size 10 and page 2. | |
| Distractors: the modal header has Close (X) and a non-functional Help icon. No other interactions are required. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: modal_flow | |
| placement: center | |
| scale: default | |
| instances: 2 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 3 | |
| density_choice_interference: 2 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 3 | |
| disambiguation_load: 4 | |
| justification: Requires opening a modal, disambiguating between two similar grids, and setting both page size and page | |
| number correctly. | |
| success_trigger: | |
| human_readable: | |
| - Invite Manager modal is open (implicitly, because the Invited users grid state can be read). | |
| - 'Invited users grid: page size = 10 and current page = 2.' | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page_size: 10 | |
| page: 2 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Invited users | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Changing Active users grid instead of Invited users grid. | |
| - Setting page size to 10 but staying on page 1. | |
| - Going to page 2 but leaving page size at 25. | |
| expected_interaction_path: Click Invite Manager → in Invited users grid footer choose 10 rows/page → click next to reach | |
| page 2. | |
| notes: 'Instrumentation: give each grid an instance testid inside modal; ensure modal open state doesn''t block querying | |
| the grid root.' | |
| - id: data_table_paginated-mui-T10 | |
| name: 'Users grid: resize the Email column to reveal full text' | |
| canonical_type: data_table_paginated | |
| implementation_source: mui | |
| implementation_variant: x-data-grid | |
| implementation_component: 'MUI X: DataGrid (column resizing)' | |
| task_template: drag_operation | |
| secondary_template: null | |
| browsergym_goal: Resize the Email column in the Users table so the full email address in the first visible row is shown | |
| (no … truncation). The task will finish automatically when done. | |
| ui_copy: Resize the Email column in the Users table so the full email address in the first visible row is shown (no … truncation). | |
| The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card positioned near the **top-right** of the viewport. | |
| Component: MUI X DataGrid with pagination and resizable columns (default behavior). Page size is 25. | |
| Initial state: the **Email** column is intentionally narrow, causing long emails to be truncated with an ellipsis (…) | |
| Example: first row shows "alex.hend…" instead of the full address "alex.henderson@company.example.com". | |
| Controls: in the header row, the boundary between columns can be dragged to resize. Drag the right edge of the Email column header to increase its width. | |
| Scale: **small** — the column resize handle is thin and requires precise pointer control. | |
| Distractors: adjacent columns (Name, Role) are also resizable; resizing the wrong column will not satisfy the checker. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: top_right | |
| scale: small | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 4 | |
| target_acquisition: 5 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Thin drag handles plus small scale make precise column resizing difficult; success depends on achieving | |
| a minimum width/visibility threshold. | |
| success_trigger: | |
| human_readable: | |
| - Email column width is at least 200 px (or equivalently, the first row's email is not truncated). | |
| - No confirmation click is required. | |
| canonical_predicate: | |
| predicate_type: range_contains | |
| target_state: | |
| column_width_px: | |
| column_id: email | |
| min: 260 | |
| tolerance: | |
| unit: px | |
| min: 260 | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Resizing a different column (e.g., Name) while Email remains truncated. | |
| - Email column width increases but stays below the threshold (still shows ellipsis). | |
| - Horizontal scrolling without resizing. | |
| expected_interaction_path: Locate Email header → drag its right edge to the right until the first row email shows fully. | |
| notes: 'Checker note: prefer measuring rendered header cell width for column_id=''email'' to avoid string-based heuristics.' | |
| - id: data_table_paginated-mantine-T01 | |
| name: 'Products table: go to page 2' | |
| canonical_type: data_table_paginated | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Table + Pagination (composed)' | |
| task_template: navigate_to | |
| secondary_template: null | |
| browsergym_goal: In the Products table, go to page 2. The task will finish automatically when done. | |
| ui_copy: In the Products table, go to page 2. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Products**. | |
| Component: a composed Mantine implementation of a paginated table: | |
| • Mantine **Table** for the rows/columns | |
| • Mantine **Pagination** component below the table for page navigation | |
| Dataset: 120 products, 10 rows per page (12 pages total). Pagination shows numbered page buttons plus next/previous. | |
| Initial state: page 1; no selected rows; no sorting/filtering. | |
| Controls: clicking a page number updates the table immediately. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Single pagination control with visible numbered buttons and immediate page switching. | |
| success_trigger: | |
| human_readable: | |
| - Products table current page is 2 (1-based). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page: 2 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Remaining on page 1. | |
| - Navigating to page 3 instead of page 2. | |
| - Scrolling without changing the pagination page. | |
| expected_interaction_path: Click page number 2 in the Pagination component. | |
| notes: 'Implementation note: Mantine core has Table and Pagination as separate components; the page composes them into one | |
| canonical data_table_paginated component.' | |
| - id: data_table_paginated-mantine-T02 | |
| name: 'Products table: set rows per page to 25' | |
| canonical_type: data_table_paginated | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Table + Pagination + Select (page size)' | |
| task_template: open_and_select | |
| secondary_template: null | |
| browsergym_goal: Set the Products table to show 25 rows per page. The task will finish automatically when done. | |
| ui_copy: Set the Products table to show 25 rows per page. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Products**. | |
| Component: composed Mantine Table + Pagination with a small table toolbar. | |
| Toolbar (part of the table component wrapper): includes a **Rows per page** Select control with options 10, 25, 50. | |
| Initial state: page 1; rows per page = 10. | |
| Controls: open the Rows per page Select and choose **25**; the table re-renders immediately and pagination total pages decreases accordingly. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: Simple dropdown selection with clear numeric choices; state change is visible in the table. | |
| success_trigger: | |
| human_readable: | |
| - Products table rows-per-page (page_size) is 25. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page_size: 25 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Leaving page size at 10. | |
| - Setting page size to 50 instead of 25. | |
| - Changing page number without changing page size. | |
| expected_interaction_path: Open Rows per page Select → choose 25. | |
| notes: 'Checker hint: in the composite adapter, treat the toolbar Select as part of the canonical table''s pagination state.' | |
| - id: data_table_paginated-mantine-T03 | |
| name: 'Products table: sort by Price (highest first)' | |
| canonical_type: data_table_paginated | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Table + Pagination (sortable headers)' | |
| task_template: table_operation | |
| secondary_template: null | |
| browsergym_goal: Sort the Products table by Price from highest to lowest. The task will finish automatically when done. | |
| ui_copy: Sort the Products table by Price from highest to lowest. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Products**. | |
| Component: Mantine Table + Pagination composite. Column headers are interactive: each sortable header is rendered as a small button (e.g., an unstyled button) with a sort indicator. | |
| Initial state: no active sorting (neutral). | |
| Controls: click the **Price** header to toggle sorting. Sorting applies immediately; the header shows an arrow indicating direction. | |
| Distractors: other columns (Name, Category, Stock) are also sortable. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: Single header interaction with visible indicator; only the correct column and direction matter. | |
| success_trigger: | |
| human_readable: | |
| - Active sort is Price descending (highest → lowest). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| sort: | |
| column_id: price | |
| direction: desc | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Price sorted ascending. | |
| - A different column is sorted. | |
| - Neutral (unsorted) state. | |
| expected_interaction_path: Click Price header until descending indicator is shown. | |
| notes: 'Checker hint: sort state is managed by the composite wrapper; expose canonical sort state for checker.' | |
| - id: data_table_paginated-mantine-T04 | |
| name: 'Products table: search and select product from reference card' | |
| canonical_type: data_table_paginated | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Table + Pagination + Search input + selection' | |
| task_template: search_and_select | |
| secondary_template: null | |
| browsergym_goal: Use the search box in the Products table to find the product shown in the reference card, then select that | |
| product's row. The task will finish automatically when done. | |
| ui_copy: Use the search box in the Products table to find the product shown in the reference card, then select that product's | |
| row. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered, split into two areas: | |
| • Main area: Products table (Mantine Table + Pagination composite) | |
| • Side area: a **Reference Product** card | |
| Reference card (mixed guidance): shows a small product thumbnail icon and the text **Acoustic Guitar**. | |
| Table toolbar (part of the component wrapper): includes a Search TextInput labeled "Search products". Typing filters the table by Name. | |
| Dataset: 120 products. "Acoustic Guitar" appears exactly once and is not on the first page. | |
| Row selection: each row has a leading checkbox. | |
| Initial state: page 1; no filter text; no selected rows. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: mixed | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 3 | |
| disambiguation_load: 2 | |
| justification: Requires using a text filter control and then selecting the correct row; the reference card adds a match | |
| step. | |
| success_trigger: | |
| human_readable: | |
| - Selected row matches the reference product (resolved SKU-0457). | |
| - Exactly that one row is selected. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| reference_id: ref-product-card-1 | |
| resolved_row_id: SKU-0457 | |
| selection: | |
| mode: single | |
| selected_row_ids: | |
| - SKU-0457 | |
| tolerance: | |
| set_mode: exact | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Filtering for the product but selecting a different row. | |
| - Selecting multiple rows. | |
| - Typing in the search input without selecting the row. | |
| expected_interaction_path: Type 'Acoustic Guitar' in Search → table filters to the item → click its checkbox. | |
| notes: 'Checker hint: validate by selected SKU; search usage is not required for success.' | |
| - id: data_table_paginated-mantine-T05 | |
| name: 'Products table: select SKU-0137 on page 4' | |
| canonical_type: data_table_paginated | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Table + Pagination (checkbox selection)' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: Select the row with SKU SKU-0137 in the Products table. The task will finish automatically when done. | |
| ui_copy: Select the row with SKU SKU-0137 in the Products table. The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card positioned near the **top-right** of the viewport titled **Products**. | |
| Component: Mantine Table + Pagination composite with checkbox row selection. | |
| Dataset: 100 products with SKUs SKU-0100 through SKU-0199, sorted by SKU ascending. Page size is 10. | |
| Therefore, SKU-0137 appears on page 4 (rows SKU-0130…SKU-0139). | |
| Initial state: page 1; no selection. | |
| Controls: use the Pagination component to go to page 4, then click the checkbox for SKU-0137. | |
| Distractors: adjacent SKUs (SKU-0136, SKU-0138) are very similar. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: top_right | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 4 | |
| density_choice_interference: 3 | |
| depth_layering: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Requires pagination plus accurate checkbox selection among visually similar SKU values. | |
| success_trigger: | |
| human_readable: | |
| - 'Exactly one selected row: SKU-0137.' | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| selection: | |
| mode: single | |
| selected_row_ids: | |
| - SKU-0137 | |
| tolerance: | |
| set_mode: exact | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Selecting SKU-0136 or SKU-0138. | |
| - Selecting multiple rows. | |
| - Navigating to page 4 but not selecting the row. | |
| expected_interaction_path: Go to page 4 via Pagination → locate SKU-0137 row → click checkbox. | |
| notes: 'Instrumentation: render each row with data-row-id=SKU for unambiguous checker mapping.' | |
| - id: data_table_paginated-mantine-T06 | |
| name: 'Products table: clear the active search filter' | |
| canonical_type: data_table_paginated | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Table + Pagination + Search (pre-filtered)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the active search filter in the Products table so all products are shown again. The task will finish | |
| automatically when done. | |
| ui_copy: Clear the active search filter in the Products table so all products are shown again. The task will finish automatically | |
| when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Products**. | |
| Component: Mantine Table + Pagination composite with a toolbar Search TextInput. | |
| Initial state (important): the Search input already contains the text **guitar**, and the table is filtered accordingly (only matching products are shown). The Search input shows a clear (×) control on the right. | |
| Controls: clear the Search input (using the × button or by deleting text) so the table returns to the unfiltered state. | |
| Distractors: pagination remains visible but may show fewer pages while the filter is active. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Requires recognizing a pre-filtered state and clearing an input via a small clear affordance. | |
| success_trigger: | |
| human_readable: | |
| - No active filters remain (search text is empty / filter list empty). | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| filters: [] | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Search input still contains 'guitar' (filter remains). | |
| - Replacing with a different query instead of clearing. | |
| - Changing page number without clearing the filter. | |
| expected_interaction_path: Click the × clear button in the Search field (or select-all and delete). | |
| notes: 'Checker hint: treat the search query as a canonical global filter; success requires empty query.' | |
| - id: data_table_paginated-mantine-T07 | |
| name: 'Dashboard: configure Products table page size and page' | |
| canonical_type: data_table_paginated | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Table + Pagination (dashboard, 2 instances)' | |
| task_template: table_operation | |
| secondary_template: null | |
| browsergym_goal: On the dashboard, in the Products table (not Services), set rows per page to 50 and go to page 3. The task | |
| will finish automatically when done. | |
| ui_copy: On the dashboard, in the Products table (not Services), set rows per page to 50 and go to page 3. The task will | |
| finish automatically when done. | |
| setup_description: |- | |
| Layout: **dashboard** with multiple cards and higher clutter. | |
| Scene contains TWO paginated tables (instances=2), each implemented as a Mantine Table + Pagination composite: | |
| 1) **Products** table (left card) — includes a Rows per page Select and Pagination. | |
| 2) **Services** table (right card) — similar controls and styling. | |
| Both cards also include small header actions (Refresh icon, Export button) as distractors. | |
| Initial state: | |
| • Products: page 1, page size 10 | |
| • Services: page 1, page size 10 | |
| Task target: only the **Products** table should end on page size 50 and page 3. | |
| Controls: Products card toolbar has a Rows per page Select (10/25/50) and the Pagination below the table. | |
| 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: 3 | |
| target_acquisition: 3 | |
| density_choice_interference: 2 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 3 | |
| disambiguation_load: 5 | |
| justification: High clutter and two near-identical table instances require careful targeting plus multiple pagination-related | |
| state changes. | |
| success_trigger: | |
| human_readable: | |
| - 'Products table: page size is 50 and current page is 3.' | |
| - Services table state is ignored. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page_size: 50 | |
| page: 3 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Products | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Applying changes to Services table instead of Products. | |
| - Setting page size to 50 but staying on page 1. | |
| - Going to page 3 but leaving page size at 10 or 25. | |
| expected_interaction_path: 'In Products card: set Rows per page to 50 → click page 3 in Pagination.' | |
| notes: 'Instrumentation: each card should set a stable instance label/testid; scope all state reads to the instance.' | |
| - id: data_table_paginated-mantine-T08 | |
| name: 'Products table: go to last page in dark compact mode' | |
| canonical_type: data_table_paginated | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Table + Pagination (withEdges)' | |
| task_template: navigate_to | |
| secondary_template: null | |
| browsergym_goal: In the Products table, go to the last page (page 12). The task will finish automatically when done. | |
| ui_copy: In the Products table, go to the last page (page 12). The task will finish automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Products** in **dark theme** with **compact spacing**. | |
| Component: Mantine Table + Pagination composite. Pagination is configured with **withEdges** enabled, so it shows small first/last controls (double-chevron buttons) in addition to previous/next. | |
| Dataset: 120 products, 10 rows per page (12 pages). | |
| Initial state: page 1. | |
| Controls: use the Pagination controls to reach page 12. In compact/dark mode, the edge controls are small and close together. | |
| Distractors: none beyond the table and pagination. | |
| scene_context: | |
| theme: dark | |
| 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: 2 | |
| target_acquisition: 4 | |
| density_choice_interference: 2 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: Small, tightly spaced pagination controls in dark theme increase click precision demands even for a simple | |
| target page. | |
| success_trigger: | |
| human_readable: | |
| - Products table current page is 12. | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| pagination: | |
| page: 12 | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Stopping at page 11. | |
| - Using next/previous but not reaching the final page. | |
| - Changing rows per page instead of navigating pages. | |
| expected_interaction_path: Click last-page edge control (or page 12 button if visible) in Pagination. | |
| notes: 'Checker hint: page is controlled by Pagination component; expose current page in a data attribute for consistent | |
| checking.' | |
| - id: data_table_paginated-mantine-T09 | |
| name: 'Invoices table: select the row matching a visual badge reference' | |
| canonical_type: data_table_paginated | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Table + Pagination (visual badge matching)' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Select the invoice row whose Flag badge matches the reference badge shown above the table. The task will | |
| finish automatically when done. | |
| ui_copy: Select the invoice row whose Flag badge matches the reference badge shown above the table. The task will finish | |
| automatically when done. | |
| setup_description: |- | |
| Layout: isolated card centered titled **Invoices**. | |
| Component: Mantine Table + Pagination composite with checkbox selection. | |
| Visual reference (guidance=visual): above the table header, there is a small **Reference badge** area showing a single Flag badge (icon + color) with no text label. Each table row has a Flag badge in the first data column. | |
| Dataset: 120 invoices with IDs INV-0001…INV-0120, 10 rows per page. The matching badge appears on exactly one row: invoice **INV-0094**, located on page 10. | |
| Initial state: page 1; no selection. | |
| Controls: navigate using Pagination to find the row that has the same badge as the reference, then select that row's checkbox. | |
| Distractors: several badges share the same color but different icons, and vice versa, making partial matches common. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: visual | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 4 | |
| density_choice_interference: 4 | |
| depth_layering: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 2 | |
| justification: Purely visual matching plus pagination search and small selection targets; partial visual matches increase | |
| interference. | |
| success_trigger: | |
| human_readable: | |
| - The selected invoice row matches the visual reference badge (resolved to INV-0094). | |
| - Exactly that one row is selected. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| target_state: | |
| reference_id: ref-flag-badge-1 | |
| resolved_row_id: INV-0094 | |
| selection: | |
| mode: single | |
| selected_row_ids: | |
| - INV-0094 | |
| tolerance: | |
| set_mode: exact | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Selecting a row with the same color but different icon (partial match). | |
| - Selecting a row with the same icon but different color (partial match). | |
| - Selecting multiple invoice rows. | |
| expected_interaction_path: Compare reference badge → paginate to page 10 → scan Flag column → select INV-0094. | |
| notes: 'Checker note: reference badge should be programmatically linked to the resolved_row_id for deterministic checking | |
| (avoid image-based inference).' | |
| - id: data_table_paginated-mantine-T10 | |
| name: 'Dashboard: select a row in the West Region table (3 instances)' | |
| canonical_type: data_table_paginated | |
| implementation_source: mantine | |
| implementation_variant: composite | |
| implementation_component: 'Mantine: Table + Pagination (3 instances dashboard)' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: On the dashboard, in the West Region table (not North or South), select the row with Record ID SALE-0423. | |
| The task will finish automatically when done. | |
| ui_copy: On the dashboard, in the West Region table (not North or South), select the row with Record ID SALE-0423. The task | |
| will finish automatically when done. | |
| setup_description: |- | |
| Layout: **dashboard** centered in the viewport. | |
| Scene contains THREE similar paginated tables (instances=3), each a Mantine Table + Pagination composite: | |
| • **North Region** | |
| • **South Region** | |
| • **West Region** | |
| Each table shows sales records with columns: Record ID, Rep, Amount, and Date, and each has a leading checkbox selection column. | |
| Dataset: each region has 120 records (12 pages at 10 rows per page). In the **West Region** table, Record ID **SALE-0423** appears on page 5. | |
| Initial state: all three tables start on page 1 with no selected rows. | |
| Task target: only the selection state of the **West Region** table matters. | |
| Distractors: a small KPI strip and a "Download CSV" button appear above the tables but do not affect the checker. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: center | |
| scale: default | |
| instances: 3 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 3 | |
| target_acquisition: 4 | |
| density_choice_interference: 4 | |
| depth_layering: 2 | |
| feedback_dynamics: 1 | |
| semantic_observability: 4 | |
| disambiguation_load: 5 | |
| justification: Three near-identical table instances require strong disambiguation before paginating and selecting a specific | |
| row by ID. | |
| success_trigger: | |
| human_readable: | |
| - 'In the West Region table, exactly one selected row exists: SALE-0423.' | |
| canonical_predicate: | |
| predicate_type: equals | |
| target_state: | |
| selection: | |
| mode: single | |
| selected_row_ids: | |
| - SALE-0423 | |
| tolerance: | |
| set_mode: exact | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: West Region | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Selecting SALE-0423 in North or South table (wrong instance). | |
| - Selecting a different record ID (e.g., SALE-0422 or SALE-0424). | |
| - Selecting multiple rows. | |
| expected_interaction_path: Locate West Region table → go to page 5 → select row SALE-0423. | |
| notes: 'Instrumentation: each region table must have an instance label/testid so the checker can scope the selection model | |
| correctly.' | |