@thinkwise/testwise 0.2.105 → 0.2.111

package/artifact-builder/CustomActionBarGenerator.ts

@@ -0,0 +1,210 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { ISubject } from '../interfaces/ISubject.js';
+import type { ITabTask } from '../interfaces/ITabTask.js';
+import { DataRetriever } from './helpers/DataRetriever.js';
+import { NamingHandler } from './helpers/NamingHandler.js';
+import { PipelinePaths } from './helpers/PipelinePaths.js';
+
+/**
+ * **Pipeline Step 6.5** — For each subject+variant that has qualifying task
+ * buttons (written by `TaskDataBuilder`), generates a subject-specific
+ * `ActionBar` subclass with a typed getter per task, then patches the
+ * already-generated subject class file(s) to use that subclass instead of
+ * the base `ActionBar`.
+ *
+ * **Why a separate step (not baked into `SubjectGenerator`):**
+ * `SubjectGenerator` and `SubjectClassModelBuilder` run pipeline checks
+ * against the known component lists (`coreComponents`, `screenComponents`).
+ * A dynamically named type like `EmployeeEditable1ActionBar` is not in those
+ * lists and would break those checks. Running as a post-step lets the normal
+ * pipeline complete cleanly, then applies the swap after all validation has
+ * passed.
+ *
+ * **Generated file:** `test-artifacts/subjects/<SubjectFolder>/<ClassName>.ts`
+ * where `ClassName = <SubjectFolderPascal><VariantPascal>ActionBar`.
+ * Example: subject `employee`, variant `editable1` → `EmployeeEditable1ActionBar.ts`
+ *
+ * **Patching:** For each screen context (Main, Detail, Popup, Zoom) of a
+ * subject+variant with tasks, the generated `<ClassName>.ts` subject class is
+ * updated to:
+ * - Import the custom ActionBar instead of `ActionBar` from components.
+ * - Declare the `actionBar` property with the custom type.
+ * - Instantiate the custom class in the constructor.
+ *
+ * **Subject folder index.ts:** After generating each custom ActionBar file,
+ * the subject folder's `index.ts` barrel is updated to re-export it.
+ *
+ * **When it runs:** Step 6.5 of `testwise sync`, after `SubjectGenerator`
+ * (which writes and indexes subject class files) and before `SubjectRegistration`.
+ */
+export class CustomActionBarGenerator {
+  private readonly _paths: PipelinePaths;
+  private readonly _namingHandler: NamingHandler;
+  private readonly _dataRetriever: DataRetriever;
+
+  constructor(paths?: PipelinePaths) {
+    this._paths = paths ?? new PipelinePaths();
+    this._namingHandler = new NamingHandler();
+    this._dataRetriever = new DataRetriever(this._paths);
+  }
+
+  public run(): void {
+    const tabTasks = this._dataRetriever.getTabTasks();
+
+    if (tabTasks.length === 0) return;
+
+    const subjects = this._dataRetriever.getSubjectsToBuild();
+
+    const taskMap = new Map<string, ITabTask>(tabTasks.map((t) => [`${t.subject}__${t.variant}`, t]));
+
+    // Track which subject+variant combos already have a generated ActionBar file
+    const generatedActionBars = new Set<string>();
+
+    for (const subject of subjects) {
+      const key = `${subject.subject}__${subject.variant}`;
+      const taskEntry = taskMap.get(key);
+
+      if (!taskEntry || taskEntry.tasks.length === 0) continue;
+
+      const subjectFolderName = this._namingHandler.toSubjectPascalCase(subject.subject);
+      const variantPascal = subject.variant ? this._namingHandler.toPascalCase(subject.variant) : '';
+      const customActionBarClassName = `${subjectFolderName}${variantPascal}ActionBar`;
+
+      if (!generatedActionBars.has(key)) {
+        this.generateCustomActionBarFile(subjectFolderName, customActionBarClassName, taskEntry.tasks);
+        this.appendToSubjectIndex(subjectFolderName, customActionBarClassName);
+        generatedActionBars.add(key);
+      }
+
+      this.patchSubjectClassFile(subject, subjectFolderName, customActionBarClassName);
+    }
+  }
+
+  /**
+   * Writes a new `<ClassName>.ts` file to the subject's `Components/` subfolder.
+   * The class extends `ActionBar` and adds one getter per qualifying task ID.
+   */
+  private generateCustomActionBarFile(subjectFolderName: string, className: string, taskIds: string[]): void {
+    const componentsFolderPath = this._paths.subjectComponentsFolder(subjectFolderName);
+
+    if (!fs.existsSync(this._paths.subjectFolder(subjectFolderName))) return;
+
+    if (!fs.existsSync(componentsFolderPath)) {
+      fs.mkdirSync(componentsFolderPath, { recursive: true });
+    }
+
+    const getters = taskIds
+      .map((taskId) => {
+        const getterName = this.taskIdToGetterName(taskId);
+        return `  get ${getterName}(): Locator {\n    return this.getTaskButtonById('${this.taskIdToTestId(taskId)}');\n  }`;
+      })
+      .join('\n\n');
+
+    const content = [
+      `import type { Locator } from '@playwright/test';`,
+      `import { ActionBar } from '../../../../components/index.js';`,
+      ``,
+      `export class ${className} extends ActionBar {`,
+      getters,
+      `}`,
+      ``
+    ].join('\n');
+
+    fs.writeFileSync(path.join(componentsFolderPath, `${className}.ts`), content, 'utf-8');
+  }
+
+  /**
+   * Appends the custom ActionBar export to the subject folder's `index.ts` barrel.
+   * `SubjectGenerator.indexGeneratedSubjects()` runs before this step, so the
+   * barrel already exists but does not yet include the custom ActionBar file.
+   */
+  private appendToSubjectIndex(subjectFolderName: string, className: string): void {
+    const indexPath = path.join(this._paths.subjectFolder(subjectFolderName), 'index.ts');
+
+    if (!fs.existsSync(indexPath)) return;
+
+    const exportLine = `export { ${className} } from './Components/${className}.js';`;
+    const existing = fs.readFileSync(indexPath, 'utf-8');
+
+    if (existing.includes(exportLine)) return;
+
+    fs.writeFileSync(indexPath, `${existing}\n${exportLine}`, 'utf-8');
+  }
+
+  /**
+   * Reads the generated subject class file for one screen context and applies
+   * three targeted text replacements to swap in the custom ActionBar type.
+   */
+  private patchSubjectClassFile(subject: ISubject, subjectFolderName: string, customActionBarClassName: string): void {
+    const className = this._namingHandler.generateSubjectClassName(subject);
+    const filePath = path.join(this._paths.subjectFolder(subjectFolderName), `${className}.ts`);
+
+    if (!fs.existsSync(filePath)) return;
+
+    let content = fs.readFileSync(filePath, 'utf-8');
+
+    content = this.swapActionBarImport(content, customActionBarClassName);
+    content = content.split(': ActionBar').join(`: ${customActionBarClassName}`);
+    content = content.split(': CustomActionBar').join(`: ${customActionBarClassName}`);
+    content = content.split('new ActionBar(').join(`new ${customActionBarClassName}(`);
+    content = content.split('new CustomActionBar(').join(`new ${customActionBarClassName}(`);
+
+    fs.writeFileSync(filePath, content, 'utf-8');
+  }
+
+  /**
+   * Removes `ActionBar` and `CustomActionBar` from the core components import
+   * and inserts a subject-local import for the generated subclass.
+   */
+  private swapActionBarImport(content: string, customActionBarClassName: string): string {
+    const customImport = `import { ${customActionBarClassName} } from './Components/${customActionBarClassName}.js';`;
+
+    // Remove ActionBar / CustomActionBar from the components barrel import
+    content = content.replace(
+      /^import \{ ([^}]+) \} from '\.\.\/\.\.\/\.\.\/components\/index\.js';$/m,
+      (_, imports: string) => {
+        const remaining = imports
+          .split(',')
+          .map((i) => i.trim())
+          .filter((i) => i !== 'ActionBar' && i !== 'CustomActionBar');
+
+        if (remaining.length === 0) return '';
+        return `import { ${remaining.join(', ')} } from '../../../components/index.js';`;
+      }
+    );
+
+    // Insert the subject-local import before the @playwright/test import line
+    content = content.replace(/^(import type \{ Page \} from '@playwright\/test';)/m, `${customImport}\n$1`);
+
+    return content;
+  }
+
+  /**
+   * Converts a Thinkwise task ID (kebab-case or snake_case) to a camelCase getter
+   * name with a `Button` suffix for consistent, discoverable naming.
+   *
+   * Examples:
+   * - `"supplier-item-add"` → `"supplierItemAddButton"`
+   * - `"pf_run_prefilter_mand_on"` → `"pfRunPrefilterMandOnButton"`
+   * - `"deactivate"` → `"deactivateButton"`
+   */
+  private taskIdToGetterName(taskId: string): string {
+    const camel = taskId.replace(/[-_]([a-z0-9])/g, (_, c: string) => c.toUpperCase());
+    return `${camel}Button`;
+  }
+
+  /**
+   * Converts a Thinkwise task ID to the id the action bar renders in its
+   * `actionbar__task__<id>` test id: lowercase, with underscores replaced by
+   * hyphens. This is the same model-to-DOM rule the pipeline applies to column
+   * and screen type ids (see `SelectorBuilder`).
+   *
+   * Examples:
+   * - `"pf_run_prefilter_mand_on"` → `"pf-run-prefilter-mand-on"`
+   * - `"supplier-item-add"` → `"supplier-item-add"` (unchanged)
+   */
+  private taskIdToTestId(taskId: string): string {
+    return taskId.toLowerCase().replace(/_/g, '-');
+  }
+}

