pomwright 1.5.0 → 2.0.0

package/dist/index.mjs

@@ -1,1201 +1,311 @@
-// src/helpers/locatorSchema.interface.ts
-var GetByMethod = /* @__PURE__ */ ((GetByMethod2) => {
-  GetByMethod2["role"] = "role";
-  GetByMethod2["text"] = "text";
-  GetByMethod2["label"] = "label";
-  GetByMethod2["placeholder"] = "placeholder";
-  GetByMethod2["altText"] = "altText";
-  GetByMethod2["title"] = "title";
-  GetByMethod2["locator"] = "locator";
-  GetByMethod2["frameLocator"] = "frameLocator";
-  GetByMethod2["testId"] = "testId";
-  GetByMethod2["dataCy"] = "dataCy";
-  GetByMethod2["id"] = "id";
-  return GetByMethod2;
-})(GetByMethod || {});
-var locatorSchemaDummy = {
-  role: void 0,
-  roleOptions: {
-    checked: void 0,
-    disabled: void 0,
-    exact: void 0,
-    expanded: void 0,
-    includeHidden: void 0,
-    level: void 0,
-    name: void 0,
-    pressed: void 0,
-    selected: void 0
-  },
-  text: void 0,
-  textOptions: {
-    exact: void 0
-  },
-  label: void 0,
-  labelOptions: {
-    exact: void 0
-  },
-  placeholder: void 0,
-  placeholderOptions: {
-    exact: void 0
-  },
-  altText: void 0,
-  altTextOptions: {
-    exact: void 0
-  },
-  title: void 0,
-  titleOptions: {
-    exact: void 0
-  },
-  locator: void 0,
-  locatorOptions: {
-    has: void 0,
-    hasNot: void 0,
-    hasNotText: void 0,
-    hasText: void 0
-  },
-  frameLocator: void 0,
-  testId: void 0,
-  dataCy: void 0,
-  id: void 0,
-  filter: {
-    has: void 0,
-    hasNot: void 0,
-    hasNotText: void 0,
-    hasText: void 0
-  },
-  locatorMethod: void 0,
-  locatorSchemaPath: void 0
-};
-function getLocatorSchemaDummy() {
-  return locatorSchemaDummy;
-}
+// src/fixture/base.fixtures.ts
+import { test as base } from "@playwright/test";
 
-// src/helpers/deprecationWarnings.ts
-var warnedDeprecationsByScope = /* @__PURE__ */ new WeakMap();
-var getWarningScope = (logger) => {
-  if (!logger) {
-    return globalThis;
-  }
-  const maybeSharedLogEntries = logger.sharedLogEntry;
-  if (Array.isArray(maybeSharedLogEntries)) {
-    return maybeSharedLogEntries;
+// src/helpers/playwrightReportLogger.ts
+var PlaywrightReportLogger = class _PlaywrightReportLogger {
+  // Initializes the logger with shared log level, log entries, and a context name.
+  constructor(sharedLogLevel, sharedLogEntry, contextName) {
+    this.sharedLogLevel = sharedLogLevel;
+    this.sharedLogEntry = sharedLogEntry;
+    this.contextName = contextName;
   }
-  return logger;
-};
-var warnDeprecationOncePerTest = (key, message, logger) => {
-  const warningScope = getWarningScope(logger);
-  const warnedDeprecations = warnedDeprecationsByScope.get(warningScope) ?? /* @__PURE__ */ new Set();
-  if (warnedDeprecations.has(key)) {
-    return;
-  }
-  warnedDeprecations.add(key);
-  warnedDeprecationsByScope.set(warningScope, warnedDeprecations);
-  logger?.warn(message);
-};
-
-// src/api/baseApi.ts
-var BaseApi = class {
-  baseUrl;
-  apiName;
-  log;
-  request;
-  constructor(baseUrl, apiName, context, pwrl) {
-    this.baseUrl = baseUrl;
-    this.apiName = apiName;
-    this.log = pwrl.getNewChildLogger(apiName);
-    this.request = context;
-    const classDeprecationMessage = "[POMWright] BaseApi is depricated and will be removed in 2.0.0 with no replacement. If you need a base API class, you can use the v1 pomwright/src/api/baseApi.ts implementation for reference to implement your own.";
-    warnDeprecationOncePerTest(`${this.constructor.name}-class-deprecation`, classDeprecationMessage, this.log);
+  contextName;
+  logLevels = ["debug", "info", "warn", "error"];
+  /**
+   * Creates a child logger with a new contextual name, sharing the same log level and log entries with the parent logger.
+   *
+   * The root loggers log "level" is referenced by all child loggers and their child loggers and so on...
+   * Changing the log "level" of one, will change it for all.
+   */
+  getNewChildLogger(prefix) {
+    return new _PlaywrightReportLogger(this.sharedLogLevel, this.sharedLogEntry, `${this.contextName} -> ${prefix}`);
   }
-};
-
-// src/basePage.ts
-import { selectors } from "@playwright/test";
-
-// src/helpers/getLocatorBase.ts
-import { test } from "@playwright/test";
+  /**
+   * Logs a message with the specified log level, prefix, and additional arguments if the current log level permits.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
+  log(level, message, ...args) {
+    const logLevelIndex = this.logLevels.indexOf(level);
+    if (logLevelIndex < this.getCurrentLogLevelIndex()) {
+      return;
+    }
+    this.sharedLogEntry.push({
+      timestamp: /* @__PURE__ */ new Date(),
+      logLevel: level,
+      prefix: this.contextName,
+      message: `${message}
 
-// srcV2/locators/utils.ts
-var formatLocatorSchemaPathForError = (path) => {
-  const json = JSON.stringify(path);
-  return json.slice(1, -1);
-};
-var RUNTIME_WHITESPACE_REGEX = /[\s\u0085]/u;
-var validateLocatorSchemaPath = (path) => {
-  if (!path) {
-    throw new Error("LocatorSchemaPath string cannot be empty");
+${args.join("\n\n")}`
+    });
   }
