pw-core 1.1.0 → 1.2.0

package/dist/component/table.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Table = exports.TableRows = void 0;
 const test_1 = require("@playwright/test");
+const caller_location_1 = require("../page/utils/caller-location");
 /**
  * A custom Array subclass representing a list of table rows.
  * Inherits all standard Array methods while adding type-safe get and getAll capabilities.
@@ -43,7 +44,7 @@ class Table {
         return test_1.test.step(`Get headers of table`, async () => {
             const headers = await this.root.locator('th').evaluateAll(ths => ths.map(th => th.textContent?.trim().toLowerCase() || ''));
             return headers;
-        });
+        }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
     }
     /**
      * Retrieves all the rows of the table as typed objects.
@@ -67,7 +68,7 @@ class Table {
                 });
             }, headers);
             return rowsData.filter((r) => r !== null);
-        });
+        }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
     }
     /**
      * Retrieves all rows from the table, returned as a custom TableRows collection
@@ -85,7 +86,7 @@ class Table {
             return await this.root.locator('tbody tr, tr[data-testid="transaction-row"]').evaluateAll(trs => {
                 return trs.filter(tr => tr.querySelectorAll('td').length > 0).length;
             });
-        });
+        }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
     }
     /**
      * Retrieves the value of a specific cell by row index and column key.
@@ -106,7 +107,7 @@ class Table {
                 const cell = dataRows[rowIndex].querySelectorAll('td')[columnIndex];
                 return cell?.textContent?.trim() ?? '';
             }, { rowIndex, columnIndex });
-        });
+        }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
     }
 }
 exports.Table = Table;

package/dist/helpers.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from '@playwright/test';
+import { Page } from '@playwright/test';
 /** Read a value from the browser's localStorage. Returns null if the key is absent. */
 export declare function getLocalStorage(page: Page, key: string): Promise<string | null>;
 /** Write a value to the browser's localStorage. */

package/dist/helpers.js

@@ -5,21 +5,31 @@ exports.setLocalStorage = setLocalStorage;
 exports.getSessionStorage = getSessionStorage;
 exports.setSessionStorage = setSessionStorage;
 exports.seedSessionStorage = seedSessionStorage;