package/artifact-builder/InterfaceGenerator.ts

@@ -108,7 +108,10 @@ export class InterfaceGenerator {
 
       let updatedContent = result.lines.join('\n');
 
-      updatedContent = updatedContent.replace(/interface\s+\w+/, `interface ${correctInterfaceName}`);
+      // Match the whole name quicktype gave the interface, up to whitespace, `{` or a type parameter.
+      // `\w+` stopped at the first non-ASCII letter, so a screen type such as "Algemeen hiërarchie"
+      // left the tail of the old name behind and the generated file did not compile.
+      updatedContent = updatedContent.replace(/interface\s+[^\s{<]+/, `interface ${correctInterfaceName}`);
 
       const formattedContent = await prettier.format(updatedContent, {
         parser: 'typescript',

package/artifact-builder/ScreenInterfaceRefiner.ts

@@ -151,7 +151,13 @@ export class ScreenInterfaceRefiner {
   }
 
   private findInterfaces(content: string): string[] {
-    const interfaceRegex = /export interface (\w+) \{[\s\S]*?\}/g;
+    // `\w` is ASCII-only. A screen type such as "Algemeen hiërarchie" gives the screen interface a
+    // non-ASCII name, which `\w+` skipped, so the first component placeholder was taken for the screen.
+    // `pascalCase` builds that name from letters, digits and `_`, and changing the case of a few letters
+    // adds a separate mark (`\p{M}`): Turkish "İ" lower-cases to "i" plus U+0307. The rename in
+    // `InterfaceGenerator` matches any character up to whitespace, `{` or `<`; this pattern lists the
+    // characters instead, because `getPlaceholderInterfaces()` puts the names it finds into a RegExp.
+    const interfaceRegex = /export interface ([\p{L}\p{M}\p{N}_]+) \{[\s\S]*?\}/gu;
     const interfaces = [];
     let match = interfaceRegex.exec(content);
 

package/artifact-builder/SubjectComponentGenerator.ts

@@ -88,7 +88,13 @@ export class SubjectComponentGenerator {
 
     componentFile.content = refineComponentInterface(componentFile.content, componentName as SubjectComponents);
 
-    const interfaceMatches: RegExpMatchArray | null = componentFile.content.match(/export interface (\w+) extends/);
+    // The interface is named after the subject, and a subject id can have any letter: "algemeen_hiërarchie" gives
+    // `AlgemeenHiërarchieForm`. `\w+` is ASCII-only, so such a component got no class, and the subject class that
+    // imports it did not compile. Same characters as `ScreenInterfaceRefiner.findInterfaces()`, including the mark
+    // (`\p{M}`) that changing case adds to a few letters. They are listed because the name goes into a RegExp below.
+    const interfaceMatches: RegExpMatchArray | null = componentFile.content.match(
+      /export interface ([\p{L}\p{M}\p{N}_]+) extends/u
+    );
 
     if (interfaceMatches) {
       const mainInterface = interfaceMatches[1];

package/artifact-builder/SubjectRegistration.ts

@@ -138,7 +138,10 @@ export class SubjectRegistration {
 
       tsFiles.forEach((tsFile) => {
         const classContent = fs.readFileSync(path.join(folderPath, tsFile), 'utf-8');
-        const classMatches = classContent.matchAll(/export\s+class\s+(\w+)/g);
+        // A subject or variant id can have any letter: "algemeen_hiërarchie" gives `AlgemeenHiërarchieMain`. `\w+`
+        // is ASCII-only and stopped at the "ë", so the class was left out of the registry. Same characters as
+        // `ScreenInterfaceRefiner.findInterfaces()`, including the mark (`\p{M}`) that changing case adds.
+        const classMatches = classContent.matchAll(/export\s+class\s+([\p{L}\p{M}\p{N}_]+)/gu);
 
         for (const match of classMatches) {
           const className = match[1];

package/artifact-builder/TaskDataBuilder.ts

@@ -0,0 +1,71 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** biome-ignore-all lint/suspicious/noExplicitAny: Because I can */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type { ITabTask } from '../interfaces/ITabTask.js';
+import { indiciumApi } from '../services/IndiciumApi.service.js';
+import { DataRetriever } from './helpers/DataRetriever.js';
+import { PipelinePaths } from './helpers/PipelinePaths.js';
+
+/**
+ * **Pipeline Step 1.5** — Fetches task button data from the Indicium API
+ * (`i_ui_tab_task`) for the verified GUI application and writes qualifying
+ * entries to `seed-data/tab-tasks.json`.
+ *
+ * **Qualifying tasks:** A task qualifies when `custom_display_type` is absent
+ * or not equal to `4`. Tasks where `custom_display_type === 4` are special
+ * UI elements (not standard toolbar buttons) and are excluded from typed
+ * ActionBar generation.
+ *
+ * **Output format:** An array of `ITabTask` objects — one per subject+variant
+ * that has at least one qualifying task. If all tasks for a given subject+variant
+ * are `custom_display_type === 4`, no entry is written for that pair (it will
+ * receive a plain `ActionBar` during subject class generation).
+ *
+ * **When it runs:** Step 1.5 of `testwise sync`, after `buildSubjects` and
+ * `buildScreens` but before `ModelDataRefiner`. Fetching here (pre-refinement)
+ * means the full model is queried once and the data is available for all
+ * registered subjects during Phase 4.
+ */
+export async function buildTaskData(): Promise<void> {
+  if (!(await indiciumApi.canConnectToProject())) {
+    console.log('Cannot connect to Indicium API. Aborting task data build.');
+    return;
+  }
+
+  const rawTasks: any[] = await indiciumApi.getTabTasks();
+
+  // Group by subject+variant, keeping only qualifying tasks
+  const grouped = new Map<string, { subject: string; variant: string; tasks: string[] }>();
+
+  for (const raw of rawTasks) {
+    const subject: string = raw.tab_id;
+    const variant: string = raw.tab_variant_id;
+    const taskId: string = raw.task_id;
+    const customDisplayType: number | undefined = raw.custom_display_type;
+
+    // Skip tasks rendered with a special custom display type (not a standard button)
+    if (customDisplayType === 4) continue;
+
+    const key = `${subject}__${variant}`;
+
+    if (!grouped.has(key)) {
+      grouped.set(key, { subject, variant, tasks: [] });
+    }
+
+    grouped.get(key)?.tasks.push(taskId);
+  }
+
+  const result: ITabTask[] = [...grouped.values()];
+
+  const paths = new PipelinePaths();
+  const tabTasksPath = paths.tabTasksJson;
+
+  await fs.mkdir(path.dirname(tabTasksPath), { recursive: true });
+  await fs.writeFile(tabTasksPath, JSON.stringify(result, null, 2), 'utf-8');
+  console.log(`Task data written to ${tabTasksPath}`);
+
+  // Verify using DataRetriever to confirm the file was written correctly
+  const written = new DataRetriever(paths).getTabTasks();
+  console.log(`Task data verified: ${written.length} subject+variant combination(s) with qualifying tasks.`);
+}

package/artifact-builder/helpers/DataRetriever.ts

@@ -1,6 +1,7 @@
 import * as fs from 'node:fs';
 import type { IRegisteredSubjects } from '../../interfaces/IRegisteredSubjects.js';
 import type { ISubject } from '../../interfaces/ISubject.js';
+import type { ITabTask } from '../../interfaces/ITabTask.js';
 import { PipelinePaths } from './PipelinePaths.js';
 
 /**
@@ -89,6 +90,16 @@ export class DataRetriever {
     return result;
   }
 
+  public getTabTasks(): ITabTask[] {
+    const tabTasksPath = this._paths.tabTasksJson;
+
+    if (!fs.existsSync(tabTasksPath)) {
+      return [];
+    }
+
+    return this.parseJsonFile<ITabTask[]>(tabTasksPath);
+  }
+
   public getSeedDataDirectory(): string {
     return this._paths.seedData;
   }

package/artifact-builder/helpers/PipelinePaths.ts

@@ -64,6 +64,11 @@ export class PipelinePaths {
     return path.join(this._consumerRoot, 'seed-data', 'registeredSubjects.json');
   }
 
+  /** `<package>/seed-data/tab-tasks.json` */
+  get tabTasksJson(): string {
+    return path.join(this.seedData, 'tab-tasks.json');
+  }
+
   // ── Package root – generated artifacts ─────────────────────────────────
 
   /** `<package>/test-artifacts/` */

package/artifact-builder/index.ts

@@ -1,5 +1,6 @@
 export * from './ArtifactManager.js';
 export * from './ComponentClassModelBuilder.js';
+export * from './CustomActionBarGenerator.js';
 export * from './helpers/index.js';
 export * from './InterfaceGenerator.js';
 export * from './ModelDataRefiner.js';
@@ -9,5 +10,6 @@ export * from './SubjectClassModelBuilder.js';
 export * from './SubjectComponentGenerator.js';
 export * from './SubjectGenerator.js';
 export * from './SubjectRegistration.js';
+export * from './TaskDataBuilder.js';
 export * from './TsFileModel.js';
 export * from './TsFileSerializer.js';

package/components/action-bar/ActionBarObjects.ts

@@ -73,7 +73,9 @@ export class ActionBarOverflowableObjects extends BaseComponentObjects {
   // Tasks: data-testid like: "actionbar__task__<something>"
   public taskButtons = () => this.context.locator('[data-testid^="actionbar__task__"]');
 
-  public taskButtonById = (id: string) => this.context.getByTestId(`actionbar__task__${id}`);
+  // The model's snake_case task id is rendered kebab-case, so both forms of the id resolve
+  public taskButtonById = (id: string) =>
+    this.context.getByTestId(`actionbar__task__${id.toLowerCase().replace(/_/g, '-')}`);
 
   public taskButtonByLabel = (label: string) =>
     this.context.locator('[data-testid^="actionbar__task__"]').filter({ hasText: label });

package/components/filter/FilterPopup.ts

@@ -1,4 +1,6 @@
 import type { Locator, Page } from '@playwright/test';
+import { isoToLocaleDigits } from '../../helpers/DateFormat.js';
+import { getDateLocale } from '../../helpers/DateLocaleHelper.js';
 import { PopUpComponent } from '../pop-up/PopUpComponent.js';
 import { FilterPopupObjects } from './FilterPopupObjects.js';
 
@@ -81,9 +83,16 @@ export class FilterPopup {
   }
 
   public async saveAsPrefilterPopup(name: string): Promise<void> {
-    await this.waitForOpen();
-    await this._filterPopupObjects.prefilterNameInput().fill(name);
-    await this._filterPopupObjects.saveButton().click();
+    const nameInput = this._filterPopupObjects.prefilterNameInput();
+    await nameInput.waitFor({ state: 'visible' });
+    await nameInput.fill(name);
+    await this._filterPopupObjects.prefilterSaveButton().click();
+
+    // "Save as prefilter" is a modal stacked on top of the filter popup, so saving unwinds
+    // TWO backdrops. Without waiting for both to detach this returns while a backdrop is
+    // still animating out, and the caller's next click gets intercepted.
+    await nameInput.waitFor({ state: 'hidden' });
+    await this._filterPopupObjects.applyFilterButton().waitFor({ state: 'hidden' });
   }
   public async setAdvanced(enabled: boolean): Promise<void> {
     await this.waitForOpen();
@@ -140,6 +149,31 @@ export class FilterPopup {
     await this._filterPopupObjects.valueInput(args.fieldId, args.part).press('Tab');
   }
 
+  /**
+   * Enter a date into a filter date input from a canonical ISO string
+   * (`YYYY-MM-DD` or `YYYY-MM-DD HH:mm:ss`). Reads the app's active date locale,
+   * reorders the digits to the picker's expected order, types them sequentially,
+   * and blurs to commit — so the same ISO value applies the same real date under
+   * any locale. Use this instead of {@link setValue} for date/date-time parts
+   * (e.g. interval `date` inputs).
+   *
+   * @param args.fieldId - The filter field/column id.
+   * @param args.value - Canonical ISO date or date-time string.
+   * @param args.part - The value part to target (defaults to `date`).
+   */
+  public async setDate(args: { fieldId: string; value: string; part?: string }): Promise<void> {
+    await this.waitForOpen();
+    const part = args.part ?? 'date';
+    const input = this._filterPopupObjects.valueInput(args.fieldId, part);
+    const locale = await getDateLocale(this.page);
+    const digits = isoToLocaleDigits(args.value, locale);
+
+    await input.click();
+    await input.press('ControlOrMeta+a');
+    await input.pressSequentially(digits);
+    await input.press('Tab');
+  }
+
   public async openControl(fieldId: string, part: string): Promise<void> {
     await this.waitForOpen();
     await this._filterPopupObjects.fieldControl(fieldId, part).click();
@@ -155,24 +189,53 @@ export class FilterPopup {
     await this._filterPopupObjects.timeOperatorControl().click();
   }
 
-  public intervalSelector(colId: string): Locator {
-    return this._filterPopupObjects.intervalSelector(colId);
+  /**
+   * One of a date column's interval selectors. Universal 2026.3.11 and later add the next interval condition row
+   * as soon as a row has a value, so a column can have several.
+   *
+   * @param colId - The column id.
+   * @param options.index - Which of the column's interval selectors, counting from 0 at the top. Defaults to 0.
+   */
+  public intervalSelector(colId: string, options?: { index?: number }): Locator {
+    return this._filterPopupObjects.intervalSelector(colId, options?.index);
   }
 
-  public intervalSelectorInput(colId: string): Locator {
-    return this._filterPopupObjects.intervalSelectorInput(colId);
+  /**
+   * The input of one of a date column's interval selectors, see {@link intervalSelector}.
+   *
+   * @param colId - The column id.
+   * @param options.index - Which of the column's interval selectors, counting from 0 at the top. Defaults to 0.
+   */
+  public intervalSelectorInput(colId: string, options?: { index?: number }): Locator {
+    return this._filterPopupObjects.intervalSelectorInput(colId, options?.index);
   }
 
-  public async openInterval(colId: string, options?: { rowIndex?: number }): Promise<void> {
+  /**
+   * Opens one of a date column's interval selectors, see {@link intervalSelector}.
+   *
+   * @param colId - The column id.
+   * @param options.index - Which of the column's interval selectors, counting from 0 at the top. Defaults to 0.
+   * @param options.rowIndex - A row number of the advanced filter grid instead, as in its test ids. Wins over
+   *   `index`. It also counts the other columns' rows, and it changes when the pop-up reopens with the active
+   *   filters at the top, so `index` is easier to use.
+   */
+  public async openInterval(colId: string, options?: { index?: number; rowIndex?: number }): Promise<void> {
     await this.waitForOpen();
-    if (options?.rowIndex !== undefined) {
-      await this._filterPopupObjects.intervalSelectorInputByRowIndex(options.rowIndex, colId).click();
-    } else {
-      await this._filterPopupObjects.intervalSelectorInput(colId).click();
-    }
+    const input =
+      options?.rowIndex !== undefined
+        ? this._filterPopupObjects.intervalSelectorInputByRowIndex(options.rowIndex, colId)
+        : this.intervalSelectorInput(colId, options);
+    await input.click();
   }
 
-  public async setInterval(colId: string, kind: IntervalType, options?: { rowIndex?: number }): Promise<void> {
+  /**
+   * Picks an interval in one of a date column's interval selectors, see {@link openInterval} for `options`.
+   */
+  public async setInterval(
+    colId: string,
+    kind: IntervalType,
+    options?: { index?: number; rowIndex?: number }
+  ): Promise<void> {
     await this.openInterval(colId, options);
     await this.pickAutocomplete(kind);
   }

package/components/filter/FilterPopupObjects.ts

@@ -28,6 +28,14 @@ export class FilterPopupObjects extends BaseComponentObjects {
 
   public prefilterNameInput = () => this.context.getByTestId('prefilter__name__input');
 
+  public saveAsPopup = () =>
+    this._page
+      .locator('[role="dialog"]')
+      .filter({ has: this._page.getByTestId('prefilter__name__input') })
+      .last();
+
+  public prefilterSaveButton = () => this.saveAsPopup().getByRole('button', { name: 'Save' });
+
   public saveAsOption = () => this._page.getByRole('menuitem', { name: 'Save' });
 
   public saveButton = () => this._page.getByRole('button', { name: 'Save' });
@@ -46,9 +54,15 @@ export class FilterPopupObjects extends BaseComponentObjects {
   public timeOperatorControl = () =>
     this.context.getByTestId('form-field__event-time__operator__control').getByRole('button', { name: 'Open' });
 
-  public intervalSelector = (colId: string) => this.context.locator(`[data-testid$="__${colId}__select-interval"]`);
+  // Universal 2026.3.11 and later add the next date interval condition row as soon as a row has a value
+  // (Universal PR 21830), so a column can show several interval selectors. `index` counts only the column's
+  // own selectors, from the top. A row number in the test id also counts the other columns' rows, and it
+  // changes when the pop-up reopens with the active filters at the top.
+  public intervalSelector = (colId: string, index = 0) =>
+    this.context.locator(`[data-testid$="__${colId}__select-interval"]`).nth(index);
 
-  public intervalSelectorInput = (colId: string) => this.intervalSelector(colId).getByTestId('select-interval__input');
+  public intervalSelectorInput = (colId: string, index = 0) =>
+    this.intervalSelector(colId, index).getByTestId('select-interval__input');
 
   public intervalSelectorByRowIndex = (rowIndex: number, colId: string) =>
     this.context.getByTestId(`advanced-filter-grid__row${rowIndex}__${colId}__select-interval`);
@@ -60,9 +74,16 @@ export class FilterPopupObjects extends BaseComponentObjects {
 
   public emptySelectFieldRow = () => this.context.getByTestId('advanced-filter-grid__row-empty-select-field');
 
-  public emptySelectFieldRowButton = () => this.emptySelectFieldRow().getByRole('button');
+  // The field picker is an MUI Select. Universal 2026.3.11 and later (MUI v6) render it with
+  // role="combobox", Universal 2026.3.10.1 and earlier (MUI 5.12.3) with role="button".
+  // Accept both so these selectors work on every supported Universal version.
+  public emptySelectFieldRowButton = () =>
+    this.emptySelectFieldRow().getByRole('combobox').or(this.emptySelectFieldRow().getByRole('button'));
 
-  public selectFieldButton = () => this._page.getByRole('button', { name: 'Select field' });
+  public selectFieldButton = () =>
+    this._page
+      .getByRole('combobox', { name: 'Select field' })
+      .or(this._page.getByRole('button', { name: 'Select field' }));
 
   public addFieldButton = () => this._page.getByRole('button', { name: 'Add field' });
 

package/components/grid/Grid.ts

@@ -121,6 +121,29 @@ export class Grid {
     return Array.from(collected);
   }
 
+  /**
+   * Retrieves the cell in the grid's pinned bottom summary row for a specified column.
+   *
+   * Only present when the subject has grid summaries (count/sum) configured on the column.
+   */
+  public getSummaryCellByColId(colId: string): Locator {
+    return this._gridObjects.summaryCellsByColumnId(colId);
+  }
+
+  /**
+   * Gets the summary value for a specified column, or `null` when the subject has no
+   * grid summary configured for it.
+   */
+  public async getSummaryValueByColId(colId: string): Promise<string | null> {
+    const summaryCell = this._gridObjects.summaryCellsByColumnId(colId);
+    if ((await summaryCell.count()) === 0) {
+      return null;
+    }
+
+    const value = await summaryCell.first().textContent();
+    return value === null ? null : value.trim();
+  }
+
   /**
    * Retrieves all column header values from the grid.
    *
@@ -216,6 +239,20 @@ export class Grid {
     return this._gridObjects.rows();
   }
 
+  /**
+   * Makes a row the active record by clicking one of its cells.
+   *
+   * Pass a read-only column. Clicking a row's centre, as `rows().nth(i).click()` does,
+   * lands on whichever cell happens to sit mid-row; on an auto-edit grid that opens an
+   * editor and dirties the record instead of selecting it.
+   *
+   * @param rowIndex Zero-based index of the row within the grid body.
+   * @param colId Column to click, e.g. the primary key column.
+   */
+  public async selectRowByIndex(rowIndex: number, colId: string): Promise<void> {
+    await this._gridObjects.cellByRowIndexAndColumnId(rowIndex, colId).click();
+  }
+
   /**
    * Verifies the number of records in the grid and checks for "No result" overlay if zero.
    * @param expectedRecordCount The expected number of records.
@@ -230,7 +267,8 @@ export class Grid {
     }
 
     await pollUntil(() => this.rows().count(), {
-      predicate: (n: number) => n === expectedRecordCount + 1 // +1 to account for header row
+      predicate: (n: number) => n === expectedRecordCount,
+      description: `the grid to show ${expectedRecordCount} records`
     });
   }
 
@@ -243,7 +281,7 @@ export class Grid {
 
     const hasCorrectWording = await pollUntil(
       async () => (await overlay.textContent())?.trim().includes('No result') ?? false,
-      { predicate: Boolean }
+      { predicate: Boolean, description: 'the grid to show the "No result" overlay' }
     );
 
     return hasCorrectWording && (await overlay.isVisible());