-  if (RUNTIME_WHITESPACE_REGEX.test(path)) {
-    const escaped = formatLocatorSchemaPathForError(path);
-    throw new Error(`LocatorSchemaPath string cannot contain whitespace chars: ${escaped}`);
+  /**
+   * Logs a debug-level message with the specified message and arguments.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
+  debug(message, ...args) {
+    this.log("debug", message, ...args);
   }
-  if (path.startsWith(".")) {
-    throw new Error(`LocatorSchemaPath string cannot start with a dot: ${path}`);
+  /**
+   * Logs a info-level message with the specified message and arguments.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
+  info(message, ...args) {
+    this.log("info", message, ...args);
   }
-  if (path.endsWith(".")) {
-    throw new Error(`LocatorSchemaPath string cannot end with a dot: ${path}`);
+  /**
+   * Logs a warn-level message with the specified message and arguments.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
+  warn(message, ...args) {
+    this.log("warn", message, ...args);
   }
-  if (path.includes("..")) {
-    throw new Error(`LocatorSchemaPath string cannot contain consecutive dots: ${path}`);
+  /**
+   * Logs a error-level message with the specified message and arguments.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
+  error(message, ...args) {
+    this.log("error", message, ...args);
   }
-};
-var expandSchemaPath = (path) => {
-  validateLocatorSchemaPath(path);
-  const parts = path.split(".");
-  return parts.map((_part, index) => parts.slice(0, index + 1).join("."));
-};
-var cssEscape = (value) => {
-  return value.replace(/([\\"'#.:;,?*+<>{}[\\]()])/g, "\\$1");
-};
-var normalizeSteps = (steps) => steps ? steps.map((step2) => ({ ...step2 })) : [];
-function normalizeIdValue(id) {
-  if (typeof id !== "string") {
-    return id;
+  /**
+   * Sets the current log level to the specified level during runTime.
+   */
+  setLogLevel(level) {
+    this.sharedLogLevel.current = level;
   }
-  if (id.startsWith("#")) {
-    return id.slice(1);
+  /**
+   * Retrieves the current log level during runtime.
+   */
+  getCurrentLogLevel() {
+    return this.sharedLogLevel.current;
   }
-  if (id.startsWith("id=")) {
-    return id.slice("id=".length);
+  /**
+   * Retrieves the index of the current log level in the logLevels array during runtime.
+   */
+  getCurrentLogLevelIndex() {
+    return this.logLevels.indexOf(this.sharedLogLevel.current);
   }
-  return id;
-}
-var stringifyForLog = (value) => {
-  const seen = /* @__PURE__ */ new WeakSet();
-  return JSON.stringify(
-    value,
-    (_key, current) => {
-      if (typeof current === "object" && current !== null) {
-        if (seen.has(current)) {
-          return "[Circular]";
-        }
-        seen.add(current);
-      }
-      if (current instanceof RegExp) {
-        return { type: "RegExp", source: current.source, flags: current.flags };
-      }
-      return current;
-    },
-    2
-  );
-};
-var applyIndexSelector = (locator, selector) => {
-  if (selector === void 0 || selector === null) {
-    return locator;
+  /**
+   * Resets the current log level to the initial level during runtime.
+   */
+  resetLogLevel() {
+    this.sharedLogLevel.current = this.sharedLogLevel.initial;
   }
-  if (selector === "first") {
-    return locator.first();
+  /**
+   * Checks if the input log level is equal to the current log level of the PlaywrightReportLogger instance.
+   */
+  isCurrentLogLevel(level) {
+    return this.sharedLogLevel.current === level;
   }
-  if (selector === "last") {
-    return locator.last();
+  /**
+   * Returns 'true' if the "level" parameter provided has an equal or greater index than the current logLevel.
+   */
+  isLogLevelEnabled(level) {
+    const logLevelIndex = this.logLevels.indexOf(level);
+    if (logLevelIndex < this.getCurrentLogLevelIndex()) {
+      return false;
+    }
+    return true;
   }
-  return locator.nth(selector);
-};
-var createLocator = (target, definition) => {
-  switch (definition.type) {
-    case "role":
-      return target.getByRole(definition.role, definition.options);
-    case "text":
-      return target.getByText(definition.text, definition.options);
-    case "label":
-      return target.getByLabel(definition.text, definition.options);
-    case "placeholder":
-      return target.getByPlaceholder(definition.text, definition.options);
-    case "altText":
-      return target.getByAltText(definition.text, definition.options);
-    case "title":
-      return target.getByTitle(definition.text, definition.options);
-    case "locator":
-      return target.locator(definition.selector, definition.options);
-    case "frameLocator":
-      return target.frameLocator(definition.selector);
-    case "testId":
-      return target.getByTestId(definition.testId);
-    case "id": {
-      if (typeof definition.id === "string") {
-        const normalized = normalizeIdValue(definition.id);
-        return target.locator(`#${cssEscape(normalized ?? "")}`);
+  /**
+   * Attaches the recorded log entries to the Playwright HTML report in a sorted and formatted manner.
+   */
+  attachLogsToTest(testInfo) {
+    this.sharedLogEntry.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    for (const log of this.sharedLogEntry) {
+      const printTime = log.timestamp.toLocaleTimeString("nb-NO", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      });
+      const printDate = log.timestamp.toLocaleDateString("nb-NO", {
+        day: "2-digit",
+        month: "2-digit",
+        year: "numeric"
+      });
+      const printLogLevel = `${log.logLevel.toUpperCase()}`;
+      const printPrefix = log.prefix ? `: [${log.prefix}]` : "";
+      let messageBody = "";
+      let messageContentType = "";
+      try {
+        const parsedMessage = JSON.parse(log.message);
+        messageContentType = "application/json";
+        messageBody = JSON.stringify(parsedMessage, null, 2);
+      } catch (_error) {
+        messageContentType = "text/plain";
+        messageBody = log.message;
       }
-      const pattern = definition.id.source;
-      const safePattern = cssEscape(pattern);
-      return target.locator(`[id*="${safePattern}"]`);
-    }
-    default: {
-      const exhaustive = definition;
-      return exhaustive;
+      testInfo.attach(`${printTime} ${printDate} - ${printLogLevel} ${printPrefix}`, {
+        contentType: messageContentType,
+        body: Buffer.from(messageBody)
+      });
     }
   }
 };
-var cloneLocatorStrategyDefinition = (definition) => {
-  switch (definition.type) {
-    case "role":
-      return {
-        type: "role",
-        role: definition.role,
-        ...definition.options ? { options: { ...definition.options } } : {}
-      };
-    case "text":
-      return {
-        type: "text",
-        text: definition.text,
-        ...definition.options ? { options: { ...definition.options } } : {}
-      };
-    case "label":
-      return {
-        type: "label",
-        text: definition.text,
-        ...definition.options ? { options: { ...definition.options } } : {}
-      };
-    case "placeholder":
-      return {
-        type: "placeholder",
-        text: definition.text,
-        ...definition.options ? { options: { ...definition.options } } : {}
-      };
-    case "altText":
-      return {
-        type: "altText",
-        text: definition.text,
-        ...definition.options ? { options: { ...definition.options } } : {}
-      };
-    case "title":
-      return {
-        type: "title",
-        text: definition.text,
-        ...definition.options ? { options: { ...definition.options } } : {}
-      };
-    case "locator":
-      return {
-        type: "locator",
-        selector: definition.selector,
-        ...definition.options ? { options: { ...definition.options } } : {}
-      };
-    case "frameLocator":
-      return { type: "frameLocator", selector: definition.selector };
-    case "testId":
-      return { type: "testId", testId: definition.testId };
-    case "id":
-      return { type: "id", id: definition.id };
-    default: {
-      const exhaustive = definition;
-      return exhaustive;
-    }
-  }
-};
-var applyDefinitionPatch = (seed, patch) => {
-  const base2 = cloneLocatorStrategyDefinition(seed);
-  switch (patch.type) {
-    case "locator": {
-      const selector = patch.selector !== void 0 ? patch.selector : base2.selector;
-      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
-      return { type: "locator", selector, ...options ? { options } : {} };
-    }
-    case "role": {
-      const role = patch.role ?? base2.role;
-      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
-      return { type: "role", role, ...options ? { options } : {} };
-    }
-    case "text": {
-      const text = patch.text ?? base2.text;
-      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
-      return { type: "text", text, ...options ? { options } : {} };
-    }
-    case "label": {
-      const text = patch.text ?? base2.text;
-      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
-      return { type: "label", text, ...options ? { options } : {} };
-    }
-    case "placeholder": {
-      const text = patch.text ?? base2.text;
-      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
-      return { type: "placeholder", text, ...options ? { options } : {} };
-    }
-    case "altText": {
-      const text = patch.text ?? base2.text;
-      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
-      return { type: "altText", text, ...options ? { options } : {} };
-    }
-    case "title": {
-      const text = patch.text ?? base2.text;
-      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
-      return { type: "title", text, ...options ? { options } : {} };
-    }
-    case "frameLocator": {
-      const selector = patch.selector !== void 0 ? patch.selector : base2.selector;
-      return { type: "frameLocator", selector };
-    }
-    case "testId": {
-      const testId = patch.testId !== void 0 ? patch.testId : base2.testId;
-      return { type: "testId", testId };
-    }
-    case "id": {
-      const id = patch.id !== void 0 ? normalizeIdValue(patch.id) ?? base2.id : base2.id;
-      return { type: "id", id };
-    }
-    default: {
-      const exhaustive = patch;
-      return exhaustive;
-    }
+
+// src/fixture/base.fixtures.ts
+var test = base.extend({
+  // biome-ignore lint/correctness/noEmptyPattern: Playwright does not support the use of _
+  log: async ({}, use, testInfo) => {
+    const contextName = "TestCase";
+    const sharedLogEntry = [];
+    const sharedLogLevel = testInfo.retry === 0 ? { current: "warn", initial: "warn" } : { current: "debug", initial: "debug" };
+    const log = new PlaywrightReportLogger(sharedLogLevel, sharedLogEntry, contextName);
+    await use(log);
+    log.attachLogsToTest(testInfo);
   }
-};
-var isFrameLocatorDefinition = (definition) => definition.type === "frameLocator";
-var isLocatorInstance = (value) => {
-  return !!value && typeof value === "object" && typeof value.filter === "function";
-};
+});
 
-// srcV2/locators/v1SchemaTranslator.ts
-var getRegistryLookup = (registry) => registry;
-var logMissingDefinition = (path, field) => {
-  console.warn(
-    `[POMWright] Skipping v2 translation for "${path}" because "${field}" is missing. Rewrite this locator in defineLocators() using the v2 registry.`
-  );
-};
-var logLocatorInstanceWarning = (path) => {
-  console.warn(
-    `[POMWright] Skipping v2 translation for "${path}" because v1 LocatorSchema.locator is a Locator instance. Rewrite this path in defineLocators() to avoid runtime gaps during migration.`
-  );
-};
-var addV1SchemaToV2Registry = (registry, locatorSchema) => {
-  const path = locatorSchema.locatorSchemaPath;
-  validateLocatorSchemaPath(path);
-  const registryWithLookup = getRegistryLookup(registry);
-  const existing = registryWithLookup.getIfExists?.(path);
-  if (existing) {
-    return;
+// src/helpers/sessionStorage.ts
+import { test as test2 } from "@playwright/test";
+var SessionStorage = class {
+  // Initializes the class with a Playwright Page object and an optional label for step titles.
+  constructor(page, options = {}) {
+    this.page = page;
+    this.options = options;
   }
-  console.info(
-    `[POMWright] LocatorSchemaPath "${path}" is not registered in the v2 registry. Translating and adding v1 schema to v2 Locator Registry; update this path to use registry.add in defineLocators().`
-  );
-  const registration = registry.add(path);
-  if (!registration) {
-    return;
-  }
-  let postDefinition = null;
-  switch (locatorSchema.locatorMethod) {
-    case "role" /* role */: {
-      if (!locatorSchema.role) {
-        logMissingDefinition(path, "role");
-        return;
-      }
-      postDefinition = registration.getByRole(locatorSchema.role, locatorSchema.roleOptions);
-      break;
-    }
-    case "text" /* text */: {
-      if (!locatorSchema.text) {
-        logMissingDefinition(path, "text");
-        return;
-      }
-      postDefinition = registration.getByText(locatorSchema.text, locatorSchema.textOptions);
-      break;
-    }
-    case "label" /* label */: {
-      if (!locatorSchema.label) {
-        logMissingDefinition(path, "label");
-        return;
-      }
-      postDefinition = registration.getByLabel(locatorSchema.label, locatorSchema.labelOptions);
-      break;
-    }
-    case "placeholder" /* placeholder */: {
-      if (!locatorSchema.placeholder) {
-        logMissingDefinition(path, "placeholder");
-        return;
-      }
-      postDefinition = registration.getByPlaceholder(locatorSchema.placeholder, locatorSchema.placeholderOptions);
-      break;
-    }
-    case "altText" /* altText */: {
-      if (!locatorSchema.altText) {
-        logMissingDefinition(path, "altText");
-        return;
-      }
-      postDefinition = registration.getByAltText(locatorSchema.altText, locatorSchema.altTextOptions);
-      break;
-    }
-    case "title" /* title */: {
-      if (!locatorSchema.title) {
-        logMissingDefinition(path, "title");
-        return;
-      }
-      postDefinition = registration.getByTitle(locatorSchema.title, locatorSchema.titleOptions);
-      break;
-    }
-    case "locator" /* locator */: {
-      if (!locatorSchema.locator) {
-        logMissingDefinition(path, "locator");
-        return;
-      }
-      if (isLocatorInstance(locatorSchema.locator)) {
-        logLocatorInstanceWarning(path);
-        return;
-      }
-      postDefinition = registration.locator(locatorSchema.locator, locatorSchema.locatorOptions);
-      break;
-    }
-    case "frameLocator" /* frameLocator */: {
-      if (!locatorSchema.frameLocator) {
-        logMissingDefinition(path, "frameLocator");
-        return;
-      }
-      postDefinition = registration.frameLocator(locatorSchema.frameLocator);
-      break;
-    }
-    case "testId" /* testId */: {
-      if (!locatorSchema.testId) {
-        logMissingDefinition(path, "testId");
-        return;
-      }
-      postDefinition = registration.getByTestId(locatorSchema.testId);
-      break;
-    }
-    case "dataCy" /* dataCy */: {
-      if (!locatorSchema.dataCy) {
-        logMissingDefinition(path, "dataCy");
+  // Defines an object to hold states to be set in session storage, allowing any value type.
+  queuedStates = {};
+  // Indicates if the session storage manipulation has been initiated.
+  isInitiated = false;
+  getStepLabel(methodName) {
+    const prefix = this.options.label ? `${this.options.label}.` : "";
+    return `${prefix}SessionStorage.${methodName}:`;
+  }
+  async hasContext() {
+    return await this.page.evaluate(() => {
+      return typeof window !== "undefined" && window.sessionStorage !== void 0;
+    });
+  }
+  async waitForContextAvailability() {
+    try {
+      const contextExists = await this.hasContext();
+      if (contextExists) {
         return;
       }
-      postDefinition = registration.locator(`[data-cy="${locatorSchema.dataCy}"]`);
-      break;
+    } catch (_e) {
     }
-    case "id" /* id */: {
-      if (!locatorSchema.id) {
-        logMissingDefinition(path, "id");
+    await new Promise((resolve) => {
+      const handler = async (frame) => {
+        if (frame !== this.page.mainFrame()) {
+          return;
+        }
+        try {
+          const contextExists = await this.hasContext();
+          if (!contextExists) {
+            return;
+          }
+        } catch (_e) {
+          return;
+        }
+        this.page.off("framenavigated", handler);
+        resolve();
+      };
+      this.page.on("framenavigated", handler);
+    });
+  }
+  async ensureContext({ waitForContext = false } = {}) {
+    try {
+      const contextExists = await this.hasContext();
+      if (contextExists) {
         return;
       }
-      postDefinition = registration.getById(locatorSchema.id);
-      break;
+    } catch (_e) {
     }
-    default: {
-      const exhaustive = locatorSchema.locatorMethod;
-      return exhaustive;
+    if (!waitForContext) {
+      throw new Error("SessionStorage context is not available.");
     }
+    await this.waitForContextAvailability();
   }
-  if (!postDefinition) {
-    return;
-  }
-  if (locatorSchema.filter && locatorSchema.locatorMethod !== "frameLocator" /* frameLocator */) {
-    const filter = locatorSchema.filter;
-    postDefinition.filter(filter);
+  /** Writes states to session storage. Accepts an object with key-value pairs representing the states. */
+  async writeToSessionStorage(states) {
+    await this.page.evaluate((storage) => {
+      for (const [key, value] of Object.entries(storage)) {
+        window.sessionStorage.setItem(key, JSON.stringify(value));
+      }
+    }, states);
   }
-};
-
-// src/helpers/getBy.locator.ts
-var GetBy = class {
-  constructor(page, pwrl) {
-    this.page = page;
-    this.log = pwrl.getNewChildLogger(this.constructor.name);
-    this.methodMap = {
-      ["role" /* role */]: this.role,
-      ["text" /* text */]: this.text,
-      ["label" /* label */]: this.label,
-      ["placeholder" /* placeholder */]: this.placeholder,
-      ["altText" /* altText */]: this.altText,
-      ["title" /* title */]: this.title,
-      ["locator" /* locator */]: this.locator,
-      ["frameLocator" /* frameLocator */]: this.frameLocator,
-      ["testId" /* testId */]: this.testId,
-      ["dataCy" /* dataCy */]: this.dataCy,
-      ["id" /* id */]: this.id
-    };
-    this.subMethodMap = {
-      ["role" /* role */]: this.page.getByRole,
-      ["text" /* text */]: this.page.getByText,
-      ["label" /* label */]: this.page.getByLabel,
-      ["placeholder" /* placeholder */]: this.page.getByPlaceholder,
-      ["altText" /* altText */]: this.page.getByAltText,
-      ["title" /* title */]: this.page.getByTitle,
-      ["locator" /* locator */]: this.page.locator
-    };
+  /** Reads all states from session storage and returns them as an object. */
+  async readFromSessionStorage() {
+    const storage = await this.page.evaluate(() => {
+      const storage2 = {};
+      for (let i = 0; i < sessionStorage.length; i++) {
+        const key = sessionStorage.key(i);
+        if (key !== null) {
+          const item = sessionStorage.getItem(key);
+          try {
+            storage2[key] = item ? JSON.parse(item) : null;
+          } catch (_e) {
+            storage2[key] = item;
+          }
+        }
+      }
+      return storage2;
+    });
+    return storage;
   }
-  log;
-  methodMap;
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  subMethodMap;
   /**
-   * Retrieves a Locator based on the details provided in a LocatorSchema.
-   * The method identifies the appropriate locator creation function from methodMap and invokes it.
-   * Throws an error if the locator method is unsupported.
-   */
-  getLocator = (locatorSchema) => {
-    const methodName = locatorSchema.locatorMethod;
-    const method = this.methodMap[methodName];
-    if (method) {
-      return method(locatorSchema);
-    }
-    throw new Error(`Unsupported locator method: ${methodName}`);
-  };
-  /**
-   * Internal method to retrieve a Locator using a specified GetByMethodSubset and LocatorSchema.
-   * It identifies the appropriate locator creation function from subMethodMap and invokes it.
-   * Throws an error if the caller is unknown or if the initial locator is not found.
+   * Sets the specified states in session storage.
+   * Optionally waits for the next main-frame navigation to establish a valid context before writing,
+   * and reloads the page after setting the data.
+   *
+   * Parameters:
+   * states: Object representing the states to set in session storage.
+   * reload: Boolean indicating whether to reload the page after setting the session storage data.
+   * waitForContext: Boolean indicating whether to wait for a main-frame navigation and a valid context.
    */
-  getBy = (caller, locator) => {
-    const method = this.subMethodMap[caller];
-    if (!method) {
-      const errorText = "Error: unknown caller of method getBy(caller, locator) in getBy.locators.ts";
-      this.log.error(errorText);
-      throw new Error(errorText);
-    }
-    const initialPWLocator = locator[caller] ? method.call(this.page, locator[caller], locator?.[`${caller}Options`]) : null;
-    if (!initialPWLocator) {
-      const errorText = `Locator "${locator.locatorSchemaPath}" .${caller} is undefined.`;
-      this.log.warn(errorText);
-      throw new Error(errorText);
-    }
-    return initialPWLocator;
-  };
+  async set(states, options = {}) {
+    await test2.step(this.getStepLabel("set"), async () => {
+      await this.ensureContext({ waitForContext: options.waitForContext });
+      await this.writeToSessionStorage(states);
+      if (options.reload) {
+        await this.page.reload();
+      }
+    });
+  }
   /**
-   * Creates a method for generating a Locator using a specific GetByMethodSubset.
-   * Returns a function that takes a LocatorSchema and returns a Locator.
-   * The returned function is a locator creation function corresponding to the specified methodName.
+   * Queues states to be set in the sessionStorage before the next navigation occurs.
+   * Handles different scenarios based on multiple calls made before the navigation occurs.
+   *
+   * 1. No Context, Single Call: Queues and sets states upon the next navigation.
+   * 2. No Context, Multiple Calls: Merges states from multiple calls and sets them upon the next navigation.
+   * 3. With Context: Still queues until the next navigation.
+   *
+   * Parameters:
+   * states: Object representing the states to queue for setting in session storage.
    */
-  createByMethod = (methodName) => {
-    return (locator) => {
-      return this.getBy(methodName, locator);
+  async setOnNextNavigation(states) {
+    this.queuedStates = { ...this.queuedStates, ...states };
+    const populateStorage = async () => {
+      await test2.step(this.getStepLabel("setOnNextNavigation"), async () => {
+        await this.writeToSessionStorage(this.queuedStates);
+      });
+      this.queuedStates = {};
     };
-  };
-  // Methods for creating locators using different locator methods.
-  // These methods are generated using createByMethod and provide a unified way to create locators based on LocatorSchema.
-  // Each method is responsible for creating a Locator based on a specific attribute (role, text, label, etc.) provided in LocatorSchema.
-  // These methods return a Locator and throw an error if the necessary attribute is not defined in the LocatorSchema.
-  role = this.createByMethod("role" /* role */);
-  text = this.createByMethod("text" /* text */);
-  label = this.createByMethod("label" /* label */);
-  placeholder = this.createByMethod("placeholder" /* placeholder */);
-  altText = this.createByMethod("altText" /* altText */);
-  title = this.createByMethod("title" /* title */);
-  locator = this.createByMethod("locator" /* locator */);
-  /**
-   * Returns a FrameLocator using the 'frameLocator' selector from a LocatorSchema.
-   * Throws an error if the frameLocator is not defined.
-   */
-  frameLocator = (locatorSchema) => {
-    const initialFrameLocator = locatorSchema.frameLocator ? this.page.frameLocator(locatorSchema.frameLocator) : null;
-    if (!initialFrameLocator) {
-      const errorText = `Locator "${locatorSchema.locatorSchemaPath}" .frameLocator is not defined.`;
-      this.log.warn(errorText);
-      throw new Error(errorText);
-    }
-    return initialFrameLocator;
-  };
-  /**
-   * Returns a Locator using the 'testId' selector from a LocatorSchema.
-   * Throws an error if the testId is not defined.
-   */
-  testId = (locator) => {
-    const initialPWLocator = locator.testId ? this.page.getByTestId(locator.testId) : null;
-    if (!initialPWLocator) {
-      const errorText = `Locator "${locator.locatorSchemaPath}" .testId is not defined.`;
-      this.log.warn(`Locator "${locator.locatorSchemaPath}" .testId is not defined.`);
-      throw new Error(errorText);
-    }
-    return initialPWLocator;
-  };
-  /**
-   * Returns a Locator using the 'dataCy' selector from a LocatorSchema.
-   * Throws an error if the dataCy is undefined.
-   */
-  dataCy = (locator) => {
-    let initialPWLocator = null;
-    if (locator.dataCy) {
-      initialPWLocator = locator.dataCy.startsWith("data-cy=") ? this.page.locator(locator.dataCy) : this.page.locator(`data-cy=${locator.dataCy}`);
-    } else {
-      const errorText = `Locator "${locator.locatorSchemaPath}" .dataCy is undefined.`;
-      this.log.warn(errorText);
-      throw new Error(errorText);
-    }
-    return initialPWLocator;
-  };
-  /**
-   * Returns a Locator using the 'id' selector from a LocatorSchema.
-   * Throws an error if the id is not defined or the id type is unsupported.
-   */
-  id = (locator) => {
-    let initialPWLocator = null;
-    let selector;
-    let regexPattern;
-    if (!locator.id) {
-      const errorText = `Locator "${locator.locatorSchemaPath}" .id is not defined.`;
-      this.log.warn(errorText);
-      throw new Error(errorText);
-    }
-    if (typeof locator.id === "string") {
-      if (locator.id.startsWith("#")) {
-        selector = locator.id;
-      } else if (locator.id.startsWith("id=")) {
-        selector = `#${locator.id.slice("id=".length)}`;
-      } else {
-        selector = `#${locator.id}`;
-      }
-    } else if (locator.id instanceof RegExp) {
-      regexPattern = locator.id.source;
-      selector = `*[id^="${regexPattern}"]`;
-    } else {
-      const errorText = `Unsupported id type: ${typeof locator.id}`;
-      this.log.error(errorText);
-      throw new Error(errorText);
-    }
-    initialPWLocator = this.page.locator(selector);
-    return initialPWLocator;
-  };
-};
-
-// src/helpers/getLocatorBase.ts
-var REQUIRED_PROPERTIES_FOR_LOCATOR_SCHEMA_WITH_METHODS = [
-  "update",
-  "addFilter",
-  "getNestedLocator",
-  "getLocator",
-  "locatorSchemaPath",
-  "locatorMethod",
-  "schemasMap",
-  "filterMap"
-];
-var safeStringifyOfNestedLocatorResults = (obj) => {
-  const seen = /* @__PURE__ */ new WeakSet();
-  return JSON.stringify(
-    obj,
-    (key, value) => {
-      if (value instanceof Map) {
-        return Array.from(value.entries());
-      }
-      if (value instanceof RegExp) {
-        return { type: "RegExp", source: value.source, flags: value.flags };
-      }
-      if (value && typeof value === "object" && value.constructor && value.constructor.name === "Locator") {
-        return { type: "Locator", note: "Custom placeholder - Locators are complex." };
-      }
-      if (typeof value === "object" && value !== null) {
-        if (seen.has(value)) return "[Circular]";
-        seen.add(value);
-      }
-      return value;
-    },
-    2
-  );
-};
-var GetLocatorBase = class {
-  constructor(pageObjectClass, log, locatorSubstring) {
-    this.pageObjectClass = pageObjectClass;
-    this.log = log;
-    this.locatorSubstring = locatorSubstring;
-    this.locatorSchemas = /* @__PURE__ */ new Map();
-    this.getBy = new GetBy(this.pageObjectClass.page, this.log.getNewChildLogger("GetBy"));
-  }
-  getBy;
-  locatorSchemas;
-  /**
-   * getLocatorSchema:
-   * Given a path P, we:
-   * 1. Collect deep copies of the schemas involved.
-   * 2. Create a WithMethodsClass instance with LocatorSubstring = P.
-   * 3. Return a locator schema copy enriched with chainable methods.
-   */
-  getLocatorSchema(locatorSchemaPath) {
-    const pathIndexPairs = this.extractPathsFromSchema(locatorSchemaPath);
-    const schemasMap = this.collectDeepCopies(locatorSchemaPath, pathIndexPairs);
-    const locatorSchemaCopy = schemasMap.get(locatorSchemaPath);
-    locatorSchemaCopy.schemasMap = schemasMap;
-    locatorSchemaCopy.filterMap = /* @__PURE__ */ new Map();
-    const wrapper = new WithMethodsClass(
-      this.pageObjectClass,
-      this.log,
-      locatorSchemaPath,
-      schemasMap
-    );
-    return wrapper.init(locatorSchemaPath, locatorSchemaCopy);
-  }
-  /**
-   * collectDeepCopies:
-   * Clones and stores all schemas related to the chosen path and its sub-paths.
-   * Ensures updates and filters don't affect original schema definitions.
-   */
-  collectDeepCopies(locatorSchemaPath, pathIndexPairs) {
-    const schemasMap = /* @__PURE__ */ new Map();
-    const fullSchemaFunc = this.safeGetLocatorSchema(locatorSchemaPath);
-    if (!fullSchemaFunc) {
-      const errorMessage = `LocatorSchema not found for path: '${locatorSchemaPath}'`;
-      this.log.error(errorMessage);
-      throw new Error(`[${this.pageObjectClass.pocName}] ${errorMessage}`);
-    }
-    schemasMap.set(locatorSchemaPath, structuredClone(fullSchemaFunc()));
-    for (const { path } of pathIndexPairs) {
-      if (path !== locatorSchemaPath) {
-        const schemaFunc = this.safeGetLocatorSchema(path);
-        if (schemaFunc) {
-          schemasMap.set(path, structuredClone(schemaFunc()));
-        }
-      }
-    }
-    return schemasMap;
-  }
-  isLocatorSchemaWithMethods(schema) {
-    return REQUIRED_PROPERTIES_FOR_LOCATOR_SCHEMA_WITH_METHODS.every((p) => p in schema);
-  }
-  /**
-   * applyUpdateToSubPath:
-   * Applies updates to a specific sub-path schema within schemasMap.
-   * Similar to applyUpdate, but we locate the sub-path schema directly by its path.
-   */
-  applyUpdateToSubPath(schemasMap, subPath, updates) {
-    const schema = schemasMap.get(subPath);
-    if (!schema) {
-      throw new Error(`No schema found for sub-path: '${subPath}'`);
-    }
-    const updatedSchema = this.deepMerge(schema, updates);
-    if (this.isLocatorSchemaWithMethods(schema)) {
-      Object.assign(schema, updatedSchema);
-    } else {
-      schemasMap.set(subPath, updatedSchema);
-    }
-  }
-  /**
-   * createLocatorSchema:
-   * Creates a fresh LocatorSchema object by merging provided schemaDetails with a required locatorSchemaPath.
-   */
-  createLocatorSchema(schemaDetails, locatorSchemaPath) {
-    const schema = { ...schemaDetails, locatorSchemaPath };
-    return schema;
-  }
-  /**
-   * addSchema:
-   * Registers a new LocatorSchema under the given locatorSchemaPath.
-   * Throws an error if a schema already exists at that path.
-   */
-  addSchema(locatorSchemaPath, schemaDetails) {
-    if (locatorSchemaPath.length === 0 || locatorSchemaPath.startsWith(".") || locatorSchemaPath.endsWith(".") || locatorSchemaPath.includes("..")) {
-      throw new Error(
-        `[${this.pageObjectClass.pocName}] Invalid LocatorSchemaPath '${locatorSchemaPath}'. LocatorSchemaPath must not be empty, start or end with a '.', or contain consecutive '.'.`
-      );
-    }
-    const newLocatorSchema = this.createLocatorSchema(schemaDetails, locatorSchemaPath);
-    const existingSchemaFunc = this.safeGetLocatorSchema(locatorSchemaPath);
-    if (existingSchemaFunc) {
-      const existingLocatorSchema = existingSchemaFunc();
-      throw new Error(
-        `[${this.pageObjectClass.pocName}] A LocatorSchema with the path '${locatorSchemaPath}' already exists. 
-Existing Schema: ${JSON.stringify(existingLocatorSchema, null, 2)} 
-Attempted to Add Schema: ${JSON.stringify(newLocatorSchema, null, 2)}`
-      );
-    }
-    this.locatorSchemas.set(locatorSchemaPath, () => newLocatorSchema);
-    const v2Registry = this.pageObjectClass.locatorRegistry;
-    if (v2Registry) {
-      addV1SchemaToV2Registry(v2Registry, newLocatorSchema);
-    }
-  }
-  /**
-   * safeGetLocatorSchema:
-   * Safely retrieves a schema function if available for the given path.
-   */
-  safeGetLocatorSchema(path) {
-    return this.locatorSchemas.get(path);
-  }
-  /**
-   * extractPathsFromSchema:
-   * Splits a path into incremental sub-paths and associates them with optional indices.
-   * Used by getNestedLocator methods.
-   */
-  extractPathsFromSchema = (paths, indices = {}) => {
-    const schemaParts = paths.split(".");
-    let cumulativePath = "";
-    return schemaParts.map((part, index) => {
-      cumulativePath = cumulativePath ? `${cumulativePath}.${part}` : part;
-      return {
-        path: cumulativePath,
-        index: indices[index] ?? void 0
-      };
-    });
-  };
-  /**
-   * logError:
-   * Logs detailed error information and re-throws the error to ensure tests fail as expected.
-   */
-  logError = (error, locatorSchemaPath, currentLocator, currentPath, pathIndexPairs, nestedLocatorResults) => {
-    const errorDetails = {
-      error: error.message,
-      locatorSchemaPath,
-      currentPath,
-      pathIndexPairs: JSON.stringify(pathIndexPairs, null, 2),
-      currentLocatorDetails: currentLocator ? {
-        locatorString: currentLocator,
-        isNotNull: true
-      } : { isNotNull: false },
-      nestedLocatorResults: safeStringifyOfNestedLocatorResults(nestedLocatorResults)
-    };
-    this.log.error(
-      "An error occurred during nested locator construction.\n",
-      "Error details:\n",
-      JSON.stringify(errorDetails, null, 2)
-    );
-    throw error;
-  };
-  /**
-   * deepMerge:
-   * Recursively merges source properties into target, validating them against LocatorSchema to ensure no invalid keys.
-   * Ensures immutability by creating a new object rather than modifying in place.
-   */
-  deepMerge(target, source, schema = getLocatorSchemaDummy()) {
-    const merged = { ...target };
-    for (const key of Object.keys(source)) {
-      if (key === "locatorSchemaPath") {
-        throw new Error(
-          `[${this.pageObjectClass.pocName}] Invalid property: 'locatorSchemaPath' cannot be updated. Attempted to update LocatorSchemaPath from '${target[key]}' to '${source[key]}'.`
-        );
-      }
-      if (!(key in schema)) {
-        throw new Error(`Invalid property: '${key}' is not a valid property of LocatorSchema`);
-      }
-      const sourceValue = source[key];
-      const targetValue = target[key];
-      if (typeof sourceValue === "object" && sourceValue !== null && schema[key] && typeof schema[key] === "object") {
-        if (targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
-          merged[key] = this.deepMerge(
-            targetValue,
-            // Updated type here
-            sourceValue,
-            schema[key]
-          );
-        } else {
-          merged[key] = this.deepMerge(
-            {},
-            sourceValue,
-            schema[key]
-          );
-        }
-      } else {
-        if (Array.isArray(sourceValue)) {
-          merged[key] = Array.isArray(targetValue) ? targetValue.concat(sourceValue) : [...sourceValue];
-        } else if (typeof sourceValue === "object" && sourceValue !== null && Object.prototype.toString.call(sourceValue) === "[object RegExp]") {
-          merged[key] = new RegExp(
-            sourceValue.source,
-            sourceValue.flags
-          );
-        } else {
-          merged[key] = sourceValue;
-        }
-      }
-    }
-    return merged;
-  }
-  /**
-   * buildNestedLocator:
-   * Constructs a nested locator by iterating through each sub-path of locatorSchemaPath and chaining locators.
-   * Applies filters, indexing (nth), and logs details for debugging during test retries.
-   */
-  buildNestedLocator = async (locatorSchemaPath, schemasMap, filterMap, indices = {}) => {
-    return await test.step(`${this.pageObjectClass.pocName}: Build Nested Locator`, async () => {
-      const pathIndexPairs = this.extractPathsFromSchema(locatorSchemaPath, indices);
-      let currentLocator = null;
-      let currentIFrame = null;
-      const nestedLocatorResults = {
-        LocatorSchema: null,
-        NestingSteps: []
-      };
-      for (const { path, index } of pathIndexPairs) {
-        const currentSchema = schemasMap.get(path);
-        if (!currentSchema) continue;
-        try {
-          const nextLocator = this.getBy.getLocator(currentSchema);
-          currentLocator = currentLocator ? currentLocator.locator(nextLocator) : nextLocator;
-          if (currentSchema.locatorMethod !== "frameLocator" /* frameLocator */ && currentSchema.filter) {
-            currentLocator = currentLocator.filter({
-              has: currentSchema.filter.has,
-              hasNot: currentSchema.filter.hasNot,
-              hasNotText: currentSchema.filter.hasNotText,
-              hasText: currentSchema.filter.hasText
-            });
-          }
-          const filterEntries = filterMap.get(path);
-          if (filterEntries) {
-            for (const filterData of filterEntries) {
-              currentLocator = currentLocator.filter({
-                has: filterData.has,
-                hasNot: filterData.hasNot,
-                hasNotText: filterData.hasNotText,
-                hasText: filterData.hasText
-              });
-            }
-          }
-          if (index != null) {
-            currentLocator = currentLocator.nth(index);
-          }
-          if (this.log.isLogLevelEnabled("debug")) {
-            if (!nestedLocatorResults.LocatorSchema) {
-              const schemaFromMap = schemasMap.get(locatorSchemaPath);
-              if (schemaFromMap) {
-                nestedLocatorResults.LocatorSchema = schemaFromMap;
-              }
-            }
-            if (currentSchema.locatorMethod === "frameLocator" /* frameLocator */) {
-              if (!currentIFrame) {
-                currentIFrame = currentSchema.frameLocator;
-              }
-              if (currentIFrame && currentSchema.frameLocator && currentIFrame.endsWith(currentSchema.frameLocator)) {
-                currentIFrame += ` -> ${currentSchema.frameLocator}`;
-              }
-            }
-            if (currentIFrame !== void 0) {
-              await this.evaluateCurrentLocator(currentLocator, nestedLocatorResults.NestingSteps, currentIFrame);
-            } else {
-              await this.evaluateCurrentLocator(currentLocator, nestedLocatorResults.NestingSteps, null);
-            }
-          }
-        } catch (error) {
-          this.logError(error, locatorSchemaPath, currentLocator, path, pathIndexPairs, nestedLocatorResults);
-          break;
-        }
-      }
-      if (!currentLocator) {
-        this.logError(
-          new Error(`Failed to build nested locator for path: ${locatorSchemaPath}`),
-          locatorSchemaPath,
-          currentLocator,
-          locatorSchemaPath,
-          pathIndexPairs
-        );
-      }
-      if (this.log.isLogLevelEnabled("debug")) {
-        this.log.debug("Nested locator evaluation results:", safeStringifyOfNestedLocatorResults(nestedLocatorResults));
-      }
-      if (currentLocator != null) {
-        return currentLocator;
-      }
-    });
-  };
-  /**
-   * evaluateCurrentLocator:
-   * Gathers debug information about the current locator's resolved elements.
-   * Helps with logging and debugging complex locator chains.
-   */
-  evaluateCurrentLocator = async (currentLocator, resultsArray, currentIFrame) => {
-    if (currentIFrame) {
-      resultsArray.push({
-        currentLocatorString: currentLocator,
-        currentIFrame,
-        Note: "iFrame locators evaluation not implemented"
-      });
-    } else {
-      const elementCount = await currentLocator.count();
-      resultsArray.push({
-        currentLocatorString: `${currentLocator}`,
-        resolved: elementCount > 0,
-        elementCount
-      });
-    }
-  };
-};
-var WithMethodsClass = class extends GetLocatorBase {
-  constructor(pageObjectClass, log, locatorSubstring, schemasMap) {
-    super(pageObjectClass, log, locatorSubstring);
-    this.pageObjectClass = pageObjectClass;
-    this.log = log;
-    this.schemasMap = schemasMap;
-  }
-  locatorSchemaPath;
-  /**
-   * init:
-   * Assigns the locatorSchemaPath and binds methods (update, addFilter, getNestedLocator, getLocator)
-   * directly on the locatorSchemaCopy. Returns the modified copy, now fully chainable and type-safe.
-   */
-  init(locatorSchemaPath, locatorSchemaCopy) {
-    this.locatorSchemaPath = locatorSchemaPath;
-    const self = this;
-    locatorSchemaCopy.update = function(subPath, updates) {
-      const fullPath = this.locatorSchemaPath;
-      if (!(subPath === fullPath || fullPath.startsWith(`${subPath}.`))) {
-        throw new Error(`Invalid sub-path: '${subPath}' is not a valid sub-path of '${fullPath}'.`);
-      }
-      self.applyUpdateToSubPath(self.schemasMap, subPath, updates);
-      return this;
-    };
-    locatorSchemaCopy.addFilter = function(subPath, filterData) {
-      const fullPath = this.locatorSchemaPath;
-      if (!self.schemasMap.has(subPath)) {
-        const allowedPaths = self.extractPathsFromSchema(fullPath).map((p) => p.path).filter((path) => self.schemasMap.has(path));
-        throw new Error(
-          `Invalid sub-path '${subPath}' in addFilter. Allowed sub-paths are:
-${allowedPaths.join(",\n")}`
-        );
-      }
-      if (!this.filterMap) {
-        this.filterMap = /* @__PURE__ */ new Map();
-      }
-      const existingFilters = this.filterMap.get(subPath) || [];
-      existingFilters.push(filterData);
-      this.filterMap.set(subPath, existingFilters);
-      return this;
-    };
-    locatorSchemaCopy.getNestedLocator = async function(arg) {
-      if (arg !== void 0 && arg !== null && typeof arg !== "object") {
-        throw new Error("Invalid argument passed to getNestedLocator: Expected an object or null.");
-      }
-      if (!arg || Object.keys(arg).length === 0) {
-        return await self.buildNestedLocator(
-          self.locatorSchemaPath,
-          self.schemasMap,
-          this.filterMap,
-          {}
-        );
-      }
-      const numericIndices = {};
-      const pathIndexPairs = self.extractPathsFromSchema(self.locatorSchemaPath);
-      const pathToIndexMap = new Map(pathIndexPairs.map((pair, idx) => [pair.path, idx]));
-      for (const [subPath, value] of Object.entries(arg)) {
-        if (!self.schemasMap.has(subPath)) {
-          const validPaths = Array.from(self.schemasMap.keys());
-          throw new Error(
-            `Invalid sub-path '${subPath}' in getNestedLocator. Allowed sub-paths are:
-${validPaths.join(",\n")}`
-          );
-        }
-        if (!pathToIndexMap.has(subPath)) {
-          const validPaths = pathIndexPairs.map((p) => p.path).filter((path) => self.schemasMap.has(path));
-          throw new Error(
-            `Invalid sub-path '${subPath}' in getNestedLocator. Allowed sub-paths are:
-${validPaths.join(",\n")}`
-          );
-        }
-        const numericIndex = pathToIndexMap.get(subPath);
-        if (numericIndex === void 0) {
-          throw new Error(`Sub-path '${subPath}' not found in pathToIndexMap.`);
-        }
-        if (value !== null && (typeof value !== "number" || value < 0)) {
-          throw new Error(`Invalid index for sub-path '${subPath}': Expected a positive number or null.`);
-        }
-        if (value !== null) {
-          numericIndices[numericIndex] = value;
-        }
-      }
-      return await self.buildNestedLocator(
-        self.locatorSchemaPath,
-        self.schemasMap,
-        this.filterMap,
-        numericIndices
-      );
-    };
-    locatorSchemaCopy.getLocator = async () => {
-      return self.getBy.getLocator(locatorSchemaCopy);
-    };
-    return locatorSchemaCopy;
-  }
-};
-
-// src/helpers/sessionStorage.actions.ts
-import { test as test2 } from "@playwright/test";
-var SessionStorage = class {
-  // Initializes the class with a Playwright Page object and a name for the Page Object Class.
-  constructor(page, pocName) {
-    this.page = page;
-    this.pocName = pocName;
-  }
-  // Defines an object to hold states to be set in session storage, allowing any value type.
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  queuedStates = {};
-  // Indicates if the session storage manipulation has been initiated.
-  isInitiated = false;
-  /** Writes states to session storage. Accepts an object with key-value pairs representing the states. */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  async writeToSessionStorage(states) {
-    await this.page.evaluate((storage) => {
-      for (const [key, value] of Object.entries(storage)) {
-        window.sessionStorage.setItem(key, JSON.stringify(value));
-      }
-    }, states);
-  }
-  /** Reads all states from session storage and returns them as an object. */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  async readFromSessionStorage() {
-    return await this.page.evaluate(() => {
-      const storage = {};
-      for (let i = 0; i < sessionStorage.length; i++) {
-        const key = sessionStorage.key(i);
-        if (key !== null) {
-          const item = sessionStorage.getItem(key);
-          try {
-            storage[key] = item ? JSON.parse(item) : null;
-          } catch (_e) {
-            storage[key] = item;
-          }
-        }
-      }
-      return storage;
-    });
-  }
-  /**
-   * Sets the specified states in session storage.
-   * Optionally reloads the page after setting the data to ensure the new session storage state is active.
-   *
-   * Parameters:
-   * states: Object representing the states to set in session storage.
-   * reload: Boolean indicating whether to reload the page after setting the session storage data.
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  async set(states, reload) {
-    await test2.step(`${this.pocName}: setSessionStorage`, async () => {
-      await this.writeToSessionStorage(states);
-      if (reload) {
-        await this.page.reload();
-      }
-    });
-  }
-  /**
-   * Queues states to be set in the sessionStorage before the next navigation occurs.
-   * Handles different scenarios based on whether the context exists or multiple calls are made.
-   *
-   * 1. No Context, Single Call: Queues and sets states upon the next navigation.
-   * 2. No Context, Multiple Calls: Merges states from multiple calls and sets them upon the next navigation.
-   * 3. With Context: Directly sets states in sessionStorage if the context already exists.
-   *
-   * Parameters:
-   * states: Object representing the states to queue for setting in session storage.
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  async setOnNextNavigation(states) {
-    this.queuedStates = { ...this.queuedStates, ...states };
-    const populateStorage = async () => {
-      await test2.step(`${this.pocName}: setSessionStorageBeforeNavigation`, async () => {
-        await this.writeToSessionStorage(this.queuedStates);
-      });
-      this.queuedStates = {};
-    };
-    let contextExists = false;
-    try {
-      contextExists = await this.page.evaluate(() => {
-        return typeof window !== "undefined" && window.sessionStorage !== void 0;
-      });
-    } catch (_e) {
-      contextExists = false;
-    }
-    if (contextExists) {
-      await populateStorage();
-      return;
-    }
     if (!this.isInitiated) {
       this.isInitiated = true;
-      this.page.once("framenavigated", async () => {
+      const handler = async (frame) => {
+        if (frame !== this.page.mainFrame()) {
+          return;
+        }
         await populateStorage();
-      });
+        this.page.off("framenavigated", handler);
+        this.isInitiated = false;
+      };
+      this.page.on("framenavigated", handler);
     }
   }
-  /**
-   * Fetches states from session storage.
-   * If specific keys are provided, fetches only those states; otherwise, fetches all states.
-   *
-   * Parameters:
-   * keys: Optional array of keys to specify which states to fetch from session storage.
-   *
-   * Returns:
-   * Object containing the fetched states.
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  async get(keys) {
+  async get(keys, options = {}) {
     let result = {};
-    await test2.step(`${this.pocName}: getSessionStorage`, async () => {
+    await test2.step(this.getStepLabel("get"), async () => {
+      await this.ensureContext(options);
       const allData = await this.readFromSessionStorage();
       if (keys && keys.length > 0) {
         for (const key of keys) {
           if (Object.hasOwn(allData, key)) {
-            result[key] = allData[key];
+            const value = allData[key];
+            if (value !== void 0) {
+              result[key] = value;
+            }
           }
         }
       } else {
@@ -1204,216 +314,301 @@ var SessionStorage = class {
     });
     return result;
   }
-  /**
-   * Clears all states in sessionStorage.
-   */
-  async clear() {
-    await test2.step(`${this.pocName}: clear SessionStorage`, async () => {
-      await this.page.evaluate(() => sessionStorage.clear());
+  async clear(keyOrOptions, options = {}) {
+    const { keys, waitForContext } = (() => {
+      if (Array.isArray(keyOrOptions)) {
+        return { keys: keyOrOptions, waitForContext: options.waitForContext };
+      }
+      if (typeof keyOrOptions === "string") {
+        return { keys: [keyOrOptions], waitForContext: options.waitForContext };
+      }
+      if (keyOrOptions) {
+        return { keys: void 0, waitForContext: keyOrOptions.waitForContext };
+      }
+      return { keys: void 0, waitForContext: options.waitForContext };
+    })();
+    await test2.step(this.getStepLabel("clear"), async () => {
+      await this.ensureContext({ waitForContext });
+      if (!keys || keys.length === 0) {
+        await this.page.evaluate(() => sessionStorage.clear());
+        return;
+      }
+      await this.page.evaluate((keysToClear) => {
+        for (const key of keysToClear) {
+          sessionStorage.removeItem(key);
+        }
+      }, keys);
     });
   }
 };
 
-// src/utils/selectorEngines.ts
-function createCypressIdEngine() {
-  return {
-    /**
-     * Uses the document's querySelector method to find the first element with a specific 'data-cy' attribute.
-     * Constructs a selector string for the 'data-cy' attribute and searches the DOM for the first match.
-     *
-     * Parameters:
-     * - document: An object that mimics the global document, having a querySelector method.
-     * - selector: A string representing the value of the 'data-cy' attribute to search for.
-     *
-     * Returns the first HTML element matching the 'data-cy' attribute, or null if no match is found.
-     */
-    query(document, selector) {
-      const attr = `[data-cy="${selector}"]`;
-      const el = document.querySelector(attr);
-      return el;
-    },
-    /**
-     * Uses the document's querySelectorAll method to find all elements with a specific 'data-cy' attribute.
-     * Constructs a selector string for the 'data-cy' attribute and retrieves all matching elements in the DOM.
-     * Converts the NodeList from querySelectorAll into an array for easier handling and manipulation.
-     *
-     * Parameters:
-     * - document: An object that mimics the global document, having a querySelectorAll method.
-     * - selector: A string representing the value of the 'data-cy' attribute to search for.
-     *
-     * Returns an array of HTML elements matching the 'data-cy' attribute. Returns an empty array if no matches are found.
-     */
-    queryAll(document, selector) {
-      const attr = `[data-cy="${selector}"]`;
-      const els = Array.from(document.querySelectorAll(attr));
-      return els;
-    }
-  };
-}
-
-// src/basePage.ts
-var selectorRegistered = false;
-var BasePage = class {
-  /** Provides Playwright page methods */
-  page;
-  /** Playwright TestInfo contains information about currently running test, available to any test function */
-  testInfo;
-  /** Selectors can be used to install custom selector engines.*/
-  selector;
-  /** The base URL of the Page Object Class */
-  baseUrl;
-  /** The URL path of the Page Object Class */
-  urlPath;
-  /** The full URL of the Page Object Class */
-  fullUrl;
-  /** The name of the Page Object Class */
-  pocName;
-  /** The Page Object Class' PlaywrightReportLogger instance, prefixed with its name. Log levels: debug, info, warn, and error.  */
-  log;
-  /** The SessionStorage class provides methods for setting and getting session storage data in Playwright.*/
-  sessionStorage;
-  /**
-   * locators:
-   * An instance of GetLocatorBase that handles schema management and provides getLocatorSchema calls.
-   * Initially, LocatorSubstring is undefined. Once getLocatorSchema(path) is called,
-   * we get a chainable object typed with LocatorSubstring = P.
-   */
-  locators;
-  constructor(page, testInfo, baseUrl, urlPath, pocName, pwrl, locatorSubstring) {
-    this.page = page;
-    this.testInfo = testInfo;
-    this.selector = selectors;
-    this.baseUrl = baseUrl;
-    this.urlPath = urlPath;
-    this.fullUrl = this.constructFullUrl(baseUrl, urlPath);
-    this.pocName = pocName;
-    this.log = pwrl.getNewChildLogger(pocName);
-    const classDeprecationMessage = "[POMWright] BasePage is depricated and will be removed in 2.0.0. Migrate to v2, preferably directly to PageObject or through the transitional bridge BasePageV1toV2 and then to PageObject.";
-    warnDeprecationOncePerTest(`${this.constructor.name}-class-deprecation`, classDeprecationMessage, this.log);
-    this.locators = new GetLocatorBase(
-      this,
-      this.log.getNewChildLogger("GetLocator"),
-      locatorSubstring
-    );
-    this.initLocatorSchemas();
-    this.sessionStorage = new SessionStorage(this.page, this.pocName);
-    if (!selectorRegistered) {
-      selectors.register("data-cy", createCypressIdEngine);
-      selectorRegistered = true;
+// src/helpers/stepDecorator.ts
+import { test as test3 } from "@playwright/test";
+var isMethodDecoratorArgs = (args) => args.length === 3 && typeof args[0] === "object" && (typeof args[1] === "string" || typeof args[1] === "symbol");
+var isStage3MethodDecoratorArgs = (args) => args.length === 2 && typeof args[0] === "function" && args[1] !== null && typeof args[1] === "object";
+var normalizeStepArguments = (args) => {
+  const [titleOrOptions, maybeOptions] = args;
+  const title = typeof titleOrOptions === "string" ? titleOrOptions : void 0;
+  const options = typeof titleOrOptions === "string" ? maybeOptions : titleOrOptions;
+  return { title, options };
+};
+var createWrappedMethod = (original, methodName, title, options) => function(...methodArgs) {
+  const rawClassName = this.constructor?.name ?? "";
+  const className = rawClassName && rawClassName !== "Object" ? rawClassName : "Anonymous";
+  const resolvedTitle = title ?? `${className}.${String(methodName)}`;
+  return test3.step(resolvedTitle, () => original.apply(this, methodArgs), options);
+};
+var createStepDecorator = ({ title, options }) => (valueOrTarget, contextOrKey, descriptor) => {
+  if (typeof valueOrTarget === "function" && isStage3MethodDecoratorArgs([valueOrTarget, contextOrKey])) {
+    const [original2, context] = [valueOrTarget, contextOrKey];
+    return createWrappedMethod(original2, context.name, title, options);
+  }
+  if (!descriptor || typeof descriptor.value !== "function") {
+    throw new Error("@step decorator can only be applied to methods.");
+  }
+  const original = descriptor.value;
+  descriptor.value = createWrappedMethod(original, contextOrKey, title, options);
+  return descriptor;
+};
+function step(...args) {
+  if (isStage3MethodDecoratorArgs(args)) {
+    return createStepDecorator(normalizeStepArguments([]))(...args);
+  }
+  if (isMethodDecoratorArgs(args)) {
+    return createStepDecorator(normalizeStepArguments([]))(...args);
+  }
+  return createStepDecorator(normalizeStepArguments(args));
+}
+
+// src/locators/utils.ts
+var formatLocatorSchemaPathForError = (path) => {
+  const json = JSON.stringify(path);
+  return json.slice(1, -1);
+};
+var RUNTIME_WHITESPACE_REGEX = /[\s\u0085]/u;
+var validateLocatorSchemaPath = (path) => {
+  if (!path) {
+    throw new Error("LocatorSchemaPath string cannot be empty");
+  }
+  if (RUNTIME_WHITESPACE_REGEX.test(path)) {
+    const escaped = formatLocatorSchemaPathForError(path);
+    throw new Error(`LocatorSchemaPath string cannot contain whitespace chars: ${escaped}`);
+  }
+  if (path.startsWith(".")) {
+    throw new Error(`LocatorSchemaPath string cannot start with a dot: ${path}`);
+  }
+  if (path.endsWith(".")) {
+    throw new Error(`LocatorSchemaPath string cannot end with a dot: ${path}`);
+  }
+  if (path.includes("..")) {
+    throw new Error(`LocatorSchemaPath string cannot contain consecutive dots: ${path}`);
+  }
+};
+var expandSchemaPath = (path) => {
+  validateLocatorSchemaPath(path);
+  const parts = path.split(".");
+  return parts.map((_part, index) => parts.slice(0, index + 1).join("."));
+};
+var cssEscape = (value) => {
+  return value.replace(/([\\"'#.:;,?*+<>{}[\\]()])/g, "\\$1");
+};
+var normalizeSteps = (steps) => steps ? steps.map((step2) => ({ ...step2 })) : [];
+function normalizeIdValue(id) {
+  if (typeof id !== "string") {
+    return id;
+  }
+  if (id.startsWith("#")) {
+    return id.slice(1);
+  }
+  if (id.startsWith("id=")) {
+    return id.slice("id=".length);
+  }
+  return id;
+}
+var stringifyForLog = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(
+    value,
+    (_key, current) => {
+      if (typeof current === "object" && current !== null) {
+        if (seen.has(current)) {
+          return "[Circular]";
+        }
+        seen.add(current);
+      }
+      if (current instanceof RegExp) {
+        return { type: "RegExp", source: current.source, flags: current.flags };
+      }
+      return current;
+    },
+    2
+  );
+};
+var applyIndexSelector = (locator, selector) => {
+  if (selector === void 0 || selector === null) {
+    return locator;
+  }
+  if (selector === "first") {
+    return locator.first();
+  }
+  if (selector === "last") {
+    return locator.last();
+  }
+  return locator.nth(selector);
+};
+var createLocator = (target, definition) => {
+  switch (definition.type) {
+    case "role":
+      return target.getByRole(definition.role, definition.options);
+    case "text":
+      return target.getByText(definition.text, definition.options);
+    case "label":
+      return target.getByLabel(definition.text, definition.options);
+    case "placeholder":
+      return target.getByPlaceholder(definition.text, definition.options);
+    case "altText":
+      return target.getByAltText(definition.text, definition.options);
+    case "title":
+      return target.getByTitle(definition.text, definition.options);
+    case "locator":
+      return target.locator(definition.selector, definition.options);
+    case "frameLocator":
+      return target.frameLocator(definition.selector);
+    case "testId":
+      return target.getByTestId(definition.testId);
+    case "id": {
+      if (typeof definition.id === "string") {
+        const normalized = normalizeIdValue(definition.id);
+        return target.locator(`#${cssEscape(normalized ?? "")}`);
+      }
+      const pattern = definition.id.source;
+      const safePattern = cssEscape(pattern);
+      return target.locator(`[id*="${safePattern}"]`);
+    }
+    default: {
+      const exhaustive = definition;
+      return exhaustive;
     }
   }
-  /**
-   * constructFullUrl:
-   * Combines baseUrl and urlPath, handling both strings and RegExps.
-   * Ensures a flexible approach to URL matching (string or regex-based).
-   */
-  constructFullUrl(baseUrl, urlPath) {
-    const escapeStringForRegExp = (str) => str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-    if (typeof baseUrl === "string" && typeof urlPath === "string") {
-      return `${baseUrl}${urlPath}`;
+};
+var cloneLocatorStrategyDefinition = (definition) => {
+  switch (definition.type) {
+    case "role":
+      return {
+        type: "role",
+        role: definition.role,
+        ...definition.options ? { options: { ...definition.options } } : {}
+      };
+    case "text":
+      return {
+        type: "text",
+        text: definition.text,
+        ...definition.options ? { options: { ...definition.options } } : {}
+      };
+    case "label":
+      return {
+        type: "label",
+        text: definition.text,
+        ...definition.options ? { options: { ...definition.options } } : {}
+      };
+    case "placeholder":
+      return {
+        type: "placeholder",
+        text: definition.text,
+        ...definition.options ? { options: { ...definition.options } } : {}
+      };
+    case "altText":
+      return {
+        type: "altText",
+        text: definition.text,
+        ...definition.options ? { options: { ...definition.options } } : {}
+      };
+    case "title":
+      return {
+        type: "title",
+        text: definition.text,
+        ...definition.options ? { options: { ...definition.options } } : {}
+      };
+    case "locator":
+      return {
+        type: "locator",
+        selector: definition.selector,
+        ...definition.options ? { options: { ...definition.options } } : {}
+      };
+    case "frameLocator":
+      return { type: "frameLocator", selector: definition.selector };
+    case "testId":
+      return { type: "testId", testId: definition.testId };
+    case "id":
+      return { type: "id", id: definition.id };
+    default: {
+      const exhaustive = definition;
+      return exhaustive;
     }
-    if (typeof baseUrl === "string" && urlPath instanceof RegExp) {
-      return new RegExp(`^${escapeStringForRegExp(baseUrl)}${urlPath.source}`);
+  }
+};
+var applyDefinitionPatch = (seed, patch) => {
+  const base2 = cloneLocatorStrategyDefinition(seed);
+  switch (patch.type) {
+    case "locator": {
+      const selector = patch.selector !== void 0 ? patch.selector : base2.selector;
+      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
+      return { type: "locator", selector, ...options ? { options } : {} };
     }
-    if (baseUrl instanceof RegExp && typeof urlPath === "string") {
-      return new RegExp(`${baseUrl.source}${escapeStringForRegExp(urlPath)}$`);
+    case "role": {
+      const role = patch.role ?? base2.role;
+      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
+      return { type: "role", role, ...options ? { options } : {} };
     }
-    if (baseUrl instanceof RegExp && urlPath instanceof RegExp) {
-      return new RegExp(`${baseUrl.source}${urlPath.source}`);
+    case "text": {
+      const text = patch.text ?? base2.text;
+      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
+      return { type: "text", text, ...options ? { options } : {} };
+    }
+    case "label": {
+      const text = patch.text ?? base2.text;
+      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
+      return { type: "label", text, ...options ? { options } : {} };
+    }
+    case "placeholder": {
+      const text = patch.text ?? base2.text;
+      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
+      return { type: "placeholder", text, ...options ? { options } : {} };
+    }
+    case "altText": {
+      const text = patch.text ?? base2.text;
+      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
+      return { type: "altText", text, ...options ? { options } : {} };
+    }
+    case "title": {
+      const text = patch.text ?? base2.text;
+      const options = patch.options || base2.options ? { ...base2.options, ...patch.options } : void 0;
+      return { type: "title", text, ...options ? { options } : {} };
+    }
+    case "frameLocator": {
+      const selector = patch.selector !== void 0 ? patch.selector : base2.selector;
+      return { type: "frameLocator", selector };
+    }
+    case "testId": {
+      const testId = patch.testId !== void 0 ? patch.testId : base2.testId;
+      return { type: "testId", testId };
+    }
+    case "id": {
+      const id = patch.id !== void 0 ? normalizeIdValue(patch.id) ?? base2.id : base2.id;
+      return { type: "id", id };
+    }
+    default: {
+      const exhaustive = patch;
+      return exhaustive;
     }
-    throw new Error("Invalid baseUrl or urlPath types. Expected string or RegExp.");
-  }
-  /**
-   * Implementation of getNestedLocator.
-   */
-  async getNestedLocator(locatorSchemaPath, subPathIndices) {
-    const withValidation = new WithSubPathValidation(
-      this,
-      this.log.getNewChildLogger("SubPathValidation"),
-      locatorSchemaPath
-    );
-    return await withValidation.getNestedLocator(subPathIndices);
-  }
-  /**
-   * Short-hand wrapper method for calling .getLocatorSchema(LocatorSchemaPath).getLocator()
-   *
-   * This method does not perform nesting,and will return the locator for which the full LocatorSchemaPath resolves to,
-   * provided by getLocatorSchema("...")
-   *
-   * Note: This short-hand wrapper method is useful for quickly getting a locator without having to call
-   * getLocatorSchema("...") first. On the other hand, it can't be used to update or add filters to the LocatorSchema.
-   *
-   * @example
-   * // Usage:
-   * const submitButton = await poc.getLocator("main.form.button@submit");
-   * await expect(submitButton, "should only exist one submit button").toHaveCount(1);
-   */
-  getLocator = async (locatorSchemaPath) => {
-    return await this.getLocatorSchema(locatorSchemaPath).getLocator();
-  };
-  /**
-   * getLocatorSchema:
-   * Delegates to this.locators.getLocatorSchema.
-   * Returns a chainable schema object for the given path.
-   * Once called with a specific path P, the update and addFilter methods are restricted to sub-paths of P.
-   *
-   * The "getLocatorSchema" method is used to retrieve an updatable deep copy of a LocatorSchema defined in the
-   * GetLocatorBase class. It enriches the returned schema with additional methods to handle updates and retrieval of
-   * deep copy locators.
-   *
-   * getLocatorSchema adds the following chainable methods to the returned LocatorSchemaWithMethods object:
-   *
-   * update
-   * - Allows updating any schema in the chain by specifying the subPath directly.
-   * - Gives compile-time suggestions for valid sub-paths of the LocatorSchemaPath provided to .getLocatorSchema().
-   * - If you want to update multiple schemas, chain multiple .update() calls.
-   *
-   * addFilter(subPath: SubPaths<LocatorSchemaPathType, LocatorSubstring>, filterData: FilterEntry)
-   * - The equivalent of the Playwright locator.filter() method
-   * - This method is used for filtering the specified locator based on the provided filterData.
-   * - Can be chained multiple times to add multiple filters to the same or different LocatorSchema.
-   *
-   * getNestedLocator
-   * - Asynchronously builds a nested locator based on the LocatorSchemaPath provided by getLocatorSchema("...")
-   * - Can be chained once after the update and addFilter methods or directly on the .getLocatorSchema method.
-   * - getNestedLocator will end the method chain and return a nested Playwright Locator.
-   * - Optionally parameter takes a list of key(subPath)-value(index) pairs, the locator constructed from the LocatorSchema
-   * with the specified subPath will resolve to the .nth(n) occurrence of the element, within the chain.
-   *
-   * getLocator()
-   * - Asynchronously retrieves a locator based on the current LocatorSchemaPath.
-   * - This method does not perform nesting and will return the locator for which the full LocatorSchemaPath resolves to, provided by getLocatorSchema("...")
-   * - Can be chained once after the update and addFilter methods or directly on the .getLocatorSchema method.
-   * - getLocator will end the method chain and return a Playwright Locator.
-   *
-   * Note: Calling getLocator() and getNestedLocator() on the same LocatorSchemaPath will return a Locator for the same
-   * element, but the Locator returned by getNestedLocator() will be a locator resolving to said same element through
-   * a chain of locators. While the Locator returned by getLocator() will be a single locator which resolves directly
-   * to said element. Thus getLocator() is rarely used, while getNestedLocator() is used extensively.
-   *
-   * That said, for certain use cases, getLocator() can be useful, and you could use it to manually chain locators
-   * yourself if some edge case required it. Though, it would be likely be more prudent to expand your LocatorSchemaPath
-   * type and initLocatorSchemas() method to include the additional locators you need for the given POC, and then use
-   * getNestedLocator() instead, or by implementing a helper method on your Page Object Class.
-   */
-  getLocatorSchema(path) {
-    return this.locators.getLocatorSchema(path);
   }
 };
-var WithSubPathValidation = class extends GetLocatorBase {
-  constructor(pageObjectClass, log, locatorSchemaPath) {
-    super(pageObjectClass, log, locatorSchemaPath);
-    this.locatorSchemaPath = locatorSchemaPath;
-  }
-  async getNestedLocator(arg) {
-    return await this.pageObjectClass.getLocatorSchema(this.locatorSchemaPath).getNestedLocator(arg);
-  }
+var isFrameLocatorDefinition = (definition) => definition.type === "frameLocator";
+var isLocatorInstance = (value) => {
+  return !!value && typeof value === "object" && typeof value.filter === "function";
 };
 
-// src/basePageV1toV2.ts
-import { selectors as selectors2 } from "@playwright/test";
-
-// srcV2/locators/locatorUpdateBuilder.ts
+// src/locators/locatorUpdateBuilder.ts
 var parseUpdateArguments = (primaryOrOptions, options, optionsProvided) => {
   let primary;
   let parsedOptions;
@@ -1903,7 +1098,7 @@ var LocatorUpdateBuilder = class {
   }
 };
 
-// srcV2/locators/locatorQueryBuilder.ts
+// src/locators/locatorQueryBuilder.ts
 var LocatorQueryBuilder = class {
   constructor(registry, path) {
     this.registry = registry;
@@ -2126,7 +1321,7 @@ var LocatorQueryBuilder = class {
   }
 };
 
-// srcV2/locators/locatorRegistrationBuilder.ts
+// src/locators/locatorRegistrationBuilder.ts
 var LocatorRegistrationBuilder = class {
   constructor(registry, path, seed) {
     this.registry = registry;
@@ -2350,7 +1545,7 @@ var LocatorRegistrationBuilder = class {
   }
 };
 
-// srcV2/locators/reusableLocatorBuilder.ts
+// src/locators/reusableLocatorBuilder.ts
 var ReusableLocatorBuilder = class {
   stepsList;
   definitionValue;
@@ -2426,7 +1621,7 @@ var ReusableLocatorFactory = class {
   }
 };
 
-// srcV2/locators/locatorRegistry.ts
+// src/locators/locatorRegistry.ts
 var LocatorRegistryInternal = class {
   constructor(page) {
     this.page = page;
@@ -2462,20 +1657,45 @@ var LocatorRegistryInternal = class {
       ...record.description !== void 0 ? { description: record.description } : {}
     };
   }
-  add(path, options) {
+  /**
+   * Registers a locator schema at the provided dot-delimited path.
+   * Accepts exactly one locator strategy (`getByRole`, `locator`, etc.) and any number of
+   * `filter`/`nth` steps chained in call order. When `{ reuse }` is supplied, the seeded
+   * definition is applied first and one matching override is allowed as a PATCH of the seed;
+   * otherwise, calling multiple locator strategies will throw.
+   *
+   * @example
+   * ```ts
+   * registry
+   *   .add("list.item")
+   *   .getByRole("listitem", { name: /Row/ })
+   *   .filter({ hasText: "Row" })
+   *   .nth("last");
+   * ```
+   */
+  add(path, ...args) {
+    const options = args[0];
     const reuse = options?.reuse;
-    if (!reuse) {
+    if (reuse === void 0) {
       return new LocatorRegistrationBuilder(
         this,
         path
       );
     }
     if (typeof reuse === "string") {
+      const targetPath = path;
+      if (reuse === targetPath) {
+        throw new Error(`Locator reuse path cannot be the same as registration path: "${targetPath}".`);
+      }
       const sourceRecord = this.get(reuse);
-      const cloned = this.cloneRecordForReuse(sourceRecord, path);
-      this.register(path, cloned);
+      const cloned = this.cloneRecordForReuse(sourceRecord, targetPath);
+      this.register(targetPath, cloned);
       return void 0;
     }
+    if (Array.isArray(reuse)) {
+      const [reason] = reuse;
+      throw new Error(`Invalid reuse path configuration for "${path}": ${reason}`);
+    }
     const reusedRecord = this.cloneRecordForReuse(
       {
         locatorSchemaPath: path,
@@ -2526,7 +1746,7 @@ Existing Schema: ${errorDetails}`);
     }
     return {
       locatorSchemaPath: record.locatorSchemaPath,
-      definition: record.definition,
+      definition: cloneLocatorStrategyDefinition(record.definition),
       steps: normalizeSteps(record.steps),
       ...record.description !== void 0 ? { description: record.description } : {}
     };
@@ -2541,7 +1761,7 @@ Existing Schema: ${errorDetails}`);
     }
     return {
       locatorSchemaPath: record.locatorSchemaPath,
-      definition: record.definition,
+      definition: cloneLocatorStrategyDefinition(record.definition),
       steps: normalizeSteps(record.steps),
       ...record.description !== void 0 ? { description: record.description } : {}
     };
@@ -2620,7 +1840,10 @@ Existing Schema: ${errorDetails}`);
    * ```
    */
   getLocatorSchema(path) {
-    return new LocatorQueryBuilder(this, path);
+    return new LocatorQueryBuilder(
+      this,
+      path
+    );
   }
   /**
    * Resolves the Playwright {@link Locator} for the provided path, applying only the terminal
@@ -2723,7 +1946,6 @@ Existing Schema: ${errorDetails}`);
   }
 };
 var createRegistryWithAccessors = (page) => {
-  const _assertValidPaths = true;
   const registryInstance = new LocatorRegistryInternal(page);
   const add = registryInstance.add.bind(registryInstance);
   const getLocator = registryInstance.getLocator.bind(registryInstance);
@@ -2733,98 +1955,8 @@ var createRegistryWithAccessors = (page) => {
   return { registry, add, getLocator, getNestedLocator, getLocatorSchema };
 };
 
-// src/basePageV1toV2.ts
-var BasePageV1toV2 = class {
-  /** Provides Playwright page methods */
-  page;
-  /** Playwright TestInfo contains information about currently running test, available to any test function */
-  testInfo;
-  /** Selectors can be used to install custom selector engines.*/
-  selector;
-  /** The base URL of the Page Object Class */
-  baseUrl;
-  /** The URL path of the Page Object Class */
-  urlPath;
-  /** The full URL of the Page Object Class */
-  fullUrl;
-  /** The name of the Page Object Class */
-  pocName;
-  /** The Page Object Class' PlaywrightReportLogger instance, prefixed with its name. Log levels: debug, info, warn, and error.  */
-  log;
-  /** The SessionStorage class provides methods for setting and getting session storage data in Playwright.*/
-  sessionStorage;
-  /**
-   * locators:
-   * An instance of GetLocatorBase that handles schema management and provides getLocatorSchema calls.
-   * Initially, LocatorSubstring is undefined. Once getLocatorSchema(path) is called,
-   * we get a chainable object typed with LocatorSubstring = P.
-   */
-  locators;
-  /**
-   * v2 locator registry and accessors, used for migration to the fluent registry DSL.
-   */
-  locatorRegistry;
-  add;
-  getLocator;
-  getLocatorSchema;
-  getNestedLocator;
-  constructor(page, testInfo, baseUrl, urlPath, pocName, pwrl, locatorSubstring) {
-    this.page = page;
-    this.testInfo = testInfo;
-    this.selector = selectors2;
-    this.baseUrl = baseUrl;
-    this.urlPath = urlPath;
-    this.fullUrl = this.constructFullUrl(baseUrl, urlPath);
-    this.pocName = pocName;
-    this.log = pwrl.getNewChildLogger(pocName);
-    const classDeprecationMessage = "[POMWright] BasePageV1toV2 is a transitional bridge and will be removed in 2.0.0. Prefer PageObject for new work and migrate existing classes to PageObject.";
-    warnDeprecationOncePerTest(`${this.constructor.name}-class-deprecation`, classDeprecationMessage, this.log);
-    const { registry, add, getLocator, getNestedLocator, getLocatorSchema } = createRegistryWithAccessors(page);
-    this.locatorRegistry = registry;
-    this.add = add;
-    this.getLocator = getLocator;
-    this.getLocatorSchema = getLocatorSchema;
-    this.getNestedLocator = getNestedLocator;
-    this.defineLocators();
-    this.locators = new GetLocatorBase(
-      this,
-      this.log.getNewChildLogger("GetLocator"),
-      locatorSubstring
-    );
-    const initLocatorSchemasDeprecationMessage = "[POMWright] initLocatorSchemas is deprecated and will be removed in 2.0.0. Define locators with the v2 registry DSL in defineLocators instead.";
-    warnDeprecationOncePerTest(
-      `${this.constructor.name}-initLocatorSchemas-deprecation`,
-      initLocatorSchemasDeprecationMessage,
-      this.log
-    );
-    this.initLocatorSchemas();
-    this.sessionStorage = new SessionStorage(this.page, this.pocName);
-  }
-  /**
-   * constructFullUrl:
-   * Combines baseUrl and urlPath, handling both strings and RegExps.
-   * Ensures a flexible approach to URL matching (string or regex-based).
-   */
-  constructFullUrl(baseUrl, urlPath) {
-    const escapeStringForRegExp = (str) => str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-    if (typeof baseUrl === "string" && typeof urlPath === "string") {
-      return `${baseUrl}${urlPath}`;
-    }
-    if (typeof baseUrl === "string" && urlPath instanceof RegExp) {
-      return new RegExp(`^${escapeStringForRegExp(baseUrl)}${urlPath.source}`);
-    }
-    if (baseUrl instanceof RegExp && typeof urlPath === "string") {
-      return new RegExp(`${baseUrl.source}${escapeStringForRegExp(urlPath)}$`);
-    }
-    if (baseUrl instanceof RegExp && urlPath instanceof RegExp) {
-      return new RegExp(`${baseUrl.source}${urlPath.source}`);
-    }
-    throw new Error("Invalid baseUrl or urlPath types. Expected string or RegExp.");
-  }
-};
-
-// srcV2/helpers/navigation.ts
-import { expect, test as test3 } from "@playwright/test";
+// src/helpers/navigation.ts
+import { expect, test as test4 } from "@playwright/test";
 var DEFAULT_WAIT_UNTIL = "load";
 var DEFAULT_LOAD_STATE = "load";
 var Navigation = class {
@@ -2859,7 +1991,7 @@ var Navigation = class {
     if (typeof this.baseUrl !== "string" || typeof this.urlPath !== "string") {
       throw new Error("goto() is not supported when baseUrl or urlPath is a RegExp.");
     }
-    await test3.step(`${this.label}: Navigate to the provided URL or URL Path`, async () => {
+    await test4.step(`${this.label}: Navigate to the provided URL or URL Path`, async () => {
       const targetUrl = urlPathOrUrl.startsWith("/") ? `${this.baseUrl}${urlPathOrUrl}` : urlPathOrUrl;
       await this.page.goto(targetUrl, { waitUntil });
     });
@@ -2869,247 +2001,60 @@ var Navigation = class {
    * Available only when fullUrl is a string.
    */
   async gotoThisPage(options) {
-    if (typeof this.fullUrl !== "string") {
-      throw new Error("gotoThisPage() is not supported when fullUrl is a RegExp.");
-    }
-    const waitUntil = this.resolveWaitUntil(options);
-    const fullUrl = this.fullUrl;
-    await test3.step(`${this.label}: Navigate to this Page`, async () => {
-      await this.page.goto(fullUrl, { waitUntil });
-      await this.executeActions();
-    });
-  }
-  /**
-   * Expect to be on this page. Works with both string and RegExp fullUrl values.
-   * Uses waitUntil from navigation options when waiting for URL.
-   */
-  async expectThisPage(options) {
-    const waitUntil = this.resolveWaitUntil(options);
-    await test3.step(`${this.label}: Expect this Page`, async () => {
-      await this.page.waitForURL(this.fullUrl, { waitUntil });
-      await expect(async () => {
-        if (this.fullUrl instanceof RegExp) {
-          expect(this.page.url(), `expected '${this.fullUrl}', found '${this.page.url()}'`).toMatch(this.fullUrl);
-        } else {
-          expect(this.page.url(), `expected '${this.fullUrl}', found '${this.page.url()}'`).toBe(this.fullUrl);
-        }
-      }).toPass();
-      await this.executeActions();
-    });
-  }
-  /**
-   * Expect to be on any other page (i.e. not this page).
-   * Uses waitForLoadState from navigation options before validating URL.
-   */
-  async expectAnotherPage(options) {
-    const waitForLoadState = this.resolveWaitForLoadState(options);
-    await test3.step(`${this.label}: Expect any other Page`, async () => {
-      await this.page.waitForLoadState(waitForLoadState);
-      if (this.fullUrl instanceof RegExp) {
-        await expect.poll(async () => this.page.url(), {
-          message: `expected url to not match '${this.fullUrl}'`
-        }).not.toMatch(this.fullUrl);
-      } else {
-        await expect.poll(async () => this.page.url(), {
-          message: `expected url to not be '${this.fullUrl}', found '${this.page.url()}'`
-        }).not.toBe(this.fullUrl);
-      }
-    });
-  }
-};
-function createNavigation(page, baseUrl, urlPath, fullUrl, label, actions = null, defaultOptions) {
-  const navigation = new Navigation(page, baseUrl, urlPath, fullUrl, label, actions, defaultOptions);
-  return navigation;
-}
-
-// srcV2/helpers/sessionStorage.ts
-import { test as test4 } from "@playwright/test";
-var SessionStorage2 = class {
-  // Initializes the class with a Playwright Page object and an optional label for step titles.
-  constructor(page, options = {}) {
-    this.page = page;
-    this.options = options;
-  }
-  // Defines an object to hold states to be set in session storage, allowing any value type.
-  queuedStates = {};
-  // Indicates if the session storage manipulation has been initiated.
-  isInitiated = false;
-  getStepLabel(methodName) {
-    const prefix = this.options.label ? `${this.options.label}.` : "";
-    return `${prefix}SessionStorage.${methodName}:`;
-  }
-  async hasContext() {
-    return await this.page.evaluate(() => {
-      return typeof window !== "undefined" && window.sessionStorage !== void 0;
-    });
-  }
-  async waitForContextAvailability() {
-    try {
-      const contextExists = await this.hasContext();
-      if (contextExists) {
-        return;
-      }
-    } catch (_e) {
-    }
-    await new Promise((resolve) => {
-      const handler = async (frame) => {
-        if (frame !== this.page.mainFrame()) {
-          return;
-        }
-        try {
-          const contextExists = await this.hasContext();
-          if (!contextExists) {
-            return;
-          }
-        } catch (_e) {
-          return;
-        }
-        this.page.off("framenavigated", handler);
-        resolve();
-      };
-      this.page.on("framenavigated", handler);
-    });
-  }
-  async ensureContext({ waitForContext = false } = {}) {
-    try {
-      const contextExists = await this.hasContext();
-      if (contextExists) {
-        return;
-      }
-    } catch (_e) {
-    }
-    if (!waitForContext) {
-      throw new Error("SessionStorage context is not available.");
-    }
-    await this.waitForContextAvailability();
-  }
-  /** Writes states to session storage. Accepts an object with key-value pairs representing the states. */
-  async writeToSessionStorage(states) {
-    await this.page.evaluate((storage) => {
-      for (const [key, value] of Object.entries(storage)) {
-        window.sessionStorage.setItem(key, JSON.stringify(value));
-      }
-    }, states);
-  }
-  /** Reads all states from session storage and returns them as an object. */
-  async readFromSessionStorage() {
-    const storage = await this.page.evaluate(() => {
-      const storage2 = {};
-      for (let i = 0; i < sessionStorage.length; i++) {
-        const key = sessionStorage.key(i);
-        if (key !== null) {
-          const item = sessionStorage.getItem(key);
-          try {
-            storage2[key] = item ? JSON.parse(item) : null;
-          } catch (_e) {
-            storage2[key] = item;
-          }
-        }
-      }
-      return storage2;
-    });
-    return storage;
-  }
-  /**
-   * Sets the specified states in session storage.
-   * Optionally waits for the next main-frame navigation to establish a valid context before writing,
-   * and reloads the page after setting the data.
-   *
-   * Parameters:
-   * states: Object representing the states to set in session storage.
-   * reload: Boolean indicating whether to reload the page after setting the session storage data.
-   * waitForContext: Boolean indicating whether to wait for a main-frame navigation and a valid context.
-   */
-  async set(states, options = {}) {
-    await test4.step(this.getStepLabel("set"), async () => {
-      await this.ensureContext({ waitForContext: options.waitForContext });
-      await this.writeToSessionStorage(states);
-      if (options.reload) {
-        await this.page.reload();
-      }
-    });
-  }
-  /**
-   * Queues states to be set in the sessionStorage before the next navigation occurs.
-   * Handles different scenarios based on multiple calls made before the navigation occurs.
-   *
-   * 1. No Context, Single Call: Queues and sets states upon the next navigation.
-   * 2. No Context, Multiple Calls: Merges states from multiple calls and sets them upon the next navigation.
-   * 3. With Context: Still queues until the next navigation.
-   *
-   * Parameters:
-   * states: Object representing the states to queue for setting in session storage.
-   */
-  async setOnNextNavigation(states) {
-    this.queuedStates = { ...this.queuedStates, ...states };
-    const populateStorage = async () => {
-      await test4.step(this.getStepLabel("setOnNextNavigation"), async () => {
-        await this.writeToSessionStorage(this.queuedStates);
-      });
-      this.queuedStates = {};
-    };
-    if (!this.isInitiated) {
-      this.isInitiated = true;
-      const handler = async (frame) => {
-        if (frame !== this.page.mainFrame()) {
-          return;
-        }
-        await populateStorage();
-        this.page.off("framenavigated", handler);
-        this.isInitiated = false;
-      };
-      this.page.on("framenavigated", handler);
-    }
-  }
-  async get(keys, options = {}) {
-    let result = {};
-    await test4.step(this.getStepLabel("get"), async () => {
-      await this.ensureContext(options);
-      const allData = await this.readFromSessionStorage();
-      if (keys && keys.length > 0) {
-        for (const key of keys) {
-          if (Object.hasOwn(allData, key)) {
-            const value = allData[key];
-            if (value !== void 0) {
-              result[key] = value;
-            }
-          }
+    if (typeof this.fullUrl !== "string") {
+      throw new Error("gotoThisPage() is not supported when fullUrl is a RegExp.");
+    }
+    const waitUntil = this.resolveWaitUntil(options);
+    const fullUrl = this.fullUrl;
+    await test4.step(`${this.label}: Navigate to this Page`, async () => {
+      await this.page.goto(fullUrl, { waitUntil });
+      await this.executeActions();
+    });
+  }
+  /**
+   * Expect to be on this page. Works with both string and RegExp fullUrl values.
+   * Uses waitUntil from navigation options when waiting for URL.
+   */
+  async expectThisPage(options) {
+    const waitUntil = this.resolveWaitUntil(options);
+    await test4.step(`${this.label}: Expect this Page`, async () => {
+      await this.page.waitForURL(this.fullUrl, { waitUntil });
+      await expect(async () => {
+        if (this.fullUrl instanceof RegExp) {
+          expect(this.page.url(), `expected '${this.fullUrl}', found '${this.page.url()}'`).toMatch(this.fullUrl);
+        } else {
+          expect(this.page.url(), `expected '${this.fullUrl}', found '${this.page.url()}'`).toBe(this.fullUrl);
         }
-      } else {
-        result = allData;
-      }
+      }).toPass();
+      await this.executeActions();
     });
-    return result;
   }
-  async clear(keyOrOptions, options = {}) {
-    const { keys, waitForContext } = (() => {
-      if (Array.isArray(keyOrOptions)) {
-        return { keys: keyOrOptions, waitForContext: options.waitForContext };
-      }
-      if (typeof keyOrOptions === "string") {
-        return { keys: [keyOrOptions], waitForContext: options.waitForContext };
-      }
-      if (keyOrOptions) {
-        return { keys: void 0, waitForContext: keyOrOptions.waitForContext };
-      }
-      return { keys: void 0, waitForContext: options.waitForContext };
-    })();
-    await test4.step(this.getStepLabel("clear"), async () => {
-      await this.ensureContext({ waitForContext });
-      if (!keys || keys.length === 0) {
-        await this.page.evaluate(() => sessionStorage.clear());
-        return;
+  /**
+   * Expect to be on any other page (i.e. not this page).
+   * Uses waitForLoadState from navigation options before validating URL.
+   */
+  async expectAnotherPage(options) {
+    const waitForLoadState = this.resolveWaitForLoadState(options);
+    await test4.step(`${this.label}: Expect any other Page`, async () => {
+      await this.page.waitForLoadState(waitForLoadState);
+      if (this.fullUrl instanceof RegExp) {
+        await expect.poll(async () => this.page.url(), {
+          message: `expected url to not match '${this.fullUrl}'`
+        }).not.toMatch(this.fullUrl);
+      } else {
+        await expect.poll(async () => this.page.url(), {
+          message: `expected url to not be '${this.fullUrl}', found '${this.page.url()}'`
+        }).not.toBe(this.fullUrl);
       }
-      await this.page.evaluate((keysToClear) => {
-        for (const key of keysToClear) {
-          sessionStorage.removeItem(key);
-        }
-      }, keys);
     });
   }
 };
+function createNavigation(page, baseUrl, urlPath, fullUrl, label, actions = null, defaultOptions) {
+  const navigation = new Navigation(page, baseUrl, urlPath, fullUrl, label, actions, defaultOptions);
+  return navigation;
+}
 
-// srcV2/pageObject.ts
+// src/pageObject.ts
 var PageObject = class {
   page;
   baseUrl;
@@ -3136,7 +2081,7 @@ var PageObject = class {
     this.getLocator = getLocator;
     this.getLocatorSchema = getLocatorSchema;
     this.getNestedLocator = getNestedLocator;
-    this.sessionStorage = new SessionStorage2(page, { label });
+    this.sessionStorage = new SessionStorage(page, { label });
     this.defineLocators();
     this.navigation = createNavigation(
       this.page,
@@ -3165,211 +2110,11 @@ var PageObject = class {
     throw new Error("Invalid baseUrl or urlPath types. Expected string or RegExp.");
   }
 };
-
-// srcV2/fixture/base.fixtures.ts
-import { test as base } from "@playwright/test";
-
-// srcV2/helpers/playwrightReportLogger.ts
-var PlaywrightReportLogger = class _PlaywrightReportLogger {
-  // Initializes the logger with shared log level, log entries, and a context name.
-  constructor(sharedLogLevel, sharedLogEntry, contextName) {
-    this.sharedLogLevel = sharedLogLevel;
-    this.sharedLogEntry = sharedLogEntry;
-    this.contextName = contextName;
-  }
-  contextName;
-  logLevels = ["debug", "info", "warn", "error"];
-  /**
-   * Creates a child logger with a new contextual name, sharing the same log level and log entries with the parent logger.
-   *
-   * The root loggers log "level" is referenced by all child loggers and their child loggers and so on...
-   * Changing the log "level" of one, will change it for all.
-   */
-  getNewChildLogger(prefix) {
-    return new _PlaywrightReportLogger(this.sharedLogLevel, this.sharedLogEntry, `${this.contextName} -> ${prefix}`);
-  }
-  /**
-   * Logs a message with the specified log level, prefix, and additional arguments if the current log level permits.
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
-  log(level, message, ...args) {
-    const logLevelIndex = this.logLevels.indexOf(level);
-    if (logLevelIndex < this.getCurrentLogLevelIndex()) {
-      return;
-    }
-    this.sharedLogEntry.push({
-      timestamp: /* @__PURE__ */ new Date(),
-      logLevel: level,
-      prefix: this.contextName,
-      message: `${message}
-
-${args.join("\n\n")}`
-    });
-  }
-  /**
-   * Logs a debug-level message with the specified message and arguments.
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
-  debug(message, ...args) {
-    this.log("debug", message, ...args);
-  }
-  /**
-   * Logs a info-level message with the specified message and arguments.
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
-  info(message, ...args) {
-    this.log("info", message, ...args);
-  }
-  /**
-   * Logs a warn-level message with the specified message and arguments.
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
-  warn(message, ...args) {
-    this.log("warn", message, ...args);
-  }
-  /**
-   * Logs a error-level message with the specified message and arguments.
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
-  error(message, ...args) {
-    this.log("error", message, ...args);
-  }
-  /**
-   * Sets the current log level to the specified level during runTime.
-   */
-  setLogLevel(level) {
-    this.sharedLogLevel.current = level;
-  }
-  /**
-   * Retrieves the current log level during runtime.
-   */
-  getCurrentLogLevel() {
-    return this.sharedLogLevel.current;
-  }
-  /**
-   * Retrieves the index of the current log level in the logLevels array during runtime.
-   */
-  getCurrentLogLevelIndex() {
-    return this.logLevels.indexOf(this.sharedLogLevel.current);
-  }
-  /**
-   * Resets the current log level to the initial level during runtime.
-   */
-  resetLogLevel() {
-    this.sharedLogLevel.current = this.sharedLogLevel.initial;
-  }
-  /**
-   * Checks if the input log level is equal to the current log level of the PlaywrightReportLogger instance.
-   */
-  isCurrentLogLevel(level) {
-    return this.sharedLogLevel.current === level;
-  }
-  /**
-   * Returns 'true' if the "level" parameter provided has an equal or greater index than the current logLevel.
-   */
-  isLogLevelEnabled(level) {
-    const logLevelIndex = this.logLevels.indexOf(level);
-    if (logLevelIndex < this.getCurrentLogLevelIndex()) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Attaches the recorded log entries to the Playwright HTML report in a sorted and formatted manner.
-   */
-  attachLogsToTest(testInfo) {
-    this.sharedLogEntry.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-    for (const log of this.sharedLogEntry) {
-      const printTime = log.timestamp.toLocaleTimeString("nb-NO", {
-        hour: "2-digit",
-        minute: "2-digit",
-        second: "2-digit"
-      });
-      const printDate = log.timestamp.toLocaleDateString("nb-NO", {
-        day: "2-digit",
-        month: "2-digit",
-        year: "numeric"
-      });
-      const printLogLevel = `${log.logLevel.toUpperCase()}`;
-      const printPrefix = log.prefix ? `: [${log.prefix}]` : "";
-      let messageBody = "";
-      let messageContentType = "";
-      try {
-        const parsedMessage = JSON.parse(log.message);
-        messageContentType = "application/json";
-        messageBody = JSON.stringify(parsedMessage, null, 2);
-      } catch (_error) {
-        messageContentType = "text/plain";
-        messageBody = log.message;
-      }
-      testInfo.attach(`${printTime} ${printDate} - ${printLogLevel} ${printPrefix}`, {
-        contentType: messageContentType,
-        body: Buffer.from(messageBody)
-      });
-    }
-  }
-};
-
-// srcV2/fixture/base.fixtures.ts
-var test5 = base.extend({
-  // biome-ignore lint/correctness/noEmptyPattern: Playwright does not support the use of _
-  log: async ({}, use, testInfo) => {
-    const contextName = "TestCase";
-    const sharedLogEntry = [];
-    const sharedLogLevel = testInfo.retry === 0 ? { current: "warn", initial: "warn" } : { current: "debug", initial: "debug" };
-    const log = new PlaywrightReportLogger(sharedLogLevel, sharedLogEntry, contextName);
-    await use(log);
-    log.attachLogsToTest(testInfo);
-  }
-});
-
-// srcV2/helpers/stepDecorator.ts
-import { test as test6 } from "@playwright/test";
-var isMethodDecoratorArgs = (args) => args.length === 3 && typeof args[0] === "object" && (typeof args[1] === "string" || typeof args[1] === "symbol");
-var isStage3MethodDecoratorArgs = (args) => args.length === 2 && typeof args[0] === "function" && args[1] !== null && typeof args[1] === "object";
-var normalizeStepArguments = (args) => {
-  const [titleOrOptions, maybeOptions] = args;
-  const title = typeof titleOrOptions === "string" ? titleOrOptions : void 0;
-  const options = typeof titleOrOptions === "string" ? maybeOptions : titleOrOptions;
-  return { title, options };
-};
-var createWrappedMethod = (original, methodName, title, options) => function(...methodArgs) {
-  const rawClassName = this.constructor?.name ?? "";
-  const className = rawClassName && rawClassName !== "Object" ? rawClassName : "Anonymous";
-  const resolvedTitle = title ?? `${className}.${String(methodName)}`;
-  return test6.step(resolvedTitle, () => original.apply(this, methodArgs), options);
-};
-var createStepDecorator = ({ title, options }) => (valueOrTarget, contextOrKey, descriptor) => {
-  if (typeof valueOrTarget === "function" && isStage3MethodDecoratorArgs([valueOrTarget, contextOrKey])) {
-    const [original2, context] = [valueOrTarget, contextOrKey];
-    return createWrappedMethod(original2, context.name, title, options);
-  }
-  if (!descriptor || typeof descriptor.value !== "function") {
-    throw new Error("@step decorator can only be applied to methods.");
-  }
-  const original = descriptor.value;
-  descriptor.value = createWrappedMethod(original, contextOrKey, title, options);
-  return descriptor;
-};
-function step(...args) {
-  if (isStage3MethodDecoratorArgs(args)) {
-    return createStepDecorator(normalizeStepArguments([]))(...args);
-  }
-  if (isMethodDecoratorArgs(args)) {
-    return createStepDecorator(normalizeStepArguments([]))(...args);
-  }
-  return createStepDecorator(normalizeStepArguments(args));
-}
 export {
-  BaseApi,
-  BasePage,
-  BasePageV1toV2,
-  GetByMethod,
-  GetLocatorBase,
   PageObject,
   PlaywrightReportLogger,
-  SessionStorage2 as SessionStorage,
+  SessionStorage,
   createRegistryWithAccessors,
   step,
-  test5 as test
+  test
 };