+const test_1 = require("@playwright/test");
+const caller_location_1 = require("./page/utils/caller-location");
 /** Read a value from the browser's localStorage. Returns null if the key is absent. */
 async function getLocalStorage(page, key) {
-    return page.evaluate((k) => localStorage.getItem(k), key);
+    return test_1.test.step(`Get localStorage "${key}"`, async () => {
+        return page.evaluate((k) => localStorage.getItem(k), key);
+    }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
 }
 /** Write a value to the browser's localStorage. */
 async function setLocalStorage(page, key, value) {
-    await page.evaluate(([k, v]) => localStorage.setItem(k, v), [key, value]);
+    await test_1.test.step(`Set localStorage "${key}"`, async () => {
+        await page.evaluate(([k, v]) => localStorage.setItem(k, v), [key, value]);
+    }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
 }
 /** Read a value from the browser's sessionStorage. Returns null if the key is absent. */
 async function getSessionStorage(page, key) {
-    return page.evaluate((k) => sessionStorage.getItem(k), key);
+    return test_1.test.step(`Get sessionStorage "${key}"`, async () => {
+        return page.evaluate((k) => sessionStorage.getItem(k), key);
+    }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
 }
 /** Write a value to the browser's sessionStorage. */
 async function setSessionStorage(page, key, value) {
-    await page.evaluate(([k, v]) => sessionStorage.setItem(k, v), [key, value]);
+    await test_1.test.step(`Set sessionStorage "${key}"`, async () => {
+        await page.evaluate(([k, v]) => sessionStorage.setItem(k, v), [key, value]);
+    }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
 }
 /**
  * Seeds sessionStorage entries via addInitScript before any navigation.
@@ -30,10 +40,12 @@ async function seedSessionStorage(page, entries) {
     const cookies = await page.context().cookies();
     if (cookies.length > 0) {
         const pairs = Object.entries(entries);
-        await page.addInitScript((items) => {
-            for (const [key, value] of items) {
-                sessionStorage.setItem(key, value);
-            }
-        }, pairs);
+        await test_1.test.step('Seed sessionStorage', async () => {
+            await page.addInitScript((items) => {
+                for (const [key, value] of items) {
+                    sessionStorage.setItem(key, value);
+                }
+            }, pairs);
+        }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
     }
 }

package/dist/page/actions/locator-actions.js

@@ -5,6 +5,7 @@ exports.defineActionMethods = defineActionMethods;
 const test_1 = require("@playwright/test");
 const config_1 = require("../config");
 const formatter_1 = require("../utils/formatter");
+const caller_location_1 = require("../utils/caller-location");
 function executeAction(prop, resolveLocatorFn, timeout, args) {
     const [locatorKey, ...methodArgs] = args;
     let optNth = undefined;
@@ -47,9 +48,41 @@ function executeAction(prop, resolveLocatorFn, timeout, args) {
             methodArgs[1] = playwrightOpts;
         }
     }
+    let shouldMask = false;
+    if (prop === 'fill' && methodArgs.length > 0) {
+        const opts = methodArgs[1];
+        if (opts && typeof opts === 'object' && opts.mask !== undefined) {
+            shouldMask = opts.mask === true;
+        }
+        else {
+            const targetStr = (0, formatter_1.formatTarget)(locatorKey);
+            const targetStrLower = targetStr.toLowerCase();
+            shouldMask = targetStrLower.includes('pass') || targetStrLower.includes('pw');
+        }
+    }
+    if (prop === 'fill' && shouldMask) {
+        return test_1.test.step(stepName, async () => {
+            await locator.focus();
+            await locator.evaluate((el, val) => {
+                const inputEl = el;
+                const prototype = el.tagName === 'TEXTAREA'
+                    ? window.HTMLTextAreaElement.prototype
+                    : window.HTMLInputElement.prototype;
+                const descriptor = Object.getOwnPropertyDescriptor(prototype, 'value');
+                if (descriptor && descriptor.set) {
+                    descriptor.set.call(inputEl, val);
+                }
+                else {
+                    inputEl.value = val;
+                }
+                inputEl.dispatchEvent(new Event('input', { bubbles: true }));
+                inputEl.dispatchEvent(new Event('change', { bubbles: true }));
+            }, methodArgs[0]);
+        }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
+    }
     return test_1.test.step(stepName, () => {
         return method.apply(locator, methodArgs);
-    });
+    }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
 }
 function defineActionMethods(instance, resolveLocatorFn, timeout) {
     const locatorMethods = [...config_1.zeroArgMethodsList, ...config_1.oneArgMethodsList];

package/dist/page/actions/page-actions.d.ts

@@ -6,34 +6,39 @@ type GotoOptions = {
 };
 type ToHaveURLOptions = Parameters<ReturnType<typeof playwrightExpect<Page>>['toHaveURL']>[1];
 type ToHaveTitleOptions = Parameters<ReturnType<typeof playwrightExpect<Page>>['toHaveTitle']>[1];
+type StepLocation = {
+    file: string;
+    line: number;
+    column: number;
+};
 /**
  * Navigate to the page URL defined in the page config.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-goto Page.goto} in a test step.
  */
-export declare function goto(page: Page, url: string | undefined, constructorName: string, options?: GotoOptions): Promise<void>;
+export declare function goto(page: Page, url: string | undefined, constructorName: string, options?: GotoOptions, location?: StepLocation): Promise<void>;
 /**
  * Assert the current URL matches the page config URL or a custom pattern.
  * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-url expect(page).toHaveURL}.
  */
-export declare function verifyURL(page: Page, url: string | undefined, constructorName: string, urlOrOptions?: string | RegExp | ToHaveURLOptions, options?: ToHaveURLOptions): Promise<void>;
+export declare function verifyURL(page: Page, url: string | undefined, constructorName: string, urlOrOptions?: string | RegExp | ToHaveURLOptions, options?: ToHaveURLOptions, location?: StepLocation): Promise<void>;
 /**
  * Assert the page title matches the expected value.
  * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-title expect(page).toHaveTitle}.
  */
-export declare function verifyTitle(page: Page, title: string | RegExp, options?: ToHaveTitleOptions): Promise<void>;
+export declare function verifyTitle(page: Page, title: string | RegExp, options?: ToHaveTitleOptions, location?: StepLocation): Promise<void>;
 /**
  * Reload the page.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-reload Page.reload} in a test step.
  */
-export declare function reload(page: Page, options?: Parameters<Page['reload']>[0]): Promise<void>;
+export declare function reload(page: Page, options?: Parameters<Page['reload']>[0], location?: StepLocation): Promise<void>;
 /**
  * Wait for the page to reach a load state.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-load-state Page.waitForLoadState} in a test step.
  */
-export declare function waitForLoadState(page: Page, state?: Parameters<Page['waitForLoadState']>[0], options?: Parameters<Page['waitForLoadState']>[1]): Promise<void>;
+export declare function waitForLoadState(page: Page, state?: Parameters<Page['waitForLoadState']>[0], options?: Parameters<Page['waitForLoadState']>[1], location?: StepLocation): Promise<void>;
 /**
  * Wait for navigation to a URL. Defaults to the page config URL when no pattern is given.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-url Page.waitForURL} in a test step.
  */
-export declare function waitForURL(page: Page, url: string | undefined, constructorName: string, urlOrOptions?: string | RegExp | Parameters<Page['waitForURL']>[1], options?: Parameters<Page['waitForURL']>[1]): Promise<void>;
+export declare function waitForURL(page: Page, url: string | undefined, constructorName: string, urlOrOptions?: string | RegExp | Parameters<Page['waitForURL']>[1], options?: Parameters<Page['waitForURL']>[1], location?: StepLocation): Promise<void>;
 export {};

package/dist/page/actions/page-actions.js

@@ -33,59 +33,59 @@ function resolveUrlPattern(url, constructorName, urlOrOptions, options) {
  * Navigate to the page URL defined in the page config.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-goto Page.goto} in a test step.
  */
-async function goto(page, url, constructorName, options) {
+async function goto(page, url, constructorName, options, location) {
     await test_1.test.step(`Goto "${url || ''}"`, async () => {
         if (!url) {
             throw new Error(`URL is not defined on ${constructorName}`);
         }
         await page.goto(url, options);
-    });
+    }, { box: true, location });
 }
 /**
  * Assert the current URL matches the page config URL or a custom pattern.
  * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-url expect(page).toHaveURL}.
  */
-async function verifyURL(page, url, constructorName, urlOrOptions, options) {
+async function verifyURL(page, url, constructorName, urlOrOptions, options, location) {
     const { targetUrl, actualOptions } = resolveUrlPattern(url, constructorName, urlOrOptions, options);
     const stepName = `Verify URL matches "${targetUrl.toString()}"`;
     await test_1.test.step(stepName, async () => {
         await (0, test_1.expect)(page).toHaveURL(targetUrl, actualOptions);
-    });
+    }, { box: true, location });
 }
 /**
  * Assert the page title matches the expected value.
  * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-title expect(page).toHaveTitle}.
  */
-async function verifyTitle(page, title, options) {
+async function verifyTitle(page, title, options, location) {
     const stepName = `Verify title matches "${title}"`;
     await test_1.test.step(stepName, async () => {
         await (0, test_1.expect)(page).toHaveTitle(title, options);
-    });
+    }, { box: true, location });
 }
 /**
  * Reload the page.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-reload Page.reload} in a test step.
  */
-async function reload(page, options) {
+async function reload(page, options, location) {
     await test_1.test.step('Reload page', async () => {
         await page.reload(options);
-    });
+    }, { box: true, location });
 }
 /**
  * Wait for the page to reach a load state.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-load-state Page.waitForLoadState} in a test step.
  */
-async function waitForLoadState(page, state, options) {
+async function waitForLoadState(page, state, options, location) {
     const stepName = `Wait for load state "${state ?? 'load'}"`;
     await test_1.test.step(stepName, async () => {
         await page.waitForLoadState(state, options);
-    });
+    }, { box: true, location });
 }
 /**
  * Wait for navigation to a URL. Defaults to the page config URL when no pattern is given.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-url Page.waitForURL} in a test step.
  */
-async function waitForURL(page, url, constructorName, urlOrOptions, options) {
+async function waitForURL(page, url, constructorName, urlOrOptions, options, location) {
     let targetUrl;
     let actualOptions = options;
     if (urlOrOptions !== undefined && (typeof urlOrOptions === 'string' || urlOrOptions instanceof RegExp)) {
@@ -103,5 +103,5 @@ async function waitForURL(page, url, constructorName, urlOrOptions, options) {
     const stepName = `Wait for URL "${targetUrl.toString()}"`;
     await test_1.test.step(stepName, async () => {
         await page.waitForURL(targetUrl, actualOptions);
-    });
+    }, { box: true, location });
 }

package/dist/page/assertions/verify-chain.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVerifyChain = createVerifyChain;
 const test_1 = require("@playwright/test");
 const formatter_1 = require("../utils/formatter");
+const caller_location_1 = require("../utils/caller-location");
 function createVerifyChain(resolveLocator, target, verifyOptions, isSoft) {
     const defaultNth = verifyOptions?.nth;
     const defaultHasText = verifyOptions?.hasText;
@@ -18,7 +19,7 @@ function createVerifyChain(resolveLocator, target, verifyOptions, isSoft) {
                 const expectation = expectFn(locator, stepName);
                 const match = isNegated ? expectation.not : expectation;
                 await match.toBeVisible(options);
-            });
+            }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
         };
         return new Proxy(baseFn, {
             get(targetObj, prop) {
@@ -53,7 +54,7 @@ function createVerifyChain(resolveLocator, target, verifyOptions, isSoft) {
                         const expectation = expectFn(locator, stepName);
                         const match = isNegated ? expectation.not : expectation;
                         await match[prop](...args);
-                    });
+                    }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
                 };
             }
         });

