@itmetsam/samurai-framework 0.2.3 → 0.3.0

package/dist/flows/run/report.js

@@ -0,0 +1,46 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { maskDeep, maskText } from "../../config/mask.js";
+/** Follows a run's events and builds its report once it ends (or `finish` is given what is known) */
+export class FlowReportBuilder {
+    constructor(flow) {
+        this.flow = flow;
+        this.environment = "";
+        this.tests = [];
+        this.started = Date.now();
+        this.startedAt = new Date(this.started).toISOString();
+    }
+    handle(event) {
+        if (event.type === "flow-start")
+            this.environment = event.environment;
+        if (event.type === "test")
+            this.collect(event.nodeId, event.event);
+    }
+    collect(nodeId, event) {
+        if (event.type === "test-end")
+            this.tests.push({ nodeId, ...event.result });
+    }
+    finish(summary, environment = this.environment) {
+        return {
+            flow: this.flow.id,
+            name: this.flow.name,
+            environment,
+            status: summary.status,
+            startedAt: this.startedAt,
+            durationMs: Date.now() - this.started,
+            nodes: summary.nodes,
+            vars: summary.vars,
+            tests: this.tests,
+            ...(summary.error ? { error: summary.error } : {}),
+        };
+    }
+}
+/** Writes `<projectDir>/result/flows/<id>.json` with the registered secrets masked, as `report.json` is. Returns the path */
+export async function writeFlowReport(projectDir, report) {
+    const file = path.join(path.resolve(projectDir), "result", "flows", `${report.flow}.json`);
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(maskDeep(report), null, 2), "utf8");
+    return file;
+}
+/** Hides the registered secrets in a line of output (a node's error) */
+export const maskSecrets = (text) => maskText(text);

package/dist/flows/run/run.d.ts

@@ -0,0 +1,42 @@
+import { type AnyNodeDefinition, type FlowFile } from "../core/index.js";
+import type { RunEvent } from "../../runner/reporter.js";
+import type { FlowEvent, FlowSummary, NodeTest } from "./events.js";
+import { type Handler } from "./handlers/index.js";
+export interface RunFlowOptions {
+    flow: FlowFile;
+    /** The tests of each Test and Group node, by node id */
+    nodeTests: Record<string, NodeTest[]>;
+    environment: {
+        name: string;
+        variables: Record<string, string | number | boolean>;
+    };
+    /** @default "manual" */
+    trigger?: "manual";
+    /** @default now */
+    startedAt?: string;
+    signal?: AbortSignal;
+    onEvent?: (event: FlowEvent) => void;
+    runTests: (input: {
+        tests: NodeTest[];
+        onEvent: (e: RunEvent) => void;
+        signal: AbortSignal;
+    }) => Promise<"passed" | "failed" | "cancelled">;
+    sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+    /**
+     * What a node of a kind with no handler does:
+     *  - `"fail"` (default): the run does not start (an error is thrown)
+     *  - `"skip"`: the node is skipped with the note "Not supported yet"
+     */
+    unsupported?: "fail" | "skip";
+    /** The handlers by kind. @default HANDLERS */
+    handlers?: Readonly<Record<string, Handler>>;
+    /** Definitions of kinds beyond the ones `flows/core` registers (a handler needs one to be walked) */
+    nodes?: readonly AnyNodeDefinition[];
+}
+/**
+ * Walks the flow from Start by the shape of each node's kind: a step runs and
+ * follows its one way out; a node with a fixed list of branches follows the one its
+ * handler names and skips the others; a node with a dynamic list walks every branch in
+ * fill order; an end stops. Branches meet again at `meetOf`.
+ */
+export declare function runFlow(options: RunFlowOptions): Promise<FlowSummary>;

package/dist/flows/run/run.js

