@itmetsam/samurai-framework 0.4.0 → 0.6.0

package/dist/flows/steps/api.js

@@ -1,5 +1,8 @@
 import { defineStep } from "./define.js";
-const METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"].map((m) => ({ label: m, value: m }));
+const METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"].map((m) => ({
+    label: m,
+    value: m,
+}));
 const isJson = (text) => {
     try {
         JSON.parse(text);
@@ -16,9 +19,27 @@ export const api = defineStep({
     icon: "globe",
     section: "integrations",
     fields: [
-        { path: "config.method", type: "select", label: "Method", options: METHODS, default: "GET" },
-        { path: "config.url", type: "expression", label: "URL", placeholder: 'env.baseUrl + "/health"', default: "" },
-        { path: "config.body", type: "code", label: "Body", placeholder: '{ "name": "test" }', default: "" },
+        {
+            path: "config.method",
+            type: "select",
+            label: "Method",
+            options: METHODS,
+            default: "GET",
+        },
+        {
+            path: "config.url",
+            type: "expression",
+            label: "URL",
+            placeholder: 'env.baseUrl + "/health"',
+            default: "",
+        },
+        {
+            path: "config.body",
+            type: "code",
+            label: "Body",
+            placeholder: '{ "name": "test" }',
+            default: "",
+        },
     ],
     summary: "{config.method} {config.url}",
     outputs: [
@@ -32,7 +53,9 @@ export const api = defineStep({
             signal,
             ...(body !== undefined && {
                 body,
-                headers: { "content-type": isJson(body) ? "application/json" : "text/plain" },
+                headers: {
+                    "content-type": isJson(body) ? "application/json" : "text/plain",
+                },
             }),
         });
         return { outputs: { statusCode: res.status, body: await res.text() } };

package/dist/flows/steps/catalog.d.ts

@@ -1,16 +1,22 @@
 import type { AnyNodeDefinition, FlowFile, FlowProblem, StepInfo } from "../core/index.js";
 import type { Handler } from "../run/handlers/support.js";
 import { type StepDefinition } from "./define.js";
+import type { SamuraiTestConfig } from "../../types/config.js";
 /** The built-in steps, in library order */
 export declare const STEPS: readonly StepDefinition<any>[];
 export declare const STEP_NODES: readonly AnyNodeDefinition[];
 export declare const STEP_HANDLERS: Readonly<Record<string, Handler>>;
 /** The steps as data, for the app */
 export declare const stepCatalog: (steps?: readonly StepDefinition<any>[]) => StepInfo[];
-/** The project's steps; the built-in ones for now (test-project steps come later) */
-export declare function listSteps(): Promise<StepInfo[]>;
-/** Only the steps' own `validate` problems: the app checks everything else itself */
+/** The project's steps as data: the built-ins, then its config's. `projectDir` defaults to the working directory. */
+export declare function listSteps(options?: {
+    projectDir?: string;
+    config?: SamuraiTestConfig;
+}): Promise<StepInfo[]>;
+/** Only the steps' own `validate` problems (the project's steps included): the app checks everything else itself */
 export declare function validateSteps(flow: FlowFile, options: {
     tests?: string[];
     groups?: string[];
-}): FlowProblem[];
+    projectDir?: string;
+    config?: SamuraiTestConfig;
+}): Promise<FlowProblem[]>;

package/dist/flows/steps/catalog.js

@@ -1,29 +1,36 @@
-import { api } from "./api.js";
-import { infoOf, stepNode } from "./define.js";
-import { stepHandler } from "./handler.js";
-import { setVariable } from "./set-variable.js";
-import { wait } from "./wait.js";
+import { infoOf } from "./define.js";
+import { BUILTIN_SET, BUILTIN_STEPS, projectSteps } from "./set.js";
 /** The built-in steps, in library order */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const STEPS = [wait, setVariable, api];
-export const STEP_NODES = STEPS.map(stepNode);
-export const STEP_HANDLERS = Object.fromEntries(STEPS.map((s) => [s.kind, stepHandler(s)]));
+export const STEPS = BUILTIN_STEPS;
+export const STEP_NODES = BUILTIN_SET.nodes;
+export const STEP_HANDLERS = BUILTIN_SET.handlers;
 /** The steps as data, for the app */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const stepCatalog = (steps = STEPS) => steps.map(infoOf);
-/** The project's steps; the built-in ones for now (test-project steps come later) */
-export async function listSteps() {
-    return stepCatalog();
+/** The project's steps as data: the built-ins, then its config's. `projectDir` defaults to the working directory. */
+export async function listSteps(options = {}) {
+    return [...(await projectSteps(options)).catalog];
 }
-/** Only the steps' own `validate` problems: the app checks everything else itself */
-export function validateSteps(flow, options) {
+/** Only the steps' own `validate` problems (the project's steps included): the app checks everything else itself */
+export async function validateSteps(flow, options) {
+    const set = await projectSteps(options);
     const tests = options.tests ? new Set(options.tests) : undefined;
     const groups = options.groups ? new Set(options.groups) : undefined;
     return flow.nodes.flatMap((n) => {
-        const step = STEPS.find((s) => s.kind === n.kind);
+        const step = set.steps.find((s) => s.kind === n.kind);
         if (!step?.validate)
             return [];
-        const def = STEP_NODES.find((d) => d.kind === n.kind);
-        return step.validate({ ...n, config: { ...Object.fromEntries(step.fields.map((f) => [f.path.slice(7), "default" in f ? f.default : undefined])), ...n.config } }, { label: def.label, tests, groups });
+        const def = set.nodes.find((d) => d.kind === n.kind);
+        return step.validate({
+            ...n,
+            config: {
+                ...Object.fromEntries(step.fields.map((f) => [
+                    f.path.slice(7),
+                    "default" in f ? f.default : undefined,
+                ])),
+                ...n.config,
+            },
+        }, { label: def.label, tests, groups });
     });
 }

package/dist/flows/steps/define.d.ts

@@ -38,6 +38,8 @@ export interface StepDefinition<C = Record<string, unknown>> extends StepInfo {
     /** What the step does in a run: return to pass, throw to fail */
     run: (input: StepRunInput<C>) => Promise<StepResult | void>;
 }
+/** The checks every step passes: in `defineStep`, and again when a project lists it. Throws for a step that can't work. */
+export declare function checkStep(def: StepDefinition<any>, where?: string): void;
 /** Declares a flow step: one way in, one way out. Throws for a definition that can't work. */
 export declare function defineStep<const F extends readonly StepField[]>(def: Omit<StepDefinition<RunConfigOf<F>>, "fields"> & {
     fields: F;

package/dist/flows/steps/define.js

@@ -1,11 +1,14 @@
 import { CLOSED_KINDS, RESERVED_OUTPUTS, STEP_KIND, stepNodeOf, } from "../core/index.js";
-/** Declares a flow step: one way in, one way out. Throws for a definition that can't work. */
-export function defineStep(def) {
-    const name = `Step "${def.kind}"`;
+/** The checks every step passes: in `defineStep`, and again when a project lists it. Throws for a step that can't work. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function checkStep(def, where = "") {
+    const name = `Step "${def.kind}"${where}`;
     if (CLOSED_KINDS.includes(def.kind))
         throw new Error(`${name}: "${def.kind}" is a closed kind; steps can't replace it.`);
     if (!STEP_KIND.test(def.kind))
         throw new Error(`${name}: "${def.kind}" isn't a valid step kind. Use lowercase letters, digits and -.`);
+    if (!Array.isArray(def.fields))
+        throw new Error(`${name}: fields must be a list.`);
     for (const f of def.fields) {
         if (!f.path.startsWith("config."))
             throw new Error(`${name}: field "${f.path}" must be a config. path.`);
@@ -24,8 +27,16 @@ export function defineStep(def) {
         if (outputs.indexOf(o) !== outputs.lastIndexOf(o))
             throw new Error(`${name}: output "${o}" is declared twice.`);
     }
-    if (def.writesVar !== undefined && !def.fields.some((f) => f.path === def.writesVar))
+    if (def.writesVar !== undefined &&
+        !def.fields.some((f) => f.path === def.writesVar))
         throw new Error(`${name}: writesVar "${def.writesVar}" isn't one of its fields.`);
+    if (typeof def.run !== "function")
+        throw new Error(`${name}: run must be a function.`);
+}
+/** Declares a flow step: one way in, one way out. Throws for a definition that can't work. */
+export function defineStep(def) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    checkStep(def);
     return def;
 }
 /** The step as data, without its functions: what the catalog holds */

package/dist/flows/steps/handler.js

@@ -27,7 +27,9 @@ export function stepHandler(step) {
         const stopped = new Promise((resolve) => {
             if (run.signal.aborted)
                 resolve("stopped");
-            run.signal.addEventListener("abort", () => resolve("stopped"), { once: true });
+            run.signal.addEventListener("abort", () => resolve("stopped"), {
+                once: true,
+            });
         });
         let result;
         try {
@@ -36,7 +38,11 @@ export function stepHandler(step) {
                     config,
                     env: { ...run.context.env },
                     vars: { ...run.context.vars },
-                    node: { id: node.id, ...(node.key && { key: node.key }), ...(node.title && { title: node.title }) },
+                    node: {
+                        id: node.id,
+                        ...(node.key && { key: node.key }),
+                        ...(node.title && { title: node.title }),
+                    },
                     signal: run.signal,
                     sleep: (ms) => run.sleep(ms, run.signal),
                     log: (level, text) => run.log(node.id, level, text),
@@ -54,11 +60,17 @@ export function stepHandler(step) {
         const declared = new Set((step.outputs ?? []).map((o) => o.name));
         const extra = keysOf(result?.outputs).filter((k) => !declared.has(k));
         if (extra.length)
-            return { status: "failed", error: `${step.label} returned outputs it doesn't declare: ${extra.join(", ")}.` };
+            return {
+                status: "failed",
+                error: `${step.label} returned outputs it doesn't declare: ${extra.join(", ")}.`,
+            };
         const allowed = step.writesVar ? getPath(typed, step.writesVar) : undefined;
         const wrongVars = keysOf(result?.vars).filter((k) => k !== allowed);
         if (wrongVars.length)
-            return { status: "failed", error: `${step.label} wrote variables it doesn't declare: ${wrongVars.join(", ")}.` };
+            return {
+                status: "failed",
+                error: `${step.label} wrote variables it doesn't declare: ${wrongVars.join(", ")}.`,
+            };
         Object.assign(run.context.vars, result?.vars);
         return {
             status: "passed",

package/dist/flows/steps/index.d.ts

@@ -1,5 +1,6 @@
 /** Flow steps: define your own, and the built-in ones. Node only. */
-export { defineStep, stepNode, type RunConfigOf, type StepDefinition, type StepResult, type StepRunInput, } from "./define.js";
+export { checkStep, defineStep, stepNode, type RunConfigOf, type StepDefinition, type StepResult, type StepRunInput, } from "./define.js";
 export { stepHandler } from "./handler.js";
+export { BUILTIN_SET, BUILTIN_STEPS, projectSteps, stepSet, type StepSet, } from "./set.js";
 export { STEPS, STEP_HANDLERS, STEP_NODES, listSteps, stepCatalog, validateSteps, } from "./catalog.js";
-export type { StepField, StepInfo, StepOutput, StepSection } from "../core/index.js";
+export type { StepField, StepInfo, StepOutput, StepSection, } from "../core/index.js";

package/dist/flows/steps/index.js

@@ -1,4 +1,5 @@
 /** Flow steps: define your own, and the built-in ones. Node only. */
-export { defineStep, stepNode, } from "./define.js";
+export { checkStep, defineStep, stepNode, } from "./define.js";
 export { stepHandler } from "./handler.js";
+export { BUILTIN_SET, BUILTIN_STEPS, projectSteps, stepSet, } from "./set.js";
 export { STEPS, STEP_HANDLERS, STEP_NODES, listSteps, stepCatalog, validateSteps, } from "./catalog.js";

package/dist/flows/steps/set-variable.js

@@ -6,11 +6,22 @@ export const setVariable = defineStep({
     section: "control",
     fields: [
         {
-            path: "config.name", type: "text", label: "Name", placeholder: "orderId", default: "",
-            required: true, pattern: "^[a-z][a-z0-9_]*$",
+            path: "config.name",
+            type: "text",
+            label: "Name",
+            placeholder: "orderId",
+            default: "",
+            required: true,
+            pattern: "^[a-z][a-z0-9_]*$",
             patternMessage: "use lowercase letters, digits and _ for the name.",
         },
-        { path: "config.value", type: "expression", label: "Value", placeholder: '"order-" + run.environment', default: "" },
+        {
+            path: "config.value",
+            type: "expression",
+            label: "Value",
+            placeholder: '"order-" + run.environment',
+            default: "",
+        },
     ],
     summary: "vars.{config.name} = {config.value}",
     writesVar: "config.name",

package/dist/flows/steps/set.d.ts

@@ -0,0 +1,26 @@
+import type { SamuraiTestConfig } from "../../types/config.js";
+import type { AnyNodeDefinition, StepInfo } from "../core/index.js";
+import type { Handler } from "../run/handlers/support.js";
+import { type StepDefinition } from "./define.js";
+type AnyStep = StepDefinition<any>;
+/** The built-in steps, in library order */
+export declare const BUILTIN_STEPS: readonly AnyStep[];
+/** Everything a project's steps give the walker, the check and the app */
+export interface StepSet {
+    /** The built-ins, then the project's in config order */
+    steps: readonly AnyStep[];
+    nodes: readonly AnyNodeDefinition[];
+    handlers: Readonly<Record<string, Handler>>;
+    /** The steps as data, for the app */
+    catalog: StepInfo[];
+}
+/** The built-in steps plus a project's (its config's `steps`). Throws for a list that can't work. */
+export declare function stepSet(projectSteps?: unknown): StepSet;
+/** The built-in steps alone */
+export declare const BUILTIN_SET: StepSet;
+/** The project's steps: its config's `steps` after the built-ins. `projectDir` defaults to the working directory. */
+export declare function projectSteps(options?: {
+    projectDir?: string;
+    config?: SamuraiTestConfig;
+}): Promise<StepSet>;
+export {};

package/dist/flows/steps/set.js

@@ -0,0 +1,43 @@
+import { projectConfig } from "../../config/config.js";
+import { api } from "./api.js";
+import { checkStep, infoOf, stepNode } from "./define.js";
+import { stepHandler } from "./handler.js";
+import { setVariable } from "./set-variable.js";
+import { wait } from "./wait.js";
+/** The built-in steps, in library order */
+export const BUILTIN_STEPS = [wait, setVariable, api];
+const WHERE = " (samurai.config.ts)";
+/** The built-in steps plus a project's (its config's `steps`). Throws for a list that can't work. */
+export function stepSet(projectSteps = []) {
+    if (!Array.isArray(projectSteps))
+        throw new Error("samurai.config.ts: steps must be a list of steps.");
+    const builtin = new Set(BUILTIN_STEPS.map((s) => s.kind));
+    const seen = new Set();
+    projectSteps.forEach((entry, i) => {
+        const kind = entry && typeof entry === "object"
+            ? entry.kind
+            : undefined;
+        if (typeof kind !== "string" || kind === "")
+            throw new Error(`Step #${i + 1}${WHERE}: it has no kind; make it with defineStep.`);
+        checkStep(entry, WHERE);
+        if (builtin.has(kind))
+            throw new Error(`Step "${kind}"${WHERE}: a built-in step already uses this kind.`);
+        if (seen.has(kind))
+            throw new Error(`Step "${kind}"${WHERE}: declared twice.`);
+        seen.add(kind);
+    });
+    const steps = [...BUILTIN_STEPS, ...projectSteps];
+    return {
+        steps,
+        nodes: steps.map(stepNode),
+        handlers: Object.fromEntries(steps.map((s) => [s.kind, stepHandler(s)])),
+        catalog: steps.map(infoOf),
+    };
+}
+/** The built-in steps alone */
+export const BUILTIN_SET = stepSet();
+/** The project's steps: its config's `steps` after the built-ins. `projectDir` defaults to the working directory. */
+export async function projectSteps(options = {}) {
+    const config = await projectConfig(options);
+    return config.steps === undefined ? BUILTIN_SET : stepSet(config.steps);
+}

package/dist/flows/steps/wait.js

@@ -5,7 +5,14 @@ export const wait = defineStep({
     icon: "timer",
     section: "control",
     fields: [
-        { path: "config.ms", type: "number", label: "Duration", unit: "ms", default: 1000, min: 0 },
+        {
+            path: "config.ms",
+            type: "number",
+            label: "Duration",
+            unit: "ms",
+            default: 1000,
+            min: 0,
+        },
     ],
     summary: "{config.ms} ms",
     async run({ config, sleep }) {

package/dist/recorder/session.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { Browser } from "../browser/browser.js";
+import { ensureWarm } from "../browser/warm-up.js";
 import { projectDir } from "../config/config.js";
 import { withProject } from "../runner/project.js";
 import { parseSpec } from "../steps/parse.js";
@@ -52,6 +53,9 @@ export async function recordSpec(options) {
         if (source === undefined && options.create === undefined) {
             throw new Error(`${options.file} does not exist; give a title with --new to create it`);
         }
+        // Before the spec is touched: a recording without its browser changes nothing
+        await ensureWarm("firefox", { port: options.port ?? 9223 }, options.signal);
+        options.signal?.throwIfAborted();
         source ??= "";
         if (options.create !== undefined &&
             !parseSpec(source).some((t) => t.name === options.create)) {

package/dist/runner/groups.d.ts

@@ -23,6 +23,11 @@ export interface ResolvedGroup {
         title: string;
     }[];
 }
+/**
+ * The real path of `p` (symlinks resolved), or `p` itself when it does not exist. Registered test files come
+ * from stack traces, which resolve symlinks, so paths compared with them must be real too
+ */
+export declare function realPath(p: string): string;
 /** Separators of any platform become `/` */
 export declare const toPosix: (p: string) => string;
 /** The id of a test: its spec file relative to `srcDir` with `/` separators, then `::` and its full name */

package/dist/runner/groups.js

@@ -1,8 +1,21 @@
+import { realpathSync } from "node:fs";
 import { matchesGlob, relative, resolve } from "node:path";
 /** The test folder when the config names none */
 export const DEFAULT_SRC_DIR = "./src";
 /** The spec pattern when a group names none */
 export const DEFAULT_TEST_MATCH = "**/*.spec.ts";
+/**
+ * The real path of `p` (symlinks resolved), or `p` itself when it does not exist. Registered test files come
+ * from stack traces, which resolve symlinks, so paths compared with them must be real too
+ */
+export function realPath(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
 /** Separators of any platform become `/` */
 export const toPosix = (p) => p.replace(/\\/g, "/");
 /** The id of a test: its spec file relative to `srcDir` with `/` separators, then `::` and its full name */

package/dist/runner/test-runner.js

@@ -3,6 +3,7 @@ import { glob } from "node:fs/promises";
 import path from "path";
 import { pathToFileURL } from "url";
 import { Browser } from "../browser/browser.js";
+import { ensureWarm } from "../browser/warm-up.js";
 import { loadConfig, projectDir, readConfig } from "../config/config.js";
 import logger from "../logger/index.js";
 import { assertModuleProject } from "./module-type.js";
@@ -14,7 +15,7 @@ import Page from "../browser/page.js";
 import { takePendingAssertions } from "../assert/expect.js";
 import { toTestError } from "./test-error.js";
 import { ConnectionClosedError } from "../transport/bidi-connection.js";
-import { DEFAULT_SRC_DIR, findGroup, resolveGroups, testId, toPosix, } from "./groups.js";
+import { DEFAULT_SRC_DIR, findGroup, realPath, resolveGroups, testId, toPosix, } from "./groups.js";
 import { judgePageLogs } from "./page-logs-report.js";
 /** Whether a test with this full name is selected by the options */
 export function isSelected(name, { grep, testNames }) {
@@ -81,8 +82,9 @@ export default class TestRunner {
     /** The config's groups, resolved against the tests the specs register */
     async resolveAll(tests) {
         const config = await loadConfig();
-        const dir = projectDir();
-        const srcDir = path.resolve(dir, config.srcDir ?? DEFAULT_SRC_DIR);
+        // Real paths: registered test files come from stack traces, which resolve symlinks
+        const dir = realPath(projectDir());
+        const srcDir = realPath(path.resolve(dir, config.srcDir ?? DEFAULT_SRC_DIR));
         const groups = resolveGroups(config, tests.map(({ file, name }) => ({
             file: toPosix(path.relative(srcDir, file)),
             name,
@@ -114,6 +116,10 @@ export default class TestRunner {
             ...(onEvent && { onEvent }),
         });
         const selected = await this.register();
+        // A missing browser is one clear error before the run, not a failure per test; a fresh build's slow
+        // first start happens here, outside any test's timeout
+        if (selected.length > 0)
+            await ensureWarm((await readConfig("browser")) ?? "firefox", { port: this.options.port ?? 9223 }, signal);
         reporter.onStart(selected.length);
         for (const test of selected) {
             if (signal?.aborted) {

package/dist/transport/bidi-connection.d.ts

@@ -1,5 +1,7 @@
 import type { BiDiCommands, BiDiEvents } from "../types/bidi.js";
 import { type EventName, type Subscription, type SubscribeOptions } from "./subscriptions.js";
+/** Time (ms) a command may wait for its reply before it fails with code "timeout" */
+export declare const DEFAULT_COMMAND_TIMEOUT = 30000;
 export interface ConnectorOptions {
     /** @default 30000 */
     commandTimeout?: number;

package/dist/transport/bidi-connection.js

@@ -4,7 +4,7 @@ import { WaitTimeoutError } from "../wait/wait-until.js";
 import { BiDiError } from "./bidi-error.js";
 import { SubscriptionManager, } from "./subscriptions.js";
 /** Time (ms) a command may wait for its reply before it fails with code "timeout" */
-const DEFAULT_COMMAND_TIMEOUT = 30000;
+export const DEFAULT_COMMAND_TIMEOUT = 30000;
 /**
  * The connection to the browser is gone (the browser exited or was closed, or the socket dropped). Commands that
  * were waiting fail with it, and so does every command sent afterwards: a closed socket would swallow them silently.

package/dist/types/config.d.ts

@@ -1,3 +1,4 @@
+import type { StepDefinition } from "../flows/steps/define.js";
 import type { SupportedBrowser } from "./browser.js";
 
 interface SamuraiTest {
@@ -48,6 +49,11 @@ export interface SamuraiTestConfig {
    * Is overwritten by the 'browser' in a group's config
    */
   browser?: SupportedBrowser;
+  /**
+   * Browser binaries to launch instead of the builds SAMURAI downloads, relative to the project.
+   * `SAMURAI_FIREFOX_PATH` / `SAMURAI_CHROME_PATH` win over these.
+   */
+  browserPaths?: { firefox?: string; chrome?: string };
   /**
    * The timeout (in ms) to use for all tests
    * @default 30000
@@ -57,6 +63,12 @@ export interface SamuraiTestConfig {
    * Define a group of test's you want to have executed with a certain configuration
    **/
   groups?: SamuraiGroup[];
+  /**
+   * Flow steps of this project, made with `defineStep`. Listed after the built-in steps;
+   * a kind a built-in or another step uses is refused.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  steps?: readonly StepDefinition<any>[];
   /**
    * The base URL to use when navigating the browser.
    * When recording starts, the browser will start at this URL.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itmetsam/samurai-framework",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Browser test framework over WebDriver BiDi: auto-waiting locators, environments and secrets, a recorder, and a command line.",
   "main": "dist/api.js",
   "exports": {
@@ -24,6 +24,10 @@
       "types": "./dist/cli/init.d.ts",
       "default": "./dist/cli/init.js"
     },
+    "./browsers": {
+      "types": "./dist/browsers/index.d.ts",
+      "default": "./dist/browsers/index.js"
+    },
     "./browser": {
       "types": "./dist/browser/index.d.ts",
       "default": "./dist/browser/index.js"
@@ -65,6 +69,7 @@
     "tsx": "^4.21.0"
   },
   "dependencies": {
+    "@puppeteer/browsers": "^3.2.4",
     "typescript": "^6.0.2",
     "winston": "^3.19.0"
   },