package/dist/page/assertions/verify-helpers.d.ts

@@ -1,4 +1,9 @@
 import { Locator, expect as playwrightExpect } from '@playwright/test';
+type StepLocation = {
+    file: string;
+    line: number;
+    column: number;
+};
 export declare function verifyHidden(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
@@ -7,7 +12,7 @@ export declare function verifyHidden(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
     message?: string;
-}): Promise<void>;
+}, location?: StepLocation): Promise<void>;
 export declare function verifyEnabled(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
@@ -16,7 +21,7 @@ export declare function verifyEnabled(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
     message?: string;
-}): Promise<void>;
+}, location?: StepLocation): Promise<void>;
 export declare function verifyDisabled(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
@@ -25,4 +30,5 @@ export declare function verifyDisabled(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
     message?: string;
-}): Promise<void>;
+}, location?: StepLocation): Promise<void>;
+export {};

package/dist/page/assertions/verify-helpers.js

@@ -5,24 +5,24 @@ exports.verifyEnabled = verifyEnabled;
 exports.verifyDisabled = verifyDisabled;
 const test_1 = require("@playwright/test");
 const formatter_1 = require("../utils/formatter");
-async function verifyHidden(resolveLocator, target, options) {
+async function verifyHidden(resolveLocator, target, options, location) {
     const stepName = options?.message ?? (0, formatter_1.formatAssertionDescription)(target, 'toBeHidden', false, [options]);
     await test_1.test.step(stepName, async () => {
         const locator = resolveLocator(target, { nth: options?.nth, hasText: options?.hasText });
         await (0, test_1.expect)(locator, stepName).toBeHidden(options);
-    });
+    }, { box: true, location });
 }
-async function verifyEnabled(resolveLocator, target, options) {
+async function verifyEnabled(resolveLocator, target, options, location) {
     const stepName = options?.message ?? (0, formatter_1.formatAssertionDescription)(target, 'toBeEnabled', false, [options]);
     await test_1.test.step(stepName, async () => {
         const locator = resolveLocator(target, { nth: options?.nth, hasText: options?.hasText });
         await (0, test_1.expect)(locator, stepName).toBeEnabled(options);
-    });
+    }, { box: true, location });
 }
-async function verifyDisabled(resolveLocator, target, options) {
+async function verifyDisabled(resolveLocator, target, options, location) {
     const stepName = options?.message ?? (0, formatter_1.formatAssertionDescription)(target, 'toBeDisabled', false, [options]);
     await test_1.test.step(stepName, async () => {
         const locator = resolveLocator(target, { nth: options?.nth, hasText: options?.hasText });
         await (0, test_1.expect)(locator, stepName).toBeDisabled(options);
-    });
+    }, { box: true, location });
 }

package/dist/page/config.d.ts

@@ -1,15 +1,52 @@
 import { Locator, Page } from '@playwright/test';
-export { ProxyLocatorMethods } from './types/proxy-methods';
+import type { DynamicTestIdEntry, DynamicSelectorEntry } from './locators/dynamic-locator-resolver.js';
+export { ProxyLocatorMethods } from './types/proxy-methods.js';
+export type { DynamicLocatorEntry, DynamicTestIdEntry, DynamicSelectorEntry } from './locators/dynamic-locator-resolver.js';
 export declare const zeroArgMethodsList: readonly ["click", "dblclick", "hover", "focus", "blur", "check", "uncheck", "clear", "waitFor", "isChecked", "isDisabled", "isVisible", "textContent", "innerText", "allInnerTexts", "allTextContents", "count", "scrollIntoViewIfNeeded", "boundingBox"];
 export declare const oneArgMethodsList: readonly ["fill", "press", "pressSequentially", "selectOption", "setInputFiles", "getAttribute", "dragTo"];
 export type AllowedZeroArgMethods = typeof zeroArgMethodsList[number];
 export type AllowedOneArgMethods = typeof oneArgMethodsList[number];
 export type AllowedMethodKeys = AllowedZeroArgMethods | AllowedOneArgMethods;
+import { ValidateDynamicEntryProperties, HasDuplicatePlaceholders } from './types/validation.js';
+/**
+ * Replaces every `{Name}` placeholder in `Pattern` with `Capitalize<Value>`
+ * where `Value` is drawn from the corresponding array in `Entry`.
+ * Template-literal unions distribute automatically, producing the full cartesian product.
+ */
+type ReplacePattern<Pattern extends string, Entry> = Pattern extends `${infer Before}{${infer Name}}${infer After}` ? Name extends keyof Entry ? Entry[Name] extends readonly string[] ? `${Before}${Capitalize<Entry[Name][number]>}${ReplacePattern<After, Entry> & string}` : never : never : Pattern;
+/**
+ * Expands a dynamic key pattern into the union of all concrete (camelCased) keys.
+ *
+ * @example
+ * ```ts
+ * type Keys = ExpandDynamicKey<
+ *   "{status}{id}Chart",
+ *   { status: readonly ['active', 'inactive']; id: readonly ['line', 'bar']; testId: "status-id-chart" }
+ * >;
+ * // => "activeLineChart" | "activeBarChart" | "inactiveLineChart" | "inactiveBarChart"
+ * ```
+ */
+type ExpandDynamicKey<Pattern extends string, Entry> = Uncapitalize<ReplacePattern<Pattern, Entry>>;
+/**
+ * Resolves every key in a testIds record:
+ * - string values → the key itself (static locator)
+ * - object values → the expanded dynamic key union
+ */
+type ResolvedTestIdKeys<I> = {
+    [K in keyof I & string]: I[K] extends string ? K : ExpandDynamicKey<K, I[K]>;
+}[keyof I & string];
+/**
+ * Validates all entries in a testIds or selectors record.
+ * Static (string) entries pass through. Dynamic entries are checked via ValidateDynamicEntryProperties.
+ */
+type ValidateTestIds<I, TargetKey extends 'testId' | 'selector'> = {
+    [K in keyof I & string]: I[K] extends string ? string : K extends `${string}{${string}}${string}` ? HasDuplicatePlaceholders<K> extends true ? "Error: Pattern contains duplicate placeholders" : ValidateDynamicEntryProperties<K, I[K], TargetKey> : I[K];
+};
 export type PageKeys<T> = (T extends {
     testIds?: infer I;
-} ? keyof I & string : never) | (T extends {
+} ? I extends Record<string, any> ? ResolvedTestIdKeys<I> : never : never) | (T extends {
     selectors?: infer S;
-} ? keyof S & string : never);
+} ? S extends Record<string, any> ? ResolvedTestIdKeys<S> : never : never);
 export type TypedLocators<T> = {
     [K in PageKeys<T>]: Locator;
 };
