@esimplicity/stack-tests 0.1.0

package/dist/chunk-YPUQQZM2.js

@@ -0,0 +1,827 @@
+// src/steps/api.http.ts
+import { createBdd } from "playwright-bdd";
+
+// src/utils.ts
+import { expect } from "@playwright/test";
+function interpolate(template, vars) {
+  return String(template).replace(/\{([a-zA-Z0-9_-]+)\}/g, (_, key) => {
+    const v = vars[key];
+    return v === void 0 ? `{${key}}` : v;
+  });
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function tokenize(path) {
+  const out = [];
+  let i = 0;
+  while (i < path.length) {
+    if (path[i] === ".") {
+      i++;
+      continue;
+    }
+    if (path[i] === "[") {
+      const j2 = path.indexOf("]", i + 1);
+      if (j2 < 0) throw new Error(`Invalid path: ${path}`);
+      const idxStr = path.slice(i + 1, j2);
+      const idx = Number(idxStr);
+      if (!Number.isInteger(idx)) throw new Error(`Invalid array index '${idxStr}' in path '${path}'`);
+      out.push(idx);
+      i = j2 + 1;
+      continue;
+    }
+    let j = i;
+    while (j < path.length && /[a-zA-Z0-9_-]/.test(path[j])) j++;
+    const key = path.slice(i, j);
+    out.push(key);
+    i = j;
+  }
+  return out;
+}
+function selectPath(root, path) {
+  if (!path) return root;
+  let cur = root;
+  for (const token of tokenize(path)) {
+    if (typeof token === "number") {
+      if (!Array.isArray(cur)) {
+        const gotType = cur === null ? "null" : Array.isArray(cur) ? "array" : typeof cur;
+        throw new Error(`Path '${path}': expected array but got ${gotType}`);
+      }
+      cur = cur[token];
+    } else {
+      if (cur == null || typeof cur !== "object" || Array.isArray(cur)) {
+        const gotType = cur === null ? "null" : Array.isArray(cur) ? "array" : typeof cur;
+        throw new Error(`Path '${path}': expected object but got ${gotType}`);
+      }
+      cur = cur[token];
+    }
+  }
+  return cur;
+}
+function parseExpected(input, world) {
+  const s = interpolate(input, world.vars);
+  if (s === "null") return null;
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (!Number.isNaN(Number(s)) && s.trim() !== "") return Number(s);
+  return s;
+}
+function assertMasked(val) {
+  expect(val).toBe("****");
+}
+function registerCleanup(world, item) {
+  const method = item.method ?? "DELETE";
+  if (world.cleanup.some((c) => c.method === method && c.path === item.path)) return;
+  world.cleanup.push({ method, path: item.path });
+}
+
+// src/steps/api.http.ts
+function registerApiHttpSteps(test) {
+  const { When } = createBdd(test);
+  async function send(args, method, pathTemplate, body) {
+    const { api, world } = args;
+    const path = interpolate(pathTemplate, world.vars);
+    const result = await api.sendJson(method, path, body, world.headers);
+    world.lastStatus = result.status;
+    world.lastText = result.text;
+    world.lastJson = result.json;
+    world.lastHeaders = result.headers;
+    world.lastContentType = result.contentType;
+    world.lastResponse = result.response;
+  }
+  When("I GET {string}", { tags: "@api" }, async ({ api, world }, path) => {
+    await send({ api, world }, "GET", path);
+  });
+  When("I DELETE {string}", { tags: "@api" }, async ({ api, world }, path) => {
+    await send({ api, world }, "DELETE", path);
+  });
+  When("I POST {string} with JSON body:", { tags: "@api" }, async ({ api, world }, path, docString) => {
+    const interpolated = interpolate(docString ?? "", world.vars);
+    const parsed = tryParseJson(interpolated) ?? interpolated;
+    await send({ api, world }, "POST", path, parsed);
+  });
+  When("I PATCH {string} with JSON body:", { tags: "@api" }, async ({ api, world }, path, docString) => {
+    const interpolated = interpolate(docString ?? "", world.vars);
+    const parsed = tryParseJson(interpolated) ?? interpolated;
+    await send({ api, world }, "PATCH", path, parsed);
+  });
+  When("I PUT {string} with JSON body:", { tags: "@api" }, async ({ api, world }, path, docString) => {
+    const interpolated = interpolate(docString ?? "", world.vars);
+    const parsed = tryParseJson(interpolated) ?? interpolated;
+    await send({ api, world }, "PUT", path, parsed);
+  });
+}
+
+// src/steps/api.assertion.ts
+import { createBdd as createBdd2 } from "playwright-bdd";
+import { expect as expect2 } from "@playwright/test";
+function registerApiAssertionSteps(test) {
+  const { Then } = createBdd2(test);
+  Then("the response status should be {int}", { tags: "@api" }, async ({ world }, code) => {
+    expect2(world.lastStatus, `Unexpected status. Body: ${world.lastText}`).toBe(code);
+  });
+  Then("the response should be a JSON array", { tags: "@api" }, async ({ world }) => {
+    expect2(Array.isArray(world.lastJson), `Expected JSON array. Body: ${world.lastText}`).toBe(true);
+  });
+  Then("the response should be a JSON object", { tags: "@api" }, async ({ world }) => {
+    const v = world.lastJson;
+    expect2(v !== null && typeof v === "object" && !Array.isArray(v), `Expected JSON object. Body: ${world.lastText}`).toBe(true);
+  });
+  Then("the value at {string} should equal {string}", { tags: "@api" }, async ({ world }, path, expectedRaw) => {
+    const actual = selectPath(world.lastJson, path);
+    const expected = parseExpected(expectedRaw, world);
+    expect2(actual).toEqual(expected);
+  });
+  Then("I store the value at {string} as {string}", { tags: "@api" }, async ({ world, cleanup }, path, varName) => {
+    const val = selectPath(world.lastJson, path);
+    world.vars[varName] = String(val);
+    cleanup.registerFromVar(world, varName, val, world.lastJson);
+  });
+}
+
+// src/steps/api.auth.ts
+import { createBdd as createBdd3 } from "playwright-bdd";
+function registerApiAuthSteps(test) {
+  const { Given } = createBdd3(test);
+  Given("I am authenticated as an admin via API", { tags: "@api" }, async ({ auth, world }) => {
+    await auth.apiLoginAsAdmin(world);
+  });
+  Given("I am authenticated as a user via API", { tags: "@api" }, async ({ auth, world }) => {
+    await auth.apiLoginAsUser(world);
+  });
+  Given("I set bearer token from variable {string}", { tags: "@api" }, async ({ auth, world }, varName) => {
+    const token = world.vars[varName];
+    if (!token) throw new Error(`No token found in variable '${varName}'`);
+    auth.apiSetBearer(world, token);
+  });
+}
+
+// src/steps/hybrid.ts
+import { createBdd as createBdd4 } from "playwright-bdd";
+function registerHybridSteps(test) {
+  const { Given } = createBdd4(test);
+  Given("I navigate to interpolated path {string}", { tags: "@hybrid" }, async ({ ui, world }, path) => {
+    await ui.goto(interpolate(path, world.vars));
+  });
+}
+
+// src/steps/shared.cleanup.ts
+import { createBdd as createBdd5 } from "playwright-bdd";
+function registerSharedCleanupSteps(test) {
+  const { Given } = createBdd5(test);
+  Given("I register cleanup DELETE {string}", async ({ world }, pathTemplate) => {
+    registerCleanup(world, { method: "DELETE", path: interpolate(pathTemplate, world.vars) });
+  });
+  Given("I register cleanup POST {string}", async ({ world }, pathTemplate) => {
+    registerCleanup(world, { method: "POST", path: interpolate(pathTemplate, world.vars) });
+  });
+  Given("I register cleanup PATCH {string}", async ({ world }, pathTemplate) => {
+    registerCleanup(world, { method: "PATCH", path: interpolate(pathTemplate, world.vars) });
+  });
+  Given("I register cleanup PUT {string}", async ({ world }, pathTemplate) => {
+    registerCleanup(world, { method: "PUT", path: interpolate(pathTemplate, world.vars) });
+  });
+}
+
+// src/steps/shared.vars.ts
+import { createBdd as createBdd6 } from "playwright-bdd";
+import { randomUUID } from "crypto";
+function registerSharedVarSteps(test) {
+  const { Given } = createBdd6(test);
+  Given("I set variable {string} to {string}", async ({ world }, name, value) => {
+    world.vars[name] = value;
+  });
+  Given("I generate a UUID and store as {string}", async ({ world }, name) => {
+    world.vars[name] = randomUUID();
+  });
+  Given("I set header {string} to {string}", async ({ world }, header, value) => {
+    world.headers = { ...world.headers || {}, [header]: value };
+  });
+  Given("I disable cleanup", async ({ world }) => {
+    world.skipCleanup = true;
+  });
+}
+
+// src/steps/ui.basic.ts
+import { createBdd as createBdd7 } from "playwright-bdd";
+function registerUiBasicSteps(test) {
+  const { Given, When, Then } = createBdd7(test);
+  Given("I navigate to {string}", { tags: "@ui" }, async ({ ui, world }, path) => {
+    await ui.goto(interpolate(path, world.vars));
+  });
+  When("I click the button {string}", { tags: "@ui" }, async ({ ui, world }, name) => {
+    await ui.clickButton(interpolate(name, world.vars));
+  });
+  When("I click the link {string}", { tags: "@ui" }, async ({ ui, world }, name) => {
+    await ui.clickLink(interpolate(name, world.vars));
+  });
+  When("I fill the placeholder {string} with {string}", { tags: "@ui" }, async ({ ui, world }, placeholder, value) => {
+    await ui.fillPlaceholder(interpolate(placeholder, world.vars), interpolate(value, world.vars));
+  });
+  When("I fill the field {string} with {string}", { tags: "@ui" }, async ({ ui, world }, label, value) => {
+    await ui.fillLabel(interpolate(label, world.vars), interpolate(value, world.vars));
+  });
+  When("I log in as admin in UI", { tags: "@ui" }, async ({ auth, world }) => {
+    await auth.uiLoginAsAdmin(world);
+  });
+  When("I log in as user in UI", { tags: "@ui" }, async ({ auth, world }) => {
+    await auth.uiLoginAsUser(world);
+  });
+  Then("I should see text {string}", { tags: "@ui" }, async ({ ui, world }, text) => {
+    await ui.expectText(interpolate(text, world.vars));
+  });
+  Then("the URL should contain {string}", { tags: "@ui" }, async ({ ui, world }, part) => {
+    await ui.expectUrlContains(interpolate(part, world.vars));
+  });
+}
+
+// src/steps/ui.wizard.ts
+import { createBdd as createBdd8 } from "playwright-bdd";
+function resolveValue(input, world) {
+  const interpolated = interpolate(input, world.vars);
+  if (interpolated === input && world.vars[input] !== void 0) {
+    return world.vars[input];
+  }
+  return interpolated;
+}
+function parseNumber(input, world) {
+  const resolved = resolveValue(input, world);
+  const n = Number.parseFloat(resolved);
+  if (!Number.isFinite(n)) {
+    throw new Error(`Expected a number but got '${resolved}'`);
+  }
+  return n;
+}
+function parseOrdinalIndex(input, world) {
+  const resolved = resolveValue(input, world);
+  const n = Number.parseInt(resolved, 10);
+  if (!Number.isFinite(n) || n < 1) {
+    throw new Error(`Expected a 1-based index number but got '${resolved}'`);
+  }
+  return n - 1;
+}
+function locatorByPage(page, method, text) {
+  switch (method) {
+    case "text":
+      return page.getByText(text);
+    case "label":
+      return page.getByLabel(text);
+    case "placeholder":
+      return page.getByPlaceholder(text);
+    case "role":
+      return page.getByRole(text);
+    case "test ID":
+      return page.getByTestId(text);
+    case "alternative text":
+      return page.getByAltText(text);
+    case "title":
+      return page.getByTitle(text);
+    case "locator":
+      return page.locator(text);
+    default: {
+      const neverMethod = method;
+      throw new Error(`Unsupported locator method '${neverMethod}'`);
+    }
+  }
+}
+function asClickMode(input) {
+  const v = input.trim().toLowerCase();
+  if (v === "click" || v === "dispatch click" || v === "force click" || v === "force dispatch click") {
+    return v;
+  }
+  throw new Error(`Unsupported click mode '${input}'`);
+}
+function asInputMode(input) {
+  const v = input.trim().toLowerCase();
+  if (v === "type" || v === "fill" || v === "choose") {
+    return v;
+  }
+  throw new Error(`Unsupported input mode '${input}'`);
+}
+function asUrlAssertMode(input) {
+  const v = input.trim().toLowerCase();
+  if (v === "contains" || v === "doesntcontain" || v === "equals") {
+    return v === "doesntcontain" ? "doesntContain" : v;
+  }
+  throw new Error(`Unsupported URL assert mode '${input}'`);
+}
+function asLocatorMethod(input) {
+  const v = input.trim().toLowerCase();
+  if (v === "text") return "text";
+  if (v === "label") return "label";
+  if (v === "placeholder") return "placeholder";
+  if (v === "role") return "role";
+  if (v === "test id" || v === "testid" || v === "test-id") return "test ID";
+  if (v === "alternative text" || v === "alt text" || v === "alt") return "alternative text";
+  if (v === "title") return "title";
+  if (v === "locator") return "locator";
+  throw new Error(`Unsupported locator method '${input}'`);
+}
+function asElementState(input) {
+  const v = input.trim().toLowerCase();
+  if (v === "visible" || v === "hidden" || v === "editable" || v === "disabled" || v === "enabled") return v;
+  if (v === "read-only" || v === "readonly" || v === "read only") return "read-only";
+  throw new Error(`Unsupported element state '${input}'`);
+}
+function parseRegex(input) {
+  const raw = String(input);
+  if (raw.startsWith("/") && raw.lastIndexOf("/") > 0) {
+    const last = raw.lastIndexOf("/");
+    const pattern = raw.slice(1, last);
+    const flags = raw.slice(last + 1);
+    return new RegExp(pattern, flags);
+  }
+  return new RegExp(raw);
+}
+function registerWizardSteps(test) {
+  const { Given, When, Then } = createBdd8(test);
+  Given("I open {string} page", { tags: "@ui" }, async ({ ui, world }, urlOrVar) => {
+    await ui.goto(resolveValue(urlOrVar, world));
+  });
+  Given("I open {string} in the browser", { tags: "@ui" }, async ({ ui, world }, urlOrVar) => {
+    await ui.goto(resolveValue(urlOrVar, world));
+  });
+  When("I go back in the browser", { tags: "@ui" }, async ({ ui }) => {
+    await ui.goBack();
+  });
+  When("I save the current URL as {string}", { tags: "@ui" }, async ({ ui, world }, varName) => {
+    world.vars[varName] = await ui.getCurrentUrl();
+  });
+  When("I save the current url as {string}", { tags: "@ui" }, async ({ ui, world }, varName) => {
+    world.vars[varName] = await ui.getCurrentUrl();
+  });
+  Then("I zoom to {string} in the browser", { tags: "@ui" }, async ({ ui, world }, scale) => {
+    await ui.zoomTo(parseNumber(scale, world));
+  });
+  When("I reload the page", { tags: "@ui" }, async ({ ui }) => {
+    await ui.reload();
+  });
+  Then("I wait {string} seconds", { tags: "@ui" }, async ({ ui, world }, seconds) => {
+    await ui.waitSeconds(parseNumber(seconds, world));
+  });
+  Then("I wait for the page to load", { tags: "@ui" }, async ({ ui }) => {
+    await ui.waitForPageLoad();
+  });
+  When(
+    "I get a part of the URL based on {string} regular expression and save it as {string}",
+    { tags: "@ui" },
+    async ({ ui, world }, regexString, varName) => {
+      const url = await ui.getCurrentUrl();
+      const regex = parseRegex(resolveValue(regexString, world));
+      const match = regex.exec(url);
+      if (!match) throw new Error(`Regex '${regex}' did not match URL '${url}'`);
+      world.vars[varName] = match[1] ?? match[0];
+    }
+  );
+  Then("I {string} {string}", { tags: "@ui" }, async ({ ui, world }, action, value) => {
+    const verb = action.trim().toLowerCase();
+    const resolved = resolveValue(value, world);
+    if (verb === "type") {
+      await ui.typeText(resolved);
+      return;
+    }
+    if (verb === "press") {
+      await ui.pressKey(resolved);
+      return;
+    }
+    throw new Error(`Unsupported keyboard action '${action}'. Expected 'type' or 'press'.`);
+  });
+  When(
+    "I {string} the {string} element that contains {string}",
+    { tags: "@ui" },
+    async ({ ui, world }, clickMode, elementType, text) => {
+      await ui.clickElementThatContains(
+        asClickMode(resolveValue(clickMode, world)),
+        resolveValue(elementType, world),
+        resolveValue(text, world)
+      );
+    }
+  );
+  When(
+    "I {string} the {string} element with {string} {string}",
+    { tags: "@ui" },
+    async ({ ui, world }, clickMode, ordinal, text, method) => {
+      await ui.clickElementWith(
+        asClickMode(resolveValue(clickMode, world)),
+        resolveValue(ordinal, world),
+        resolveValue(text, world),
+        asLocatorMethod(resolveValue(method, world))
+      );
+    }
+  );
+  When("I click on the top left corner of the page", { tags: "@ui" }, async ({ page }) => {
+    await page.mouse.click(0, 0);
+  });
+  When(
+    "If its visible, I {string} the {string} element with {string} {string}",
+    { tags: "@ui" },
+    async ({ page, ui, world }, clickMode, ordinal, text, method) => {
+      const idx = parseOrdinalIndex(ordinal, world);
+      const resolvedText = resolveValue(text, world);
+      const resolvedMethod = asLocatorMethod(resolveValue(method, world));
+      const locator = locatorByPage(page, resolvedMethod, resolvedText).nth(idx);
+      if (await locator.count() === 0) return;
+      if (!await locator.isVisible()) return;
+      await ui.clickElementWith(asClickMode(resolveValue(clickMode, world)), ordinal, resolvedText, resolvedMethod);
+    }
+  );
+  Then("I fill {string} into the {string} dropdown", { tags: "@ui" }, async ({ ui, world }, value, label) => {
+    await ui.fillDropdown(resolveValue(value, world), resolveValue(label, world));
+  });
+  When(
+    "I {string} {string} in the {string} element with {string} {string}",
+    { tags: "@ui" },
+    async ({ ui, world }, action, value, ordinal, text, method) => {
+      await ui.inputInElement(
+        asInputMode(resolveValue(action, world)),
+        resolveValue(value, world),
+        resolveValue(ordinal, world),
+        resolveValue(text, world),
+        asLocatorMethod(resolveValue(method, world))
+      );
+    }
+  );
+  Then(
+    "I verify if a new tab which URL {string} {string} opens",
+    { tags: "@ui" },
+    async ({ ui, world }, mode, expected) => {
+      await ui.expectNewTabUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
+    }
+  );
+  Then(
+    "I verify if a new tab which url {string} {string} opens",
+    { tags: "@ui" },
+    async ({ ui, world }, mode, expected) => {
+      await ui.expectNewTabUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
+    }
+  );
+  Then("I verify if the URL {string} {string}", { tags: "@ui" }, async ({ ui, world }, mode, expected) => {
+    await ui.expectUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
+  });
+  Then("I verify if the url {string} {string}", { tags: "@ui" }, async ({ ui, world }, mode, expected) => {
+    await ui.expectUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
+  });
+  Then("I verify if the URL {string} {string} opens", { tags: "@ui" }, async ({ ui, world }, mode, expected) => {
+    await ui.expectUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
+  });
+  Then("I verify if the url {string} {string} opens", { tags: "@ui" }, async ({ ui, world }, mode, expected) => {
+    await ui.expectUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
+  });
+  Then(
+    "I verify that a {string} element with {string} text {string} visible",
+    { tags: "@ui" },
+    async ({ ui, world }, elementType, text, assertion) => {
+      const normalized = resolveValue(assertion, world).trim().toLowerCase();
+      const shouldBeVisible = normalized === "is";
+      if (!shouldBeVisible && normalized !== "is not") {
+        throw new Error(`Expected 'is' or 'is not' but got '${assertion}'`);
+      }
+      await ui.expectElementWithTextVisible(resolveValue(elementType, world), resolveValue(text, world), shouldBeVisible);
+    }
+  );
+  Then(
+    "I verify that {string} element with {string} {string} is {string}",
+    { tags: "@ui" },
+    async ({ ui, world }, ordinal, text, method, state) => {
+      await ui.expectElementState(
+        resolveValue(ordinal, world),
+        resolveValue(text, world),
+        asLocatorMethod(resolveValue(method, world)),
+        asElementState(resolveValue(state, world))
+      );
+    }
+  );
+  Then(
+    "I verify that {string} element with {string} {string} becomes {string} during {string} seconds",
+    { tags: "@ui" },
+    async ({ ui, world }, ordinal, text, method, state, seconds) => {
+      await ui.expectElementStateWithin(
+        resolveValue(ordinal, world),
+        resolveValue(text, world),
+        asLocatorMethod(resolveValue(method, world)),
+        asElementState(resolveValue(state, world)),
+        parseNumber(seconds, world)
+      );
+    }
+  );
+}
+
+// src/steps/tui.basic.ts
+import { createBdd as createBdd9 } from "playwright-bdd";
+function registerTuiBasicSteps(test) {
+  const { Given, When, Then } = createBdd9(test);
+  Given("I start the TUI application", { tags: "@tui" }, async ({ tui }) => {
+    await tui.start();
+    await tui.waitForReady();
+  });
+  Given("the TUI application is running", { tags: "@tui" }, async ({ tui }) => {
+    if (!tui.isRunning()) {
+      await tui.start();
+      await tui.waitForReady();
+    }
+  });
+  When("I restart the TUI application", { tags: "@tui" }, async ({ tui }) => {
+    await tui.restart();
+    await tui.waitForReady();
+  });
+  When("I stop the TUI application", { tags: "@tui" }, async ({ tui }) => {
+    await tui.stop();
+  });
+  When("I type {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+    await tui.typeText(interpolate(text, world.vars));
+  });
+  When("I type {string} slowly", { tags: "@tui" }, async ({ tui, world }, text) => {
+    await tui.typeText(interpolate(text, world.vars), { delay: 50 });
+  });
+  When("I press {string}", { tags: "@tui" }, async ({ tui }, key) => {
+    await tui.pressKey(key);
+  });
+  When("I press {string} with ctrl", { tags: "@tui" }, async ({ tui }, key) => {
+    await tui.pressKey(key, { ctrl: true });
+  });
+  When("I press {string} with alt", { tags: "@tui" }, async ({ tui }, key) => {
+    await tui.pressKey(key, { alt: true });
+  });
+  When("I press {string} with shift", { tags: "@tui" }, async ({ tui }, key) => {
+    await tui.pressKey(key, { shift: true });
+  });
+  When("I press enter", { tags: "@tui" }, async ({ tui }) => {
+    await tui.pressKey("enter");
+  });
+  When("I press tab", { tags: "@tui" }, async ({ tui }) => {
+    await tui.pressKey("tab");
+  });
+  When("I press escape", { tags: "@tui" }, async ({ tui }) => {
+    await tui.pressKey("escape");
+  });
+  When(
+    "I fill the TUI field {string} with {string}",
+    { tags: "@tui" },
+    async ({ tui, world }, field, value) => {
+      await tui.fillField(interpolate(field, world.vars), interpolate(value, world.vars));
+    }
+  );
+  When(
+    "I enter {string} in the {string} field",
+    { tags: "@tui" },
+    async ({ tui, world }, value, field) => {
+      await tui.fillField(interpolate(field, world.vars), interpolate(value, world.vars));
+    }
+  );
+  When("I select {string}", { tags: "@tui" }, async ({ tui, world }, option) => {
+    await tui.selectOption(interpolate(option, world.vars));
+  });
+  When("I select option {string}", { tags: "@tui" }, async ({ tui, world }, option) => {
+    await tui.selectOption(interpolate(option, world.vars));
+  });
+  When("I click at position {int}, {int}", { tags: "@tui" }, async ({ tui }, x, y) => {
+    await tui.click(x, y);
+  });
+  When("I click on {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+    await tui.clickOnText(interpolate(text, world.vars));
+  });
+  Then("I should see {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+    await tui.expectText(interpolate(text, world.vars));
+  });
+  Then("I should see {string} in the terminal", { tags: "@tui" }, async ({ tui, world }, text) => {
+    await tui.expectText(interpolate(text, world.vars));
+  });
+  Then("I should see text {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+    await tui.expectText(interpolate(text, world.vars));
+  });
+  Then("I should not see {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+    await tui.expectNotText(interpolate(text, world.vars));
+  });
+  Then("the screen should contain {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+    await tui.assertScreenContains(interpolate(text, world.vars));
+  });
+  Then("the screen should match pattern {string}", { tags: "@tui" }, async ({ tui }, pattern) => {
+    await tui.assertScreenMatches(new RegExp(pattern));
+  });
+  When("I wait for {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+    await tui.waitForText(interpolate(text, world.vars));
+  });
+  When(
+    "I wait for {string} for {int} seconds",
+    { tags: "@tui" },
+    async ({ tui, world }, text, seconds) => {
+      await tui.waitForText(interpolate(text, world.vars), { timeout: seconds * 1e3 });
+    }
+  );
+  When("I wait {int} seconds", { tags: "@tui" }, async ({ tui }, seconds) => {
+    await tui.waitSeconds(seconds);
+  });
+  Then("the screen should match snapshot {string}", { tags: "@tui" }, async ({ tui }, name) => {
+    const result = await tui.matchSnapshot(name);
+    if (!result.pass) {
+      throw new Error(`Snapshot "${name}" mismatch:
+${result.diff || "No diff available"}`);
+    }
+  });
+  Then("I take a snapshot named {string}", { tags: "@tui" }, async ({ tui }, name) => {
+    await tui.takeSnapshot(name);
+  });
+  When("I clear the terminal", { tags: "@tui" }, async ({ tui }) => {
+    await tui.clear();
+  });
+  When("I resize the terminal to {int}x{int}", { tags: "@tui" }, async ({ tui }, cols, rows) => {
+    await tui.resize({ cols, rows });
+  });
+}
+
+// src/steps/tui.wizard.ts
+import { createBdd as createBdd10 } from "playwright-bdd";
+function registerTuiWizardSteps(test) {
+  const { Given, When, Then } = createBdd10(test);
+  When("I navigate down {int} times", { tags: "@tui" }, async ({ tui }, times) => {
+    for (let i = 0; i < times; i++) {
+      await tui.pressKey("down");
+    }
+  });
+  When("I navigate up {int} times", { tags: "@tui" }, async ({ tui }, times) => {
+    for (let i = 0; i < times; i++) {
+      await tui.pressKey("up");
+    }
+  });
+  When("I navigate to {string} and select", { tags: "@tui" }, async ({ tui, world }, option) => {
+    const target = interpolate(option, world.vars);
+    await tui.waitForText(target);
+    await tui.pressKey("enter");
+  });
+  When("I go back", { tags: "@tui" }, async ({ tui }) => {
+    await tui.pressKey("escape");
+  });
+  When("I fill the form:", { tags: "@tui" }, async ({ tui, world }, dataTable) => {
+    const rows = dataTable.hashes();
+    for (const row of rows) {
+      const field = interpolate(row.field || row.Field, world.vars);
+      const value = interpolate(row.value || row.Value, world.vars);
+      await tui.fillField(field, value);
+      await tui.pressKey("tab");
+    }
+  });
+  When("I submit the form", { tags: "@tui" }, async ({ tui }) => {
+    await tui.pressKey("enter");
+  });
+  When("I submit the form with ctrl+s", { tags: "@tui" }, async ({ tui }) => {
+    await tui.pressKey("s", { ctrl: true });
+  });
+  When("I select menu item {string}", { tags: "@tui" }, async ({ tui, world }, item) => {
+    const target = interpolate(item, world.vars);
+    await tui.waitForText(target);
+    await tui.selectOption(target);
+  });
+  When("I open the menu", { tags: "@tui" }, async ({ tui }) => {
+    await tui.pressKey("m", { alt: true });
+  });
+  When("I select from dropdown {string} value {string}", { tags: "@tui" }, async ({ tui, world }, dropdown, value) => {
+    const dropdownLabel = interpolate(dropdown, world.vars);
+    const selectedValue = interpolate(value, world.vars);
+    await tui.waitForText(dropdownLabel);
+    await tui.pressKey("enter");
+    await tui.waitForText(selectedValue);
+    await tui.pressKey("enter");
+  });
+  When("I press ctrl+{word}", { tags: "@tui" }, async ({ tui }, key) => {
+    await tui.pressKey(key, { ctrl: true });
+  });
+  When("I press alt+{word}", { tags: "@tui" }, async ({ tui }, key) => {
+    await tui.pressKey(key, { alt: true });
+  });
+  When("I press shift+{word}", { tags: "@tui" }, async ({ tui }, key) => {
+    await tui.pressKey(key, { shift: true });
+  });
+  When("I press ctrl+shift+{word}", { tags: "@tui" }, async ({ tui }, key) => {
+    await tui.pressKey(key, { ctrl: true, shift: true });
+  });
+  When("I quit the application", { tags: "@tui" }, async ({ tui }) => {
+    await tui.pressKey("q");
+  });
+  When("I force quit the application", { tags: "@tui" }, async ({ tui }) => {
+    await tui.pressKey("c", { ctrl: true });
+  });
+  Then("line {int} should contain {string}", { tags: "@tui" }, async ({ tui, world }, lineNum, text) => {
+    const lines = await tui.getScreenLines();
+    const expectedText = interpolate(text, world.vars);
+    const lineIndex = lineNum - 1;
+    if (lineIndex < 0 || lineIndex >= lines.length) {
+      throw new Error(`Line ${lineNum} does not exist. Screen has ${lines.length} lines.`);
+    }
+    if (!lines[lineIndex].includes(expectedText)) {
+      throw new Error(`Expected line ${lineNum} to contain "${expectedText}"
+Actual: "${lines[lineIndex]}"`);
+    }
+  });
+  Then("the first line should contain {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+    const lines = await tui.getScreenLines();
+    const expectedText = interpolate(text, world.vars);
+    if (!lines[0]?.includes(expectedText)) {
+      throw new Error(`Expected first line to contain "${expectedText}"
+Actual: "${lines[0]}"`);
+    }
+  });
+  Then("the last line should contain {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+    const lines = await tui.getScreenLines();
+    const expectedText = interpolate(text, world.vars);
+    const lastLine = lines[lines.length - 1] || "";
+    if (!lastLine.includes(expectedText)) {
+      throw new Error(`Expected last line to contain "${expectedText}"
+Actual: "${lastLine}"`);
+    }
+  });
+  Then("I should see all of:", { tags: "@tui" }, async ({ tui, world }, dataTable) => {
+    const rows = dataTable.raw();
+    for (const row of rows) {
+      const text = interpolate(row[0], world.vars);
+      await tui.expectText(text);
+    }
+  });
+  Then("I should not see any of:", { tags: "@tui" }, async ({ tui, world }, dataTable) => {
+    const rows = dataTable.raw();
+    for (const row of rows) {
+      const text = interpolate(row[0], world.vars);
+      await tui.expectNotText(text);
+    }
+  });
+  When("I capture the screen", { tags: "@tui" }, async ({ tui, world }) => {
+    const capture = await tui.captureScreen();
+    world.vars["lastScreenCapture"] = capture.text;
+  });
+  Then("I print the screen", { tags: "@tui" }, async ({ tui }) => {
+    const text = await tui.getScreenText();
+    console.log("=== Screen Content ===");
+    console.log(text);
+    console.log("======================");
+  });
+  When("I execute command {string}", { tags: "@tui" }, async ({ tui, world }, command) => {
+    const cmd = interpolate(command, world.vars);
+    await tui.typeText(cmd);
+    await tui.pressKey("enter");
+  });
+  When("I run {string}", { tags: "@tui" }, async ({ tui, world }, command) => {
+    const cmd = interpolate(command, world.vars);
+    await tui.typeText(cmd);
+    await tui.pressKey("enter");
+  });
+  When("I confirm the dialog", { tags: "@tui" }, async ({ tui }) => {
+    await tui.typeText("y");
+    await tui.pressKey("enter");
+  });
+  When("I cancel the dialog", { tags: "@tui" }, async ({ tui }) => {
+    await tui.typeText("n");
+    await tui.pressKey("enter");
+  });
+  When("I dismiss the dialog", { tags: "@tui" }, async ({ tui }) => {
+    await tui.pressKey("escape");
+  });
+}
+
+// src/steps/index.ts
+function registerApiSteps(test) {
+  registerApiAuthSteps(test);
+  registerApiHttpSteps(test);
+  registerApiAssertionSteps(test);
+}
+function registerUiSteps(test) {
+  registerUiBasicSteps(test);
+  registerWizardSteps(test);
+}
+function registerSharedSteps(test) {
+  registerSharedVarSteps(test);
+  registerSharedCleanupSteps(test);
+}
+function registerHybridSuite(test) {
+  registerHybridSteps(test);
+}
+function registerTuiSteps(test) {
+  registerTuiBasicSteps(test);
+  registerTuiWizardSteps(test);
+}
+
+export {
+  interpolate,
+  tryParseJson,
+  selectPath,
+  parseExpected,
+  assertMasked,
+  registerCleanup,
+  registerApiHttpSteps,
+  registerApiAssertionSteps,
+  registerApiAuthSteps,
+  registerHybridSteps,
+  registerSharedCleanupSteps,
+  registerSharedVarSteps,
+  registerUiBasicSteps,
+  registerWizardSteps,
+  registerTuiBasicSteps,
+  registerTuiWizardSteps,
+  registerApiSteps,
+  registerUiSteps,
+  registerSharedSteps,
+  registerHybridSuite,
+  registerTuiSteps
+};