@esimplicitylabs/katalyst-xspec 0.6.0 → 0.7.1

package/dist/{chunk-ACAXOGKZ.js → chunk-UTTKW2SR.js}

@@ -93,23 +93,23 @@ function registerApiHttpSteps(test) {
     world.lastContentType = result.contentType;
     world.lastResponse = result.response;
   }
-  When("I GET {string}", { tags: "@api or @hybrid" }, async ({ api, world }, path) => {
+  When("I GET {string}", async ({ api, world }, path) => {
     await send({ api, world }, "GET", path);
   });
-  When("I DELETE {string}", { tags: "@api or @hybrid" }, async ({ api, world }, path) => {
+  When("I DELETE {string}", async ({ api, world }, path) => {
     await send({ api, world }, "DELETE", path);
   });
-  When("I POST {string} with JSON body:", { tags: "@api or @hybrid" }, async ({ api, world }, path, docString) => {
+  When("I POST {string} with JSON body:", 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 or @hybrid" }, async ({ api, world }, path, docString) => {
+  When("I PATCH {string} with JSON body:", 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 or @hybrid" }, async ({ api, world }, path, docString) => {
+  When("I PUT {string} with JSON body:", async ({ api, world }, path, docString) => {
     const interpolated = interpolate(docString ?? "", world.vars);
     const parsed = tryParseJson(interpolated) ?? interpolated;
     await send({ api, world }, "PUT", path, parsed);
@@ -121,22 +121,22 @@ 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 or @hybrid" }, async ({ world }, code) => {
+  Then("the response status should be {int}", async ({ world }, code) => {
     expect2(world.lastStatus, `Unexpected status. Body: ${world.lastText}`).toBe(code);
   });
-  Then("the response should be a JSON array", { tags: "@api or @hybrid" }, async ({ world }) => {
+  Then("the response should be a JSON array", 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 or @hybrid" }, async ({ world }) => {
+  Then("the response should be a JSON object", 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 or @hybrid" }, async ({ world }, path, expectedRaw) => {
+  Then("the value at {string} should equal {string}", 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 or @hybrid" }, async ({ world, cleanup }, path, varName) => {
+  Then("I store the value at {string} as {string}", async ({ world, cleanup }, path, varName) => {
     const val = selectPath(world.lastJson, path);
     world.vars[varName] = String(val);
     cleanup.registerFromVar(world, varName, val, world.lastJson);
@@ -147,13 +147,13 @@ function registerApiAssertionSteps(test) {
 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 or @hybrid" }, async ({ auth, world }) => {
+  Given("I am authenticated as an admin via API", async ({ auth, world }) => {
     await auth.apiLoginAsAdmin(world);
   });
-  Given("I am authenticated as a user via API", { tags: "@api or @hybrid" }, async ({ auth, world }) => {
+  Given("I am authenticated as a user via API", async ({ auth, world }) => {
     await auth.apiLoginAsUser(world);
   });
-  Given("I set bearer token from variable {string}", { tags: "@api or @hybrid" }, async ({ auth, world }, varName) => {
+  Given("I set bearer token from variable {string}", async ({ auth, world }, varName) => {
     const token = world.vars[varName];
     if (!token) throw new Error(`No token found in variable '${varName}'`);
     auth.apiSetBearer(world, token);
@@ -164,7 +164,7 @@ function registerApiAuthSteps(test) {
 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) => {
+  Given("I navigate to interpolated path {string}", async ({ ui, world }, path) => {
     await ui.goto(interpolate(path, world.vars));
   });
 }
@@ -332,42 +332,41 @@ async function expectElementAttribute(page, selector, attribute, value, options)
 // src/steps/ui.basic.ts
 function registerUiBasicSteps(test) {
   const { Given, When, Then } = createBdd8(test);
-  Given("I navigate to {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, path) => {
+  Given("I navigate to {string}", async ({ ui, world }, path) => {
     await ui.goto(interpolate(path, world.vars));
   });
-  When("I click the button {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, name) => {
+  When("I click the button {string}", async ({ ui, world }, name) => {
     await ui.clickButton(interpolate(name, world.vars));
   });
-  When("I click the {string} button", { tags: "@ui or @hybrid" }, async ({ ui, world }, name) => {
+  When("I click the {string} button", async ({ ui, world }, name) => {
     await ui.clickButton(interpolate(name, world.vars));
   });
-  When("I click the link {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, name) => {
+  When("I click the link {string}", async ({ ui, world }, name) => {
     await ui.clickLink(interpolate(name, world.vars));
   });
-  When("I fill the placeholder {string} with {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, placeholder, value) => {
+  When("I fill the placeholder {string} with {string}", 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 or @hybrid" }, async ({ ui, world }, label, value) => {
+  When("I fill the field {string} with {string}", async ({ ui, world }, label, value) => {
     await ui.fillLabel(interpolate(label, world.vars), interpolate(value, world.vars));
   });
-  When("I fill in {string} with {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, label, value) => {
+  When("I fill in {string} with {string}", 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 or @hybrid" }, async ({ auth, world }) => {
+  When("I log in as admin in UI", async ({ auth, world }) => {
     await auth.uiLoginAsAdmin(world);
   });
-  When("I log in as user in UI", { tags: "@ui or @hybrid" }, async ({ auth, world }) => {
+  When("I log in as user in UI", async ({ auth, world }) => {
     await auth.uiLoginAsUser(world);
   });
-  When("I click the element {string}", { tags: "@ui or @hybrid" }, async ({ page, world }, selector) => {
+  When("I click the element {string}", async ({ page, world }, selector) => {
     await page.locator(interpolate(selector, world.vars)).click();
   });
-  When("I select {string} from dropdown {string}", { tags: "@ui or @hybrid" }, async ({ page, world }, option, selector) => {
+  When("I select {string} from dropdown {string}", async ({ page, world }, option, selector) => {
     await page.locator(interpolate(selector, world.vars)).selectOption({ label: interpolate(option, world.vars) });
   });
   When(
     "I set the file input {string} to a file named {string} with content {string}",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, selector, fileName, content) => {
       await setFileInputContent(
         page,
@@ -377,25 +376,25 @@ function registerUiBasicSteps(test) {
       );
     }
   );
-  Then("I should see text {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, text) => {
+  Then("I should see text {string}", async ({ ui, world }, text) => {
     await ui.expectText(interpolate(text, world.vars));
   });
-  Then("the URL should contain {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, part) => {
+  Then("the URL should contain {string}", async ({ ui, world }, part) => {
     await ui.expectUrlContains(interpolate(part, world.vars));
   });
-  Then("I should be on page {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, path) => {
+  Then("I should be on page {string}", async ({ ui, world }, path) => {
     await ui.expectUrlContains(interpolate(path, world.vars));
   });
-  Then("the element {string} should be visible", { tags: "@ui or @hybrid" }, async ({ page, world }, selector) => {
+  Then("the element {string} should be visible", async ({ page, world }, selector) => {
     await expect4(page.locator(interpolate(selector, world.vars))).toBeVisible();
   });
-  Then("the element {string} should not be visible", { tags: "@ui or @hybrid" }, async ({ page, world }, selector) => {
+  Then("the element {string} should not be visible", async ({ page, world }, selector) => {
     await expect4(page.locator(interpolate(selector, world.vars))).not.toBeVisible();
   });
-  Then("the element {string} should have value {string}", { tags: "@ui or @hybrid" }, async ({ page, world }, selector, value) => {
+  Then("the element {string} should have value {string}", async ({ page, world }, selector, value) => {
     await expect4(page.locator(interpolate(selector, world.vars))).toHaveValue(interpolate(value, world.vars));
   });
-  Then("the element {string} should have attribute {string} equal to {string}", { tags: "@ui or @hybrid" }, async ({ page, world }, selector, attribute, value) => {
+  Then("the element {string} should have attribute {string} equal to {string}", async ({ page, world }, selector, attribute, value) => {
     await expectElementAttribute(
       page,
       interpolate(selector, world.vars),
@@ -403,10 +402,10 @@ function registerUiBasicSteps(test) {
       interpolate(value, world.vars)
     );
   });
-  Then("the element {string} should be checked", { tags: "@ui or @hybrid" }, async ({ page, world }, selector) => {
+  Then("the element {string} should be checked", async ({ page, world }, selector) => {
     await expect4(page.locator(interpolate(selector, world.vars))).toBeChecked();
   });
-  Then("the element {string} should not be checked", { tags: "@ui or @hybrid" }, async ({ page, world }, selector) => {
+  Then("the element {string} should not be checked", async ({ page, world }, selector) => {
     await expect4(page.locator(interpolate(selector, world.vars))).not.toBeChecked();
   });
 }
@@ -511,36 +510,35 @@ function parseRegex(input) {
 }
 function registerWizardSteps(test) {
   const { Given, When, Then } = createBdd9(test);
-  Given("I open {string} page", { tags: "@ui or @hybrid" }, async ({ ui, world }, urlOrVar) => {
+  Given("I open {string} page", async ({ ui, world }, urlOrVar) => {
     await ui.goto(resolveValue(urlOrVar, world));
   });
-  Given("I open {string} in the browser", { tags: "@ui or @hybrid" }, async ({ ui, world }, urlOrVar) => {
+  Given("I open {string} in the browser", async ({ ui, world }, urlOrVar) => {
     await ui.goto(resolveValue(urlOrVar, world));
   });
-  When("I go back in the browser", { tags: "@ui or @hybrid" }, async ({ ui }) => {
+  When("I go back in the browser", async ({ ui }) => {
     await ui.goBack();
   });
-  When("I save the current URL as {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, varName) => {
+  When("I save the current URL as {string}", async ({ ui, world }, varName) => {
     world.vars[varName] = await ui.getCurrentUrl();
   });
-  When("I save the current url as {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, varName) => {
+  When("I save the current url as {string}", async ({ ui, world }, varName) => {
     world.vars[varName] = await ui.getCurrentUrl();
   });
-  Then("I zoom to {string} in the browser", { tags: "@ui or @hybrid" }, async ({ ui, world }, scale) => {
+  Then("I zoom to {string} in the browser", async ({ ui, world }, scale) => {
     await ui.zoomTo(parseNumber(scale, world));
   });
-  When("I reload the page", { tags: "@ui or @hybrid" }, async ({ ui }) => {
+  When("I reload the page", async ({ ui }) => {
     await ui.reload();
   });
-  Then("I wait {string} seconds", { tags: "@ui or @hybrid" }, async ({ ui, world }, seconds) => {
+  Then("I wait {string} seconds", async ({ ui, world }, seconds) => {
     await ui.waitSeconds(parseNumber(seconds, world));
   });
-  Then("I wait for the page to load", { tags: "@ui or @hybrid" }, async ({ ui }) => {
+  Then("I wait for the page to load", 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 or @hybrid" },
     async ({ ui, world }, regexString, varName) => {
       const url = await ui.getCurrentUrl();
       const regex = parseRegex(resolveValue(regexString, world));
@@ -549,7 +547,7 @@ function registerWizardSteps(test) {
       world.vars[varName] = match[1] ?? match[0];
     }
   );
-  Then("I {string} {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, action, value) => {
+  Then("I {string} {string}", async ({ ui, world }, action, value) => {
     const verb = action.trim().toLowerCase();
     const resolved = resolveValue(value, world);
     if (verb === "type") {
@@ -564,7 +562,6 @@ function registerWizardSteps(test) {
   });
   When(
     "I {string} the {string} element that contains {string}",
-    { tags: "@ui or @hybrid" },
     async ({ ui, world }, clickMode, elementType, text) => {
       await ui.clickElementThatContains(
         asClickMode(resolveValue(clickMode, world)),
@@ -575,7 +572,6 @@ function registerWizardSteps(test) {
   );
   When(
     "I {string} the {string} element with {string} {string}",
-    { tags: "@ui or @hybrid" },
     async ({ ui, world }, clickMode, ordinal, text, method) => {
       await ui.clickElementWith(
         asClickMode(resolveValue(clickMode, world)),
@@ -585,12 +581,11 @@ function registerWizardSteps(test) {
       );
     }
   );
-  When("I click on the top left corner of the page", { tags: "@ui or @hybrid" }, async ({ page }) => {
+  When("I click on the top left corner of the page", async ({ page }) => {
     await page.mouse.click(0, 0);
   });
   When(
     "If its visible, I {string} the {string} element with {string} {string}",
-    { tags: "@ui or @hybrid" },
     async ({ page, ui, world }, clickMode, ordinal, text, method) => {
       const idx = parseOrdinalIndex(ordinal, world);
       const resolvedText = resolveValue(text, world);
@@ -601,12 +596,11 @@ function registerWizardSteps(test) {
       await ui.clickElementWith(asClickMode(resolveValue(clickMode, world)), ordinal, resolvedText, resolvedMethod);
     }
   );
-  Then("I fill {string} into the {string} dropdown", { tags: "@ui or @hybrid" }, async ({ ui, world }, value, label) => {
+  Then("I fill {string} into the {string} dropdown", 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 or @hybrid" },
     async ({ ui, world }, action, value, ordinal, text, method) => {
       await ui.inputInElement(
         asInputMode(resolveValue(action, world)),
@@ -619,33 +613,30 @@ function registerWizardSteps(test) {
   );
   Then(
     "I verify if a new tab which URL {string} {string} opens",
-    { tags: "@ui or @hybrid" },
     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 or @hybrid" },
     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 or @hybrid" }, async ({ ui, world }, mode, expected) => {
+  Then("I verify if the URL {string} {string}", 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 or @hybrid" }, async ({ ui, world }, mode, expected) => {
+  Then("I verify if the url {string} {string}", 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 or @hybrid" }, async ({ ui, world }, mode, expected) => {
+  Then("I verify if the URL {string} {string} opens", 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 or @hybrid" }, async ({ ui, world }, mode, expected) => {
+  Then("I verify if the url {string} {string} opens", 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 or @hybrid" },
     async ({ ui, world }, elementType, text, assertion) => {
       const normalized = resolveValue(assertion, world).trim().toLowerCase();
       const shouldBeVisible = normalized === "is";
@@ -657,7 +648,6 @@ function registerWizardSteps(test) {
   );
   Then(
     "I verify that {string} element with {string} {string} is {string}",
-    { tags: "@ui or @hybrid" },
     async ({ ui, world }, ordinal, text, method, state) => {
       await ui.expectElementState(
         resolveValue(ordinal, world),
@@ -669,7 +659,6 @@ function registerWizardSteps(test) {
   );
   Then(
     "I verify that {string} element with {string} {string} becomes {string} during {string} seconds",
-    { tags: "@ui or @hybrid" },
     async ({ ui, world }, ordinal, text, method, state, seconds) => {
       await ui.expectElementStateWithin(
         resolveValue(ordinal, world),
@@ -688,7 +677,6 @@ function registerFormSteps(test) {
   const { Given, When } = createBdd10(test);
   When(
     "I fill the form:",
-    { tags: "@ui or @hybrid" },
     async ({ ui, world }, dataTable) => {
       const rows = dataTable.hashes ? dataTable.hashes() : dataTable.rawTable?.slice(1).map((row) => ({
         field: row[0],
@@ -703,7 +691,6 @@ function registerFormSteps(test) {
   );
   When(
     "I fill the form with {string} locators:",
-    { tags: "@ui or @hybrid" },
     async ({ ui, world }, locatorMethod, dataTable) => {
       const rows = dataTable.hashes ? dataTable.hashes() : dataTable.rawTable?.slice(1).map((row) => ({
         field: row[0],
@@ -718,7 +705,6 @@ function registerFormSteps(test) {
   );
   When(
     "I fill and submit the form:",
-    { tags: "@ui or @hybrid" },
     async ({ ui, world }, dataTable) => {
       const rows = dataTable.hashes ? dataTable.hashes() : dataTable.rawTable?.slice(1).map((row) => ({
         field: row[0],
@@ -734,7 +720,6 @@ function registerFormSteps(test) {
   );
   Given(
     "I clear and fill the form:",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, dataTable) => {
       const rows = dataTable.hashes ? dataTable.hashes() : dataTable.rawTable?.slice(1).map((row) => ({
         field: row[0],
@@ -757,7 +742,6 @@ function registerDebugSteps(test) {
   const { When, Then } = createBdd11(test);
   When(
     "I capture the page HTML as {string}",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, varName) => {
       const content = await page.content();
       world.vars[varName] = content;
@@ -765,14 +749,12 @@ function registerDebugSteps(test) {
   );
   Then(
     "I log the current URL",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       console.log(`[DEBUG] Current URL: ${page.url()}`);
     }
   );
   Then(
     "I log the page title",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const title = await page.title();
       console.log(`[DEBUG] Page title: ${title}`);
@@ -780,7 +762,6 @@ function registerDebugSteps(test) {
   );
   When(
     "I save a screenshot as {string}",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, filename) => {
       const resolvedFilename = interpolate(filename, world.vars);
       await page.screenshot({ path: resolvedFilename });
@@ -789,7 +770,6 @@ function registerDebugSteps(test) {
   );
   When(
     "I save a full page screenshot as {string}",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, filename) => {
       const resolvedFilename = interpolate(filename, world.vars);
       await page.screenshot({ path: resolvedFilename, fullPage: true });
@@ -798,7 +778,6 @@ function registerDebugSteps(test) {
   );
   When(
     "I pause for debugging",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       console.log('[DEBUG] Pausing for debugging. Press "Resume" in Playwright Inspector to continue.');
       await page.pause();
@@ -806,7 +785,6 @@ function registerDebugSteps(test) {
   );
   Then(
     "I print visible text",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const text = await page.innerText("body");
       const truncated = text.length > 2e3 ? `${text.substring(0, 2e3)}...(truncated)` : text;
@@ -816,7 +794,6 @@ ${truncated}`);
   );
   Then(
     "I count elements matching {string}",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, selector) => {
       const resolvedSelector = interpolate(selector, world.vars);
       const count = await page.locator(resolvedSelector).count();
@@ -825,7 +802,6 @@ ${truncated}`);
   );
   Then(
     "I print browser console messages",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       console.log("[DEBUG] Browser console messages will be captured from this point.");
       page.on("console", (msg) => {
@@ -835,7 +811,6 @@ ${truncated}`);
   );
   When(
     "I capture viewport size",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }) => {
       const viewport = page.viewportSize();
       if (viewport) {
@@ -849,7 +824,6 @@ ${truncated}`);
   );
   Then(
     "I log all cookies",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const context = page.context();
       const cookies = await context.cookies();
@@ -861,7 +835,6 @@ ${truncated}`);
   );
   Then(
     "I log localStorage",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const storage = await page.evaluate(() => {
         const items = {};
@@ -882,7 +855,6 @@ ${truncated}`);
   );
   When(
     "I highlight element {string}",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, selector) => {
       const resolvedSelector = interpolate(selector, world.vars);
       await page.evaluate((sel) => {
@@ -904,7 +876,6 @@ function registerLayoutSteps(test) {
   const { Given, When, Then } = createBdd12(test);
   Then(
     "I should see the {string} panel",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, panelName) => {
       const resolvedName = interpolate(panelName, world.vars);
       const panel = page.getByTestId(`${resolvedName}-panel`);
@@ -913,7 +884,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "I should not see the {string} panel",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, panelName) => {
       const resolvedName = interpolate(panelName, world.vars);
       const panel = page.getByTestId(`${resolvedName}-panel`);
@@ -922,7 +892,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "the {string} panel should be {string}",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, panelName, state) => {
       const resolvedName = interpolate(panelName, world.vars);
       const panel = page.getByTestId(`${resolvedName}-panel`);
@@ -937,7 +906,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "the {string} panel should be full width",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, panelName) => {
       const resolvedName = interpolate(panelName, world.vars);
       const panel = page.getByTestId(`${resolvedName}-panel`);
@@ -949,7 +917,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "the {string} panel should be narrow",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, panelName) => {
       const resolvedName = interpolate(panelName, world.vars);
       const panel = page.getByTestId(`${resolvedName}-panel`);
@@ -961,7 +928,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "I should see a split view layout",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const splitContainer = page.locator("[data-testid='split-view'], .split-view, [data-split-view]");
       await expect5(splitContainer.first()).toBeVisible();
@@ -969,7 +935,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "I should not see a split view layout",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const splitContainer = page.locator("[data-testid='split-view'], .split-view, [data-split-view]");
       const count = await splitContainer.count();
@@ -978,7 +943,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "the sidebar should be visible",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const sidebar = page.locator("[data-testid='sidebar'], aside, nav.sidebar, .sidebar");
       await expect5(sidebar.first()).toBeVisible();
@@ -986,7 +950,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "the sidebar should be hidden",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const sidebar = page.locator("[data-testid='sidebar'], aside.sidebar, nav.sidebar");
       const count = await sidebar.count();
@@ -997,7 +960,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "the sidebar should be collapsed",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const sidebar = page.locator("[data-testid='sidebar'], aside, nav.sidebar, .sidebar").first();
       const isCollapsed = await sidebar.evaluate((el) => {
@@ -1008,7 +970,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "I should see a modal dialog",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const modal = page.locator("[role='dialog'], [data-testid='modal'], .modal, [aria-modal='true']");
       await expect5(modal.first()).toBeVisible();
@@ -1016,7 +977,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "I should not see a modal dialog",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const modal = page.locator("[role='dialog'], [data-testid='modal'], .modal, [aria-modal='true']");
       const count = await modal.count();
@@ -1027,7 +987,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "I should see the {string} modal",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, modalName) => {
       const resolvedName = interpolate(modalName, world.vars);
       const modal = page.getByTestId(`${resolvedName}-modal`);
@@ -1036,7 +995,6 @@ function registerLayoutSteps(test) {
   );
   Given(
     "the viewport is {string} size",
-    { tags: "@ui or @hybrid" },
     async ({ page }, sizeName) => {
       const sizes = {
         mobile: { width: 375, height: 667 },
@@ -1053,14 +1011,12 @@ function registerLayoutSteps(test) {
   );
   Given(
     "the viewport is {int}x{int}",
-    { tags: "@ui or @hybrid" },
     async ({ page }, width, height) => {
       await page.setViewportSize({ width, height });
     }
   );
   Then(
     "the layout should be responsive",
-    { tags: "@ui or @hybrid" },
     async ({ page }) => {
       const original = page.viewportSize();
       await page.setViewportSize({ width: 375, height: 667 });
@@ -1074,7 +1030,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "the {string} tab should be active",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, tabName) => {
       const resolvedName = interpolate(tabName, world.vars);
       const tab = page.getByRole("tab", { name: resolvedName });
@@ -1083,7 +1038,6 @@ function registerLayoutSteps(test) {
   );
   Then(
     "the {string} tab should not be active",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, tabName) => {
       const resolvedName = interpolate(tabName, world.vars);
       const tab = page.getByRole("tab", { name: resolvedName });
@@ -1092,7 +1046,6 @@ function registerLayoutSteps(test) {
   );
   When(
     "I click the {string} tab",
-    { tags: "@ui or @hybrid" },
     async ({ page, world }, tabName) => {
       const resolvedName = interpolate(tabName, world.vars);
       const tab = page.getByRole("tab", { name: resolvedName });
@@ -1174,7 +1127,6 @@ function registerUiAuthSteps(test) {
   const { Given } = createBdd13(test);
   Given(
     "I am authenticated in UI as {string}",
-    { tags: "@ui" },
     async ({ page, world }, rolesStr) => {
       const roles = rolesStr.split(",").map((r) => r.trim());
       const testRunId = world.testRunId || world.vars.test_run_id || Date.now();
@@ -1192,7 +1144,6 @@ function registerUiAuthSteps(test) {
   );
   Given(
     "I am authenticated in UI as {string} for tenant {string}",
-    { tags: "@ui" },
     async ({ page, world }, rolesStr, tenantId) => {
       const roles = rolesStr.split(",").map((r) => r.trim());
       const testRunId = world.testRunId || world.vars.test_run_id || Date.now();
@@ -1207,7 +1158,6 @@ function registerUiAuthSteps(test) {
   );
   Given(
     "I am authenticated in UI as {string} with id {string}",
-    { tags: "@ui" },
     async ({ page, world }, rolesStr, userId) => {
       const roles = rolesStr.split(",").map((r) => r.trim());
       const resolvedUserId = interpolate(userId, world.vars);
@@ -1221,7 +1171,6 @@ function registerUiAuthSteps(test) {
   );
   Given(
     "I am authenticated in UI with bearer token {string}",
-    { tags: "@ui" },
     async ({ page, world }, token) => {
       const resolvedToken = interpolate(token, world.vars);
       await setupBearerAuth(page, resolvedToken);
@@ -1230,7 +1179,6 @@ function registerUiAuthSteps(test) {
   );
   Given(
     "I am authenticated in UI with headers:",
-    { tags: "@ui" },
     async ({ page, world }, dataTable) => {
       const rows = dataTable.hashes ? dataTable.hashes() : dataTable.rawTable?.slice(1).map((row) => ({
         header: row[0],
@@ -1254,7 +1202,6 @@ function registerUiAuthSteps(test) {
   );
   Given(
     "I switch UI user to {string} with id {string}",
-    { tags: "@ui" },
     async ({ page, world }, rolesStr, userId) => {
       const roles = rolesStr.split(",").map((r) => r.trim());
       const resolvedUserId = interpolate(userId, world.vars);
@@ -1272,121 +1219,115 @@ function registerUiAuthSteps(test) {
 import { createBdd as createBdd14 } from "playwright-bdd";
 function registerTuiBasicSteps(test) {
   const { Given, When, Then } = createBdd14(test);
-  Given("I start the TUI application", { tags: "@tui" }, async ({ tui }) => {
+  Given("I start the TUI application", async ({ tui }) => {
     await tui.start();
     await tui.waitForReady();
   });
-  Given("the TUI application is running", { tags: "@tui" }, async ({ tui }) => {
+  Given("the TUI application is running", async ({ tui }) => {
     if (!tui.isRunning()) {
       await tui.start();
       await tui.waitForReady();
     }
   });
-  When("I restart the TUI application", { tags: "@tui" }, async ({ tui }) => {
+  When("I restart the TUI application", async ({ tui }) => {
     await tui.restart();
     await tui.waitForReady();
   });
-  When("I stop the TUI application", { tags: "@tui" }, async ({ tui }) => {
+  When("I stop the TUI application", async ({ tui }) => {
     await tui.stop();
   });
-  When("I type {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+  When("I type {string}", async ({ tui, world }, text) => {
     await tui.typeText(interpolate(text, world.vars));
   });
-  When("I type {string} slowly", { tags: "@tui" }, async ({ tui, world }, text) => {
+  When("I type {string} slowly", async ({ tui, world }, text) => {
     await tui.typeText(interpolate(text, world.vars), { delay: 50 });
   });
-  When("I press {string}", { tags: "@tui" }, async ({ tui }, key) => {
+  When("I press {string}", async ({ tui }, key) => {
     await tui.pressKey(key);
   });
-  When("I press {string} with ctrl", { tags: "@tui" }, async ({ tui }, key) => {
+  When("I press {string} with ctrl", async ({ tui }, key) => {
     await tui.pressKey(key, { ctrl: true });
   });
-  When("I press {string} with alt", { tags: "@tui" }, async ({ tui }, key) => {
+  When("I press {string} with alt", async ({ tui }, key) => {
     await tui.pressKey(key, { alt: true });
   });
-  When("I press {string} with shift", { tags: "@tui" }, async ({ tui }, key) => {
+  When("I press {string} with shift", async ({ tui }, key) => {
     await tui.pressKey(key, { shift: true });
   });
-  When("I press enter", { tags: "@tui" }, async ({ tui }) => {
+  When("I press enter", async ({ tui }) => {
     await tui.pressKey("enter");
   });
-  When("I press tab", { tags: "@tui" }, async ({ tui }) => {
+  When("I press tab", async ({ tui }) => {
     await tui.pressKey("tab");
   });
-  When("I press escape", { tags: "@tui" }, async ({ tui }) => {
+  When("I press escape", 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) => {
+  When("I select {string}", async ({ tui, world }, option) => {
     await tui.selectOption(interpolate(option, world.vars));
   });
-  When("I select option {string}", { tags: "@tui" }, async ({ tui, world }, option) => {
+  When("I select option {string}", async ({ tui, world }, option) => {
     await tui.selectOption(interpolate(option, world.vars));
   });
-  When("I click at position {int}, {int}", { tags: "@tui" }, async ({ tui }, x, y) => {
+  When("I click at position {int}, {int}", async ({ tui }, x, y) => {
     await tui.click(x, y);
   });
-  When("I click on {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+  When("I click on {string}", async ({ tui, world }, text) => {
     await tui.clickOnText(interpolate(text, world.vars));
   });
-  Then("I should see {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+  Then("I should see {string}", 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) => {
+  Then("I should see {string} in the terminal", 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) => {
+  Then("I should not see {string}", async ({ tui, world }, text) => {
     await tui.expectNotText(interpolate(text, world.vars));
   });
-  Then("the screen should contain {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+  Then("the screen should contain {string}", async ({ tui, world }, text) => {
     await tui.assertScreenContains(interpolate(text, world.vars));
   });
-  Then("the screen should match pattern {string}", { tags: "@tui" }, async ({ tui }, pattern) => {
+  Then("the screen should match pattern {string}", async ({ tui }, pattern) => {
     await tui.assertScreenMatches(new RegExp(pattern));
   });
-  When("I wait for {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+  When("I wait for {string}", 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) => {
+  When("I wait {int} seconds", async ({ tui }, seconds) => {
     await tui.waitSeconds(seconds);
   });
-  Then("the screen should match snapshot {string}", { tags: "@tui" }, async ({ tui }, name) => {
+  Then("the screen should match snapshot {string}", 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) => {
+  Then("I take a snapshot named {string}", async ({ tui }, name) => {
     await tui.takeSnapshot(name);
   });
-  When("I clear the terminal", { tags: "@tui" }, async ({ tui }) => {
+  When("I clear the terminal", async ({ tui }) => {
     await tui.clear();
   });
-  When("I resize the terminal to {int}x{int}", { tags: "@tui" }, async ({ tui }, cols, rows) => {
+  When("I resize the terminal to {int}x{int}", async ({ tui }, cols, rows) => {
     await tui.resize({ cols, rows });
   });
 }
@@ -1395,25 +1336,25 @@ ${result.diff || "No diff available"}`);
 import { createBdd as createBdd15 } from "playwright-bdd";
 function registerTuiWizardSteps(test) {
   const { Given, When, Then } = createBdd15(test);
-  When("I navigate down {int} times", { tags: "@tui" }, async ({ tui }, times) => {
+  When("I navigate down {int} times", 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) => {
+  When("I navigate up {int} times", 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) => {
+  When("I navigate to {string} and select", 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 }) => {
+  When("I go back", async ({ tui }) => {
     await tui.pressKey("escape");
   });
-  When("I fill the form:", { tags: "@tui" }, async ({ tui, world }, dataTable) => {
+  When("I fill the TUI form:", async ({ tui, world }, dataTable) => {
     const rows = dataTable.hashes();
     for (const row of rows) {
       const field = interpolate(row.field || row.Field, world.vars);
@@ -1422,21 +1363,21 @@ function registerTuiWizardSteps(test) {
       await tui.pressKey("tab");
     }
   });
-  When("I submit the form", { tags: "@tui" }, async ({ tui }) => {
+  When("I submit the form", async ({ tui }) => {
     await tui.pressKey("enter");
   });
-  When("I submit the form with ctrl+s", { tags: "@tui" }, async ({ tui }) => {
+  When("I submit the form with ctrl+s", async ({ tui }) => {
     await tui.pressKey("s", { ctrl: true });
   });
-  When("I select menu item {string}", { tags: "@tui" }, async ({ tui, world }, item) => {
+  When("I select menu item {string}", 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 }) => {
+  When("I open the menu", async ({ tui }) => {
     await tui.pressKey("m", { alt: true });
   });
-  When("I select from dropdown {string} value {string}", { tags: "@tui" }, async ({ tui, world }, dropdown, value) => {
+  When("I select from dropdown {string} value {string}", async ({ tui, world }, dropdown, value) => {
     const dropdownLabel = interpolate(dropdown, world.vars);
     const selectedValue = interpolate(value, world.vars);
     await tui.waitForText(dropdownLabel);
@@ -1444,25 +1385,25 @@ function registerTuiWizardSteps(test) {
     await tui.waitForText(selectedValue);
     await tui.pressKey("enter");
   });
-  When("I press ctrl+{word}", { tags: "@tui" }, async ({ tui }, key) => {
+  When(/^I press ctrl\+([^+\s]+)$/, async ({ tui }, key) => {
     await tui.pressKey(key, { ctrl: true });
   });
-  When("I press alt+{word}", { tags: "@tui" }, async ({ tui }, key) => {
+  When("I press alt+{word}", async ({ tui }, key) => {
     await tui.pressKey(key, { alt: true });
   });
-  When("I press shift+{word}", { tags: "@tui" }, async ({ tui }, key) => {
+  When("I press shift+{word}", async ({ tui }, key) => {
     await tui.pressKey(key, { shift: true });
   });
-  When("I press ctrl+shift+{word}", { tags: "@tui" }, async ({ tui }, key) => {
+  When("I press ctrl+shift+{word}", async ({ tui }, key) => {
     await tui.pressKey(key, { ctrl: true, shift: true });
   });
-  When("I quit the application", { tags: "@tui" }, async ({ tui }) => {
+  When("I quit the application", async ({ tui }) => {
     await tui.pressKey("q");
   });
-  When("I force quit the application", { tags: "@tui" }, async ({ tui }) => {
+  When("I force quit the application", async ({ tui }) => {
     await tui.pressKey("c", { ctrl: true });
   });
-  Then("line {int} should contain {string}", { tags: "@tui" }, async ({ tui, world }, lineNum, text) => {
+  Then("line {int} should contain {string}", async ({ tui, world }, lineNum, text) => {
     const lines = await tui.getScreenLines();
     const expectedText = interpolate(text, world.vars);
     const lineIndex = lineNum - 1;
@@ -1474,7 +1415,7 @@ function registerTuiWizardSteps(test) {
 Actual: "${lines[lineIndex]}"`);
     }
   });
-  Then("the first line should contain {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+  Then("the first line should contain {string}", async ({ tui, world }, text) => {
     const lines = await tui.getScreenLines();
     const expectedText = interpolate(text, world.vars);
     if (!lines[0]?.includes(expectedText)) {
@@ -1482,7 +1423,7 @@ Actual: "${lines[lineIndex]}"`);
 Actual: "${lines[0]}"`);
     }
   });
-  Then("the last line should contain {string}", { tags: "@tui" }, async ({ tui, world }, text) => {
+  Then("the last line should contain {string}", async ({ tui, world }, text) => {
     const lines = await tui.getScreenLines();
     const expectedText = interpolate(text, world.vars);
     const lastLine = lines[lines.length - 1] || "";
@@ -1491,49 +1432,49 @@ Actual: "${lines[0]}"`);
 Actual: "${lastLine}"`);
     }
   });
-  Then("I should see all of:", { tags: "@tui" }, async ({ tui, world }, dataTable) => {
+  Then("I should see all of:", 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) => {
+  Then("I should not see any of:", 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 }) => {
+  When("I capture the screen", async ({ tui, world }) => {
     const capture = await tui.captureScreen();
     world.vars["lastScreenCapture"] = capture.text;
   });
-  Then("I print the screen", { tags: "@tui" }, async ({ tui }) => {
+  Then("I print the screen", 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) => {
+  When("I execute command {string}", 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) => {
+  When("I run {string}", 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 }) => {
+  When("I confirm the dialog", async ({ tui }) => {
     await tui.typeText("y");
     await tui.pressKey("enter");
   });
-  When("I cancel the dialog", { tags: "@tui" }, async ({ tui }) => {
+  When("I cancel the dialog", async ({ tui }) => {
     await tui.typeText("n");
     await tui.pressKey("enter");
   });
-  When("I dismiss the dialog", { tags: "@tui" }, async ({ tui }) => {
+  When("I dismiss the dialog", async ({ tui }) => {
     await tui.pressKey("escape");
   });
 }