@@ -17,16 +54,29 @@ export type ChainedKeys<T> = `${PageKeys<T>}.${PageKeys<T>}`;
 export type TargetKey<T> = PageKeys<T> | ChainedKeys<T> | Locator;
 export type ValidateTarget<K, T> = K extends Locator ? Locator : K extends (PageKeys<T> | ChainedKeys<T>) ? K : never;
 export declare function getOptionsArgumentIndex(methodName: AllowedMethodKeys): number;
-export type PageConfig<T = any> = {
+/** Map type accepted by the `testIds` property in a page config. */
+export type TestIdMap = Record<string, string | DynamicTestIdEntry>;
+export type SelectorMap = Record<string, string | DynamicSelectorEntry>;
+export type PageConfig = {
     url?: string;
-    testIds?: Record<string, string>;
+    testIds?: TestIdMap;
+    selectors?: SelectorMap;
+    Class?: new (page: Page, config?: any) => any;
+};
+export type ValidatePageConfig<T> = {
+    url?: string;
+    testIds?: T extends {
+        testIds: infer I;
+    } ? I extends Record<string, any> ? ValidateTestIds<I, 'testId'> : TestIdMap : TestIdMap;
     selectors?: T extends {
         testIds: infer I;
         selectors: infer S;
-    } ? {
-        [K in keyof S]: K extends keyof I ? `Duplicate key: ${K & string} already exists in testIds` : S[K];
-    } : Record<string, string>;
+    } ? S extends Record<string, any> ? {
+        [K in keyof S]: K extends keyof I ? `Duplicate key: ${K & string} already exists in testIds` : ValidateTestIds<S, 'selector'>[K & keyof S & string];
+    } : SelectorMap : SelectorMap;
     Class?: new (page: Page, config?: any) => any;
+} & {
+    [K in Exclude<keyof T, keyof PageConfig>]: never;
 };
 /**
  * Creates a strongly-typed page configuration object containing URLs, testIds, and CSS selectors.
@@ -48,4 +98,4 @@ export type PageConfig<T = any> = {
  * });
  * ```
  */
-export declare function createPageConfig<T extends PageConfig<T>>(config: T): T;
+export declare function createPageConfig<const T extends PageConfig>(config: [T] extends [ValidatePageConfig<T>] ? T : ValidatePageConfig<T>): T;

package/dist/page/index.d.ts

@@ -5,6 +5,7 @@ export * from './assertions/verify-helpers';
 export * from './assertions/expect';
 export * from './actions/page-actions';
 export * from './actions/locator-actions';
+export * from './locators/dynamic-locator-resolver';
 export * from './locators/resolver';
 export * from './typed-page';
 export * from './registry';

package/dist/page/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./assertions/verify-helpers"), exports);
 __exportStar(require("./assertions/expect"), exports);
 __exportStar(require("./actions/page-actions"), exports);
 __exportStar(require("./actions/locator-actions"), exports);
+__exportStar(require("./locators/dynamic-locator-resolver"), exports);
 __exportStar(require("./locators/resolver"), exports);
 __exportStar(require("./typed-page"), exports);
 __exportStar(require("./registry"), exports);

package/dist/page/locators/dynamic-locator-resolver.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Dynamic locator resolver — expands `{placeholder}` patterns in testId keys
+ * into all value combinations at runtime.
+ *
+ * @example
+ * ```ts
+ * const testIds = {
+ *   staticKey: 'static-test-id',
+ *   "{status}{id}Chart": {
+ *     id: ['line', 'bar'],
+ *     status: ['active', 'inactive'],
+ *     testId: "status-id-chart"
+ *   }
+ * };
+ *
+ * expandDynamicLocators(testIds);
+ * // => {
+ * //   staticKey: 'static-test-id',
+ * //   activeLineChart:    'active-line-chart',
+ * //   activeBarChart:     'active-bar-chart',
+ * //   inactiveLineChart:  'inactive-line-chart',
+ * //   inactiveBarChart:   'inactive-bar-chart'
+ * // }
+ * ```
+ */
+/**
+ * Shape of a dynamic testId entry.
+ *
+ * `testId` — the test-id pattern with placeholder *names* as literal substrings.
+ * Every other property is a placeholder name mapped to its list of allowed values.
+ */
+export type DynamicTestIdEntry = {
+    testId?: string;
+    [placeholder: string]: string | readonly string[] | undefined;
+};
+export type DynamicSelectorEntry = {
+    selector?: string;
+    [placeholder: string]: string | readonly string[] | undefined;
+};
+export type DynamicLocatorEntry = DynamicTestIdEntry | DynamicSelectorEntry;
+/** Returns true when `key` contains at least one `{…}` placeholder. */
+export declare function isDynamicKey(key: string): boolean;
+/**
+ * Expands all dynamic entries in a `testIds` map into a flat `key → testId` map.
+ * Static (string-valued) entries pass through unchanged.
+ */
+export declare function expandDynamicLocators(testIds: Record<string, string | DynamicLocatorEntry>): Record<string, string>;
+/** Return the expanded (flat) testIds map, caching the result per config object. */
+export declare function getExpandedTestIds(testIds: Record<string, string | DynamicLocatorEntry>): Record<string, string>;