@@ -0,0 +1,244 @@
+import { inFillOrder, meetOf, nodeDef, } from "../core/index.js";
+import { HANDLERS } from "./handlers/index.js";
+const defaultSleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal.aborted)
+        return reject(new Error("aborted"));
+    const onAbort = () => {
+        clearTimeout(timer);
+        reject(new Error("aborted"));
+    };
+    const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+});
+class ShapeError extends Error {
+}
+const dynamicBranches = (def) => def.shape === "branches" && !!def.branches && !Array.isArray(def.branches);
+/**
+ * Walks the flow from Start by the shape of each node's kind: a step runs and
+ * follows its one way out; a node with a fixed list of branches follows the one its
+ * handler names and skips the others; a node with a dynamic list walks every branch in
+ * fill order; an end stops. Branches meet again at `meetOf`.
+ */
+export async function runFlow(options) {
+    const { flow, onEvent = () => { } } = options;
+    const signal = options.signal ?? new AbortController().signal;
+    const handlers = options.handlers ?? HANDLERS;
+    const defOf = (kind) => options.nodes?.find((d) => d.kind === kind) ??
+        (() => {
+            try {
+                return nodeDef(kind);
+            }
+            catch {
+                return undefined;
+            }
+        })();
+    if ((options.unsupported ?? "fail") === "fail") {
+        const problems = flow.nodes
+            .map((n) => ({ n, def: defOf(n.kind) }))
+            .filter(({ n, def }) => def &&
+            (def.shape === "step" || def.shape === "branches") &&
+            !handlers[n.kind])
+            .map(({ def }) => `${def.label} can't run yet.`);
+        if (problems.length)
+            throw new Error(`This flow can't run: ${[...new Set(problems)].join(" ")}`);
+    }
+    const byId = new Map(flow.nodes.map((n) => [n.id, n]));
+    const results = {};
+    const context = {
+        env: { ...options.environment.variables },
+        vars: {},
+        nodes: {},
+        run: {
+            environment: options.environment.name,
+            trigger: options.trigger ?? "manual",
+            startedAt: options.startedAt ?? new Date().toISOString(),
+        },
+    };
+    const handlerRun = {
+        flow,
+        environment: options.environment,
+        context,
+        nodeTests: options.nodeTests,
+        signal,
+        sleep: options.sleep ?? defaultSleep,
+        runTests: (tests, onTestEvent) => options.runTests({ tests, onEvent: onTestEvent, signal }),
+        onTestEvent: (nodeId, event) => onEvent({ type: "test", nodeId, event }),
+    };
+    let stopped;
+    const visited = new Set();
+    const record = (node, result) => {
+        results[node.id] = result;
+        if (node.key)
+            context.nodes[node.key] = {
+                status: result.status,
+                durationMs: result.durationMs,
+                error: result.error,
+            };
+    };
+    const out = (id) => flow.edges.filter((e) => e.source === id);
+    /** Marks every node from `from` up to `stop` as skipped (a branch not taken) */
+    const skip = (from, stop) => {
+        const seen = new Set();
+        const visit = (id) => {
+            if (id === stop || seen.has(id))
+                return;
+            seen.add(id);
+            const node = byId.get(id);
+            if (node && !results[id]) {
+                record(node, { status: "skipped" });
+                onEvent({
+                    type: "node-end",
+                    nodeId: id,
+                    result: { status: "skipped" },
+                });
+            }
+            for (const e of out(id))
+                visit(e.target);
+        };
+        visit(from);
+    };
+    const shapeError = (message) => new ShapeError(`This flow's shape can't run: ${message}`);
+    async function runNode(node, def) {
+        if (visited.has(node.id))
+            throw shapeError(`${node.key ?? node.id} is reached twice.`);
+        visited.add(node.id);
+        if (signal.aborted) {
+            stopped = "cancelled";
+            return undefined;
+        }
+        onEvent({ type: "node-start", nodeId: node.id });
+        const began = Date.now();
+        const handler = handlers[node.kind];
+        const outcome = handler
+            ? await handler(node, handlerRun)
+            : { status: "skipped", note: "Not supported yet" };
+        if (outcome === "cancelled" || signal.aborted) {
+            stopped = "cancelled";
+            return undefined;
+        }
+        const result = { ...outcome, durationMs: Date.now() - began };
+        record(node, result);
+        // A node with a dynamic list of branches ends after them: walk() reports it then
+        if (dynamicBranches(def))
+            return result;
+        onEvent({ type: "node-end", nodeId: node.id, result });
+        if (result.status === "failed" && node.onFailure === "stop")
+            stopped = "failed";
+        return result;
+    }
+    /** Whether `target` is on the chain from `from` before `stop` */
+    const reachesBefore = (from, target, stop) => {
+        const seen = new Set();
+        const visit = (id) => {
+            if (id === stop || seen.has(id))
+                return false;
+            if (id === target)
+                return true;
+            seen.add(id);
+            return out(id).some((e) => visit(e.target));
+        };
+        return visit(from);
+    };
+    /** Runs the chain from `from` up to `stop` (undefined: through End) */
+    async function walk(from, stop) {
+        let at = from;
+        while (at !== undefined && at !== stop && !stopped) {
+            const node = byId.get(at);
+            if (!node)
+                throw shapeError("an edge leads to a missing node.");
+            const def = defOf(node.kind);
+            if (!def)
+                throw shapeError(`${node.key ?? node.id} has an unknown kind (${node.kind}).`);
+            const result = await runNode(node, def);
+            if (!result || stopped)
+                return;
+            if (def.shape === "end")
+                return;
+            const edges = out(node.id);
+            if (def.shape === "branches") {
+                const meet = meetOf(flow, node.id);
+                if (!meet)
+                    throw shapeError(`the branches of ${node.key ?? node.id} never meet.`);
+                if (!dynamicBranches(def)) {
+                    const taken = result.status === "passed"
+                        ? edges.find((e) => e.sourceHandle === result.branch)
+                        : undefined;
+                    for (const e of edges)
+                        if (e !== taken)
+                            skip(e.target, meet);
+                    if (taken)
+                        await walk(taken.target, meet);
+                }
+                else {
+                    const opened = Date.now();
+                    for (const e of inFillOrder(edges)) {
+                        if (stopped)
+                            break;
+                        if (e.target !== meet)
+                            await walk(e.target, meet);
+                    }
+                    if (stopped === "cancelled") {
+                        // Stopped inside its branches: like any node cut short, it didn't run to the end
+                        delete results[node.id];
+                        return;
+                    }
+                    // The node fails when anything in its branches failed
+                    const failed = flow.nodes.some((n) => results[n.id]?.status === "failed" &&
+                        edges.some((e) => e.target !== meet && reachesBefore(e.target, n.id, meet)));
+                    const durationMs = (result.durationMs ?? 0) + Date.now() - opened;
+                    const ended = failed
+                        ? {
+                            ...result,
+                            durationMs,
+                            status: "failed",
+                            error: "A branch failed.",
+                        }
+                        : { ...result, durationMs };
+                    record(node, ended);
+                    onEvent({ type: "node-end", nodeId: node.id, result: ended });
+                    if (failed && node.onFailure === "stop")
+                        stopped = "failed";
+                    if (stopped)
+                        return;
+                }
+                at = meet;
+                continue;
+            }
+            if (edges.length !== 1)
+                throw shapeError(`${node.key ?? node.id} has ${edges.length} ways out.`);
+            at = edges[0].target;
+        }
+    }
+    onEvent({ type: "flow-start", environment: options.environment.name });
+    let error;
+    const start = flow.nodes.find((n) => defOf(n.kind)?.shape === "start");
+    try {
+        if (!start)
+            throw shapeError("it has no Start.");
+        await walk(start.id);
+    }
+    catch (e) {
+        if (!(e instanceof ShapeError))
+            throw e;
+        error = e.message;
+    }
+    for (const node of flow.nodes)
+        if (!results[node.id])
+            results[node.id] = { status: "not-run" };
+    const status = stopped === "cancelled"
+        ? "cancelled"
+        : error || Object.values(results).some((r) => r.status === "failed")
+            ? "failed"
+            : "passed";
+    const summary = {
+        status,
+        nodes: results,
+        vars: context.vars,
+        ...(error ? { error } : {}),
+    };
+    onEvent({ type: "flow-end", summary });
+    return summary;
+}

