@esimplicitylabs/katalyst-xspec 0.6.0

package/dist/chunk-ACAXOGKZ.js

@@ -0,0 +1,1611 @@
+// 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, body: item.body });
+}
+
+// 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 or @hybrid" }, async ({ api, world }, path) => {
+    await send({ api, world }, "GET", path);
+  });
+  When("I DELETE {string}", { tags: "@api or @hybrid" }, 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) => {
+    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) => {
+    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) => {
+    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 or @hybrid" }, 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 }) => {
+    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 }) => {
+    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) => {
+    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) => {
+    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 or @hybrid" }, async ({ auth, world }) => {
+    await auth.apiLoginAsAdmin(world);
+  });
+  Given("I am authenticated as a user via API", { tags: "@api or @hybrid" }, async ({ auth, world }) => {
+    await auth.apiLoginAsUser(world);
+  });
+  Given("I set bearer token from variable {string}", { tags: "@api or @hybrid" }, 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/shared.flags.ts
+import { createBdd as createBdd7 } from "playwright-bdd";
+var globalFlags = {};
+function isFlagEnabled(world, flagName) {
+  const worldFlags = world._featureFlags || {};
+  if (flagName in worldFlags) {
+    return worldFlags[flagName];
+  }
+  return globalFlags[flagName] ?? false;
+}
+function setFlag(world, flagName, enabled) {
+  if (!world._featureFlags) {
+    world._featureFlags = {};
+  }
+  world._featureFlags[flagName] = enabled;
+  world.vars[`flag_${flagName}`] = String(enabled);
+}
+function registerFlagSteps(test) {
+  const { Given, Then } = createBdd7(test);
+  Given(
+    "the feature flag {string} is enabled",
+    async ({ world }, flagName) => {
+      setFlag(world, flagName, true);
+      console.log(`[BDD] Feature flag "${flagName}" enabled`);
+    }
+  );
+  Given(
+    "the feature flag {string} is disabled",
+    async ({ world }, flagName) => {
+      setFlag(world, flagName, false);
+      console.log(`[BDD] Feature flag "${flagName}" disabled`);
+    }
+  );
+  Given(
+    "the feature flag {string} is set to {string}",
+    async ({ world }, flagName, value) => {
+      const enabled = value.toLowerCase() === "true" || value === "1";
+      setFlag(world, flagName, enabled);
+      console.log(`[BDD] Feature flag "${flagName}" set to ${enabled}`);
+    }
+  );
+  Given(
+    "the following feature flags are enabled:",
+    async ({ world }, dataTable) => {
+      const rows = dataTable.hashes ? dataTable.hashes() : dataTable.rawTable?.slice(1) || [];
+      for (const row of rows) {
+        const flagName = row.flag || row[0];
+        setFlag(world, flagName, true);
+        console.log(`[BDD] Feature flag "${flagName}" enabled`);
+      }
+    }
+  );
+  Given(
+    "the following feature flags are disabled:",
+    async ({ world }, dataTable) => {
+      const rows = dataTable.hashes ? dataTable.hashes() : dataTable.rawTable?.slice(1) || [];
+      for (const row of rows) {
+        const flagName = row.flag || row[0];
+        setFlag(world, flagName, false);
+        console.log(`[BDD] Feature flag "${flagName}" disabled`);
+      }
+    }
+  );
+  Then(
+    "the feature flag {string} should be enabled",
+    async ({ world }, flagName) => {
+      const enabled = isFlagEnabled(world, flagName);
+      if (!enabled) {
+        throw new Error(`Expected feature flag "${flagName}" to be enabled, but it was disabled`);
+      }
+    }
+  );
+  Then(
+    "the feature flag {string} should be disabled",
+    async ({ world }, flagName) => {
+      const enabled = isFlagEnabled(world, flagName);
+      if (enabled) {
+        throw new Error(`Expected feature flag "${flagName}" to be disabled, but it was enabled`);
+      }
+    }
+  );
+  Then(
+    "I log all feature flags",
+    async ({ world }) => {
+      const worldFlags = world._featureFlags || {};
+      console.log("[DEBUG] Feature flags:");
+      for (const [name, enabled] of Object.entries(worldFlags)) {
+        console.log(`  - ${name}: ${enabled ? "enabled" : "disabled"}`);
+      }
+      if (Object.keys(worldFlags).length === 0) {
+        console.log("  (no flags set)");
+      }
+    }
+  );
+}
+
+// src/steps/ui.basic.ts
+import { createBdd as createBdd8 } from "playwright-bdd";
+import { expect as expect4 } from "@playwright/test";
+
+// src/helpers/ui-element.ts
+import { expect as expect3 } from "@playwright/test";
+var MIME_TYPES = {
+  csv: "text/csv",
+  json: "application/json",
+  xml: "application/xml"
+};
+function mimeTypeForFileName(fileName) {
+  const dot = fileName.lastIndexOf(".");
+  if (dot === -1) return "text/plain";
+  return MIME_TYPES[fileName.slice(dot + 1).toLowerCase()] ?? "text/plain";
+}
+async function setFileInputContent(page, selector, fileName, content) {
+  await page.locator(selector).setInputFiles({
+    name: fileName,
+    mimeType: mimeTypeForFileName(fileName),
+    buffer: Buffer.from(content)
+  });
+}
+async function expectElementAttribute(page, selector, attribute, value, options) {
+  await expect3(page.locator(selector)).toHaveAttribute(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) => {
+    await ui.goto(interpolate(path, world.vars));
+  });
+  When("I click the button {string}", { tags: "@ui or @hybrid" }, 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) => {
+    await ui.clickButton(interpolate(name, world.vars));
+  });
+  When("I click the link {string}", { tags: "@ui or @hybrid" }, 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) => {
+    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) => {
+    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) => {
+    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 }) => {
+    await auth.uiLoginAsAdmin(world);
+  });
+  When("I log in as user in UI", { tags: "@ui or @hybrid" }, async ({ auth, world }) => {
+    await auth.uiLoginAsUser(world);
+  });
+  When("I click the element {string}", { tags: "@ui or @hybrid" }, 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) => {
+    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,
+        interpolate(selector, world.vars),
+        interpolate(fileName, world.vars),
+        interpolate(content, world.vars)
+      );
+    }
+  );
+  Then("I should see text {string}", { tags: "@ui or @hybrid" }, 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) => {
+    await ui.expectUrlContains(interpolate(part, world.vars));
+  });
+  Then("I should be on page {string}", { tags: "@ui or @hybrid" }, 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) => {
+    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) => {
+    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) => {
+    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) => {
+    await expectElementAttribute(
+      page,
+      interpolate(selector, world.vars),
+      interpolate(attribute, world.vars),
+      interpolate(value, world.vars)
+    );
+  });
+  Then("the element {string} should be checked", { tags: "@ui or @hybrid" }, 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) => {
+    await expect4(page.locator(interpolate(selector, world.vars))).not.toBeChecked();
+  });
+}
+
+// src/steps/ui.wizard.ts
+import { createBdd as createBdd9 } 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 } = createBdd9(test);
+  Given("I open {string} page", { tags: "@ui or @hybrid" }, 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) => {
+    await ui.goto(resolveValue(urlOrVar, world));
+  });
+  When("I go back in the browser", { tags: "@ui or @hybrid" }, async ({ ui }) => {
+    await ui.goBack();
+  });
+  When("I save the current URL as {string}", { tags: "@ui or @hybrid" }, 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) => {
+    world.vars[varName] = await ui.getCurrentUrl();
+  });
+  Then("I zoom to {string} in the browser", { tags: "@ui or @hybrid" }, async ({ ui, world }, scale) => {
+    await ui.zoomTo(parseNumber(scale, world));
+  });
+  When("I reload the page", { tags: "@ui or @hybrid" }, async ({ ui }) => {
+    await ui.reload();
+  });
+  Then("I wait {string} seconds", { tags: "@ui or @hybrid" }, async ({ ui, world }, seconds) => {
+    await ui.waitSeconds(parseNumber(seconds, world));
+  });
+  Then("I wait for the page to load", { tags: "@ui or @hybrid" }, 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));
+      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 or @hybrid" }, 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 or @hybrid" },
+    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 or @hybrid" },
+    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 or @hybrid" }, 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);
+      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 or @hybrid" }, 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)),
+        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 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) => {
+    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) => {
+    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) => {
+    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) => {
+    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";
+      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 or @hybrid" },
+    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 or @hybrid" },
+    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/ui.form.ts
+import { createBdd as createBdd10 } from "playwright-bdd";
+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],
+        value: row[1]
+      })) || [];
+      for (const row of rows) {
+        const field = interpolate(row.field, world.vars);
+        const value = interpolate(row.value, world.vars);
+        await ui.fillLabel(field, value);
+      }
+    }
+  );
+  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],
+        value: row[1]
+      })) || [];
+      for (const row of rows) {
+        const field = interpolate(row.field, world.vars);
+        const value = interpolate(row.value, world.vars);
+        await ui.inputInElement("fill", value, "1", field, locatorMethod);
+      }
+    }
+  );
+  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],
+        value: row[1]
+      })) || [];
+      for (const row of rows) {
+        const field = interpolate(row.field, world.vars);
+        const value = interpolate(row.value, world.vars);
+        await ui.fillLabel(field, value);
+      }
+      await ui.pressKey("Enter");
+    }
+  );
+  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],
+        value: row[1]
+      })) || [];
+      for (const row of rows) {
+        const field = interpolate(row.field, world.vars);
+        const value = interpolate(row.value, world.vars);
+        const locator = page.getByLabel(field);
+        await locator.clear();
+        await locator.fill(value);
+      }
+    }
+  );
+}
+
+// src/steps/ui.debug.ts
+import { createBdd as createBdd11 } from "playwright-bdd";
+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;
+    }
+  );
+  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}`);
+    }
+  );
+  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 });
+      console.log(`[DEBUG] Screenshot saved: ${resolvedFilename}`);
+    }
+  );
+  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 });
+      console.log(`[DEBUG] Full page screenshot saved: ${resolvedFilename}`);
+    }
+  );
+  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();
+    }
+  );
+  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;
+      console.log(`[DEBUG] Visible text:
+${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();
+      console.log(`[DEBUG] Found ${count} elements matching "${resolvedSelector}"`);
+    }
+  );
+  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) => {
+        console.log(`[BROWSER ${msg.type().toUpperCase()}] ${msg.text()}`);
+      });
+    }
+  );
+  When(
+    "I capture viewport size",
+    { tags: "@ui or @hybrid" },
+    async ({ page, world }) => {
+      const viewport = page.viewportSize();
+      if (viewport) {
+        world.vars.viewportWidth = String(viewport.width);
+        world.vars.viewportHeight = String(viewport.height);
+        console.log(`[DEBUG] Viewport size: ${viewport.width}x${viewport.height}`);
+      } else {
+        console.log("[DEBUG] Viewport size not available");
+      }
+    }
+  );
+  Then(
+    "I log all cookies",
+    { tags: "@ui or @hybrid" },
+    async ({ page }) => {
+      const context = page.context();
+      const cookies = await context.cookies();
+      console.log(`[DEBUG] Cookies (${cookies.length}):`);
+      for (const cookie of cookies) {
+        console.log(`  - ${cookie.name}: ${cookie.value.substring(0, 50)}${cookie.value.length > 50 ? "..." : ""}`);
+      }
+    }
+  );
+  Then(
+    "I log localStorage",
+    { tags: "@ui or @hybrid" },
+    async ({ page }) => {
+      const storage = await page.evaluate(() => {
+        const items = {};
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key) {
+            items[key] = localStorage.getItem(key) || "";
+          }
+        }
+        return items;
+      });
+      console.log("[DEBUG] localStorage:");
+      for (const [key, value] of Object.entries(storage)) {
+        const truncated = value.length > 100 ? `${value.substring(0, 100)}...` : value;
+        console.log(`  - ${key}: ${truncated}`);
+      }
+    }
+  );
+  When(
+    "I highlight element {string}",
+    { tags: "@ui or @hybrid" },
+    async ({ page, world }, selector) => {
+      const resolvedSelector = interpolate(selector, world.vars);
+      await page.evaluate((sel) => {
+        const elements = document.querySelectorAll(sel);
+        elements.forEach((el) => {
+          el.style.outline = "3px solid red";
+          el.style.outlineOffset = "2px";
+        });
+      }, resolvedSelector);
+      console.log(`[DEBUG] Highlighted ${await page.locator(resolvedSelector).count()} element(s) matching "${resolvedSelector}"`);
+    }
+  );
+}
+
+// src/steps/ui.layout.ts
+import { expect as expect5 } from "@playwright/test";
+import { createBdd as createBdd12 } from "playwright-bdd";
+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`);
+      await expect5(panel).toBeVisible();
+    }
+  );
+  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`);
+      await expect5(panel).toBeHidden();
+    }
+  );
+  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`);
+      if (state === "visible") {
+        await expect5(panel).toBeVisible();
+      } else if (state === "hidden") {
+        await expect5(panel).toBeHidden();
+      } else {
+        throw new Error(`Unknown panel state: ${state}. Expected 'visible' or 'hidden'.`);
+      }
+    }
+  );
+  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`);
+      const isFullWidth = await panel.evaluate((el) => {
+        return !el.classList.contains("split") && !el.classList.contains("narrow") && !el.classList.contains("split-view-list");
+      });
+      expect5(isFullWidth, `Expected "${resolvedName}" panel to be full width`).toBe(true);
+    }
+  );
+  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`);
+      const isNarrow = await panel.evaluate((el) => {
+        return el.classList.contains("split") || el.classList.contains("narrow") || el.classList.contains("split-view-list");
+      });
+      expect5(isNarrow, `Expected "${resolvedName}" panel to be narrow`).toBe(true);
+    }
+  );
+  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();
+    }
+  );
+  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();
+      expect5(count === 0 || !await splitContainer.first().isVisible()).toBe(true);
+    }
+  );
+  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();
+    }
+  );
+  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();
+      if (count > 0) {
+        await expect5(sidebar.first()).toBeHidden();
+      }
+    }
+  );
+  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) => {
+        return el.classList.contains("collapsed") || el.classList.contains("minimized") || el.getAttribute("data-collapsed") === "true";
+      });
+      expect5(isCollapsed, "Expected sidebar to be collapsed").toBe(true);
+    }
+  );
+  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();
+    }
+  );
+  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();
+      if (count > 0) {
+        await expect5(modal.first()).toBeHidden();
+      }
+    }
+  );
+  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`);
+      await expect5(modal).toBeVisible();
+    }
+  );
+  Given(
+    "the viewport is {string} size",
+    { tags: "@ui or @hybrid" },
+    async ({ page }, sizeName) => {
+      const sizes = {
+        mobile: { width: 375, height: 667 },
+        tablet: { width: 768, height: 1024 },
+        desktop: { width: 1280, height: 800 },
+        "large-desktop": { width: 1920, height: 1080 }
+      };
+      const size = sizes[sizeName.toLowerCase()];
+      if (!size) {
+        throw new Error(`Unknown viewport size: ${sizeName}. Available: ${Object.keys(sizes).join(", ")}`);
+      }
+      await page.setViewportSize(size);
+    }
+  );
+  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 });
+      await page.waitForTimeout(100);
+      await page.setViewportSize({ width: 1280, height: 800 });
+      await page.waitForTimeout(100);
+      if (original) {
+        await page.setViewportSize(original);
+      }
+    }
+  );
+  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 });
+      await expect5(tab).toHaveAttribute("aria-selected", "true");
+    }
+  );
+  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 });
+      await expect5(tab).toHaveAttribute("aria-selected", "false");
+    }
+  );
+  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 });
+      await tab.click();
+    }
+  );
+}
+
+// src/steps/ui.auth.ts
+import { createBdd as createBdd13 } from "playwright-bdd";
+
+// src/adapters/ui/fetch-intercept-auth.adapter.ts
+var defaultBypassConfig = {
+  urlPattern: "/api/",
+  headers: {
+    "x-user-id": (data) => data.userId,
+    "x-tenant-id": (data) => data.tenantId || "",
+    "x-user-roles": (data) => data.roles.join(",")
+  },
+  localStorageKey: "mockAuth"
+};
+var defaultBearerConfig = {
+  urlPattern: "/api/",
+  headers: {
+    Authorization: (data) => `Bearer ${data.token || ""}`
+  }
+};
+async function setupFetchIntercept(page, authData, config = defaultBypassConfig) {
+  const staticHeaders = {};
+  for (const [key, value] of Object.entries(config.headers)) {
+    staticHeaders[key] = typeof value === "function" ? value(authData) : value;
+  }
+  const headers = {};
+  for (const [key, value] of Object.entries(staticHeaders)) {
+    if (value) {
+      headers[key] = value;
+    }
+  }
+  const urlPattern = config.urlPattern instanceof RegExp ? config.urlPattern.source : config.urlPattern || "";
+  await page.addInitScript(
+    (params) => {
+      if (params.localStorageKey) {
+        localStorage.setItem(params.localStorageKey, JSON.stringify(params.authData));
+      }
+      const originalFetch = window.fetch;
+      window.fetch = function(input, init) {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        const shouldIntercept = !params.urlPattern || url.includes(params.urlPattern);
+        if (shouldIntercept) {
+          const modifiedInit = init || {};
+          modifiedInit.headers = {
+            ...modifiedInit.headers || {},
+            ...params.headers
+          };
+          return originalFetch.call(this, input, modifiedInit);
+        }
+        return originalFetch.call(this, input, init);
+      };
+    },
+    { authData, headers, urlPattern, localStorageKey: config.localStorageKey }
+  );
+}
+async function clearFetchIntercept(page) {
+  await page.reload();
+}
+async function setupBypassAuth(page, userId, roles, tenantId) {
+  await setupFetchIntercept(page, { userId, roles, tenantId }, defaultBypassConfig);
+}
+async function setupBearerAuth(page, token) {
+  await setupFetchIntercept(
+    page,
+    { userId: "", roles: [], token },
+    defaultBearerConfig
+  );
+}
+
+// src/steps/ui.auth.ts
+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();
+      const userId = `test-user-${testRunId}`;
+      const isAdmin = roles.includes("admin");
+      const tenantId = isAdmin ? void 0 : "org-a";
+      await setupBypassAuth(page, userId, roles, tenantId);
+      world.vars.currentUserId = userId;
+      world.vars.currentRoles = roles.join(",");
+      if (tenantId) {
+        world.vars.currentTenantId = tenantId;
+      }
+      console.log(`[BDD] UI authenticated as ${roles.join(", ")} (user: ${userId})`);
+    }
+  );
+  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();
+      const userId = `test-user-${testRunId}`;
+      const resolvedTenantId = interpolate(tenantId, world.vars);
+      await setupBypassAuth(page, userId, roles, resolvedTenantId);
+      world.vars.currentUserId = userId;
+      world.vars.currentTenantId = resolvedTenantId;
+      world.vars.currentRoles = roles.join(",");
+      console.log(`[BDD] UI authenticated as ${roles.join(", ")} for tenant ${resolvedTenantId}`);
+    }
+  );
+  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);
+      const tenantId = "org-a";
+      await setupBypassAuth(page, resolvedUserId, roles, tenantId);
+      world.vars.currentUserId = resolvedUserId;
+      world.vars.currentTenantId = tenantId;
+      world.vars.currentRoles = roles.join(",");
+      console.log(`[BDD] UI authenticated as ${roles.join(", ")} with id ${resolvedUserId}`);
+    }
+  );
+  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);
+      console.log("[BDD] UI authenticated with bearer token");
+    }
+  );
+  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],
+        value: row[1]
+      })) || [];
+      const headers = {};
+      for (const row of rows) {
+        headers[row.header] = interpolate(row.value, world.vars);
+      }
+      await setupFetchIntercept(
+        page,
+        { userId: headers["x-user-id"] || "", roles: (headers["x-user-roles"] || "").split(","), tenantId: headers["x-tenant-id"] },
+        {
+          urlPattern: "/api/",
+          headers,
+          localStorageKey: "mockAuth"
+        }
+      );
+      console.log(`[BDD] UI authenticated with custom headers: ${Object.keys(headers).join(", ")}`);
+    }
+  );
+  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);
+      const tenantId = world.vars.currentTenantId || "org-a";
+      await page.reload();
+      await setupBypassAuth(page, resolvedUserId, roles, tenantId);
+      world.vars.currentUserId = resolvedUserId;
+      world.vars.currentRoles = roles.join(",");
+      console.log(`[BDD] UI switched to user ${resolvedUserId} with roles ${roles.join(", ")}`);
+    }
+  );
+}
+
+// src/steps/tui.basic.ts
+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 }) => {
+    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 createBdd15 } from "playwright-bdd";
+function registerTuiWizardSteps(test) {
+  const { Given, When, Then } = createBdd15(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);
+  registerFormSteps(test);
+  registerDebugSteps(test);
+  registerLayoutSteps(test);
+  registerUiAuthSteps(test);
+}
+function registerSharedSteps(test) {
+  registerSharedVarSteps(test);
+  registerSharedCleanupSteps(test);
+  registerFlagSteps(test);
+}
+function registerHybridSuite(test) {
+  registerHybridSteps(test);
+}
+function registerTuiSteps(test) {
+  registerTuiBasicSteps(test);
+  registerTuiWizardSteps(test);
+}
+function registerAllSteps(test) {
+  registerApiSteps(test);
+  registerUiSteps(test);
+  registerTuiSteps(test);
+  registerSharedSteps(test);
+  registerHybridSuite(test);
+}
+
+export {
+  interpolate,
+  tryParseJson,
+  selectPath,
+  parseExpected,
+  assertMasked,
+  registerCleanup,
+  defaultBypassConfig,
+  defaultBearerConfig,
+  setupFetchIntercept,
+  clearFetchIntercept,
+  setupBypassAuth,
+  setupBearerAuth,
+  registerApiHttpSteps,
+  registerApiAssertionSteps,
+  registerApiAuthSteps,
+  registerHybridSteps,
+  registerSharedCleanupSteps,
+  registerSharedVarSteps,
+  isFlagEnabled,
+  setFlag,
+  registerFlagSteps,
+  registerUiBasicSteps,
+  registerWizardSteps,
+  registerFormSteps,
+  registerDebugSteps,
+  registerLayoutSteps,
+  registerUiAuthSteps,
+  registerTuiBasicSteps,
+  registerTuiWizardSteps,
+  registerApiSteps,
+  registerUiSteps,
+  registerSharedSteps,
+  registerHybridSuite,
+  registerTuiSteps,
+  registerAllSteps
+};