package/dist/page/locators/dynamic-locator-resolver.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Dynamic locator resolver — expands `{placeholder}` patterns in testId keys
+ * into all value combinations at runtime.
+ *
+ * @example
+ * ```ts
+ * const testIds = {
+ *   staticKey: 'static-test-id',
+ *   "{status}{id}Chart": {
+ *     id: ['line', 'bar'],
+ *     status: ['active', 'inactive'],
+ *     testId: "status-id-chart"
+ *   }
+ * };
+ *
+ * expandDynamicLocators(testIds);
+ * // => {
+ * //   staticKey: 'static-test-id',
+ * //   activeLineChart:    'active-line-chart',
+ * //   activeBarChart:     'active-bar-chart',
+ * //   inactiveLineChart:  'inactive-line-chart',
+ * //   inactiveBarChart:   'inactive-bar-chart'
+ * // }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDynamicKey = isDynamicKey;
+exports.expandDynamicLocators = expandDynamicLocators;
+exports.getExpandedTestIds = getExpandedTestIds;
+/** Returns true when `key` contains at least one `{…}` placeholder. */
+function isDynamicKey(key) {
+    return /\{[^}]+\}/.test(key);
+}
+/**
+ * Capitalize the first character of a string.
+ * @internal
+ */
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+/**
+ * Compute the cartesian product of an array-of-arrays.
+ *
+ * @example cartesianProduct([['a','b'],['1','2']]) // [['a','1'],['a','2'],['b','1'],['b','2']]
+ * @internal
+ */
+function cartesianProduct(arrays) {
+    if (arrays.length === 0)
+        return [[]];
+    return arrays.reduce((acc, arr) => acc.flatMap(combo => arr.map(val => [...combo, val])), [[]]);
+}
+/**
+ * Extract placeholder names from a pattern like `"{status}{id}Chart"`.
+ * @internal
+ */
+function extractPlaceholders(pattern) {
+    const names = [];
+    const re = /\{([^}]+)\}/g;
+    let m;
+    while ((m = re.exec(pattern)) !== null) {
+        names.push(m[1]);
+    }
+    return names;
+}
+/**
+ * Expand a single dynamic key pattern + entry into flat key → locator-value pairs.
+ * Validates the entry at runtime before expansion.
+ * @internal
+ */
+function expandSingleDynamic(pattern, entry) {
+    const testIdPattern = entry.testId;
+    const selectorPattern = entry.selector;
+    const targetPattern = (testIdPattern !== undefined ? testIdPattern : selectorPattern);
+    const targetKey = testIdPattern !== undefined ? 'testId' : 'selector';
+    if (targetPattern === undefined) {
+        throw new Error(`Dynamic locator "${pattern}": entry must contain either 'testId' or 'selector' property.`);
+    }
+    const placeholders = { ...entry };
+    delete placeholders.testId;
+    delete placeholders.selector;
+    // ─── Validation ──────────────────────────────────────────────────────
+    const expectedNames = extractPlaceholders(pattern);
+    // 0.5. No duplicate placeholders in the pattern
+    const uniqueNames = Array.from(new Set(expectedNames));
+    if (uniqueNames.length !== expectedNames.length) {
+        throw new Error(`Dynamic locator "${pattern}": pattern has duplicate placeholders.`);
+    }
+    // 1. No unknown keys (only placeholder names + targetKey)
+    const actualKeys = Object.keys(placeholders);
+    const unknownKeys = actualKeys.filter(k => !expectedNames.includes(k));
+    if (unknownKeys.length > 0) {
+        throw new Error(`Dynamic locator "${pattern}": unknown key(s) [${unknownKeys.join(', ')}]. ` +
+            `Only '${targetKey}' and placeholder keys [${expectedNames.join(', ')}] are allowed.`);
+    }
+    // 2. All placeholders from the pattern must have a key in the entry
+    const missingKeys = expectedNames.filter(name => !(name in placeholders));
+    if (missingKeys.length > 0) {
+        throw new Error(`Dynamic locator "${pattern}": missing placeholder key(s) [${missingKeys.join(', ')}]. ` +
+            `You must provide values for all placeholders defined in the pattern.`);
+    }
+    // 2.5. Placeholder values must be arrays
+    const nonArrayKeys = expectedNames.filter(name => !Array.isArray(placeholders[name]));
+    if (nonArrayKeys.length > 0) {
+        throw new Error(`Dynamic locator "${pattern}": placeholder key(s) [${nonArrayKeys.join(', ')}] must be arrays.`);
+    }
+    // 3. All placeholder names must appear as substrings in the target pattern value
+    const missingInPattern = expectedNames.filter(name => !targetPattern.includes(name));
+    if (missingInPattern.length > 0) {
+        throw new Error(`Dynamic locator "${pattern}": ${targetKey} "${targetPattern}" does not contain ` +
+            `placeholder name(s) [${missingInPattern.join(', ')}]. ` +
+            `All placeholder names must appear in the ${targetKey} so they can be replaced at runtime.`);
+    }
+    // ─── Expansion ───────────────────────────────────────────────────────
+    // Sort placeholder names longest-first to avoid substring replacement issues
+    const names = Object.keys(placeholders).sort((a, b) => b.length - a.length);
+    const values = names.map(name => {
+        const v = placeholders[name];
+        return v;
+    });
+    const result = {};
+    for (const combo of cartesianProduct(values)) {
+        // Build the *key* — replace {name} with Capitalize(value), then uncapitalize the first char
+        let expandedKey = pattern;
+        let expandedValue = targetPattern;
+        for (let i = 0; i < names.length; i++) {
+            const name = names[i];
+            const val = combo[i];
+            expandedKey = expandedKey.replace(`{${name}}`, capitalize(val));
+            expandedValue = expandedValue.replaceAll(name, targetKey === 'selector' ? val : val.toLowerCase());
+        }
+        // camelCase: uncapitalize the first character
+        expandedKey = expandedKey.charAt(0).toLowerCase() + expandedKey.slice(1);
+        result[expandedKey] = expandedValue;
+    }
+    return result;
+}
+/**
+ * Expands all dynamic entries in a `testIds` map into a flat `key → testId` map.
+ * Static (string-valued) entries pass through unchanged.
+ */
+function expandDynamicLocators(testIds) {
+    const result = {};
+    for (const [key, value] of Object.entries(testIds)) {
+        if (typeof value === 'string') {
+            result[key] = value;
+        }
+        else {
+            Object.assign(result, expandSingleDynamic(key, value));
+        }
+    }
+    return result;
+}
+/**
+ * Cached expansion — avoids re-expanding the same config on every action call.
+ * @internal
+ */
+const expandedCache = new WeakMap();
+/** Return the expanded (flat) testIds map, caching the result per config object. */
+function getExpandedTestIds(testIds) {
+    let expanded = expandedCache.get(testIds);
+    if (!expanded) {
+        expanded = expandDynamicLocators(testIds);
+        expandedCache.set(testIds, expanded);
+    }
+    return expanded;
+}

package/dist/page/locators/resolver.d.ts

@@ -1,12 +1,13 @@
 import { Page, Locator } from '@playwright/test';
-import { ChainedKeys, PageKeys } from '../config';
+import { ChainedKeys, PageKeys, DynamicSelectorEntry } from '../config';
+import type { DynamicLocatorEntry } from './dynamic-locator-resolver';
 export declare function defineLocators<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
+    testIds?: Record<string, string | DynamicLocatorEntry>;
+    selectors?: Record<string, string | DynamicSelectorEntry>;
 }>(instance: any, context: Page | Locator, config: T): void;
 export declare function resolveLocator<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
+    testIds?: Record<string, string | DynamicLocatorEntry>;
+    selectors?: Record<string, string | DynamicSelectorEntry>;
 }>(context: Page | Locator, config: T, target: PageKeys<T> | ChainedKeys<T> | Locator, options?: {
     nth?: number;
     raw?: boolean;
@@ -16,8 +17,8 @@ export declare function resolveLocator<T extends {
  * Resolve a config key to a proxied Locator with step-wrapped Playwright methods.
  */
 export declare function locator<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
+    testIds?: Record<string, string | DynamicLocatorEntry>;
+    selectors?: Record<string, string | DynamicSelectorEntry>;
 }>(context: Page | Locator, config: T, target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<Locator['filter']>[0] & {
     nth?: number;
 }): Locator;

package/dist/page/locators/resolver.js

@@ -7,12 +7,15 @@ exports.wrapLocatorWithProxy = wrapLocatorWithProxy;
 const test_1 = require("@playwright/test");
 const config_1 = require("../config");
 const formatter_1 = require("../utils/formatter");
+const dynamic_locator_resolver_1 = require("./dynamic-locator-resolver");
+const caller_location_1 = require("../utils/caller-location");
 function defineLocators(instance, context, config) {
     if (config.testIds) {
-        for (const key of Object.keys(config.testIds)) {
+        const expanded = (0, dynamic_locator_resolver_1.getExpandedTestIds)(config.testIds);
+        for (const key of Object.keys(expanded)) {
             Object.defineProperty(instance, key, {
                 get: () => {
-                    return context.getByTestId(config.testIds[key]);
+                    return context.getByTestId(expanded[key]);
                 },
                 enumerable: true,
                 configurable: true,
@@ -20,10 +23,11 @@ function defineLocators(instance, context, config) {
         }
     }
     if (config.selectors) {
-        for (const key of Object.keys(config.selectors)) {
+        const expanded = (0, dynamic_locator_resolver_1.getExpandedTestIds)(config.selectors);
+        for (const key of Object.keys(expanded)) {
             Object.defineProperty(instance, key, {
                 get: () => {
-                    return context.locator(config.selectors[key]);
+                    return context.locator(expanded[key]);
                 },
                 enumerable: true,
                 configurable: true,
@@ -36,12 +40,14 @@ function resolveLocator(context, config, target, options) {
         return target;
     const targetStr = target;
     const parts = targetStr.split('.');
+    const expandedTestIds = config.testIds ? (0, dynamic_locator_resolver_1.getExpandedTestIds)(config.testIds) : undefined;
+    const expandedSelectors = config.selectors ? (0, dynamic_locator_resolver_1.getExpandedTestIds)(config.selectors) : undefined;
     const resolveSingle = (key, ctx) => {
-        if (config.testIds && key in config.testIds) {
-            return ctx.getByTestId(config.testIds[key]);
+        if (expandedTestIds && key in expandedTestIds) {
+            return ctx.getByTestId(expandedTestIds[key]);
         }
-        if (config.selectors && key in config.selectors) {
-            return ctx.locator(config.selectors[key]);
+        if (expandedSelectors && key in expandedSelectors) {
+            return ctx.locator(expandedSelectors[key]);
         }
         throw new Error(`Locator key '${key}' is not defined in testIds or selectors.`);
     };
@@ -78,7 +84,39 @@ function wrapLocatorWithProxy(loc) {
             if (typeof val === 'function' && actionMethods.includes(propKey)) {
                 return (...args) => {
                     const stepName = (0, formatter_1.formatStepDescription)(propKey, targetLoc, args);
-                    return test_1.test.step(stepName, () => val.apply(targetLoc, args));
+                    if (propKey === 'fill') {
+                        const options = args[1];
+                        let shouldMask = false;
+                        if (options && typeof options === 'object' && options.mask !== undefined) {
+                            shouldMask = options.mask === true;
+                        }
+                        else {
+                            const targetStr = (0, formatter_1.formatTarget)(targetLoc);
+                            const targetStrLower = targetStr.toLowerCase();
+                            shouldMask = targetStrLower.includes('pass') || targetStrLower.includes('pw');
+                        }
+                        if (shouldMask) {
+                            return test_1.test.step(stepName, async () => {
+                                await targetLoc.focus();
+                                await targetLoc.evaluate((el, val) => {
+                                    const inputEl = el;
+                                    const prototype = el.tagName === 'TEXTAREA'
+                                        ? window.HTMLTextAreaElement.prototype
+                                        : window.HTMLInputElement.prototype;
+                                    const descriptor = Object.getOwnPropertyDescriptor(prototype, 'value');
+                                    if (descriptor && descriptor.set) {
+                                        descriptor.set.call(inputEl, val);
+                                    }
+                                    else {
+                                        inputEl.value = val;
+                                    }
+                                    inputEl.dispatchEvent(new Event('input', { bubbles: true }));
+                                    inputEl.dispatchEvent(new Event('change', { bubbles: true }));
+                                }, args[0]);
+                            }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
+                        }
+                    }
+                    return test_1.test.step(stepName, () => val.apply(targetLoc, args), { box: true, location: (0, caller_location_1.getCallerLocation)() });
                 };
             }
             return val;

package/dist/page/registry.d.ts

@@ -1,11 +1,11 @@
 import test, { Page, TestType } from '@playwright/test';
-import { PageConfig } from './config';
+import { PageConfig, ValidatePageConfig } from './config';
 import { TypedPage } from './typed-page';
 export type PageRegistry = Record<string, PageConfig>;
-export interface PageConstructor<C extends PageConfig<any>> {
+export interface PageConstructor<C extends PageConfig> {
     new (page: Page): TypedPage<C>;
 }
-export type PageRegistryTest<T extends Record<string, PageConfig<any>>, P, W, O = {}> = TestType<P & {
+export type PageRegistryTest<T extends Record<string, PageConfig>, P, W, O = {}> = TestType<P & {
     [K in keyof T]: K extends keyof O ? O[K] extends new (page: Page, ...args: any[]) => infer R ? R : NonNullable<T[K]['Class']> extends new (page: Page, ...args: any[]) => infer R2 ? R2 : TypedPage<T[K]> : NonNullable<T[K]['Class']> extends new (page: Page, ...args: any[]) => infer R ? R : TypedPage<T[K]>;
 }, W & {
     [K in keyof T as `worker${Capitalize<K & string>}`]: K extends keyof O ? O[K] extends new (page: Page, ...args: any[]) => infer R ? R : NonNullable<T[K]['Class']> extends new (page: Page, ...args: any[]) => infer R2 ? R2 : TypedPage<T[K]> : NonNullable<T[K]['Class']> extends new (page: Page, ...args: any[]) => infer R ? R : TypedPage<T[K]>;
@@ -51,6 +51,8 @@ export type PageRegistryTest<T extends Record<string, PageConfig<any>>, P, W, O
  * });
  * ```
  */