package/dist/runner/groups.d.ts

@@ -0,0 +1,39 @@
+import type { SamuraiGroup } from "../types/config.js";
+/** The test folder when the config names none */
+export declare const DEFAULT_SRC_DIR = "./src";
+/** The spec pattern when a group names none */
+export declare const DEFAULT_TEST_MATCH = "**/*.spec.ts";
+/** A test as groups see it: its spec file (relative to `srcDir`, or any path inside it) and full name */
+export interface GroupTest {
+    file: string;
+    name: string;
+}
+/** A group with the tests it holds */
+export interface ResolvedGroup {
+    name: string;
+    /** `picked`: the group lists its tests; `pattern`: `src` and `testMatch` select them */
+    kind: "picked" | "pattern";
+    /** What selects the tests of a pattern group, for display */
+    pattern?: string;
+    /** Ids (see `testId`) of the found tests in the group */
+    testIds: string[];
+    /** Picked tests that no longer exist */
+    missing: {
+        file: string;
+        title: 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 */
+export declare const testId: (file: string, name: string) => string;
+/** Works out which of `tests` (files relative to `srcDir`) belong to the group */
+export declare function resolveGroup(group: SamuraiGroup, tests: GroupTest[], projectDir: string, srcDir: string): ResolvedGroup;
+/** Resolves every group of the config */
+export declare function resolveGroups(config: {
+    groups?: SamuraiGroup[];
+}, tests: GroupTest[], projectDir: string, srcDir: string): ResolvedGroup[];
+/** The group called `name`, or an error naming the groups there are */
+export declare function findGroup<T extends {
+    name: string;
+}>(groups: T[], name: string): T;

package/dist/runner/groups.js

@@ -0,0 +1,58 @@
+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";
+/** 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 */
+export const testId = (file, name) => `${toPosix(file)}::${name}`;
+/** Works out which of `tests` (files relative to `srcDir`) belong to the group */
+export function resolveGroup(group, tests, projectDir, srcDir) {
+    const found = tests.map((t) => ({ ...t, id: testId(t.file, t.name) }));
+    // Tests picked by hand override src and testMatch
+    if (group.tests) {
+        const known = new Set(found.map((t) => t.id));
+        const picked = group.tests.map(({ file, title }) => ({
+            file,
+            title,
+            id: testId(file, title),
+        }));
+        return {
+            name: group.name,
+            kind: "picked",
+            testIds: picked.filter((t) => known.has(t.id)).map((t) => t.id),
+            missing: picked
+                .filter((t) => !known.has(t.id))
+                .map(({ file, title }) => ({ file, title })),
+        };
+    }
+    const base = group.src ? resolve(projectDir, group.src) : srcDir;
+    const pattern = group.testMatch ?? DEFAULT_TEST_MATCH;
+    const testIds = found
+        .filter((t) => {
+        const fromBase = toPosix(relative(base, resolve(srcDir, t.file)));
+        return !fromBase.startsWith("..") && matchesGlob(fromBase, pattern);
+    })
+        .map((t) => t.id);
+    return {
+        name: group.name,
+        kind: "pattern",
+        pattern: [group.src, group.testMatch].filter(Boolean).join(" · ") || pattern,
+        testIds,
+        missing: [],
+    };
+}
+/** Resolves every group of the config */
+export function resolveGroups(config, tests, projectDir, srcDir) {
+    return (config.groups ?? []).map((group) => resolveGroup(group, tests, projectDir, srcDir));
+}
+/** The group called `name`, or an error naming the groups there are */
+export function findGroup(groups, name) {
+    const group = groups.find((g) => g.name === name);
+    if (group)
+        return group;
+    throw new Error(groups.length === 0
+        ? `Unknown group "${name}". No groups are configured.`
+        : `Unknown group "${name}". Groups: ${groups.map((g) => g.name).join(", ")}.`);
+}

package/dist/runner/run.d.ts

@@ -1,5 +1,6 @@
 import type { TestSummary } from "../types/test.js";
 import { type ProjectOptions } from "./project.js";
+import type { ResolvedGroup } from "./groups.js";
 import { type RunnerOptions } from "./test-runner.js";
 export interface RunTestsOptions extends RunnerOptions, ProjectOptions {
 }
@@ -21,7 +22,10 @@ export interface FoundTest {
 }
 /** Imports the project's specs without running anything and lists the tests the options select */
 export declare function listTests(options?: RunTestsOptions): Promise<FoundTest[]>;
+/** Imports the project's specs without running anything and lists the config's groups with the tests each holds */
+export declare function listGroups(options?: RunTestsOptions): Promise<ResolvedGroup[]>;
 export type { RunEvent } from "./reporter.js";
 export type { TestError, TestResult, TestSummary } from "../types/test.js";
+export type { ResolvedGroup } from "./groups.js";
 export type { RunnerOptions } from "./test-runner.js";
 export type { ProjectOptions } from "./project.js";

package/dist/runner/run.js

@@ -32,3 +32,15 @@ export async function listTests(options = {}) {
         expectTimeout,
     }, async (run) => (await (await TestRunner.init(run, undefined, runner)).register()).map(({ name, file }) => ({ name, file })));
 }
