@saucebase/laravel-playwright 1.0.0 → 2.0.1

package/README.md

@@ -45,9 +45,10 @@ return [
 
     /**
      * The environments in which the testing endpoints are enabled.
-     * CAUTION: Enabling testing endpoints in production is a critical security issue.
+     * CAUTION: the endpoints run arbitrary PHP and SQL. Never enable them in
+     * production, nor in `local`, the environment your own dev server runs in.
      */
-    'environments' => ['local', 'testing'],
+    'environments' => ['e2e', 'testing'],
 
     /**
      * Optional secret token to authenticate Playwright requests.
@@ -88,6 +89,45 @@ export default defineConfig<LaravelOptions>({
 });
 ```
 
+## 🏝️ A dedicated environment
+
+Run the suite on its own server and database, so it never touches your dev app or its data. This works the same however you serve the app day to day: Herd, Valet, Sail, Docker or `artisan serve`.
+
+**1. Create `.env.e2e`.** Copy `.env` and give it its own database and port:
+
+```dotenv
+APP_ENV=e2e
+APP_URL=http://localhost:8100
+DB_CONNECTION=sqlite
+DB_DATABASE=database/e2e.sqlite
+SESSION_DRIVER=file
+CACHE_STORE=file
+QUEUE_CONNECTION=sync
+MAIL_MAILER=log
+```
+
+Keep `.env.e2e` out of git like `.env`.
+
+**2. Let Playwright start the server:**
+
+```ts
+import { defineConfig } from '@playwright/test';
+import { laravelServer, type LaravelOptions } from '@saucebase/laravel-playwright';
+
+export default defineConfig<LaravelOptions>({
+    use: { baseURL: 'http://localhost:8100' },
+    webServer: laravelServer(),   // migrate, then php artisan serve --env=e2e on APP_URL's port
+});
+```
+
+`laravelServer({ env, host, workers, cwd, migrate })` returns a Playwright `webServer` entry. It serves the app on the port of `.env.e2e`'s `APP_URL` and waits on that URL, because an app that tells tenants apart by host answers 404 on any other. It migrates the database first (creating the SQLite file if needed), because an app that reads the database on every request, such as a tenant lookup at boot, can't be migrated over HTTP while its tables are missing. Pass `migrate: false` to skip that. It sets `APP_ENV` and `PHP_CLI_SERVER_WORKERS` (4 by default) for the server, and reuses a running one outside CI. It gives the server its own config, route and event caches (`bootstrap/cache/e2e/`). A config you cached with `config:cache` would otherwise skip every env file and give the server your dev database. It refuses to start if:
+
+- `.env.e2e` is missing, because Laravel would then fall back to `.env`.
+- `APP_URL` is missing or not `http:`. `artisan serve` has no TLS.
+- The Playwright process already has another `APP_ENV`. The server inherits the process's environment, and real environment variables override any env file, so `import 'dotenv/config'` (which loads `.env`) would give the server your dev database. To read values from `.env.e2e` in the config, use `config({ path: '.env.e2e' })` from dotenv.
+
+**Subdomains and multi-tenancy.** Chromium resolves every `*.localhost` to your machine, so `http://acme.localhost:8100` reaches the same server with no DNS or hosts-file setup. To use a real wildcard host instead (Herd or Valet `*.app.test`), skip `laravelServer()` and point `baseURL` at that host, served with `APP_ENV=e2e`.
+
 ## 🔒 Security
 
 The package supports an optional shared secret to prevent unauthorized access to the testing endpoints.
@@ -205,7 +245,13 @@ test('example', async ({ laravel }) => {
 
 ## 🔄 Dynamic Configuration
 
-You can update Laravel config for **ALL** subsequent requests until the test ends.
+You can update Laravel config for every subsequent request **of the same test**, until the test ends.
+
+The state is kept per test. The `laravel` fixture gives each test an id and sends it in an `X-Playwright-Test` header, on its own calls and on the browser's requests to the app. The server applies a test's state only to requests that carry its id. Parallel tests never see or remove each other's config, time or boot functions, and requests without the header (your own browser, a queue worker) see none.
+
+- Only requests to the app carry the header: the `baseURL` host and its subdomains. Third-party requests (Stripe, CDNs) are left alone, so no CORS preflight fails. Override the match with the `laravelIsAppUrl: (url: URL) => boolean` option.
+- The header is added with `context.route()`. If you add your own route for app URLs, call `route.fallback()`, not `route.continue()`, so the header is still added.
+- A context you create yourself (`browser.newContext()`) doesn't get the header.
 
 ```ts
 import { test } from '@saucebase/laravel-playwright';
@@ -283,7 +329,19 @@ test('checkout with fake payment gateway', async ({ laravel, page }) => {
 > **Why not use `callFunction` instead?**
 > `callFunction` runs once and returns. `registerBootFunction` runs at the start of **every** request the browser makes during the test, so service bindings registered in the boot phase are in place for the full request lifecycle — including middleware, controllers, and event listeners.
 
-> **Note:** The helper class only needs to exist in your `local` and `testing` environments. You can guard it with an environment check or keep it out of production deployments entirely.
+> **Note:** The helper class only needs to exist in your `e2e` and `testing` environments. You can guard it with an environment check or keep it out of production deployments entirely.
+
+## 🤖 Laravel Boost
+
+The package ships a [Laravel Boost](https://laravel.com/docs/boost) guideline and a `laravel-playwright-development` skill, covering the e2e environment, per-test state, subdomains and common failures. Boost asks before including third-party packages: pick `saucebase/laravel-playwright` in `php artisan boost:install`, or add it to `packages` in `boost.json` and run `php artisan boost:update`.
+
+## ⬆️ Upgrading from v1
+
+- **The endpoints are off in `local`.** The default `environments` is now `['e2e', 'testing']`. Serve the suite with `APP_ENV=e2e` (see [A dedicated environment](#️-a-dedicated-environment)). If you published the config, update `environments` there.
+- **Dynamic config, `travel()` and boot functions are per test.** State moved from `storage/laravel-playwright-config.json` to `storage/framework/playwright/<test-id>.json`, and only applies to requests that carry the test's `X-Playwright-Test` header. The fixture sends the header for you. If you call the endpoints from your own client, send it yourself; `dynamicConfig`, `travel` and `registerBootFunction` return 400 without it.
+- `DynamicConfig::set()`, `get()`, `getAll()`, `load()` and `delete()` now take the test id as their first argument.
+- **Artisan commands run from the application root**, like the CLI, rather than the web server's `public/`.
+- Requires Laravel 12 or 13.
 
 ## 🙏 Credits
 

package/dist/config.d.ts

@@ -0,0 +1,42 @@
+export interface LaravelServerOptions {
+    /** The environment to serve; `.env.<env>` is loaded, and its APP_URL is where the app is served. @default 'e2e' */
+    env?: string;
+    /** The address to bind. @default '127.0.0.1' */
+    host?: string;
+    /** PHP_CLI_SERVER_WORKERS, so parallel tests are not served one request at a time. @default 4 */
+    workers?: number;
+    /** The application root. @default process.cwd() */
+    cwd?: string;
+    /**
+     * Migrate before serving. An app that reads the database on every request (a
+     * tenant lookup at boot) cannot be migrated over HTTP while its tables are missing.
+     * @default true
+     */
+    migrate?: boolean;
+}
+/**
+ * A Playwright `webServer` entry serving the app in its own environment.
+ *
+ * The suite then never touches the developer's own server or database, whatever
+ * serves those (Herd, Valet, Sail, Docker or `artisan serve`): `.env.<env>` names
+ * its own database and APP_URL, and nothing else is shared.
+ */
+export declare function laravelServer(options?: LaravelServerOptions): {
+    command: string;
+    url: string;
+    cwd: string;
+    env: {
+        APP_ENV: string;
+        PHP_CLI_SERVER_WORKERS: string;
+        APP_CONFIG_CACHE: string;
+        APP_ROUTES_CACHE: string;
+        APP_EVENTS_CACHE: string;
+    };
+    reuseExistingServer: boolean;
+};
+/**
+ * Whether a request goes to the app: the base URL's host or one of its subdomains,
+ * on any port, so subdomain multi-tenancy is covered. Third parties are not, so the
+ * test header never turns their requests into failing CORS preflights.
+ */
+export declare function isAppUrl(url: URL, baseURL: string | undefined): boolean;

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 import { APIRequestContext } from '@playwright/test';
+export { isAppUrl, laravelServer, type LaravelServerOptions } from './config.ts';
+/** Ties a request to the test that made it, so its state applies to it alone. */
+export declare const TEST_HEADER = "X-Playwright-Test";
 export interface LaravelOptions {
     /**
      * The base URL to the endpoints
@@ -9,16 +12,24 @@ export interface LaravelOptions {
      * Optional secret token sent as X-Playwright-Secret header
      */
     laravelSecret: string | undefined;
+    /**
+     * Which browser requests go to the app and carry the test header.
+     * @default the base URL's host and its subdomains
+     */
+    laravelIsAppUrl: ((url: URL) => boolean) | undefined;
 }
 interface LaravelFixtures {
     laravel: Laravel;
+    /** Unique per test; the server keeps each test's config, time and boot functions apart by it. */
+    laravelTestId: string;
 }
 export declare const test: import('playwright/test').TestType<import('playwright/test').PlaywrightTestArgs & import('playwright/test').PlaywrightTestOptions & LaravelFixtures & LaravelOptions, import('playwright/test').PlaywrightWorkerArgs & import('playwright/test').PlaywrightWorkerOptions>;
 export declare class Laravel {
     private baseUrl;
     private request;
     private secret;
-    constructor(baseUrl: string, request: APIRequestContext, secret?: string | undefined);
+    readonly testId: string;
+    constructor(baseUrl: string, request: APIRequestContext, secret?: string | undefined, testId?: string);
     call<T = unknown>(endpoint: string, data?: object): Promise<T>;
     artisan(command: string, parameters?: string[]): Promise<{
         code: number;
@@ -49,4 +60,3 @@ export declare class Laravel {
     registerBootFunction(func: string): Promise<unknown>;
     tearDown(): Promise<unknown>;
 }
-export {};

package/dist/laravel-playwright.js

@@ -1,60 +1,120 @@
-import { test as i } from "@playwright/test";
-const u = i.extend({
+import { test as h } from "@playwright/test";
+import { existsSync as p, readFileSync as u } from "node:fs";
+import { join as v } from "node:path";
+import { parseEnv as w } from "node:util";
+function m(s = {}) {
+  const { env: t = "e2e", host: e = "127.0.0.1", workers: a = 4, cwd: r = process.cwd(), migrate: n = !0 } = s, o = v(r, `.env.${t}`);
+  if (!p(o))
+    throw new Error(`laravelServer: create .env.${t} in ${r}, with its own database, before running the suite.`);
+  if (process.env.APP_ENV !== void 0 && process.env.APP_ENV !== t)
+    throw new Error(
+      `laravelServer: the Playwright process has APP_ENV=${process.env.APP_ENV}, so another env file was loaded and its values would override .env.${t}. Load .env.${t} instead (dotenv config({ path: '.env.${t}' })) or none.`
+    );
+  const i = w(u(o, "utf8")).APP_URL;
+  if (!i)
+    throw new Error(`laravelServer: set APP_URL in .env.${t}, e.g. http://localhost:8100.`);
+  const c = new URL(i);
+  if (c.protocol !== "http:")
+    throw new Error(`laravelServer: APP_URL in .env.${t} must be http: (artisan serve has no TLS), got ${i}.`);
+  return {
+    command: [
+      n && `php artisan migrate --env=${t} --force`,
+      // --no-reload: without it artisan serve ignores PHP_CLI_SERVER_WORKERS.
+      `php artisan serve --env=${t} --host=${e} --port=${c.port || 80} --no-reload`
+    ].filter(Boolean).join(" && "),
+    url: c.origin,
+    cwd: r,
+    env: {
+      APP_ENV: t,
+      PHP_CLI_SERVER_WORKERS: String(a),
+      // A cached config skips every env file, so the developer's `config:cache`
+      // would hand this server (and its migrate) their database. Cached routes
+      // were built without the e2e endpoints. Laravel reads these paths from the
+      // environment, so the e2e server gets caches of its own.
+      APP_CONFIG_CACHE: `bootstrap/cache/${t}/config.php`,
+      APP_ROUTES_CACHE: `bootstrap/cache/${t}/routes.php`,
+      APP_EVENTS_CACHE: `bootstrap/cache/${t}/events.php`
+    },
+    reuseExistingServer: !process.env.CI
+  };
+}
+function d(s, t) {
+  if (!t)
+    return !1;
+  const e = new URL(t).hostname;
+  return s.hostname === e || s.hostname.endsWith(`.${e}`);
+}
+const l = "X-Playwright-Test", g = h.extend({
   laravelBaseUrl: [void 0, { option: !0 }],
   laravelSecret: [void 0, { option: !0 }],
-  laravel: async ({ laravelBaseUrl: s, laravelSecret: t, baseURL: a, request: e }, n) => {
-    const r = s || a + "/playwright", c = new l(r, e, t);
-    await n(c), await c.tearDown();
+  laravelIsAppUrl: [void 0, { option: !0 }],
+  laravelTestId: async ({}, s) => {
+    await s(crypto.randomUUID());
+  },
+  /**
+   * Adds the test header to the browser's requests to the app only. `extraHTTPHeaders`
+   * would send it to third parties too, turning their requests into CORS preflights
+   * that fail. `fallback()` lets any route registered later still handle the request.
+   */
+  context: async ({ context: s, baseURL: t, laravelIsAppUrl: e, laravelTestId: a }, r) => {
+    const n = e ?? ((o) => d(o, t));
+    await s.route(n, (o) => o.fallback({
+      headers: { ...o.request().headers(), [l]: a }
+    })), await r(s);
+  },
+  laravel: async ({ laravelBaseUrl: s, laravelSecret: t, laravelTestId: e, baseURL: a, request: r }, n) => {
+    const o = s || a + "/playwright", i = new f(o, r, t, e);
+    await n(i), await i.tearDown();
   }
 });
-class l {
-  constructor(t, a, e = void 0) {
-    this.baseUrl = t, this.request = a, this.secret = e;
+class f {
+  constructor(t, e, a = void 0, r = crypto.randomUUID()) {
+    this.baseUrl = t, this.request = e, this.secret = a, this.testId = r;
   }
-  async call(t, a = {}) {
-    const e = this.baseUrl.replace(/\/$/, "") + t, n = { Accept: "application/json" };
-    this.secret && (n["X-Playwright-Secret"] = this.secret);
-    const r = await this.request.post(e, { data: a, headers: n });
-    if (r.status() !== 200)
+  async call(t, e = {}) {
+    const a = this.baseUrl.replace(/\/$/, "") + t, r = { Accept: "application/json", [l]: this.testId };
+    this.secret && (r["X-Playwright-Secret"] = this.secret);
+    const n = await this.request.post(a, { data: e, headers: r });
+    if (n.status() !== 200)
       throw new Error(`
                 Failed to call Laravel ${t}.
-                Status: ${r.status()}
-                Response: ${await r.text()}
+                Status: ${n.status()}
+                Response: ${await n.text()}
             `);
-    return await r.json();
+    return await n.json();
   }
-  async artisan(t, a = []) {
-    return await this.call("/artisan", { command: t, parameters: a });
+  async artisan(t, e = []) {
+    return await this.call("/artisan", { command: t, parameters: e });
   }
   async truncate(t = []) {
     return await this.call("/truncate", { connections: t });
   }
-  async factory(t, a = {}, e) {
-    return await this.call("/factory", { model: t, count: e, attrs: a });
+  async factory(t, e = {}, a) {
+    return await this.call("/factory", { model: t, count: a, attrs: e });
   }
-  async query(t, a = [], e = {}) {
-    const { connection: n = null, unprepared: r = !1 } = e;
-    if (r && a.length > 0)
+  async query(t, e = [], a = {}) {
+    const { connection: r = null, unprepared: n = !1 } = a;
+    if (n && e.length > 0)
       throw new Error("Cannot use unprepared with bindings");
     return await this.call("/query", {
       query: t,
-      bindings: a,
-      connection: n,
-      unprepared: r
+      bindings: e,
+      connection: r,
+      unprepared: n
     });
   }
-  async select(t, a = {}, e = {}) {
-    const { connection: n = null } = e;
-    return await this.call("/select", { query: t, bindings: a, connection: n });
+  async select(t, e = {}, a = {}) {
+    const { connection: r = null } = a;
+    return await this.call("/select", { query: t, bindings: e, connection: r });
   }
-  async callFunction(t, a = []) {
-    return await this.call("/function", { function: t, args: a });
+  async callFunction(t, e = []) {
+    return await this.call("/function", { function: t, args: e });
   }
   /**
    * Sets a laravel config value until tearDown is called (or the test ends)
    */
-  async config(t, a) {
-    return await this.call("/dynamicConfig", { key: t, value: a });
+  async config(t, e) {
+    return await this.call("/dynamicConfig", { key: t, value: e });
   }
   /**
    * Travel to a specific time
@@ -71,6 +131,9 @@ class l {
   }
 }
 export {
-  l as Laravel,
-  u as test
+  f as Laravel,
+  l as TEST_HEADER,
+  d as isAppUrl,
+  m as laravelServer,
+  g as test
 };

package/dist/laravel-playwright.umd.cjs

@@ -1,5 +1,5 @@
-(function(r,i){typeof exports=="object"&&typeof module<"u"?i(exports,require("@playwright/test")):typeof define=="function"&&define.amd?define(["exports","@playwright/test"],i):(r=typeof globalThis<"u"?globalThis:r||self,i(r.LaravelPlaywright={},r.PlaywrightTest))})(this,(function(r,i){"use strict";const u=i.test.extend({laravelBaseUrl:[void 0,{option:!0}],laravelSecret:[void 0,{option:!0}],laravel:async({laravelBaseUrl:l,laravelSecret:t,baseURL:e,request:a},s)=>{const n=l||e+"/playwright",o=new c(n,a,t);await s(o),await o.tearDown()}});class c{constructor(t,e,a=void 0){this.baseUrl=t,this.request=e,this.secret=a}async call(t,e={}){const a=this.baseUrl.replace(/\/$/,"")+t,s={Accept:"application/json"};this.secret&&(s["X-Playwright-Secret"]=this.secret);const n=await this.request.post(a,{data:e,headers:s});if(n.status()!==200)throw new Error(`
-                Failed to call Laravel ${t}.
-                Status: ${n.status()}
-                Response: ${await n.text()}
-            `);return await n.json()}async artisan(t,e=[]){return await this.call("/artisan",{command:t,parameters:e})}async truncate(t=[]){return await this.call("/truncate",{connections:t})}async factory(t,e={},a){return await this.call("/factory",{model:t,count:a,attrs:e})}async query(t,e=[],a={}){const{connection:s=null,unprepared:n=!1}=a;if(n&&e.length>0)throw new Error("Cannot use unprepared with bindings");return await this.call("/query",{query:t,bindings:e,connection:s,unprepared:n})}async select(t,e={},a={}){const{connection:s=null}=a;return await this.call("/select",{query:t,bindings:e,connection:s})}async callFunction(t,e=[]){return await this.call("/function",{function:t,args:e})}async config(t,e){return await this.call("/dynamicConfig",{key:t,value:e})}async travel(t){return await this.call("/travel",{to:t})}async registerBootFunction(t){return await this.call("/registerBootFunction",{function:t})}async tearDown(){return await this.call("/tearDown")}}r.Laravel=c,r.test=u,Object.defineProperty(r,Symbol.toStringTag,{value:"Module"})}));
+(function(n,l){typeof exports=="object"&&typeof module<"u"?l(exports,require("@playwright/test"),require("node:fs"),require("node:path"),require("node:util")):typeof define=="function"&&define.amd?define(["exports","@playwright/test","node:fs","node:path","node:util"],l):(n=typeof globalThis<"u"?globalThis:n||self,l(n.LaravelPlaywright={},n.PlaywrightTest,n.node_fs,n.node_path,n.node_util))})(this,(function(n,l,p,d,f){"use strict";function y(o={}){const{env:e="e2e",host:t="127.0.0.1",workers:a=4,cwd:r=process.cwd(),migrate:s=!0}=o,i=d.join(r,`.env.${e}`);if(!p.existsSync(i))throw new Error(`laravelServer: create .env.${e} in ${r}, with its own database, before running the suite.`);if(process.env.APP_ENV!==void 0&&process.env.APP_ENV!==e)throw new Error(`laravelServer: the Playwright process has APP_ENV=${process.env.APP_ENV}, so another env file was loaded and its values would override .env.${e}. Load .env.${e} instead (dotenv config({ path: '.env.${e}' })) or none.`);const c=f.parseEnv(p.readFileSync(i,"utf8")).APP_URL;if(!c)throw new Error(`laravelServer: set APP_URL in .env.${e}, e.g. http://localhost:8100.`);const u=new URL(c);if(u.protocol!=="http:")throw new Error(`laravelServer: APP_URL in .env.${e} must be http: (artisan serve has no TLS), got ${c}.`);return{command:[s&&`php artisan migrate --env=${e} --force`,`php artisan serve --env=${e} --host=${t} --port=${u.port||80} --no-reload`].filter(Boolean).join(" && "),url:u.origin,cwd:r,env:{APP_ENV:e,PHP_CLI_SERVER_WORKERS:String(a),APP_CONFIG_CACHE:`bootstrap/cache/${e}/config.php`,APP_ROUTES_CACHE:`bootstrap/cache/${e}/routes.php`,APP_EVENTS_CACHE:`bootstrap/cache/${e}/events.php`},reuseExistingServer:!process.env.CI}}function v(o,e){if(!e)return!1;const t=new URL(e).hostname;return o.hostname===t||o.hostname.endsWith(`.${t}`)}const h="X-Playwright-Test",P=l.test.extend({laravelBaseUrl:[void 0,{option:!0}],laravelSecret:[void 0,{option:!0}],laravelIsAppUrl:[void 0,{option:!0}],laravelTestId:async({},o)=>{await o(crypto.randomUUID())},context:async({context:o,baseURL:e,laravelIsAppUrl:t,laravelTestId:a},r)=>{const s=t??(i=>v(i,e));await o.route(s,i=>i.fallback({headers:{...i.request().headers(),[h]:a}})),await r(o)},laravel:async({laravelBaseUrl:o,laravelSecret:e,laravelTestId:t,baseURL:a,request:r},s)=>{const i=o||a+"/playwright",c=new w(i,r,e,t);await s(c),await c.tearDown()}});class w{constructor(e,t,a=void 0,r=crypto.randomUUID()){this.baseUrl=e,this.request=t,this.secret=a,this.testId=r}async call(e,t={}){const a=this.baseUrl.replace(/\/$/,"")+e,r={Accept:"application/json",[h]:this.testId};this.secret&&(r["X-Playwright-Secret"]=this.secret);const s=await this.request.post(a,{data:t,headers:r});if(s.status()!==200)throw new Error(`
+                Failed to call Laravel ${e}.
+                Status: ${s.status()}
+                Response: ${await s.text()}
+            `);return await s.json()}async artisan(e,t=[]){return await this.call("/artisan",{command:e,parameters:t})}async truncate(e=[]){return await this.call("/truncate",{connections:e})}async factory(e,t={},a){return await this.call("/factory",{model:e,count:a,attrs:t})}async query(e,t=[],a={}){const{connection:r=null,unprepared:s=!1}=a;if(s&&t.length>0)throw new Error("Cannot use unprepared with bindings");return await this.call("/query",{query:e,bindings:t,connection:r,unprepared:s})}async select(e,t={},a={}){const{connection:r=null}=a;return await this.call("/select",{query:e,bindings:t,connection:r})}async callFunction(e,t=[]){return await this.call("/function",{function:e,args:t})}async config(e,t){return await this.call("/dynamicConfig",{key:e,value:t})}async travel(e){return await this.call("/travel",{to:e})}async registerBootFunction(e){return await this.call("/registerBootFunction",{function:e})}async tearDown(){return await this.call("/tearDown")}}n.Laravel=w,n.TEST_HEADER=h,n.isAppUrl=v,n.laravelServer=y,n.test=P,Object.defineProperty(n,Symbol.toStringTag,{value:"Module"})}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saucebase/laravel-playwright",
-  "version": "v1.0.0",
+  "version": "v2.0.1",
   "description": "Blends Laravel and Playwright into seamless E2E tests — factories, queries, artisan commands, and time travel.",
   "license": "MIT",
   "repository": {
@@ -13,7 +13,8 @@
   "homepage": "https://github.com/saucebase-dev/laravel-playwright",
   "type": "module",
   "scripts": {
-    "build": "tsc && vite build"
+    "build": "tsc && vite build",
+    "test": "node --test 'src/playwright/tests/*.test.ts'"
   },
   "devDependencies": {
     "@types/node": "^25.3.1",