-export declare function createPageRegistry<T extends {
-    [K in keyof T]: PageConfig<T[K]>;
-} & Record<string, PageConfig<any>>>(registry: T): typeof test extends TestType<infer P, infer W> ? PageRegistryTest<T, P, W> : never;
+export declare function createPageRegistry<const T extends Record<string, PageConfig>>(registry: [T] extends [{
+    [K in keyof T]: ValidatePageConfig<T[K]>;
+}] ? T : {
+    [K in keyof T]: ValidatePageConfig<T[K]>;
+}): typeof test extends TestType<infer P, infer W> ? PageRegistryTest<T, P, W> : never;

package/dist/page/typed-page.d.ts

@@ -1,9 +1,10 @@
 import { Page, Locator, expect as playwrightExpect } from '@playwright/test';
-import { TypedLocators, ProxyLocatorMethods, PageKeys, ChainedKeys } from './config';
+import { TypedLocators, ProxyLocatorMethods, PageKeys, ChainedKeys, DynamicSelectorEntry } from './config';
+import type { DynamicLocatorEntry } from './locators/dynamic-locator-resolver';
 import { VerifyFn, AssertionsMethod } from './assertions/verify-chain';
 declare class TypedPageClass<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
+    testIds?: Record<string, string | DynamicLocatorEntry>;
+    selectors?: Record<string, string | DynamicSelectorEntry>;
     url?: string;
 }> {
     readonly page: Page;
@@ -58,22 +59,22 @@ declare class TypedPageClass<T extends {
     expect(target: PageKeys<T> | ChainedKeys<T> | Locator, message?: string): ReturnType<typeof playwrightExpect<Locator>>;
 }
 export type TypedPageType<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
+    testIds?: Record<string, string | DynamicLocatorEntry>;
+    selectors?: Record<string, string | DynamicSelectorEntry>;
     url?: string;
 }> = TypedPageClass<T> & TypedLocators<T> & ProxyLocatorMethods<T> & AssertionsMethod<T>;
 export declare const TypedPage: {
     new <T extends {
-        testIds?: Record<string, string>;
-        selectors?: Record<string, string>;
+        testIds?: Record<string, string | DynamicLocatorEntry>;
+        selectors?: Record<string, string | DynamicSelectorEntry>;
         url?: string;
     }>(context: Page | Locator, config: T, options?: {
         timeout?: number;
     }): TypedPageType<T>;
 };
 export type TypedPage<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