+/** Imports the project's specs without running anything and lists the config's groups with the tests each holds */
+export async function listGroups(options = {}) {
+    const { projectDir, config, dataDir, environment, timeout, expectTimeout, ...runner } = options;
+    return withProject({
+        projectDir,
+        config,
+        dataDir,
+        environment,
+        timeout,
+        expectTimeout,
+    }, async (run) => (await TestRunner.init(run, undefined, runner)).groups());
+}

package/dist/runner/test-runner.d.ts

@@ -2,6 +2,7 @@ import type { RegisteredTestCase } from "../types/test.js";
 import type { PreparedRun } from "./prepare-run.js";
 import { type RunEvent } from "./reporter.js";
 import type { SamuraiGroup } from "../types/config.js";
+import type { ResolvedGroup } from "./groups.js";
 /** What decides which tests of the found files run, and how the browser starts */
 export interface RunnerOptions {
     /** Spec files to run, absolute or relative to the project folder. Default: every `*.spec.ts` under `srcDir` */
@@ -10,6 +11,8 @@ export interface RunnerOptions {
     grep?: string | RegExp;
     /** Only tests with exactly one of these full names (`describe` titles joined with " > ") */
     testNames?: string[];
+    /** Only the tests of this group of the config's `groups` (unknown name: an error). Combines with the other filters */
+    group?: string;
     /** Run the browser without a window. @default false */
     headless?: boolean;
     /** Remote debugging port of the browser. @default 9223 */
@@ -30,12 +33,19 @@ export default class TestRunner {
     private options;
     constructor(testFiles: string[], run: PreparedRun, group?: SamuraiGroup, options?: RunnerOptions);
     static init(run: PreparedRun, group?: SamuraiGroup, options?: RunnerOptions): Promise<TestRunner>;
-    /** Runs the selected tests and returns the summary that was also written to the report */
     /**
-     * Imports the spec files and returns the tests the options select. A fresh registry and a fresh import of each
+     * Imports the spec files and returns every test they register. A fresh registry and a fresh import of each
      * file, so a second run in this process registers its tests again (and sees edited specs, for files loaded as
      * ES modules; CommonJS files stay cached until the process ends)
      */
+    private registerAll;
+    /** Id of a registered test: its spec file relative to `srcDir`, then its name */
+    private idOf;
+    /** The config's groups, resolved against the tests the specs register */
+    private resolveAll;
+    /** The groups of the config with the tests each holds; see `listGroups` */
+    groups(): Promise<ResolvedGroup[]>;
+    /** Imports the spec files and returns the tests the options select: by `group`, `testNames` and `grep` */
     register(): Promise<RegisteredTestCase[]>;
     /** Runs the selected tests and returns the summary that was also written to the report */
     start(): Promise<import("../types/test.js").TestSummary>;

package/dist/runner/test-runner.js

@@ -3,7 +3,7 @@ import { glob } from "node:fs/promises";
 import path from "path";
 import { pathToFileURL } from "url";
 import { Browser } from "../browser/browser.js";
-import { projectDir, readConfig } from "../config/config.js";
+import { loadConfig, projectDir, readConfig } from "../config/config.js";
 import logger from "../logger/index.js";
 import { assertModuleProject } from "./module-type.js";
 import { clearRegistry, registeredTests } from "./registry.js";
@@ -14,6 +14,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 { judgePageLogs } from "./page-logs-report.js";
 /** Whether a test with this full name is selected by the options */
 export function isSelected(name, { grep, testNames }) {
@@ -57,13 +58,12 @@ export default class TestRunner {
         logger.debug("Found %d tests in srcDir", testFiles.length);
         return new TestRunner(testFiles.map((file) => path.join(cwd, file)), run, group, options);
     }
-    /** Runs the selected tests and returns the summary that was also written to the report */
     /**
-     * Imports the spec files and returns the tests the options select. A fresh registry and a fresh import of each
+     * Imports the spec files and returns every test they register. A fresh registry and a fresh import of each
      * file, so a second run in this process registers its tests again (and sees edited specs, for files loaded as
      * ES modules; CommonJS files stay cached until the process ends)
      */
-    async register() {
+    async registerAll() {
         clearRegistry();
         const stamp = `?run=${Date.now().toString(36)}`;
         for (const file of this.testFiles)
@@ -72,8 +72,38 @@ export default class TestRunner {
             logger.verbose("Trying to register file: %s", file);
             await import(pathToFileURL(file).href + stamp);
         }
-        // TODO: Implement test grouping
-        return registeredTests().filter((test) => isSelected(test.name, this.options));
+        return [...registeredTests()];
+    }
+    /** Id of a registered test: its spec file relative to `srcDir`, then its name */
+    idOf(test, srcDir) {
+        return testId(toPosix(path.relative(srcDir, test.file)), test.name);
+    }
+    /** 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);
+        const groups = resolveGroups(config, tests.map(({ file, name }) => ({
+            file: toPosix(path.relative(srcDir, file)),
+            name,
+        })), dir, srcDir);
+        return { groups, srcDir };
+    }
+    /** The groups of the config with the tests each holds; see `listGroups` */
+    async groups() {
+        return (await this.resolveAll(await this.registerAll())).groups;
+    }
+    /** Imports the spec files and returns the tests the options select: by `group`, `testNames` and `grep` */
+    async register() {
+        const all = await this.registerAll();
+        const { group } = this.options;
+        let inGroup = () => true;
+        if (group !== undefined) {
+            const { groups, srcDir } = await this.resolveAll(all);
+            const members = new Set(findGroup(groups, group).testIds);
+            inGroup = (test) => members.has(this.idOf(test, srcDir));
+        }
+        return all.filter((test) => inGroup(test) && isSelected(test.name, this.options));
     }
     /** Runs the selected tests and returns the summary that was also written to the report */
     async start() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itmetsam/samurai-framework",
-  "version": "0.2.3",
+  "version": "0.3.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": {
@@ -28,6 +28,14 @@
       "types": "./dist/browser/index.d.ts",
       "default": "./dist/browser/index.js"
     },
+    "./flows": {
+      "types": "./dist/flows/core/index.d.ts",
+      "default": "./dist/flows/core/index.js"
+    },
+    "./flows/run": {
+      "types": "./dist/flows/run/index.d.ts",
+      "default": "./dist/flows/run/index.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {