pomwright 1.4.0 → 1.5.1

package/dist/index.mjs

@@ -1,9 +1,3 @@
-// src/basePage.ts
-import { selectors } from "@playwright/test";
-
-// src/helpers/getLocatorBase.ts
-import { test } from "@playwright/test";
-
 // src/helpers/locatorSchema.interface.ts
 var GetByMethod = /* @__PURE__ */ ((GetByMethod2) => {
   GetByMethod2["role"] = "role";
@@ -76,6 +70,414 @@ function getLocatorSchemaDummy() {
   return locatorSchemaDummy;
 }
 
+// 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;
+  }
+  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);
+  }
+};
+
+// src/basePage.ts
+import { selectors } from "@playwright/test";
+
+// src/helpers/getLocatorBase.ts
+import { test } from "@playwright/test";
+
+// 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");
+  }
+  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;
+    }
+  }
+};
+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;
+    }
+  }
+};
+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;
+  }
+  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");
+        return;
+      }
+      postDefinition = registration.locator(`[data-cy="${locatorSchema.dataCy}"]`);
+      break;
+    }
+    case "id" /* id */: {
+      if (!locatorSchema.id) {
+        logMissingDefinition(path, "id");
+        return;
+      }
+      postDefinition = registration.getById(locatorSchema.id);
+      break;
+    }
+    default: {
+      const exhaustive = locatorSchema.locatorMethod;
+      return exhaustive;
+    }
+  }
+  if (!postDefinition) {
+    return;
+  }
+  if (locatorSchema.filter && locatorSchema.locatorMethod !== "frameLocator" /* frameLocator */) {
+    const filter = locatorSchema.filter;
+    postDefinition.filter(filter);
+  }
+};
+
 // src/helpers/getBy.locator.ts
 var GetBy = class {
   constructor(page, pwrl) {
@@ -376,6 +778,10 @@ 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:
@@ -882,6 +1288,8 @@ var BasePage = class {
     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"),
@@ -1002,71 +1410,1854 @@ var WithSubPathValidation = class extends GetLocatorBase {
   }
 };
 
-// src/fixture/base.fixtures.ts
-import { test as base } from "@playwright/test";
+// src/basePageV1toV2.ts
+import { selectors as selectors2 } from "@playwright/test";
 
-// 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;
+// srcV2/locators/locatorUpdateBuilder.ts
+var parseUpdateArguments = (primaryOrOptions, options, optionsProvided) => {
+  let primary;
+  let parsedOptions;
+  let hasOptions = optionsProvided ?? false;
+  if (options !== void 0) {
+    parsedOptions = options;
+    hasOptions = true;
+  }
+  if (primaryOrOptions !== void 0) {
+    const treatAsOptions = !hasOptions && options === void 0 && typeof primaryOrOptions === "object" && !(primaryOrOptions instanceof RegExp);
+    if (treatAsOptions) {
+      parsedOptions = primaryOrOptions;
+      hasOptions = true;
+    } else {
+      primary = primaryOrOptions;
+    }
+  }
+  return { primary, options: parsedOptions, hasOptions };
+};
+var mergeOptions = (currentOptions, updates) => {
+  if (updates && "options" in updates) {
+    const updateOptions = updates.options;
+    if (updateOptions && typeof updateOptions === "object") {
+      return {
+        ...typeof currentOptions === "object" && currentOptions !== null ? currentOptions : {},
+        ...updateOptions
+      };
+    }
+    return updateOptions;
+  }
+  return currentOptions;
+};
+var mergeLocatorDefinition = (current, updates, path, preferredSource, baseline) => {
+  if (!updates || typeof updates !== "object" || !("type" in updates)) {
+    throw new Error(`Locator update for "${path}" requires a "type" property.`);
+  }
+  const source = (targetType) => {
+    if (current.type === targetType) {
+      return current;
+    }
+    if (preferredSource?.type === targetType) {
+      return preferredSource;
+    }
+    if (baseline?.type === targetType) {
+      return baseline;
+    }
+    return void 0;
+  };
+  switch (updates.type) {
+    case "role": {
+      const roleSource = source("role");
+      const role = updates.role ?? roleSource?.role;
+      if (role === void 0) {
+        throw new Error(`Locator update for "${path}" of type "role" requires a "role" value.`);
+      }
+      const options = mergeOptions(roleSource?.options, updates);
+      return options !== void 0 ? { type: "role", role, options } : { type: "role", role };
+    }
+    case "text": {
+      const textSource = source("text");
+      const text = updates.text ?? textSource?.text;
+      if (text === void 0) {
+        throw new Error(`Locator update for "${path}" of type "text" requires a "text" value.`);
+      }
+      const options = mergeOptions(textSource?.options, updates);
+      return options !== void 0 ? { type: "text", text, options } : { type: "text", text };
+    }
+    case "label": {
+      const textSource = source("label");
+      const text = updates.text ?? textSource?.text;
+      if (text === void 0) {
+        throw new Error(`Locator update for "${path}" of type "label" requires a "text" value.`);
+      }
+      const options = mergeOptions(textSource?.options, updates);
+      return options !== void 0 ? { type: "label", text, options } : { type: "label", text };
+    }
+    case "placeholder": {
+      const textSource = source("placeholder");
+      const text = updates.text ?? textSource?.text;
+      if (text === void 0) {
+        throw new Error(`Locator update for "${path}" of type "placeholder" requires a "text" value.`);
+      }
+      const options = mergeOptions(textSource?.options, updates);
+      return options !== void 0 ? { type: "placeholder", text, options } : { type: "placeholder", text };
+    }
+    case "altText": {
+      const textSource = source("altText");
+      const text = updates.text ?? textSource?.text;
+      if (text === void 0) {
+        throw new Error(`Locator update for "${path}" of type "altText" requires a "text" value.`);
+      }
+      const options = mergeOptions(textSource?.options, updates);
+      return options !== void 0 ? { type: "altText", text, options } : { type: "altText", text };
+    }
+    case "title": {
+      const textSource = source("title");
+      const text = updates.text ?? textSource?.text;
+      if (text === void 0) {
+        throw new Error(`Locator update for "${path}" of type "title" requires a "text" value.`);
+      }
+      const options = mergeOptions(textSource?.options, updates);
+      return options !== void 0 ? { type: "title", text, options } : { type: "title", text };
+    }
+    case "locator": {
+      const selectorSource = source("locator");
+      const selector = updates.selector ?? selectorSource?.selector;
+      if (selector === void 0) {
+        throw new Error(`Locator update for "${path}" of type "locator" requires a "selector" value.`);
+      }
+      const options = mergeOptions(selectorSource?.options, updates);
+      return options !== void 0 ? { type: "locator", selector, options } : { type: "locator", selector };
+    }
+    case "frameLocator": {
+      const selectorSource = source("frameLocator");
+      const selector = updates.selector ?? selectorSource?.selector;
+      if (selector === void 0) {
+        throw new Error(`Locator update for "${path}" of type "frameLocator" requires a "selector" value.`);
+      }
+      return { type: "frameLocator", selector };
+    }
+    case "testId": {
+      const testIdSource = source("testId");
+      const testId = updates.testId ?? testIdSource?.testId;
+      if (testId === void 0) {
+        throw new Error(`Locator update for "${path}" of type "testId" requires a "testId" value.`);
+      }
+      return { type: "testId", testId };
+    }
+    case "id": {
+      const idSource = source("id");
+      const rawId = updates.id ?? idSource?.id;
+      const id = normalizeIdValue(rawId);
+      if (id === void 0) {
+        throw new Error(`Locator update for "${path}" of type "id" requires an "id" value.`);
+      }
+      return { type: "id", id };
+    }
+    default: {
+      const exhaustive = updates;
+      return exhaustive;
+    }
+  }
+};
+var buildReplacementDefinition = (updates, path) => {
+  if (!updates || typeof updates !== "object" || !("type" in updates)) {
+    throw new Error(`Locator replace for "${path}" requires a "type" property.`);
+  }
+  switch (updates.type) {
+    case "role": {
+      const { role, options } = updates;
+      if (role === void 0) {
+        throw new Error(`Locator replace for "${path}" of type "role" requires a "role" value.`);
+      }
+      return options !== void 0 ? { type: "role", role, options } : { type: "role", role };
+    }
+    case "text": {
+      const { text, options } = updates;
+      if (text === void 0) {
+        throw new Error(`Locator replace for "${path}" of type "text" requires a "text" value.`);
+      }
+      return options !== void 0 ? { type: "text", text, options } : { type: "text", text };
+    }
+    case "label": {
+      const { text, options } = updates;
+      if (text === void 0) {
+        throw new Error(`Locator replace for "${path}" of type "label" requires a "text" value.`);
+      }
+      return options !== void 0 ? { type: "label", text, options } : { type: "label", text };
+    }
+    case "placeholder": {
+      const { text, options } = updates;
+      if (text === void 0) {
+        throw new Error(`Locator replace for "${path}" of type "placeholder" requires a "text" value.`);
+      }
+      return options !== void 0 ? { type: "placeholder", text, options } : { type: "placeholder", text };
+    }
+    case "altText": {
+      const { text, options } = updates;
+      if (text === void 0) {
+        throw new Error(`Locator replace for "${path}" of type "altText" requires a "text" value.`);
+      }
+      return options !== void 0 ? { type: "altText", text, options } : { type: "altText", text };
+    }
+    case "title": {
+      const { text, options } = updates;
+      if (text === void 0) {
+        throw new Error(`Locator replace for "${path}" of type "title" requires a "text" value.`);
+      }
+      return options !== void 0 ? { type: "title", text, options } : { type: "title", text };
+    }
+    case "locator": {
+      const { selector, options } = updates;
+      if (selector === void 0) {
+        throw new Error(`Locator replace for "${path}" of type "locator" requires a "selector" value.`);
+      }
+      return options !== void 0 ? { type: "locator", selector, options } : { type: "locator", selector };
+    }
+    case "frameLocator": {
+      const { selector } = updates;
+      if (selector === void 0) {
+        throw new Error(`Locator replace for "${path}" of type "frameLocator" requires a "selector" value.`);
+      }
+      return { type: "frameLocator", selector };
+    }
+    case "testId": {
+      const { testId } = updates;
+      if (testId === void 0) {
+        throw new Error(`Locator replace for "${path}" of type "testId" requires a "testId" value.`);
+      }
+      return { type: "testId", testId };
+    }
+    case "id": {
+      const rawId = updates.id;
+      const id = normalizeIdValue(rawId);
+      if (id === void 0) {
+        throw new Error(`Locator replace for "${path}" of type "id" requires an "id" value.`);
+      }
+      return { type: "id", id };
+    }
+    default: {
+      const exhaustive = updates;
+      return exhaustive;
+    }
+  }
+};
+var LocatorUpdateBuilder = class {
+  constructor(parent, subPath, mode = "update") {
+    this.parent = parent;
+    this.subPath = subPath;
+    this.mode = mode;
   }
-  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.
+   * Defines or patches a `getByRole` locator strategy for the target subpath. In `update` mode the
+   * `role` and `options` arguments are optional (PATCH semantics); in `replace` mode they follow
+   * Playwright requirements (POST semantics) and `role` is required.
    *
-   * 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.
+   * @example
+   * ```ts
+   * getLocatorSchema("form.button")
+   *   .update("form.button")
+   *   .getByRole({ name: "Save" })
+   *   .getNestedLocator();
+   * ```
    */
-  getNewChildLogger(prefix) {
-    return new _PlaywrightReportLogger(this.sharedLogLevel, this.sharedLogEntry, `${this.contextName} -> ${prefix}`);
+  getByRole(...args) {
+    const [roleOrOptions, options] = args;
+    const {
+      primary: role,
+      options: parsedOptions,
+      hasOptions
+    } = parseUpdateArguments(
+      roleOrOptions,
+      options,
+      args.length >= 2
+    );
+    const definition = {
+      type: "role",
+      ...role !== void 0 ? { role } : {},
+      ...hasOptions ? { options: parsedOptions } : {}
+    };
+    return this.commit(definition);
   }
   /**
-   * Logs a message with the specified log level, prefix, and additional arguments if the current log level permits.
+   * Defines or patches a `getByText` locator strategy for the target subpath. In `update` mode,
+   * text/options are optional; in `replace` mode text is required.
+   *
+   * @example
+   * ```ts
+   * getLocatorSchema("banner.message")
+   *   .replace("banner.message")
+   *   .getByText(/Updated/, { exact: false })
+   *   .getNestedLocator();
+   * ```
    */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  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")}`
-    });
+  getByText(...args) {
+    const [textOrOptions, options] = args;
+    const {
+      primary: text,
+      options: parsedOptions,
+      hasOptions
+    } = parseUpdateArguments(
+      textOrOptions,
+      options,
+      args.length >= 2
+    );
+    const definition = {
+      type: "text",
+      ...text !== void 0 ? { text } : {},
+      ...hasOptions ? { options: parsedOptions } : {}
+    };
+    return this.commit(definition);
   }
   /**
-   * Logs a debug-level message with the specified message and arguments.
+   * Defines or patches a `getByLabel` locator strategy for the target subpath. In `update` mode the
+   * label text/options are optional; in `replace` mode text is required.
+   *
+   * @example
+   * ```ts
+   * getLocatorSchema("form.email").update("form.email").getByLabel({ exact: true }).getNestedLocator();
+   * ```
    */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  debug(message, ...args) {
-    this.log("debug", message, ...args);
+  getByLabel(...args) {
+    const [textOrOptions, options] = args;
+    const {
+      primary: text,
+      options: parsedOptions,
+      hasOptions
+    } = parseUpdateArguments(
+      textOrOptions,
+      options,
+      args.length >= 2
+    );
+    const definition = {
+      type: "label",
+      ...text !== void 0 ? { text } : {},
+      ...hasOptions ? { options: parsedOptions } : {}
+    };
+    return this.commit(definition);
   }
   /**
-   * Logs a info-level message with the specified message and arguments.
+   * Defines or patches a `getByPlaceholder` locator strategy for the target subpath. In `update`
+   * mode text/options are optional; in `replace` mode text is required.
+   *
+   * @example
+   * ```ts
+   * getLocatorSchema("form.search").update("form.search").getByPlaceholder({ exact: true }).getNestedLocator();
+   * ```
    */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  info(message, ...args) {
-    this.log("info", message, ...args);
+  getByPlaceholder(...args) {
+    const [textOrOptions, options] = args;
+    const {
+      primary: text,
+      options: parsedOptions,
+      hasOptions
+    } = parseUpdateArguments(
+      textOrOptions,
+      options,
+      args.length >= 2
+    );
+    const definition = {
+      type: "placeholder",
+      ...text !== void 0 ? { text } : {},
+      ...hasOptions ? { options: parsedOptions } : {}
+    };
+    return this.commit(definition);
   }
   /**
-   * Logs a warn-level message with the specified message and arguments.
+   * Defines or patches a `getByAltText` locator strategy for the target subpath. In `update` mode
+   * text/options are optional; in `replace` mode text is required.
+   *
+   * @example
+   * ```ts
+   * getLocatorSchema("image.logo").replace("image.logo").getByAltText("Logo").getNestedLocator();
+   * ```
    */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  warn(message, ...args) {
-    this.log("warn", message, ...args);
+  getByAltText(...args) {
+    const [textOrOptions, options] = args;
+    const {
+      primary: text,
+      options: parsedOptions,
+      hasOptions
+    } = parseUpdateArguments(
+      textOrOptions,
+      options,
+      args.length >= 2
+    );
+    const definition = {
+      type: "altText",
+      ...text !== void 0 ? { text } : {},
+      ...hasOptions ? { options: parsedOptions } : {}
+    };
+    return this.commit(definition);
   }
   /**
-   * Logs a error-level message with the specified message and arguments.
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+   * Defines or patches a `getByTitle` locator strategy for the target subpath. In `update` mode
+   * text/options are optional; in `replace` mode text is required.
+   *
+   * @example
+   * ```ts
+   * getLocatorSchema("icon.info").update("icon.info").getByTitle({ exact: true }).getNestedLocator();
+   * ```
+   */
+  getByTitle(...args) {
+    const [textOrOptions, options] = args;
+    const {
+      primary: text,
+      options: parsedOptions,
+      hasOptions
+    } = parseUpdateArguments(
+      textOrOptions,
+      options,
+      args.length >= 2
+    );
+    const definition = {
+      type: "title",
+      ...text !== void 0 ? { text } : {},
+      ...hasOptions ? { options: parsedOptions } : {}
+    };
+    return this.commit(definition);
+  }
+  /**
+   * Defines or patches a `locator` strategy for the target subpath. In `update` mode selector and
+   * options are optional and merge with the existing definition; in `replace` mode selector is
+   * required.
+   *
+   * @example
+   * ```ts
+   * getLocatorSchema("list.items")
+   *   .replace("list.items")
+   *   .locator("ul > li", { hasText: /Row/ })
+   *   .getNestedLocator();
+   * ```
+   */
+  locator(...args) {
+    const [selectorOrOptions, options] = args;
+    const {
+      primary: selector,
+      options: parsedOptions,
+      hasOptions
+    } = parseUpdateArguments(
+      selectorOrOptions,
+      options,
+      args.length >= 2
+    );
+    const definition = {
+      type: "locator",
+      ...selector !== void 0 ? { selector } : {},
+      ...hasOptions ? { options: parsedOptions } : {}
+    };
+    return this.commit(definition);
+  }
+  /**
+   * Defines or patches a `frameLocator` strategy for the target subpath. In `update` mode the
+   * selector is optional and, when omitted, inherits the existing selector; in `replace` mode the
+   * selector is required.
+   *
+   * @example
+   * ```ts
+   * getLocatorSchema("frame.login").replace("frame.login").frameLocator("iframe.auth").getNestedLocator();
+   * ```
+   */
+  frameLocator(...args) {
+    const [selector] = args;
+    const definition = {
+      type: "frameLocator",
+      ...selector !== void 0 ? { selector } : {}
+    };
+    return this.commit(definition);
+  }
+  /**
+   * Defines or patches a `getByTestId` locator strategy for the target subpath. In `update` mode
+   * `testId` is optional and merges with existing options; in `replace` mode it is required.
+   *
+   * @example
+   * ```ts
+   * getLocatorSchema("card.title").update("card.title").getByTestId().getNestedLocator();
+   * ```
+   */
+  getByTestId(...args) {
+    const [testId] = args;
+    const definition = {
+      type: "testId",
+      ...testId !== void 0 ? { testId } : {}
+    };
+    return this.commit(definition);
+  }
+  /**
+   * Defines or patches an `id` locator strategy for the target subpath. In `update` mode the id is
+   * optional and will be normalized if provided; in `replace` mode the id is required.
+   *
+   * @example
+   * ```ts
+   * getLocatorSchema("modal.close").update("modal.close").getById().getNestedLocator();
+   * ```
+   */
+  getById(...args) {
+    const [idValue] = args;
+    const id = idValue !== void 0 ? normalizeIdValue(idValue) : void 0;
+    const definition = {
+      type: "id",
+      ...id !== void 0 ? { id } : {}
+    };
+    return this.commit(definition);
+  }
+  commit(definition) {
+    return this.mode === "replace" ? this.parent.applyReplacement(this.subPath, definition) : this.parent.applyUpdate(this.subPath, definition);
+  }
+};
+
+// srcV2/locators/locatorQueryBuilder.ts
+var LocatorQueryBuilder = class {
+  constructor(registry, path) {
+    this.registry = registry;
+    this.path = path;
+    const chain = expandSchemaPath(path);
+    let hasTerminal = false;
+    for (const part of chain) {
+      const record = this.registry.getIfExists(part);
+      if (!record) {
+        continue;
+      }
+      const clonedDefinition = cloneLocatorStrategyDefinition(record.definition);
+      this.definitions.set(part, clonedDefinition);
+      this.ensureTypeCache(part, clonedDefinition);
+      const recordSteps = normalizeSteps(
+        record.steps
+      );
+      this.steps.set(part, recordSteps);
+      if (record.description !== void 0) {
+        this.descriptions.set(part, record.description);
+      }
+      if (part === path) {
+        hasTerminal = true;
+      }
+    }
+    if (!hasTerminal) {
+      throw new Error(`No locator schema registered for path "${path}".`);
+    }
+  }
+  definitions = /* @__PURE__ */ new Map();
+  perPathTypeCache = /* @__PURE__ */ new Map();
+  steps = /* @__PURE__ */ new Map();
+  descriptions = /* @__PURE__ */ new Map();
+  tombstones = /* @__PURE__ */ new Set();
+  update(subPath) {
+    const resolvedSubPath = subPath ?? this.path;
+    this.ensureSubPath(resolvedSubPath);
+    return new LocatorUpdateBuilder(
+      this,
+      resolvedSubPath
+    );
+  }
+  filter(...args) {
+    const hasExplicitSubPath = args.length === 2;
+    const [subPathOrFilter, maybeFilter] = args;
+    const resolvedSubPath = hasExplicitSubPath ? subPathOrFilter : this.path;
+    const filter = hasExplicitSubPath ? maybeFilter : subPathOrFilter;
+    this.ensureSubPath(resolvedSubPath);
+    const existing = this.steps.get(resolvedSubPath) ?? [];
+    existing.push({ kind: "filter", filter });
+    this.steps.set(resolvedSubPath, existing);
+    return this;
+  }
+  clearSteps(subPath) {
+    const resolvedSubPath = subPath ?? this.path;
+    this.ensureSubPath(resolvedSubPath);
+    this.steps.set(resolvedSubPath, []);
+    return this;
+  }
+  nth(...args) {
+    const hasExplicitSubPath = args.length === 2;
+    const [subPathOrIndex, maybeIndex] = args;
+    const resolvedSubPath = hasExplicitSubPath ? subPathOrIndex : this.path;
+    const index = hasExplicitSubPath ? maybeIndex : subPathOrIndex;
+    this.ensureSubPath(resolvedSubPath);
+    const existing = this.steps.get(resolvedSubPath) ?? [];
+    existing.push({ kind: "index", index });
+    this.steps.set(resolvedSubPath, existing);
+    return this;
+  }
+  /**
+   * Adds or overrides the description for the terminal path of this builder. The description is
+   * applied only to the resolved terminal locator and does not mutate registry state.
+   *
+   * @example
+   * ```ts
+   * getLocatorSchema("section.button")
+   *   .describe("Save button")
+   *   .getNestedLocator();
+   * ```
+   */
+  describe(description) {
+    this.ensureSubPath(this.path);
+    this.descriptions.set(this.path, description);
+    return this;
+  }
+  /** @internal */
+  applyUpdate(subPath, updates) {
+    this.ensureSubPath(subPath);
+    if (!this.definitions.has(subPath) && this.tombstones.has(subPath)) {
+      const baseline2 = this.registry.get(subPath).definition;
+      const baselineClone = cloneLocatorStrategyDefinition(baseline2);
+      this.definitions.set(subPath, baselineClone);
+      this.steps.set(subPath, []);
+      this.tombstones.delete(subPath);
+    }
+    const current = this.definitions.get(subPath);
+    if (!current) {
+      throw new Error(`No locator schema registered for sub-path "${subPath}".`);
+    }
+    const baseline = this.registry.get(subPath).definition;
+    const cacheForPath = this.ensureTypeCache(subPath, cloneLocatorStrategyDefinition(baseline));
+    const cachedDefinition = cacheForPath.get(updates.type);
+    const merged = mergeLocatorDefinition(current, updates, subPath, cachedDefinition, baseline);
+    const mergedClone = cloneLocatorStrategyDefinition(merged);
+    cacheForPath.set(mergedClone.type, mergedClone);
+    this.definitions.set(subPath, mergedClone);
+    return this;
+  }
+  replace(subPath) {
+    const resolvedSubPath = subPath ?? this.path;
+    this.ensureSubPath(resolvedSubPath);
+    return new LocatorUpdateBuilder(
+      this,
+      resolvedSubPath,
+      "replace"
+    );
+  }
+  /** @internal */
+  applyReplacement(subPath, updates) {
+    this.ensureSubPath(subPath);
+    if (this.tombstones.has(subPath) && !this.definitions.has(subPath)) {
+      this.steps.set(subPath, []);
+      this.tombstones.delete(subPath);
+    }
+    const nextDefinition = buildReplacementDefinition(updates, subPath);
+    const cloned = cloneLocatorStrategyDefinition(nextDefinition);
+    const cacheForPath = this.ensureTypeCache(subPath, cloned);
+    cacheForPath.set(cloned.type, cloneLocatorStrategyDefinition(cloned));
+    this.definitions.set(subPath, cloned);
+    return this;
+  }
+  remove(subPath) {
+    const resolvedSubPath = subPath ?? this.path;
+    this.ensureSubPath(resolvedSubPath);
+    this.definitions.delete(resolvedSubPath);
+    this.steps.delete(resolvedSubPath);
+    this.perPathTypeCache.delete(resolvedSubPath);
+    this.descriptions.delete(resolvedSubPath);
+    this.tombstones.add(resolvedSubPath);
+    return this;
+  }
+  /**
+   * Resolves and returns the Playwright {@link Locator} for the terminal path of this builder,
+   * applying only the terminal definition and its steps. Throws if the terminal path has been
+   * removed or is otherwise missing.
+   *
+   * @example
+   * ```ts
+   * const locator = getLocatorSchema("form.submit").getLocator();
+   * ```
+   */
+  getLocator() {
+    const definition = this.definitions.get(this.path);
+    if (!definition) {
+      throw new Error(`No locator schema registered for path "${this.path}".`);
+    }
+    const stepsForPath = this.steps.get(this.path) ?? [];
+    const definitions = /* @__PURE__ */ new Map([[this.path, definition]]);
+    const steps = /* @__PURE__ */ new Map([
+      [
+        this.path,
+        normalizeSteps(stepsForPath)
+      ]
+    ]);
+    const { locator } = this.registry.buildLocatorChain(
+      this.path,
+      definitions,
+      steps,
+      this.tombstones,
+      this.descriptions.get(this.path)
+    );
+    if (!locator) {
+      throw new Error(`Unable to resolve direct locator for path "${this.path}".`);
+    }
+    return locator;
+  }
+  /**
+   * Resolves the chained Playwright {@link Locator} for this builder’s root path, traversing each
+   * registered segment and applying recorded steps. Throws if any required segment is missing.
+   *
+   * @example
+   * ```ts
+   * const nested = getLocatorSchema("list.item")
+   *   .filter("list", { hasText: "List" })
+   *   .getNestedLocator();
+   * ```
+   */
+  getNestedLocator() {
+    const { locator } = this.resolve();
+    if (!locator) {
+      throw new Error(`Unable to resolve nested locator for path "${this.path}".`);
+    }
+    return locator;
+  }
+  ensureSubPath(subPath) {
+    if (!this.definitions.has(subPath) && !this.tombstones.has(subPath)) {
+      throw new Error(`"${subPath}" is not a valid sub-path of "${this.path}".`);
+    }
+  }
+  resolve() {
+    return this.registry.buildLocatorChain(
+      this.path,
+      this.definitions,
+      this.steps,
+      this.tombstones,
+      this.descriptions.get(this.path)
+    );
+  }
+  ensureTypeCache(subPath, baseline) {
+    if (!this.perPathTypeCache.has(subPath)) {
+      this.perPathTypeCache.set(
+        subPath,
+        /* @__PURE__ */ new Map([
+          [baseline.type, cloneLocatorStrategyDefinition(baseline)]
+        ])
+      );
+    }
+    return this.perPathTypeCache.get(subPath);
+  }
+};
+
+// srcV2/locators/locatorRegistrationBuilder.ts
+var LocatorRegistrationBuilder = class {
+  constructor(registry, path, seed) {
+    this.registry = registry;
+    this.path = path;
+    if (seed?.initialSteps) {
+      this.steps = normalizeSteps(seed.initialSteps);
+    }
+    if (seed?.initialDefinition) {
+      this.definition = seed.initialDefinition;
+      this.seededDefinition = true;
+    } else {
+      this.seededDefinition = false;
+    }
+    this.reuseType = seed?.reuseType;
+    this.description = seed?.initialDescription;
+  }
+  steps = [];
+  definition;
+  description;
+  registered = false;
+  reuseType;
+  seededDefinition;
+  overrideApplied = false;
+  postDefinitionView;
+  persistSeededDefinition() {
+    if (this.seededDefinition && !this.registered) {
+      this.persist();
+    }
+    return this;
+  }
+  /**
+   * Records a Playwright-style filter on the locator being registered. Filters are applied in the
+   * order they are chained and can include `has`/`hasNot` locator references. Requires that a
+   * locator strategy has already been set for this registration.
+   *
+   * @example
+   * ```ts
+   * registry.add("list.item").locator("li").filter({ hasText: /Row/ });
+   * ```
+   */
+  filter(filter) {
+    this.applyFilter(filter);
+    return this.getPostDefinitionView();
+  }
+  /**
+   * Adds an index selector for the locator being registered. Indices are applied in the order they
+   * are chained and require a locator definition to have been set first.
+   *
+   * @example
+   * ```ts
+   * registry.add("table.rows").locator("tr").nth(0);
+   * ```
+   */
+  nth(index) {
+    this.applyIndex(index);
+    return this.getPostDefinitionView();
+  }
+  describe(description) {
+    this.description = description;
+    this.persist();
+    return this.getPostDefinitionView();
+  }
+  getByRole(roleOrOptions, options) {
+    const definition = typeof roleOrOptions === "string" ? options !== void 0 ? { type: "role", role: roleOrOptions, options } : { type: "role", role: roleOrOptions } : { type: "role", options: roleOrOptions };
+    return this.commit(definition);
+  }
+  getByText(textOrOptions, options) {
+    const definition = typeof textOrOptions === "string" || textOrOptions instanceof RegExp ? options !== void 0 ? { type: "text", text: textOrOptions, options } : { type: "text", text: textOrOptions } : { type: "text", options: textOrOptions };
+    return this.commit(definition);
+  }
+  getByLabel(textOrOptions, options) {
+    const definition = typeof textOrOptions === "string" || textOrOptions instanceof RegExp ? options !== void 0 ? { type: "label", text: textOrOptions, options } : { type: "label", text: textOrOptions } : { type: "label", options: textOrOptions };
+    return this.commit(definition);
+  }
+  getByPlaceholder(textOrOptions, options) {
+    const definition = typeof textOrOptions === "string" || textOrOptions instanceof RegExp ? options !== void 0 ? { type: "placeholder", text: textOrOptions, options } : { type: "placeholder", text: textOrOptions } : { type: "placeholder", options: textOrOptions };
+    return this.commit(definition);
+  }
+  getByAltText(textOrOptions, options) {
+    const definition = typeof textOrOptions === "string" || textOrOptions instanceof RegExp ? options !== void 0 ? { type: "altText", text: textOrOptions, options } : { type: "altText", text: textOrOptions } : { type: "altText", options: textOrOptions };
+    return this.commit(definition);
+  }
+  getByTitle(textOrOptions, options) {
+    const definition = typeof textOrOptions === "string" || textOrOptions instanceof RegExp ? options !== void 0 ? { type: "title", text: textOrOptions, options } : { type: "title", text: textOrOptions } : { type: "title", options: textOrOptions };
+    return this.commit(definition);
+  }
+  locator(selectorOrOptions, options) {
+    const definition = typeof selectorOrOptions === "string" ? options !== void 0 ? { type: "locator", selector: selectorOrOptions, options } : { type: "locator", selector: selectorOrOptions } : { type: "locator", options: selectorOrOptions };
+    return this.commit(definition);
+  }
+  /**
+   * Uses Playwright `frameLocator` semantics to define the locator strategy, entering the targeted
+   * frame for subsequent chained locators. When seeded, `selector` may be omitted to retain the
+   * existing selector while overriding options elsewhere.
+   *
+   * @example
+   * ```ts
+   * registry.add("frame.login").frameLocator("iframe.auth");
+   * ```
+   */
+  frameLocator(selector) {
+    const definition = selector ? { type: "frameLocator", selector } : { type: "frameLocator" };
+    return this.commit(definition);
+  }
+  /**
+   * Uses Playwright `getByTestId` semantics to define the locator strategy. When seeded, omitting
+   * the argument inherits the seeded `testId` while allowing options from other overrides.
+   *
+   * @example
+   * ```ts
+   * registry.add("card.title").getByTestId("card-title");
+   * ```
+   */
+  getByTestId(testId) {
+    const definition = testId ? { type: "testId", testId } : { type: "testId" };
+    return this.commit(definition);
+  }
+  /**
+   * Targets elements by `id`, normalizing string or RegExp input. When seeded, the argument can be
+   * omitted to inherit the seeded id.
+   *
+   * @example
+   * ```ts
+   * registry.add("modal.close").getById("close-modal");
+   * ```
+   */
+  getById(id) {
+    const definition = id ? { type: "id", id: normalizeIdValue(id) } : { type: "id" };
+    return this.commit(definition);
+  }
+  commit(definition) {
+    this.ensureDefinitionAllowedWithRollback(definition);
+    const mergedDefinition = this.seededDefinition ? applyDefinitionPatch(this.definition, definition) : definition;
+    this.definition = mergedDefinition;
+    if (this.reuseType && this.seededDefinition) {
+      this.overrideApplied = true;
+    }
+    this.persist();
+    return this.getPostDefinitionView();
+  }
+  applyFilter(filter) {
+    this.ensureDefinition();
+    this.steps.push({ kind: "filter", filter });
+    this.persist();
+  }
+  applyIndex(index) {
+    this.ensureDefinition();
+    this.steps.push({ kind: "index", index });
+    this.persist();
+  }
+  ensureDefinitionAllowedWithRollback(definition) {
+    if (this.seededDefinition) {
+      if (definition.type !== this.reuseType) {
+        this.rollbackSeededRegistration();
+        throw new Error(
+          `The locator definition for "${this.path}" must use the "${this.reuseType}" strategy when reusing a locator.`
+        );
+      }
+      if (this.overrideApplied) {
+        throw new Error(
+          `A locator definition for "${this.path}" was already provided from reuse; only one matching override is allowed.`
+        );
+      }
+      return;
+    }
+    if (this.definition) {
+      throw new Error(
+        `A locator definition for "${this.path}" has already been provided; only one locator type can be set for a registration.`
+      );
+    }
+  }
+  ensureDefinition() {
+    if (!this.definition) {
+      throw new Error(`A locator definition must be provided before applying filters or indices for "${this.path}".`);
+    }
+  }
+  persist() {
+    if (!this.definition) {
+      throw new Error(`No locator schema definition provided for path "${this.path}".`);
+    }
+    const record = {
+      locatorSchemaPath: this.path,
+      definition: this.definition,
+      steps: normalizeSteps(this.steps),
+      ...this.description !== void 0 ? { description: this.description } : {}
+    };
+    if (this.registered) {
+      this.registry.replace(this.path, record);
+    } else {
+      this.registry.register(this.path, record);
+      this.registered = true;
+    }
+  }
+  rollbackSeededRegistration() {
+    if (this.seededDefinition && this.registered) {
+      this.registry.unregister(this.path);
+      this.registered = false;
+    }
+  }
+  getPostDefinitionView() {
+    if (this.postDefinitionView) {
+      return this.postDefinitionView;
+    }
+    const view = {
+      filter: (filter) => {
+        this.applyFilter(filter);
+        return view;
+      },
+      nth: (index) => {
+        this.applyIndex(index);
+        return view;
+      },
+      describe: (description) => {
+        this.description = description;
+        this.persist();
+        return view;
+      }
+    };
+    this.postDefinitionView = view;
+    return view;
+  }
+};
+
+// srcV2/locators/reusableLocatorBuilder.ts
+var ReusableLocatorBuilder = class {
+  stepsList;
+  definitionValue;
+  descriptionValue;
+  type;
+  constructor(definition, steps = []) {
+    this.definitionValue = definition;
+    this.type = definition.type;
+    this.stepsList = normalizeSteps(steps);
+  }
+  filter(filter) {
+    this.stepsList.push({ kind: "filter", filter });
+    return this;
+  }
+  nth(index) {
+    this.stepsList.push({ kind: "index", index });
+    return this;
+  }
+  describe(description) {
+    this.descriptionValue = description;
+    return this;
+  }
+  get definition() {
+    return this.definitionValue;
+  }
+  get steps() {
+    return normalizeSteps(this.stepsList);
+  }
+  get description() {
+    return this.descriptionValue;
+  }
+};
+var ReusableLocatorFactory = class {
+  getByRole(role, options) {
+    const definition = options !== void 0 ? { type: "role", role, options } : { type: "role", role };
+    return this.create(definition);
+  }
+  getByText(text, options) {
+    const definition = options !== void 0 ? { type: "text", text, options } : { type: "text", text };
+    return this.create(definition);
+  }
+  getByLabel(text, options) {
+    const definition = options !== void 0 ? { type: "label", text, options } : { type: "label", text };
+    return this.create(definition);
+  }
+  getByPlaceholder(text, options) {
+    const definition = options !== void 0 ? { type: "placeholder", text, options } : { type: "placeholder", text };
+    return this.create(definition);
+  }
+  getByAltText(text, options) {
+    const definition = options !== void 0 ? { type: "altText", text, options } : { type: "altText", text };
+    return this.create(definition);
+  }
+  getByTitle(text, options) {
+    const definition = options !== void 0 ? { type: "title", text, options } : { type: "title", text };
+    return this.create(definition);
+  }
+  locator(selector, options) {
+    const definition = options !== void 0 ? { type: "locator", selector, options } : { type: "locator", selector };
+    return this.create(definition);
+  }
+  frameLocator(selector) {
+    return this.create({ type: "frameLocator", selector });
+  }
+  getByTestId(testId) {
+    return this.create({ type: "testId", testId });
+  }
+  getById(id) {
+    return this.create({ type: "id", id: normalizeIdValue(id) });
+  }
+  create(definition) {
+    return new ReusableLocatorBuilder(definition);
+  }
+};
+
+// srcV2/locators/locatorRegistry.ts
+var LocatorRegistryInternal = class {
+  constructor(page) {
+    this.page = page;
+    this.createReusable = new ReusableLocatorFactory();
+  }
+  schemas = /* @__PURE__ */ new Map();
+  /**
+   * Factory for reusable locator seeds that capture a locator strategy plus any chained
+   * `filter`/`nth` steps without registering them. Pass the resulting seed to
+   * {@link LocatorRegistryInternal.add} via `{ reuse }` to register a path that inherits the
+   * stored definition and steps.
+   *
+   * @example
+   * ```ts
+   * const seed = registry.createReusable.getByRole("heading", { level: 2 }).filter({ hasText: /Summary/ });
+   * registry.add("hero.title", { reuse: seed }).getByRole({ name: "Summary" });
+   * ```
+   */
+  createReusable;
+  normalizeRecord(record) {
+    return {
+      locatorSchemaPath: record.locatorSchemaPath,
+      definition: record.definition,
+      steps: normalizeSteps(record.steps),
+      ...record.description !== void 0 ? { description: record.description } : {}
+    };
+  }
+  cloneRecordForReuse(record, path) {
+    return {
+      locatorSchemaPath: path,
+      definition: cloneLocatorStrategyDefinition(record.definition),
+      steps: normalizeSteps(record.steps),
+      ...record.description !== void 0 ? { description: record.description } : {}
+    };
+  }
+  /**
+   * 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 === 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, 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,
+        definition: reuse.definition,
+        steps: reuse.steps,
+        description: reuse.description
+      },
+      path
+    );
+    return new LocatorRegistrationBuilder(
+      this,
+      path,
+      {
+        initialDefinition: reusedRecord.definition,
+        initialSteps: reusedRecord.steps,
+        reuseType: reusedRecord.definition.type,
+        initialDescription: reusedRecord.description
+      }
+    ).persistSeededDefinition();
+  }
+  register(path, record) {
+    validateLocatorSchemaPath(path);
+    if (this.schemas.has(path)) {
+      const existing = this.schemas.get(path);
+      if (!existing) {
+        throw new Error(`A locator schema with the path "${path}" already exists.`);
+      }
+      const errorDetails = stringifyForLog({
+        existing,
+        attempted: record
+      });
+      throw new Error(`A locator schema with the path "${path}" already exists.
+Existing Schema: ${errorDetails}`);
+    }
+    this.schemas.set(path, this.normalizeRecord(record));
+  }
+  replace(path, record) {
+    validateLocatorSchemaPath(path);
+    if (!this.schemas.has(path)) {
+      throw new Error(`No locator schema registered for path "${path}".`);
+    }
+    this.schemas.set(path, this.normalizeRecord(record));
+  }
+  get(path) {
+    const record = this.schemas.get(path);
+    if (!record) {
+      throw new Error(`No locator schema registered for path "${path}".`);
+    }
+    return {
+      locatorSchemaPath: record.locatorSchemaPath,
+      definition: cloneLocatorStrategyDefinition(record.definition),
+      steps: normalizeSteps(record.steps),
+      ...record.description !== void 0 ? { description: record.description } : {}
+    };
+  }
+  unregister(path) {
+    this.schemas.delete(path);
+  }
+  getIfExists(path) {
+    const record = this.schemas.get(path);
+    if (!record) {
+      return void 0;
+    }
+    return {
+      locatorSchemaPath: record.locatorSchemaPath,
+      definition: cloneLocatorStrategyDefinition(record.definition),
+      steps: normalizeSteps(record.steps),
+      ...record.description !== void 0 ? { description: record.description } : {}
+    };
+  }
+  resolveFilterLocator(locatorReference, context) {
+    if (isLocatorInstance(locatorReference)) {
+      return locatorReference;
+    }
+    if (typeof locatorReference === "string") {
+      return this.getLocatorWithContext(locatorReference, context);
+    }
+    throw new Error(
+      `Unsupported filter reference while resolving "${context.rootPath}". Filter has/hasNot supports Playwright Locator instances or registry path strings.`
+    );
+  }
+  createResolutionContext(rootPath) {
+    return {
+      rootPath,
+      resolvingPaths: /* @__PURE__ */ new Set()
+    };
+  }
+  getLocatorWithContext(path, context) {
+    if (context.resolvingPaths.has(path)) {
+      throw new Error(`Detected cyclic filter reference while resolving "${context.rootPath}": "${path}".`);
+    }
+    context.resolvingPaths.add(path);
+    try {
+      const record = this.get(path);
+      const definitions = /* @__PURE__ */ new Map([[path, record.definition]]);
+      const steps = /* @__PURE__ */ new Map([[path, normalizeSteps(record.steps)]]);
+      const { locator } = this.buildLocatorChain(path, definitions, steps, void 0, record.description, context);
+      if (!locator) {
+        throw new Error(`Unable to resolve direct locator for path "${path}".`);
+      }
+      return locator;
+    } finally {
+      context.resolvingPaths.delete(path);
+    }
+  }
+  resolveFiltersForTarget(filters, context) {
+    if (!filters || filters.length === 0) {
+      return [];
+    }
+    const resolved = [];
+    for (const filter of filters) {
+      if (filter && typeof filter === "object" && ("has" in filter || "hasNot" in filter)) {
+        const { has, hasNot, ...rest } = filter;
+        const normalizedFilter = {
+          ...rest
+        };
+        if (has !== void 0) {
+          normalizedFilter.has = this.resolveFilterLocator(has, context);
+        }
+        if (hasNot !== void 0) {
+          normalizedFilter.hasNot = this.resolveFilterLocator(hasNot, context);
+        }
+        resolved.push(normalizedFilter);
+        continue;
+      }
+      resolved.push(filter);
+    }
+    return resolved;
+  }
+  /**
+   * Returns a mutable query builder clone for the provided path. Use the builder to add or clear
+   * `filter`/`nth` steps, or to `update`/`replace` locator definitions before resolving locators.
+   * Changes affect only the builder clone; the registry’s stored schema remains untouched.
+   *
+   * @example
+   * ```ts
+   * const builder = registry
+   *   .getLocatorSchema("section.button")
+   *   .filter("section.button", { hasText: /Save/ })
+   *   .nth("section", 0);
+   * const locator = builder.getNestedLocator();
+   * ```
+   */
+  getLocatorSchema(path) {
+    return new LocatorQueryBuilder(
+      this,
+      path
+    );
+  }
+  /**
+   * Resolves the Playwright {@link Locator} for the provided path, applying only the terminal
+   * definition and its recorded steps (no ancestor chaining). Throws if the path is not registered.
+   *
+   * @example
+   * ```ts
+   * const button = registry.getLocator("form.submit");
+   * await button.click();
+   * ```
+   */
+  getLocator(path) {
+    return this.getLocatorSchema(path).getLocator();
+  }
+  /**
+   * Resolves a chained Playwright {@link Locator} for a nested path, traversing each registered
+   * segment and applying their steps in order. Throws if any segment in the chain is missing.
+   *
+   * @example
+   * ```ts
+   * const nested = registry.getNestedLocator("list.item");
+   * await expect(nested).toBeVisible();
+   * ```
+   */
+  getNestedLocator(path) {
+    return this.getLocatorSchema(path).getNestedLocator();
+  }
+  buildLocatorChain(path, definitions, steps, tombstones, terminalDescription, context) {
+    const resolutionContext = context ?? this.createResolutionContext(path);
+    const chain = expandSchemaPath(path);
+    const registeredChain = chain.filter((part) => definitions.has(part));
+    if (tombstones?.has(path) || !definitions.has(path)) {
+      throw new Error(`No locator schema registered for path "${path}".`);
+    }
+    let currentTarget = this.page;
+    let lastLocator = null;
+    const debugSteps = [];
+    const lastIndex = registeredChain.length - 1;
+    for (const [index, part] of registeredChain.entries()) {
+      const isTerminalStep = index === lastIndex;
+      const definition = definitions.get(part);
+      if (tombstones?.has(part)) {
+        if (isTerminalStep) {
+          throw new Error(`No locator schema registered for path "${path}".`);
+        }
+        continue;
+      }
+      if (!definition) {
+        throw new Error(`Missing locator definition for "${part}" while resolving "${path}".`);
+      }
+      if (isFrameLocatorDefinition(definition)) {
+        const frameLocator = createLocator(currentTarget, definition);
+        const isTerminalStep2 = index === lastIndex;
+        if (isTerminalStep2) {
+          const ownerLocator = frameLocator.owner();
+          currentTarget = ownerLocator;
+          lastLocator = ownerLocator;
+        } else {
+          currentTarget = frameLocator;
+          lastLocator = frameLocator;
+        }
+        if (isTerminalStep2 && terminalDescription && isLocatorInstance(lastLocator)) {
+          lastLocator = lastLocator.describe(terminalDescription);
+          currentTarget = lastLocator;
+        }
+        debugSteps.push({ path: part, definition, appliedFilters: [], recordedSteps: [] });
+        continue;
+      }
+      const locatorResult = createLocator(currentTarget, definition);
+      const recordedSteps = steps.get(part) ?? [];
+      let resolvedLocator = locatorResult;
+      const appliedFilters = [];
+      let appliedIndex;
+      for (const step2 of recordedSteps) {
+        if (step2.kind === "filter") {
+          const [resolvedFilter] = this.resolveFiltersForTarget([step2.filter], resolutionContext);
+          if (resolvedFilter) {
+            resolvedLocator = resolvedLocator.filter(resolvedFilter);
+            appliedFilters.push(resolvedFilter);
+          }
+        } else {
+          appliedIndex = step2.index ?? null;
+          resolvedLocator = applyIndexSelector(resolvedLocator, appliedIndex ?? void 0);
+        }
+      }
+      if (isTerminalStep && terminalDescription) {
+        resolvedLocator = resolvedLocator.describe(terminalDescription);
+      }
+      currentTarget = resolvedLocator;
+      lastLocator = resolvedLocator;
+      debugSteps.push({
+        path: part,
+        definition,
+        appliedFilters,
+        index: appliedIndex,
+        recordedSteps
+      });
+    }
+    return { locator: lastLocator, steps: debugSteps };
+  }
+};
+var createRegistryWithAccessors = (page) => {
+  const registryInstance = new LocatorRegistryInternal(page);
+  const add = registryInstance.add.bind(registryInstance);
+  const getLocator = registryInstance.getLocator.bind(registryInstance);
+  const getNestedLocator = registryInstance.getNestedLocator.bind(registryInstance);
+  const getLocatorSchema = registryInstance.getLocatorSchema.bind(registryInstance);
+  const registry = registryInstance;
+  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";
+var DEFAULT_WAIT_UNTIL = "load";
+var DEFAULT_LOAD_STATE = "load";
+var Navigation = class {
+  constructor(page, baseUrl, urlPath, fullUrl, label, actions = null, defaultOptions) {
+    this.page = page;
+    this.baseUrl = baseUrl;
+    this.urlPath = urlPath;
+    this.fullUrl = fullUrl;
+    this.label = label;
+    this.pageActionsToPerform = actions ?? [];
+    this.defaultOptions = defaultOptions;
+  }
+  pageActionsToPerform;
+  defaultOptions;
+  resolveWaitUntil(options) {
+    return options?.waitUntil ?? this.defaultOptions?.waitUntil ?? DEFAULT_WAIT_UNTIL;
+  }
+  resolveWaitForLoadState(options) {
+    return options?.waitForLoadState ?? this.defaultOptions?.waitForLoadState ?? DEFAULT_LOAD_STATE;
+  }
+  async executeActions() {
+    for (const action of this.pageActionsToPerform) {
+      await action();
+    }
+  }
+  /**
+   * Navigate to a provided URL or URL path. If the input starts with "/", the POC's baseUrl is used as a prefix.
+   * Available only when baseUrl and urlPath are strings.
+   */
+  async goto(urlPathOrUrl, options) {
+    const waitUntil = this.resolveWaitUntil(options);
+    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 () => {
+      const targetUrl = urlPathOrUrl.startsWith("/") ? `${this.baseUrl}${urlPathOrUrl}` : urlPathOrUrl;
+      await this.page.goto(targetUrl, { waitUntil });
+    });
+  }
+  /**
+   * Navigate to this page's fullUrl and run any post-navigation actions.
+   * 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;
+            }
+          }
+        }
+      } else {
+        result = allData;
+      }
+    });
+    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;
+      }
+      await this.page.evaluate((keysToClear) => {
+        for (const key of keysToClear) {
+          sessionStorage.removeItem(key);
+        }
+      }, keys);
+    });
+  }
+};
+
+// srcV2/pageObject.ts
+var PageObject = class {
+  page;
+  baseUrl;
+  urlPath;
+  fullUrl;
+  label;
+  sessionStorage;
+  navigation;
+  locatorRegistry;
+  add;
+  getLocator;
+  getLocatorSchema;
+  getNestedLocator;
+  constructor(page, baseUrl, urlPath, options) {
+    this.page = page;
+    this.baseUrl = baseUrl;
+    this.urlPath = urlPath;
+    this.fullUrl = this.composeFullUrl(baseUrl, urlPath);
+    const label = options?.label ?? this.constructor.name;
+    this.label = label;
+    const { registry, add, getLocator, getNestedLocator, getLocatorSchema } = createRegistryWithAccessors(page);
+    this.locatorRegistry = registry;
+    this.add = add;
+    this.getLocator = getLocator;
+    this.getLocatorSchema = getLocatorSchema;
+    this.getNestedLocator = getNestedLocator;
+    this.sessionStorage = new SessionStorage2(page, { label });
+    this.defineLocators();
+    this.navigation = createNavigation(
+      this.page,
+      this.baseUrl,
+      this.urlPath,
+      this.fullUrl,
+      this.label,
+      this.pageActionsToPerformAfterNavigation(),
+      options?.navOptions
+    );
+  }
+  composeFullUrl(baseUrl, urlPath) {
+    const escapeRegex = (value) => value.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+    if (typeof baseUrl === "string" && typeof urlPath === "string") {
+      return `${baseUrl}${urlPath}`;
+    }
+    if (typeof baseUrl === "string" && urlPath instanceof RegExp) {
+      return new RegExp(`^${escapeRegex(baseUrl)}${urlPath.source}`);
+    }
+    if (baseUrl instanceof RegExp && typeof urlPath === "string") {
+      return new RegExp(`${baseUrl.source}${escapeRegex(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/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);
   }
@@ -1146,9 +3337,9 @@ ${args.join("\n\n")}`
   }
 };
 
-// src/fixture/base.fixtures.ts
-var test3 = base.extend({
-  // biome-ignore lint/correctness/noEmptyPattern: <Playwright does not support the use of _, thus we must provide an empty object {}>
+// 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 = [];
@@ -1159,24 +3350,53 @@ var test3 = base.extend({
   }
 });
 
-// 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;
+// 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,
-  test3 as test
+  SessionStorage2 as SessionStorage,
+  createRegistryWithAccessors,
+  step,
+  test5 as test
 };