@razohq/razo 0.1.0

package/dist/index.mjs

@@ -0,0 +1,892 @@
+import {
+  AI_STEP_ATTACHMENT,
+  emitStepEvent,
+  stripAnsi
+} from "./chunk-UCLP2ILU.mjs";
+
+// src/controls/Control.ts
+import { expect, test } from "@playwright/test";
+var SENTENCES = {
+  click: (c) => `Click ${c.controlType} "${c.name}"`,
+  fill: (c) => `Type "${c.detail}" into ${c.controlType} "${c.name}"`,
+  clear: (c) => `Clear ${c.controlType} "${c.name}"`,
+  select: (c) => `Select option "${c.detail}" in ${c.controlType} "${c.name}"`,
+  check: (c) => `Check ${c.controlType} "${c.name}"`,
+  uncheck: (c) => `Uncheck ${c.controlType} "${c.name}"`,
+  choose: (c) => `Choose "${c.detail}" in ${c.controlType} "${c.name}"`,
+  "choose-many": (c) => `Choose options "${c.detail}" in ${c.controlType} "${c.name}"`,
+  open: (c) => `Open ${c.controlType} "${c.name}"`,
+  attach: (c) => `Attach "${c.detail}" to ${c.controlType} "${c.name}"`,
+  set: (c) => `Set ${c.controlType} "${c.name}" to "${c.detail}"`,
+  "assert-visible": (c) => `Assert ${c.controlType} "${c.name}" is visible`,
+  "assert-enabled": (c) => `Assert ${c.controlType} "${c.name}" is enabled`,
+  "assert-disabled": (c) => `Assert ${c.controlType} "${c.name}" is disabled`,
+  "assert-text": (c) => `Assert ${c.controlType} "${c.name}" has text "${c.expected}"`,
+  "assert-checked": (c) => `Assert ${c.controlType} "${c.name}" is checked`,
+  "assert-unchecked": (c) => `Assert ${c.controlType} "${c.name}" is not checked`,
+  "assert-selected": (c) => `Assert ${c.controlType} "${c.name}" has option "${c.expected}" selected`,
+  "assert-value": (c) => `Assert ${c.controlType} "${c.name}" has value "${c.expected}"`,
+  "assert-href": (c) => `Assert ${c.controlType} "${c.name}" points to "${c.expected}"`,
+  // Universal interactions
+  hover: (c) => `Hover over ${c.controlType} "${c.name}"`,
+  "double-click": (c) => `Double-click ${c.controlType} "${c.name}"`,
+  "right-click": (c) => `Right-click ${c.controlType} "${c.name}"`,
+  press: (c) => `Press "${c.detail}" on ${c.controlType} "${c.name}"`,
+  focus: (c) => `Focus ${c.controlType} "${c.name}"`,
+  "scroll-to": (c) => `Scroll to ${c.controlType} "${c.name}"`,
+  // detail carries the drop target already rendered as `type "name"`
+  drag: (c) => `Drag ${c.controlType} "${c.name}" onto ${c.detail}`,
+  // Universal assertions
+  "assert-hidden": (c) => `Assert ${c.controlType} "${c.name}" is hidden`,
+  "assert-focused": (c) => `Assert ${c.controlType} "${c.name}" is focused`,
+  "assert-contains-text": (c) => `Assert ${c.controlType} "${c.name}" contains text "${c.expected}"`,
+  "assert-attribute": (c) => `Assert ${c.controlType} "${c.name}" attribute "${c.detail}" is "${c.expected}"`,
+  "assert-empty": (c) => `Assert ${c.controlType} "${c.name}" is empty`,
+  // Switch
+  "turn-on": (c) => `Turn on ${c.controlType} "${c.name}"`,
+  "turn-off": (c) => `Turn off ${c.controlType} "${c.name}"`,
+  "assert-on": (c) => `Assert ${c.controlType} "${c.name}" is on`,
+  "assert-off": (c) => `Assert ${c.controlType} "${c.name}" is off`,
+  // Combobox
+  pick: (c) => `Pick "${c.detail}" in ${c.controlType} "${c.name}"`,
+  // Table
+  "assert-row-count": (c) => `Assert ${c.controlType} "${c.name}" has ${c.expected} rows`,
+  "assert-row-contains": (c) => `Assert ${c.controlType} "${c.name}" has a row containing "${c.expected}"`,
+  // Dialog
+  close: (c) => `Close ${c.controlType} "${c.name}"`,
+  "assert-open": (c) => `Assert ${c.controlType} "${c.name}" is open`,
+  "assert-closed": (c) => `Assert ${c.controlType} "${c.name}" is closed`,
+  // Tabs
+  "open-tab": (c) => `Open tab "${c.detail}" in ${c.controlType} "${c.name}"`,
+  "assert-active-tab": (c) => `Assert ${c.controlType} "${c.name}" has active tab "${c.expected}"`,
+  // Image
+  "assert-alt": (c) => `Assert ${c.controlType} "${c.name}" has alt text "${c.expected}"`,
+  "assert-loaded": (c) => `Assert ${c.controlType} "${c.name}" is loaded`,
+  // DatePicker
+  "pick-date": (c) => `Pick date "${c.detail}" in ${c.controlType} "${c.name}"`,
+  // Collections
+  "assert-count": (c) => `Assert ${c.controlType} "${c.name}" appears ${c.expected} times`,
+  // Tooltip
+  "assert-tooltip": (c) => `Assert ${c.controlType} "${c.name}" says "${c.expected}"`
+};
+var IMPLICIT_ROLE = {
+  button: "button",
+  link: "link",
+  checkbox: "checkbox",
+  "radio group": "radiogroup",
+  switch: "switch",
+  field: "textbox",
+  "text area": "textbox",
+  // Single-choice <select>; a `multiple` select is a listbox and will simply
+  // not match the count()===1 guard — it fails safe instead of mis-healing.
+  select: "combobox",
+  combobox: "combobox",
+  slider: "slider",
+  dialog: "dialog",
+  menu: "menu",
+  tabs: "tablist",
+  image: "img",
+  table: "table"
+};
+function healingMode() {
+  const value = process.env.RAZO_HEALING;
+  return value === "fail" || value === "off" ? value : "pass";
+}
+function resolveLocator(root, spec) {
+  if (typeof spec === "string") return root.getByTestId(spec);
+  if ("testId" in spec) return root.getByTestId(spec.testId);
+  if ("role" in spec) return root.getByRole(spec.role, { name: spec.name, exact: spec.exact });
+  if ("label" in spec) return root.getByLabel(spec.label, { exact: spec.exact });
+  if ("placeholder" in spec) return root.getByPlaceholder(spec.placeholder);
+  if ("text" in spec) return root.getByText(spec.text, { exact: spec.exact });
+  if ("altText" in spec) return root.getByAltText(spec.altText);
+  if ("title" in spec) return root.getByTitle(spec.title);
+  if ("css" in spec) return root.locator(spec.css);
+  return spec.locator;
+}
+function describeSelector(spec) {
+  if (typeof spec === "string") return `[data-testid="${spec}"]`;
+  if ("testId" in spec) return `[data-testid="${spec.testId}"]`;
+  if ("role" in spec) return spec.name ? `role=${spec.role}[name="${spec.name}"]` : `role=${spec.role}`;
+  if ("label" in spec) return `label="${spec.label}"`;
+  if ("placeholder" in spec) return `placeholder="${spec.placeholder}"`;
+  if ("text" in spec) return `text="${spec.text}"`;
+  if ("altText" in spec) return `alt="${spec.altText}"`;
+  if ("title" in spec) return `title="${spec.title}"`;
+  if ("css" in spec) return `css=${spec.css}`;
+  return String(spec.locator);
+}
+var Control = class {
+  constructor(page, locate, name, options = {}) {
+    this.page = page;
+    this.name = name;
+    if (!name || !name.trim()) {
+      throw new Error(
+        `Control located by ${describeSelector(locate)} needs a human-readable name: an anonymous control breaks the narration.`
+      );
+    }
+    this.testId = typeof locate === "string" ? locate : "testId" in locate ? locate.testId : "";
+    this.parent = options.within;
+    this.fallbacks = options.fallbacks ?? [];
+    this._locator = resolveLocator(this.healRoot, locate);
+    this._selector = this.withinPrefix + describeSelector(locate);
+  }
+  page;
+  name;
+  /** @deprecated Only set when the control was located by testid; use `selector`. */
+  testId;
+  // Mutable internals so deterministic healing can re-point the control; the
+  // public surface stays read-only.
+  _locator;
+  _selector;
+  parent;
+  fallbacks;
+  /**
+   * Root that fallbacks resolve against — read lazily so a child control
+   * follows its `within` parent even after the PARENT healed.
+   */
+  get healRoot() {
+    return this.parent?.locator ?? this.page;
+  }
+  get withinPrefix() {
+    return this.parent ? `${this.parent.selector} ` : "";
+  }
+  /** The Playwright locator currently backing this control. */
+  get locator() {
+    return this._locator;
+  }
+  /** Readable selector, chained through `within` parents; travels in every StepEvent. */
+  get selector() {
+    return this._selector;
+  }
+  /**
+   * Core of the framework: runs `fn` inside a test.step titled with the
+   * grammar sentence, and emits the matching structured StepEvent —
+   * also (especially) when it fails.
+   */
+  async step(action, options, fn) {
+    const context = {
+      controlType: this.controlType,
+      name: this.name,
+      detail: options.detail,
+      expected: options.expected
+    };
+    const sentence = options.as ?? SENTENCES[action](context);
+    const base = {
+      action,
+      controlType: this.controlType,
+      name: this.name,
+      sentence,
+      detail: options.detail,
+      expected: options.expected
+    };
+    const fail = (error, extra = {}) => {
+      emitStepEvent({
+        ...base,
+        ...extra,
+        selector: this.selector,
+        status: "failed",
+        error: stripAnsi(error instanceof Error ? error.message : String(error)),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    };
+    return test.step(sentence, async () => {
+      try {
+        const result = await fn();
+        emitStepEvent({
+          ...base,
+          selector: this.selector,
+          status: "passed",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return result;
+      } catch (error) {
+        const gone = healingMode() !== "off" && await this.primaryGone();
+        if (gone) {
+          const healedSpec = await this.findHealingSpec();
+          if (healedSpec) {
+            const healed = {
+              from: this.selector,
+              to: this.withinPrefix + describeSelector(healedSpec)
+            };
+            this._locator = resolveLocator(this.healRoot, healedSpec);
+            this._selector = healed.to;
+            if (healingMode() === "fail") {
+              const drift = new Error(
+                `locator drift: ${healed.from} no longer resolves; element found via ${healed.to} \u2014 update the locator`
+              );
+              fail(drift, { healed });
+              throw drift;
+            }
+            try {
+              const result = await fn();
+              emitStepEvent({
+                ...base,
+                selector: this.selector,
+                healed,
+                status: "passed",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              return result;
+            } catch (retryError) {
+              const actual2 = options.readActual ? await options.readActual().catch(() => void 0) : void 0;
+              fail(retryError, { healed, actual: actual2 });
+              throw retryError;
+            }
+          }
+        }
+        const actual = options.readActual ? await options.readActual().catch(() => void 0) : void 0;
+        const domCandidates = gone ? await this.collectDomCandidates() : void 0;
+        fail(error, { actual, domCandidates });
+        throw error;
+      }
+    });
+  }
+  /** True when the primary locator currently matches nothing (safe: never throws). */
+  async primaryGone() {
+    try {
+      return await this._locator.count() === 0;
+    } catch {
+      return false;
+    }
+  }
+  /** First fallback (explicit, then implicit role+name) resolving to exactly one element. */
+  async findHealingSpec() {
+    const role = IMPLICIT_ROLE[this.controlType];
+    const candidates = [
+      ...this.fallbacks,
+      // exact: getByRole's name matching is substring by default, which on a
+      // page with "Export" and "Confirm export…" would match both and block
+      // (or worse, mis-target) the heal. Exact accessible name only.
+      ...role ? [{ role, name: this.name, exact: true }] : []
+    ];
+    for (const spec of candidates) {
+      try {
+        if (await resolveLocator(this.healRoot, spec).count() === 1) return spec;
+      } catch {
+      }
+    }
+    return null;
+  }
+  /**
+   * Same-role elements on the page, as evidence for the analyzer to propose
+   * a replacement locator. Best-effort: capped, time-boxed, never throws.
+   */
+  async collectDomCandidates() {
+    const role = IMPLICIT_ROLE[this.controlType];
+    if (!role) return void 0;
+    const collect = async () => {
+      const elements = (await this.healRoot.getByRole(role).all()).slice(0, 5);
+      const out = [];
+      for (const element of elements) {
+        const label = await element.getAttribute("aria-label") ?? await element.textContent() ?? "";
+        out.push(`role=${role} name="${label.trim().replace(/\s+/g, " ").slice(0, 120)}"`);
+      }
+      return out.length > 0 ? out : void 0;
+    };
+    const timeBox = new Promise((resolve) => {
+      setTimeout(() => resolve(void 0), 2e3).unref?.();
+    });
+    try {
+      return await Promise.race([collect().catch(() => void 0), timeBox]);
+    } catch {
+      return void 0;
+    }
+  }
+  async expectVisible(options = {}) {
+    await this.step(
+      "assert-visible",
+      {
+        ...options,
+        expected: "visible",
+        readActual: async () => await this.locator.isVisible() ? "visible" : "hidden"
+      },
+      () => expect(this.locator).toBeVisible()
+    );
+  }
+  async expectEnabled(options = {}) {
+    await this.step(
+      "assert-enabled",
+      {
+        ...options,
+        expected: "enabled",
+        readActual: async () => await this.locator.isEnabled() ? "enabled" : "disabled"
+      },
+      () => expect(this.locator).toBeEnabled()
+    );
+  }
+  async expectDisabled(options = {}) {
+    await this.step(
+      "assert-disabled",
+      {
+        ...options,
+        expected: "disabled",
+        readActual: async () => await this.locator.isEnabled() ? "enabled" : "disabled"
+      },
+      () => expect(this.locator).toBeDisabled()
+    );
+  }
+  async expectText(expected, options = {}) {
+    await this.step(
+      "assert-text",
+      {
+        ...options,
+        expected,
+        readActual: async () => (await this.locator.textContent() ?? "").trim()
+      },
+      () => expect(this.locator).toHaveText(expected)
+    );
+  }
+  /** The control as it appears in the narration: `button "Export"`. */
+  describe() {
+    return `${this.controlType} "${this.name}"`;
+  }
+  // --- universal interactions ---
+  async hover(options = {}) {
+    await this.step("hover", options, () => this.locator.hover());
+  }
+  async doubleClick(options = {}) {
+    await this.step("double-click", options, () => this.locator.dblclick());
+  }
+  async rightClick(options = {}) {
+    await this.step("right-click", options, () => this.locator.click({ button: "right" }));
+  }
+  async press(key, options = {}) {
+    await this.step("press", { ...options, detail: key }, () => this.locator.press(key));
+  }
+  async focus(options = {}) {
+    await this.step("focus", options, () => this.locator.focus());
+  }
+  async scrollTo(options = {}) {
+    await this.step("scroll-to", options, () => this.locator.scrollIntoViewIfNeeded());
+  }
+  async dragTo(target, options = {}) {
+    await this.step(
+      "drag",
+      { ...options, detail: target.describe() },
+      () => this.locator.dragTo(target.locator)
+    );
+  }
+  // --- universal assertions ---
+  async expectHidden(options = {}) {
+    await this.step(
+      "assert-hidden",
+      {
+        ...options,
+        expected: "hidden",
+        readActual: async () => await this.locator.isVisible() ? "visible" : "hidden"
+      },
+      () => expect(this.locator).toBeHidden()
+    );
+  }
+  async expectFocused(options = {}) {
+    await this.step(
+      "assert-focused",
+      {
+        ...options,
+        expected: "focused",
+        readActual: () => this.locator.evaluate(
+          (el) => el === el.ownerDocument.activeElement ? "focused" : "not focused"
+        )
+      },
+      () => expect(this.locator).toBeFocused()
+    );
+  }
+  async expectContainsText(expected, options = {}) {
+    await this.step(
+      "assert-contains-text",
+      {
+        ...options,
+        expected,
+        readActual: async () => (await this.locator.textContent() ?? "").trim()
+      },
+      () => expect(this.locator).toContainText(expected)
+    );
+  }
+  async expectAttribute(attribute, expected, options = {}) {
+    await this.step(
+      "assert-attribute",
+      {
+        ...options,
+        detail: attribute,
+        expected,
+        readActual: async () => await this.locator.getAttribute(attribute) ?? "none"
+      },
+      () => expect(this.locator).toHaveAttribute(attribute, expected)
+    );
+  }
+  /** For repeated testids (list items): how many elements the control matches. */
+  async expectCount(expected, options = {}) {
+    await this.step(
+      "assert-count",
+      {
+        ...options,
+        expected: String(expected),
+        readActual: async () => String(await this.locator.count())
+      },
+      () => expect(this.locator).toHaveCount(expected)
+    );
+  }
+};
+
+// src/controls/Button.ts
+var Button = class extends Control {
+  controlType = "button";
+  async click(options = {}) {
+    await this.step("click", options, () => this.locator.click());
+  }
+};
+
+// src/controls/Input.ts
+import { expect as expect2 } from "@playwright/test";
+var Input = class extends Control {
+  controlType = "field";
+  /** For a field, "text" means its value, not its DOM content. */
+  async expectText(expected, options = {}) {
+    await this.step(
+      "assert-text",
+      { ...options, expected, readActual: () => this.locator.inputValue() },
+      () => expect2(this.locator).toHaveValue(expected)
+    );
+  }
+  async fill(value, options = {}) {
+    await this.step("fill", { ...options, detail: value }, () => this.locator.fill(value));
+  }
+  async clear(options = {}) {
+    await this.step("clear", options, () => this.locator.clear());
+  }
+  async expectEmpty(options = {}) {
+    await this.step(
+      "assert-empty",
+      { ...options, expected: "empty", readActual: () => this.locator.inputValue() },
+      () => expect2(this.locator).toHaveValue("")
+    );
+  }
+};
+
+// src/controls/RadioButton.ts
+import { expect as expect3 } from "@playwright/test";
+var RadioButton = class extends Control {
+  controlType = "radio group";
+  async select(option, options = {}) {
+    await this.step(
+      "select",
+      { ...options, detail: option },
+      () => this.locator.getByRole("radio", { name: option }).check()
+    );
+  }
+  async expectSelected(option, options = {}) {
+    await this.step(
+      "assert-selected",
+      {
+        ...options,
+        expected: option,
+        readActual: () => this.locator.locator('input[type="radio"]').evaluateAll(
+          (radios) => radios.find((r) => r.checked)?.value ?? "none"
+        )
+      },
+      () => expect3(this.locator.getByRole("radio", { name: option })).toBeChecked()
+    );
+  }
+};
+
+// src/controls/Checkbox.ts
+import { expect as expect4 } from "@playwright/test";
+var Checkbox = class extends Control {
+  controlType = "checkbox";
+  readActualState = async () => await this.locator.isChecked() ? "checked" : "unchecked";
+  async expectChecked(options = {}) {
+    await this.step(
+      "assert-checked",
+      { ...options, expected: "checked", readActual: this.readActualState },
+      () => expect4(this.locator).toBeChecked()
+    );
+  }
+  async expectUnchecked(options = {}) {
+    await this.step(
+      "assert-unchecked",
+      { ...options, expected: "unchecked", readActual: this.readActualState },
+      () => expect4(this.locator).not.toBeChecked()
+    );
+  }
+  async check(options = {}) {
+    await this.step("check", options, () => this.locator.check());
+  }
+  async uncheck(options = {}) {
+    await this.step("uncheck", options, () => this.locator.uncheck());
+  }
+};
+
+// src/controls/Select.ts
+var Select = class extends Control {
+  controlType = "select";
+  /** Chooses an option by its visible label. */
+  async choose(option, options = {}) {
+    await this.step("choose", { ...options, detail: option }, async () => {
+      await this.locator.selectOption({ label: option });
+    });
+  }
+  /** Chooses several options by label (for <select multiple>). */
+  async chooseMany(optionLabels, options = {}) {
+    await this.step("choose-many", { ...options, detail: optionLabels.join(", ") }, async () => {
+      await this.locator.selectOption(optionLabels.map((label) => ({ label })));
+    });
+  }
+};
+
+// src/controls/Link.ts
+import { expect as expect5 } from "@playwright/test";
+var Link = class extends Control {
+  controlType = "link";
+  async open(options = {}) {
+    await this.step("open", options, () => this.locator.click());
+  }
+  async expectHref(expected, options = {}) {
+    await this.step(
+      "assert-href",
+      {
+        ...options,
+        expected,
+        readActual: async () => await this.locator.getAttribute("href") ?? "none"
+      },
+      () => expect5(this.locator).toHaveAttribute("href", expected)
+    );
+  }
+};
+
+// src/controls/Label.ts
+var Label = class extends Control {
+  controlType = "label";
+};
+
+// src/controls/FileInput.ts
+import * as path from "path";
+import { expect as expect6 } from "@playwright/test";
+var FileInput = class extends Control {
+  controlType = "file input";
+  /** Attaches one or more files by path. The narration shows the file names. */
+  async attach(files, options = {}) {
+    const list = Array.isArray(files) ? files : [files];
+    const names = list.map((f) => path.basename(f)).join(", ");
+    await this.step(
+      "attach",
+      { ...options, detail: names },
+      () => this.locator.setInputFiles(list)
+    );
+  }
+  async clear(options = {}) {
+    await this.step("clear", options, () => this.locator.setInputFiles([]));
+  }
+  /** Asserts the name of the file currently selected. */
+  async expectFile(expectedName, options = {}) {
+    const readSelectedName = () => this.locator.evaluate(
+      (el) => el.files?.[0]?.name ?? "none"
+    );
+    await this.step(
+      "assert-value",
+      { ...options, expected: expectedName, readActual: readSelectedName },
+      () => expect6.poll(readSelectedName).toBe(expectedName)
+    );
+  }
+};
+
+// src/controls/Slider.ts
+import { expect as expect7 } from "@playwright/test";
+var Slider = class extends Control {
+  controlType = "slider";
+  /**
+   * Sets the slider value. Range inputs cannot be filled, so the value is
+   * set in the DOM and the input/change events the app listens to are fired.
+   */
+  async setValue(value, options = {}) {
+    const detail = String(value);
+    await this.step("set", { ...options, detail }, async () => {
+      await expect7(this.locator).toBeVisible();
+      await this.locator.evaluate((el, v) => {
+        const input = el;
+        input.value = v;
+        input.dispatchEvent(new Event("input", { bubbles: true }));
+        input.dispatchEvent(new Event("change", { bubbles: true }));
+      }, detail);
+    });
+  }
+  async expectValue(expected, options = {}) {
+    const value = String(expected);
+    await this.step(
+      "assert-value",
+      { ...options, expected: value, readActual: () => this.locator.inputValue() },
+      () => expect7(this.locator).toHaveValue(value)
+    );
+  }
+};
+
+// src/controls/TextArea.ts
+var TextArea = class extends Input {
+  controlType = "text area";
+};
+
+// src/controls/Switch.ts
+import { expect as expect8 } from "@playwright/test";
+var Switch = class extends Control {
+  controlType = "switch";
+  readState = async () => await this.locator.getAttribute("aria-checked") === "true" ? "on" : "off";
+  async turnOn(options = {}) {
+    await this.step("turn-on", options, async () => {
+      if (await this.readState() !== "on") await this.locator.click();
+      await expect8(this.locator).toHaveAttribute("aria-checked", "true");
+    });
+  }
+  async turnOff(options = {}) {
+    await this.step("turn-off", options, async () => {
+      if (await this.readState() !== "off") await this.locator.click();
+      await expect8(this.locator).toHaveAttribute("aria-checked", "false");
+    });
+  }
+  async expectOn(options = {}) {
+    await this.step(
+      "assert-on",
+      { ...options, expected: "on", readActual: this.readState },
+      () => expect8(this.locator).toHaveAttribute("aria-checked", "true")
+    );
+  }
+  async expectOff(options = {}) {
+    await this.step(
+      "assert-off",
+      { ...options, expected: "off", readActual: this.readState },
+      () => expect8(this.locator).toHaveAttribute("aria-checked", "false")
+    );
+  }
+};
+
+// src/controls/Combobox.ts
+import { expect as expect9 } from "@playwright/test";
+var Combobox = class extends Control {
+  controlType = "combobox";
+  async search(text, options = {}) {
+    await this.step("fill", { ...options, detail: text }, () => this.locator.fill(text));
+  }
+  async pick(option, options = {}) {
+    await this.step(
+      "pick",
+      { ...options, detail: option },
+      () => this.page.getByRole("option", { name: option }).click()
+    );
+  }
+  async expectSelected(expected, options = {}) {
+    await this.step(
+      "assert-value",
+      { ...options, expected, readActual: () => this.locator.inputValue() },
+      () => expect9(this.locator).toHaveValue(expected)
+    );
+  }
+};
+
+// src/controls/Table.ts
+import { expect as expect10 } from "@playwright/test";
+var Table = class extends Control {
+  controlType = "table";
+  rows() {
+    return this.locator.locator("tbody tr");
+  }
+  async expectRowCount(expected, options = {}) {
+    await this.step(
+      "assert-row-count",
+      {
+        ...options,
+        expected: String(expected),
+        readActual: async () => String(await this.rows().count())
+      },
+      () => expect10(this.rows()).toHaveCount(expected)
+    );
+  }
+  async expectRowContains(expected, options = {}) {
+    await this.step(
+      "assert-row-contains",
+      {
+        ...options,
+        expected,
+        readActual: async () => `${await this.rows().count()} rows, none matching`
+      },
+      () => expect10(this.rows().filter({ hasText: expected }).first()).toBeVisible()
+    );
+  }
+};
+
+// src/controls/Dialog.ts
+import { expect as expect11 } from "@playwright/test";
+var Dialog = class extends Control {
+  controlType = "dialog";
+  readState = async () => await this.locator.isVisible() ? "open" : "closed";
+  async close(options = {}) {
+    await this.step("close", options, async () => {
+      await this.page.keyboard.press("Escape");
+      await expect11(this.locator).toBeHidden();
+    });
+  }
+  async expectOpen(options = {}) {
+    await this.step(
+      "assert-open",
+      { ...options, expected: "open", readActual: this.readState },
+      () => expect11(this.locator).toBeVisible()
+    );
+  }
+  async expectClosed(options = {}) {
+    await this.step(
+      "assert-closed",
+      { ...options, expected: "closed", readActual: this.readState },
+      () => expect11(this.locator).toBeHidden()
+    );
+  }
+};
+
+// src/controls/Tabs.ts
+import { expect as expect12 } from "@playwright/test";
+var Tabs = class extends Control {
+  controlType = "tabs";
+  async open(tab, options = {}) {
+    await this.step(
+      "open-tab",
+      { ...options, detail: tab },
+      () => this.locator.getByRole("tab", { name: tab }).click()
+    );
+  }
+  async expectActive(expected, options = {}) {
+    await this.step(
+      "assert-active-tab",
+      {
+        ...options,
+        expected,
+        readActual: async () => (await this.locator.locator('[role="tab"][aria-selected="true"]').first().textContent() ?? "none").trim()
+      },
+      () => expect12(this.locator.getByRole("tab", { name: expected })).toHaveAttribute(
+        "aria-selected",
+        "true"
+      )
+    );
+  }
+};
+
+// src/controls/Image.ts
+import { expect as expect13 } from "@playwright/test";
+var Image = class extends Control {
+  controlType = "image";
+  async expectAlt(expected, options = {}) {
+    await this.step(
+      "assert-alt",
+      {
+        ...options,
+        expected,
+        readActual: async () => await this.locator.getAttribute("alt") ?? "none"
+      },
+      () => expect13(this.locator).toHaveAttribute("alt", expected)
+    );
+  }
+  async expectLoaded(options = {}) {
+    const isLoaded = () => this.locator.evaluate(
+      (el) => el.complete && el.naturalWidth > 0
+    );
+    await this.step(
+      "assert-loaded",
+      {
+        ...options,
+        expected: "loaded",
+        readActual: async () => await isLoaded() ? "loaded" : "not loaded"
+      },
+      () => expect13.poll(isLoaded).toBe(true)
+    );
+  }
+};
+
+// src/controls/DatePicker.ts
+import { expect as expect14 } from "@playwright/test";
+var DatePicker = class extends Control {
+  controlType = "date picker";
+  async pick(isoDate, options = {}) {
+    await this.step(
+      "pick-date",
+      { ...options, detail: isoDate },
+      () => this.locator.fill(isoDate)
+    );
+  }
+  async expectDate(expected, options = {}) {
+    await this.step(
+      "assert-value",
+      { ...options, expected, readActual: () => this.locator.inputValue() },
+      () => expect14(this.locator).toHaveValue(expected)
+    );
+  }
+};
+
+// src/controls/Menu.ts
+var Menu = class extends Control {
+  controlType = "menu";
+  async choose(item, options = {}) {
+    await this.step("choose", { ...options, detail: item }, async () => {
+      await this.locator.click();
+      await this.page.getByRole("menuitem", { name: item }).click();
+    });
+  }
+};
+
+// src/controls/Tooltip.ts
+import { expect as expect15 } from "@playwright/test";
+var Tooltip = class extends Control {
+  controlType = "tooltip";
+  async tooltipText() {
+    const id = await this.locator.getAttribute("aria-describedby");
+    if (!id) return "no tooltip";
+    const text = await this.page.locator(`#${id}`).textContent();
+    return (text ?? "").trim() || "no tooltip";
+  }
+  /** Hovers the trigger and asserts the tooltip content. */
+  async expectContent(expected, options = {}) {
+    await this.step(
+      "assert-tooltip",
+      { ...options, expected, readActual: () => this.tooltipText() },
+      async () => {
+        await this.locator.hover();
+        const id = await this.locator.getAttribute("aria-describedby");
+        if (!id) throw new Error("trigger has no aria-describedby tooltip");
+        await expect15(this.page.locator(`#${id}`)).toBeVisible();
+        await expect15(this.page.locator(`#${id}`)).toHaveText(expected);
+      }
+    );
+  }
+};
+
+// src/controls/Editor.ts
+var Editor = class extends Control {
+  controlType = "editor";
+  async write(text, options = {}) {
+    await this.step("fill", { ...options, detail: text }, () => this.locator.fill(text));
+  }
+  async clear(options = {}) {
+    await this.step("clear", options, () => this.locator.fill(""));
+  }
+};
+export {
+  AI_STEP_ATTACHMENT,
+  Button,
+  Checkbox,
+  Combobox,
+  Control,
+  DatePicker,
+  Dialog,
+  Editor,
+  FileInput,
+  Image,
+  Input,
+  Label,
+  Link,
+  Menu,
+  RadioButton,
+  Select,
+  Slider,
+  Switch,
+  Table,
+  Tabs,
+  TextArea,
+  Tooltip,
+  emitStepEvent
+};
+//# sourceMappingURL=index.mjs.map