@cronn/playwright-utils 0.5.0 → 0.7.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
+import { APIRequestContext, APIResponse, ConsoleMessage, Fixtures, Locator, Page, PlaywrightTestArgs, PlaywrightTestOptions, Request, Response, Route } from "@playwright/test";
 import { Normalizer } from "@cronn/playwright-file-snapshots";
-import { APIRequestContext, APIResponse, ConsoleMessage, Locator, Page, Request, Response, Route } from "@playwright/test";
 //#region src/environment.d.ts
 /**
  * Whether the current process runs in a CI environment, based on the `CI`
@@ -7,7 +7,7 @@ import { APIRequestContext, APIResponse, ConsoleMessage, Locator, Page, Request,
  *
  * Evaluated once when the module is loaded.
  */
-declare const isCI: boolean;
+export declare const isCI: boolean;
 //#endregion
 //#region src/api/fetch-adapter.d.ts
 type FetchAPI = typeof fetch;
@@ -21,7 +21,7 @@ type FetchAPI = typeof fetch;
  * @param requestContext - Playwright request context to send requests with
  * @returns A function with the signature of the global `fetch`
  */
-declare function createFetchAdapter(requestContext: APIRequestContext): FetchAPI;
+export declare function createFetchAdapter(requestContext: APIRequestContext): FetchAPI;
 //#endregion
 //#region src/capturing/console-captor.d.ts
 /**
@@ -57,7 +57,7 @@ type ConsoleMessageLevel = ReturnType<ConsoleMessage["type"]>;
  * ]);
  * ```
  */