+    testIds?: Record<string, string | DynamicLocatorEntry>;
+    selectors?: Record<string, string | DynamicSelectorEntry>;
     url?: string;
 }> = TypedPageType<T>;
 export {};

package/dist/page/typed-page.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypedPage = void 0;
+const test_1 = require("@playwright/test");
 const verify_chain_1 = require("./assertions/verify-chain");
 const verify_helpers_1 = require("./assertions/verify-helpers");
 const expect_1 = require("./assertions/expect");
 const page_actions_1 = require("./actions/page-actions");
 const locator_actions_1 = require("./actions/locator-actions");
 const resolver_1 = require("./locators/resolver");
+const caller_location_1 = require("./utils/caller-location");
 class TypedPageClass {
     page;
     context;
@@ -23,30 +25,76 @@ class TypedPageClass {
         this.timeout = options?.timeout;
         (0, resolver_1.defineLocators)(this, this.context, this.config);
         (0, locator_actions_1.defineActionMethods)(this, this.resolveLocator.bind(this), this.timeout);
+        // Auto-wrap subclass methods with Playwright test.step
+        const builtInMethods = new Set([
+            'constructor', 'goto', 'verifyURL', 'verifyTitle', 'reload',
+            'waitForLoadState', 'waitForURL', 'resolveLocator', 'locator',
+            'verify', 'verifyHidden', 'verifyEnabled', 'verifyDisabled', 'expect'
+        ]);
+        let proto = Object.getPrototypeOf(this);
+        while (proto && proto !== Object.prototype && proto !== TypedPageClass.prototype) {
+            const propNames = Object.getOwnPropertyNames(proto);
+            for (const prop of propNames) {
+                const desc = Object.getOwnPropertyDescriptor(proto, prop);
+                if (desc && typeof desc.value === 'function' && !builtInMethods.has(prop) && !prop.startsWith('_')) {
+                    const originalFn = desc.value;
+                    Object.defineProperty(this, prop, {
+                        value: function (...args) {
+                            const words = prop.split(/(?=[A-Z])/).map(w => w.toLowerCase());
+                            if (words.length > 0) {
+                                words[0] = words[0].charAt(0).toUpperCase() + words[0].slice(1);
+                            }
+                            const sentence = words.join(' ');
+                            const formattedArgs = args.map(arg => {
+                                if (typeof arg === 'object' && arg !== null) {
+                                    try {
+                                        return JSON.stringify(arg);
+                                    }
+                                    catch {
+                                        return String(arg);
+                                    }
+                                }
+                                return String(arg);
+                            });
+                            const stepName = formattedArgs.length > 0
+                                ? `${sentence} - ${formattedArgs.join(' - ')}`
+                                : sentence;
+                            return test_1.test.step(stepName, () => {
+                                return originalFn.apply(this, args);
+                            });
+                        },
+                        writable: true,
+                        configurable: true,
+                        enumerable: true
+                    });
+                }
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
     }
     /** Navigate to the URL from page config. */
     async goto(options) {
-        return (0, page_actions_1.goto)(this.page, this.url, this.constructor.name, options);
+        return (0, page_actions_1.goto)(this.page, this.url, this.constructor.name, options, (0, caller_location_1.getCallerLocation)());
     }
     /** Assert the current URL matches the page config URL or a custom pattern. */
     async verifyURL(urlOrOptions, options) {
-        return (0, page_actions_1.verifyURL)(this.page, this.url, this.constructor.name, urlOrOptions, options);
+        return (0, page_actions_1.verifyURL)(this.page, this.url, this.constructor.name, urlOrOptions, options, (0, caller_location_1.getCallerLocation)());
     }
     /** Assert the page title matches the expected value. */
     async verifyTitle(title, options) {
-        return (0, page_actions_1.verifyTitle)(this.page, title, options);
+        return (0, page_actions_1.verifyTitle)(this.page, title, options, (0, caller_location_1.getCallerLocation)());
     }
     /** Reload the current page. */
     async reload(options) {
-        return (0, page_actions_1.reload)(this.page, options);
+        return (0, page_actions_1.reload)(this.page, options, (0, caller_location_1.getCallerLocation)());
     }
     /** Wait for the page to reach a load state. */
     async waitForLoadState(state, options) {
-        return (0, page_actions_1.waitForLoadState)(this.page, state, options);
+        return (0, page_actions_1.waitForLoadState)(this.page, state, options, (0, caller_location_1.getCallerLocation)());
     }
     /** Wait for navigation to a URL. Defaults to the page config URL. */
     async waitForURL(urlOrOptions, options) {
-        return (0, page_actions_1.waitForURL)(this.page, this.url, this.constructor.name, urlOrOptions, options);
+        return (0, page_actions_1.waitForURL)(this.page, this.url, this.constructor.name, urlOrOptions, options, (0, caller_location_1.getCallerLocation)());
     }
     resolveLocator(target, options) {
         return (0, resolver_1.resolveLocator)(this.context, this.config, target, options);
@@ -62,13 +110,13 @@ class TypedPageClass {
         return fn;
     }
     async verifyHidden(target, options) {
-        return (0, verify_helpers_1.verifyHidden)(this.resolveLocator.bind(this), target, options);
+        return (0, verify_helpers_1.verifyHidden)(this.resolveLocator.bind(this), target, options, (0, caller_location_1.getCallerLocation)());
     }
     async verifyEnabled(target, options) {
-        return (0, verify_helpers_1.verifyEnabled)(this.resolveLocator.bind(this), target, options);
+        return (0, verify_helpers_1.verifyEnabled)(this.resolveLocator.bind(this), target, options, (0, caller_location_1.getCallerLocation)());
     }
     async verifyDisabled(target, options) {
-        return (0, verify_helpers_1.verifyDisabled)(this.resolveLocator.bind(this), target, options);
+        return (0, verify_helpers_1.verifyDisabled)(this.resolveLocator.bind(this), target, options, (0, caller_location_1.getCallerLocation)());
     }
     expect(target, message) {
         const resolved = typeof target !== 'string' ? target : this.resolveLocator(target);

package/dist/page/types/validation.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Extracts placeholder names from a `{name}` pattern string.
+ */
+export type ExtractPlaceholders<S extends string> = S extends `${string}{${infer Name}}${infer Rest}` ? Name | ExtractPlaceholders<Rest> : never;
+/**
+ * Checks recursively if a pattern string contains duplicate placeholders.
+ */
+export type HasDuplicatePlaceholders<S extends string, Seen extends string = never> = S extends `${string}{${infer Name}}${infer Rest}` ? Name extends Seen ? true : HasDuplicatePlaceholders<Rest, Seen | Name> : false;
+/**
+ * Returns the subset of `Placeholders` whose names are NOT found as
+ * substrings of `TestId`. Evaluates to `never` when all are present.
+ */
+export type MissingInTestId<TestId extends string, Placeholders extends string> = Placeholders extends any ? TestId extends `${string}${Placeholders}${string}` ? never : Placeholders : never;
+/**
+ * Validates a dynamic entry by mapping each of its properties to their expected types.
+ *
+ * By checking properties individually, TypeScript reports the error exactly on the offending line
+ * (e.g. on the wrong value or unknown key) instead of marking the entire object as invalid.
+ */
+export type ValidateDynamicEntryProperties<Pattern extends string, Entry, TargetKey extends 'testId' | 'selector'> = {
+    [Key in (keyof Entry | ExtractPlaceholders<Pattern> | TargetKey)]: Key extends TargetKey ? Entry extends Record<TargetKey, infer TPat> ? TPat extends string ? [MissingInTestId<TPat, ExtractPlaceholders<Pattern>>] extends [never] ? string : `Error: ${TargetKey} must contain all placeholder names` : `Error: ${TargetKey} must be a string` : `Error: Dynamic entry must include a ${TargetKey} property` : Key extends ExtractPlaceholders<Pattern> ? Key extends keyof Entry ? Entry[Key] extends readonly string[] ? readonly string[] : `Error: Placeholder key must be an array: ${Key & string}` : `Error: Missing placeholder key: ${Key & string}` : `Error: Only placeholder keys and '${TargetKey}' are allowed`;
+};

package/dist/page/types/validation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/page/utils/caller-location.d.ts

@@ -0,0 +1,5 @@
+export declare function getCallerLocation(): {
+    file: string;
+    line: number;
+    column: number;
+} | undefined;

package/dist/page/utils/caller-location.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCallerLocation = getCallerLocation;
+// Global stack trace filter to remove pw-core internal frames from all error stacks.
+// This ensures that Playwright's auto-generated steps and expectations are attributed
+// directly to the user's project files instead of showing internal pw-core library paths.
+const originalPrepare = Error.prepareStackTrace;
+Error.prepareStackTrace = (err, stack) => {
+    const filteredStack = stack.filter(frame => {
+        const file = frame.getFileName();
+        if (!file)
+            return true;
+        const normalized = file.replace(/\\/g, '/');
+        if (normalized.includes('pw-core/src') ||
+            normalized.includes('pw-core/dist') ||
+            normalized.includes('node_modules/pw-core')) {
+            return false;
+        }
+        return true;
+    });
+    if (originalPrepare) {
+        try {
+            return originalPrepare(err, filteredStack);
+        }
+        catch {
+            // Fallback if originalPrepare fails on filtered stack
+        }
+    }
+    const errString = err.toString ? err.toString() : String(err);
+    return errString + '\n' + filteredStack.map(frame => {
+        try {
+            return '    at ' + frame.toString();
+        }
+        catch {
+            return '    at <unknown>';
+        }
+    }).join('\n');
+};
+function getCallerLocation() {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+        const err = {};
+        Error.prepareStackTrace = (_err, stack) => stack;
+        Error.captureStackTrace(err);
+        const stack = err.stack;
+        if (!stack)
+            return undefined;
+        for (let i = 1; i < stack.length; i++) {
+            const frame = stack[i];
+            const file = frame.getFileName();
+            if (!file)
+                continue;
+            const normalizedFile = file.replace(/\\/g, '/');
+            // Skip internal node_modules, node built-ins, and pw-core source/dist files
+            if (normalizedFile.includes('node_modules') ||
+                normalizedFile.includes('pw-core/src') ||
+                normalizedFile.includes('pw-core/dist') ||
+                normalizedFile.includes('playwright/lib') ||
+                normalizedFile.includes('@playwright') ||
+                normalizedFile.startsWith('node:') ||
+                !normalizedFile.includes('/')) {
+                continue;
+            }
+            const line = frame.getLineNumber();
+            const column = frame.getColumnNumber();
+            if (!line)
+                continue;
+            return { file, line, column: column ?? 1 };
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        Error.prepareStackTrace = originalPrepareStackTrace;
+    }
+}

package/dist/page/utils/formatter.js

@@ -15,7 +15,14 @@ function formatStepDescription(methodName, target, args) {
     const targetStr = formatTarget(target);
     if (methodName === 'fill' && args[0] !== undefined) {
         const options = args[1];
-        const shouldMask = !(options && typeof options === 'object' && options.mask === false);
+        let shouldMask = false;
+        if (options && typeof options === 'object' && options.mask !== undefined) {
+            shouldMask = options.mask === true;
+        }
+        else {
+            const targetStrLower = targetStr.toLowerCase();
+            shouldMask = targetStrLower.includes('pass') || targetStrLower.includes('pw');
+        }
         const displayValue = shouldMask ? '*'.repeat(String(args[0]).length) : args[0];
         return `Fill "${targetStr}" with "${displayValue}"`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pw-core",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "workspaces": [
     "examples",
     "create-pw-core"