-declare class ConsoleCaptor {
+export declare class ConsoleCaptor {
   private readonly page;
   private readonly consoleListener;
   /**
@@ -166,12 +166,9 @@ declare class ConsoleCaptor {
  * @example
  * ```ts
  * const errorCaptor = captureConsole(page, "error");
- * const cspCaptor = captureConsole(page, message =>
- *     hasLogLevel(message, "warning", "error") && message.text().includes("Content Security Policy")
- * );
  * ```
  */
-declare function captureConsole(page: Page, levelOrFilter?: ConsoleMessageLevel | Array<ConsoleMessageLevel> | ConsoleMessageFilter): ConsoleCaptor;
+export declare function captureConsole(page: Page, levelOrFilter?: ConsoleMessageLevel | Array<ConsoleMessageLevel> | ConsoleMessageFilter): ConsoleCaptor;
 /**
  * Tests whether the given console message has one of the specified log levels.
  *
@@ -181,7 +178,154 @@ declare function captureConsole(page: Page, levelOrFilter?: ConsoleMessageLevel
  * @param level - The log level
  * @returns True if the message has one of the given log levels
  */
-declare function hasLogLevel(message: ConsoleMessage, ...level: Array<ConsoleMessageLevel>): boolean;
+export declare function hasLogLevel(message: ConsoleMessage, ...level: Array<ConsoleMessageLevel>): boolean;
+//#endregion
+//#region src/capturing/csp-captor.d.ts
+/**
+ * A Content Security Policy violation, as reported by the browser's
+ * [`securitypolicyviolation`](https://developer.mozilla.org/en-US/docs/Web/API/Document/securitypolicyviolation_event) event.
+ */
+type CspViolation = SecurityPolicyViolationEventInit;
+/**
+ * Collects the Content Security Policy violations of a page.
+ *
+ * Browsers report CSP violations through the `securitypolicyviolation` DOM event,
+ * which is not otherwise exposed by Playwright. A captor registers a listener for
+ * this event on every document of the page and collects the reported violations,
+ * and can limit the capturing to a single action.
+ *
+ * Several captors can run on the same page at the same time, and every captor
+ * receives all violations independently.
+ *
+ * @example
+ * ```ts
+ * const violations = captureCspViolations(page);
+ *
+ * await violations.during(() => page.goto("/users"));
+ *
+ * expect(violations.violations).toEqual([]);
+ * ```
+ */
+export declare class CspCaptor {
+  private readonly page;
+  private readonly bindingName;
+  private initialized;
+  private capturing;
+  /**
+   * The captured violations, in the order in which the page reported them.
+   *
+   * The array is filled while the captor is running, so it can also be
+   * inspected inside the action passed to {@link during}.
+   */
+  readonly violations: Array<CspViolation>;
+  /**
+   * Create a captor for the CSP violations of a page.
+   *
+   * The captor does not collect anything until it is started, either by
+   * {@link startCapture} or by {@link during}.
+   *
+   * @param page - The page to capture CSP violations of
+   */
+  constructor(page: Page);
+  private ensureInitialized;
+  /**
+   * Start collecting the CSP violations of the page.
+   *
+   * A captor can be started and stopped repeatedly; the collected violations are
+   * kept across restarts.
+   *
+   * Because violations are captured through an init script, {@link startCapture}
+   * has to be called before the page navigates for violations of the initial
+   * load to be captured.
+   */
+  startCapture(): Promise<void>;
+  /**
+   * Stop collecting the CSP violations of the page.
+   *
+   * The already captured {@link violations} are kept.
+   */
+  stopCapture(): void;
+  /**
+   * Remove all captured {@link violations}.
+   */
+  clearViolations(): void;
+  /**
+   * Collect the CSP violations reported while the callback runs.
+   *
+   * The capturing is stopped once the action has finished, even if it throws.
+   * A promise returned by the action is awaited before the captor stops, no
+   * matter when it is awaited by the caller.
+   *
+   * @param action - The action to capture CSP violations during
+   * @returns The value of the action
+   *
+   * @example
+   * ```ts
+   * const captor = captureCspViolations(page);
+   *
+   * await captor.during(() => page.goto("/users"));
+   *
+   * expect(captor.violations).toEqual([]);
+   * ```
+   */
+  during<T>(action: () => Promise<T>): Promise<T>;
+}
+/**
+ * Factory method to create a {@link CspCaptor}.
+ *
+ * @param page - The page to capture CSP violations for
+ * @returns CspCaptor
+ *
+ * @example
+ * ```ts
+ * const captor = captureCspViolations(page);
+ * ```
+ */
+export declare function captureCspViolations(page: Page): CspCaptor;
+interface CspFixtures {
+  /**
+   * A {@link CspCaptor} capturing every CSP violation of the page, available for
+   * tests that want to trigger and assert on a specific violation.
+   */
+  cspCaptor: CspCaptor;
+  /**
+   * Option fixture controlling whether {@link cspFixtures} skips failing
+   * a test that produced unexpected CSP violations.
+   *
+   * @default false
+   */
+  ignoreCspViolations: boolean;
+}
+/**
+ * Playwright fixtures reporting Content Security Policy violations for every test.
+ *
+ * `cspCaptor` is installed automatically on the page fixture and, by default, fails
+ * a test if it produced any CSP violation. Disable this for an individual test with
+ * `test.use({ ignoreCspViolations: true })`, and inspect `cspCaptor.violations`
+ * manually for tests targeting CSP behavior specifically.
+ *
+ * @example
+ * ```ts
+ * import { cspFixtures, type CspFixtures } from "@cronn/playwright-utils";
+ * import { test as base } from "@playwright/test";
+ *
+ * export const test = base.extend<CspFixtures>({
+ *   ...cspFixtures,
+ *   // ...other fixtures
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * test.use({ ignoreCspViolations: true });
+ *
+ * test("shows a warning banner on CSP violation", async ({ page, cspCaptor }) => {
+ *   await page.getByRole("button", { name: "Load untrusted script" }).click();
+ *   expect(cspCaptor.violations).toHaveLength(1);
+ * });
+ * ```
+ */
+export declare const cspFixtures: Fixtures<CspFixtures, object, PlaywrightTestArgs & PlaywrightTestOptions>;
 //#endregion
 //#region src/api/route-interceptor/filter.d.ts
 /**
@@ -211,7 +355,7 @@ interface RouteFilter {
  *   });
  * ```
  */
-declare function matchPath(pattern: RegExp | string): RouteFilter;
+export declare function matchPath(pattern: RegExp | string): RouteFilter;
 //#endregion
 //#region src/api/route-interceptor/response-handler.d.ts
 /**
@@ -236,7 +380,7 @@ type ResponseHandler = (response: APIResponse) => Promise<FulfillOptions> | Fulf
  *   });
  * ```
  */
-declare function modifyJsonBody<T>(modifier: (body: T) => T): ResponseHandler;
+export declare function modifyJsonBody<T>(modifier: (body: T) => T): ResponseHandler;
 /**
  * Helper to create a {@link ResponseHandler} that modifies the response body as a plaintext string.
  *
@@ -252,7 +396,7 @@ declare function modifyJsonBody<T>(modifier: (body: T) => T): ResponseHandler;
  *   });
  * ```
  */
-declare function modifyTextBody(modifier: (body: string) => string): ResponseHandler;
+export declare function modifyTextBody(modifier: (body: string) => string): ResponseHandler;
 //#endregion
 //#region src/api/route-interceptor/interceptor.d.ts
 type Action<T> = () => Promise<T> | T;
@@ -260,7 +404,7 @@ type FulfillOptions = Parameters<Route["fulfill"]>[0];
 /**
  * Entrypoint to create various network interceptors using the {@link Page#route} API.
  */
-declare class RouteInterceptor {
+export declare class RouteInterceptor {
   readonly page: Page;
   readonly filter: RouteFilter;
   constructor(page: Page, filter: RouteFilter);
@@ -398,7 +542,7 @@ declare class ExecutableRouteInterceptor {
  *   });
  * ```
  */
-declare function interceptRoute(page: Page, filter: RouteFilter): RouteInterceptor;
+export declare function interceptRoute(page: Page, filter: RouteFilter): RouteInterceptor;
 /**
  * Base class to build re-usable route interceptors.
  *
@@ -428,7 +572,7 @@ declare function interceptRoute(page: Page, filter: RouteFilter): RouteIntercept
  * });
  * ```
  */
-declare class RouteInterceptorFixture {
+export declare class RouteInterceptorFixture {
   private readonly page;
   constructor(page: Page);
   /**
@@ -460,7 +604,42 @@ declare class RouteInterceptorFixture {
  * @returns The absolute path to the resolved location
  * @throws If no package root can be found
  */
-declare function resolveFromPackageRoot(...paths: Array<string>): string;
+export declare function resolveFromPackageRoot(...paths: Array<string>): string;
+//#endregion
+//#region src/page-object-model/locator-extensions.d.ts
+type RoleLocators = Record<Role, RoleLocator>;
+interface RoleLocator {
+  (options?: RoleLocatorOptions): Locator;
+  (name: string | RegExp, options?: RoleLocatorOptions): Locator;
+}
+type RoleLocatorOptions = Omit<GetByRoleOptions, "name">;
+type Role = Parameters<Locator["getByRole"]>[0];
+type GetByRoleOptions = Parameters<Locator["getByRole"]>[1];
+/**
+ * Creates a set of locator functions for every ARIA role, so tests don't
+ * have to repeat `getByRole` and its role string throughout a page object.
+ *
+ * Every generated locator applies `exact: true` by default, keeping name
+ * matches from accidentally matching unrelated elements with a similar
+ * accessible name. This can be overridden per call through `options`, or
+ * replaced entirely for every locator by passing a custom `defaultOptions`.
+ *
+ * The accessible name can be omitted when an element should be located by
+ * role alone, in which case `options` can be passed as the first argument.
+ *
+ * @param locator - The page or locator to scope the role locators to
+ * @param defaultOptions - Optional. Options applied to every generated locator, overridden by per-call options; defaults to `{ exact: true }`
+ * @returns A `RoleLocators` object with one locator function per ARIA role
+ *
+ * @example
+ * ```ts
+ * const { button, textbox } = roleLocators(page);
+ *
+ * await textbox("Email").fill("user@example.com");
+ * await button("Submit").click();
+ * ```
+ */
+export declare function roleLocators(locator: Pick<Locator, "getByRole">, defaultOptions?: GetByRoleOptions): RoleLocators;
 //#endregion
 //#region src/normalizers/mask-base-url.d.ts
 /**
@@ -469,7 +648,7 @@ declare function resolveFromPackageRoot(...paths: Array<string>): string;
  *
  * @param baseURL - Base URL to mask; if `undefined`, values are left unchanged
  */
-declare function maskBaseURL<TValue>(baseURL: string | undefined): Normalizer<TValue>;
+export declare function maskBaseURL<TValue>(baseURL: string | undefined): Normalizer<TValue>;
 //#endregion
 //#region src/normalizers/masked-value.d.ts
 /**
@@ -478,14 +657,14 @@ declare function maskBaseURL<TValue>(baseURL: string | undefined): Normalizer<TV
  *
  * @param name - Name of the masked value
  */
-declare function maskedValue(name: string): string;
+export declare function maskedValue(name: string): string;
 /**
  * Creates a factory for indexed masked placeholders, e.g. `[USER_1]`.
  *
  * @param name - Name of the masked value
  * @returns A function mapping an index to a masked placeholder
  */
-declare function maskedValueWithIndex(name: string): (index: number) => string;
+export declare function maskedValueWithIndex(name: string): (index: number) => string;
 //#endregion
 //#region src/types/playwright.d.ts
 /**
@@ -494,4 +673,4 @@ declare function maskedValueWithIndex(name: string): (index: number) => string;
  */
 type PlaywrightTarget = Page | Locator;
 //#endregion
-export { ConsoleCaptor, type ConsoleMessageFilter, type ConsoleMessageLevel, type HttpMethod, type PlaywrightTarget, type ResponseHandler, type RouteFilter, RouteInterceptor, RouteInterceptorFixture, captureConsole, createFetchAdapter, hasLogLevel, interceptRoute, isCI, maskBaseURL, maskedValue, maskedValueWithIndex, matchPath, modifyJsonBody, modifyTextBody, resolveFromPackageRoot };
+export type { ConsoleMessageFilter, ConsoleMessageLevel, CspFixtures, CspViolation, HttpMethod, PlaywrightTarget, ResponseHandler, RoleLocators, RouteFilter };

package/dist/index.mjs

@@ -1,3 +1,4 @@
+import { expect } from "@playwright/test";
 import path from "node:path";
 import { packageDirectorySync } from "package-directory";
 import { maskString, stringNormalizer } from "@cronn/playwright-file-snapshots";
@@ -210,9 +211,6 @@ var ConsoleCaptor = class {
 * @example
 * ```ts
 * const errorCaptor = captureConsole(page, "error");
-* const cspCaptor = captureConsole(page, message =>
-*     hasLogLevel(message, "warning", "error") && message.text().includes("Content Security Policy")
-* );
 * ```
 */
 function captureConsole(page, levelOrFilter) {
@@ -234,6 +232,188 @@ function hasLogLevel(message, ...level) {
 	return level.includes(message.type());
 }
 //#endregion
+//#region src/capturing/csp-captor.ts
+let nextBindingId = 0;
+/**
+* Collects the Content Security Policy violations of a page.
+*
+* Browsers report CSP violations through the `securitypolicyviolation` DOM event,
+* which is not otherwise exposed by Playwright. A captor registers a listener for
+* this event on every document of the page and collects the reported violations,
+* and can limit the capturing to a single action.
+*
+* Several captors can run on the same page at the same time, and every captor
+* receives all violations independently.
+*
+* @example
+* ```ts
+* const violations = captureCspViolations(page);
+*
+* await violations.during(() => page.goto("/users"));
+*
+* expect(violations.violations).toEqual([]);
+* ```
+*/
+var CspCaptor = class {
+	page;
+	bindingName = `__playwrightUtilsCspCaptor${nextBindingId++}__`;
+	initialized = false;
+	capturing = false;
+	/**
+	* The captured violations, in the order in which the page reported them.
+	*
+	* The array is filled while the captor is running, so it can also be
+	* inspected inside the action passed to {@link during}.
+	*/
+	violations = [];
+	/**
+	* Create a captor for the CSP violations of a page.
+	*
+	* The captor does not collect anything until it is started, either by
+	* {@link startCapture} or by {@link during}.
+	*
+	* @param page - The page to capture CSP violations of
+	*/
+	constructor(page) {
+		this.page = page;
+	}
+	async ensureInitialized() {
+		if (this.initialized) return;
+		this.initialized = true;
+		await this.page.exposeFunction(this.bindingName, (violation) => {
+			if (this.capturing) this.violations.push(violation);
+		});
+		await this.page.addInitScript((bindingName) => {
+			document.addEventListener("securitypolicyviolation", (event) => {
+				const report = window[bindingName];
+				report({
+					blockedURI: event.blockedURI,
+					disposition: event.disposition,
+					documentURI: event.documentURI,
+					effectiveDirective: event.effectiveDirective,
+					lineNumber: event.lineNumber,
+					columnNumber: event.columnNumber,
+					originalPolicy: event.originalPolicy,
+					referrer: event.referrer,
+					sample: event.sample,
+					sourceFile: event.sourceFile,
+					statusCode: event.statusCode,
+					violatedDirective: event.violatedDirective
+				});
+			});
+		}, this.bindingName);
+	}
+	/**
+	* Start collecting the CSP violations of the page.
+	*
+	* A captor can be started and stopped repeatedly; the collected violations are
+	* kept across restarts.
+	*
+	* Because violations are captured through an init script, {@link startCapture}
+	* has to be called before the page navigates for violations of the initial
+	* load to be captured.
+	*/
+	async startCapture() {
+		await this.ensureInitialized();
+		this.capturing = true;
+	}
+	/**
+	* Stop collecting the CSP violations of the page.
+	*
+	* The already captured {@link violations} are kept.
+	*/
+	stopCapture() {
+		this.capturing = false;
+	}
+	/**
+	* Remove all captured {@link violations}.
+	*/
+	clearViolations() {
+		this.violations.length = 0;
+	}
+	/**
+	* Collect the CSP violations reported while the callback runs.
+	*
+	* The capturing is stopped once the action has finished, even if it throws.
+	* A promise returned by the action is awaited before the captor stops, no
+	* matter when it is awaited by the caller.
+	*
+	* @param action - The action to capture CSP violations during
+	* @returns The value of the action
+	*
+	* @example
+	* ```ts
+	* const captor = captureCspViolations(page);
+	*
+	* await captor.during(() => page.goto("/users"));
+	*
+	* expect(captor.violations).toEqual([]);
+	* ```
+	*/
+	async during(action) {
+		await this.startCapture();
+		try {
+			return await action();
+		} finally {
+			this.stopCapture();
+		}
+	}
+};
+/**
+* Factory method to create a {@link CspCaptor}.
+*
+* @param page - The page to capture CSP violations for
+* @returns CspCaptor
+*
+* @example
+* ```ts
+* const captor = captureCspViolations(page);
+* ```
+*/
+function captureCspViolations(page) {
+	return new CspCaptor(page);
+}
+async function provideCspCaptor({ page, ignoreCspViolations }, use) {
+	const captor = captureCspViolations(page);
+	await captor.startCapture();
+	await use(captor);
+	captor.stopCapture();
+	if (!ignoreCspViolations) expect(captor.violations, "Unexpected CSP violations").toEqual([]);
+}
+/**
+* Playwright fixtures reporting Content Security Policy violations for every test.
+*
+* `cspCaptor` is installed automatically on the page fixture and, by default, fails
+* a test if it produced any CSP violation. Disable this for an individual test with
+* `test.use({ ignoreCspViolations: true })`, and inspect `cspCaptor.violations`
+* manually for tests targeting CSP behavior specifically.
+*
+* @example
+* ```ts
+* import { cspFixtures, type CspFixtures } from "@cronn/playwright-utils";
+* import { test as base } from "@playwright/test";
+*
+* export const test = base.extend<CspFixtures>({
+*   ...cspFixtures,
+*   // ...other fixtures
+* });
+* ```
+*
+* @example
+* ```ts
+* test.use({ ignoreCspViolations: true });
+*
+* test("shows a warning banner on CSP violation", async ({ page, cspCaptor }) => {
+*   await page.getByRole("button", { name: "Load untrusted script" }).click();
+*   expect(cspCaptor.violations).toHaveLength(1);
+* });
+* ```
+*/
+const cspFixtures = {
+	ignoreCspViolations: [false, { option: true }],
+	cspCaptor: [provideCspCaptor, { auto: true }]
+};
+//#endregion
 //#region src/api/route-interceptor/interceptor.ts
 function isFiltered(filter, request) {
 	if (!filter.url(new URL(request.url()))) return false;
@@ -609,6 +789,133 @@ function resolveFromPackageRoot(...paths) {
 	return path.resolve(packageDir, ...paths);
 }
 //#endregion
+//#region src/page-object-model/locator-extensions.ts
+const ROLES = [
+	"alert",
+	"alertdialog",
+	"application",
+	"article",
+	"banner",
+	"blockquote",
+	"button",
+	"caption",
+	"cell",
+	"checkbox",
+	"code",
+	"columnheader",
+	"combobox",
+	"complementary",
+	"contentinfo",
+	"definition",
+	"deletion",
+	"dialog",
+	"directory",
+	"document",
+	"emphasis",
+	"feed",
+	"figure",
+	"form",
+	"generic",
+	"grid",
+	"gridcell",
+	"group",
+	"heading",
+	"img",
+	"insertion",
+	"link",
+	"list",
+	"listbox",
+	"listitem",
+	"log",
+	"main",
+	"marquee",
+	"math",
+	"meter",
+	"menu",
+	"menubar",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"navigation",
+	"none",
+	"note",
+	"option",
+	"paragraph",
+	"presentation",
+	"progressbar",
+	"radio",
+	"radiogroup",
+	"region",
+	"row",
+	"rowgroup",
+	"rowheader",
+	"scrollbar",
+	"search",
+	"searchbox",
+	"separator",
+	"slider",
+	"spinbutton",
+	"status",
+	"strong",
+	"subscript",
+	"superscript",
+	"switch",
+	"tab",
+	"table",
+	"tablist",
+	"tabpanel",
+	"term",
+	"textbox",
+	"time",
+	"timer",
+	"toolbar",
+	"tooltip",
+	"tree",
+	"treegrid",
+	"treeitem"
+];
+const DEFAULT_OPTIONS = { exact: true };
+/**
+* Creates a set of locator functions for every ARIA role, so tests don't
+* have to repeat `getByRole` and its role string throughout a page object.
+*
+* Every generated locator applies `exact: true` by default, keeping name
+* matches from accidentally matching unrelated elements with a similar
+* accessible name. This can be overridden per call through `options`, or
+* replaced entirely for every locator by passing a custom `defaultOptions`.
+*
+* The accessible name can be omitted when an element should be located by
+* role alone, in which case `options` can be passed as the first argument.
+*
+* @param locator - The page or locator to scope the role locators to
+* @param defaultOptions - Optional. Options applied to every generated locator, overridden by per-call options; defaults to `{ exact: true }`
+* @returns A `RoleLocators` object with one locator function per ARIA role
+*
+* @example
+* ```ts
+* const { button, textbox } = roleLocators(page);
+*
+* await textbox("Email").fill("user@example.com");
+* await button("Submit").click();
+* ```
+*/
+function roleLocators(locator, defaultOptions = DEFAULT_OPTIONS) {
+	function getByRole(role) {
+		return (nameOrOptions, options) => {
+			if (typeof nameOrOptions === "string" || nameOrOptions instanceof RegExp) return locator.getByRole(role, {
+				name: nameOrOptions,
+				...defaultOptions,
+				...options
+			});
+			return locator.getByRole(role, {
+				...defaultOptions,
+				...nameOrOptions
+			});
+		};
+	}
+	return Object.fromEntries(ROLES.map((role) => [role, getByRole(role)]));
+}
+//#endregion
 //#region src/normalizers/masked-value.ts
 /**
 * Formats a name as a masked placeholder, e.g. `maskedValue("base url")`
@@ -644,4 +951,4 @@ function identity(value) {
 	return value;
 }
 //#endregion
-export { ConsoleCaptor, RouteInterceptor, RouteInterceptorFixture, captureConsole, createFetchAdapter, hasLogLevel, interceptRoute, isCI, maskBaseURL, maskedValue, maskedValueWithIndex, matchPath, modifyJsonBody, modifyTextBody, resolveFromPackageRoot };
+export { ConsoleCaptor, CspCaptor, RouteInterceptor, RouteInterceptorFixture, captureConsole, captureCspViolations, createFetchAdapter, cspFixtures, hasLogLevel, interceptRoute, isCI, maskBaseURL, maskedValue, maskedValueWithIndex, matchPath, modifyJsonBody, modifyTextBody, resolveFromPackageRoot, roleLocators };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cronn/playwright-utils",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Utilities for writing tests with Playwright",
   "keywords": [
     "playwright",
@@ -33,30 +33,29 @@
   },
   "devDependencies": {
     "@arethetypeswrong/core": "0.18.5",
-    "@changesets/cli": "3.0.1",
-    "@cronn/element-snapshot": "0.28.0",
-    "@cronn/playwright-file-snapshots": "2.2.1",
-    "@playwright/test": "1.62.1",
-    "@types/node": "24.13.3",
+    "@changesets/cli": "3.0.2",
+    "@cronn/element-snapshot": "0.30.0",
+    "@cronn/playwright-file-snapshots": "2.2.2",
+    "@playwright/test": "1.63.0",
+    "@types/node": "24.13.4",
     "@typescript/native": "npm:typescript@^7.0.2",
-    "@vitest/coverage-v8": "4.1.11",
-    "eslint": "10.9.1",
+    "@vitest/coverage-v8": "5.0.0",
+    "eslint": "10.10.0",
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-check-file": "3.3.2",
     "eslint-plugin-unused-imports": "4.4.1",
-    "knip": "6.33.0",
-    "oxc-minify": "0.147.0",
-    "oxfmt": "0.65.0",
+    "knip": "6.35.1",
+    "oxc-minify": "0.149.0",
+    "oxfmt": "0.67.0",
     "publint": "0.3.24",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "turbo": "2.10.12",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "typescript-eslint": "8.68.0",
-    "vitepress": "2.0.0-alpha.19",
+    "typescript-eslint": "8.70.0",
+    "vitepress": "2.0.0-alpha.20",
     "vitepress-plugin-group-icons": "1.7.6",
-    "vitest": "4.1.11",
-    "node": "runtime:24.20.0"
+    "vitest": "5.0.0"
   },
   "peerDependencies": {
     "@cronn/playwright-file-snapshots": "^2",
@@ -65,12 +64,12 @@
   "devEngines": {
     "packageManager": {
       "name": "pnpm",
-      "version": "11.25.0",
+      "version": "12.5.1",
       "onFail": "download"
     },
     "runtime": {
       "name": "node",
-      "version": "24.20.0",
+      "version": "24.21.0",
       "onFail": "download"
     }
   },