@appduct/e2e 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Szymon Chmal and Callstack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,87 @@
-# Temporary Holding Version
+<a href="https://callstackincubator.github.io/appduct/"><img src="https://raw.githubusercontent.com/callstackincubator/appduct/main/.github/assets/readme-banner.png" alt="Appduct by Callstack. Your app is an MCP server now: your agent calls its functions over MCP, on iOS, Android, React Native, Flutter and web." width="100%" /></a>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# Appduct for e2e
+
+Call your app's Appduct tools from [e2e](https://github.com/tester-army/e2e) tests, and let e2e's agent call them during agent steps. Set up state without tapping through the UI, and check what the app holds instead of only what it shows.
+
+## Requirements
+
+- An app that registers tools with an Appduct SDK, in a debug build. Web pages load `@appduct/web` from a development build.
+- e2e 0.21 or newer, with its web or mobile engine.
+- Web, iOS simulator or Android emulator targets.
+- For iOS and Android, the app's URL scheme in `.appduct/config.json` at your e2e project root, as the `appduct` CLI reads it.
+
+## Getting started
+
+```bash
+npm install -D @appduct/e2e
+```
+
+Add the `appduct` fixture to your `test` in one place:
+
+```ts
+// tests/fixtures.ts
+import { test as base } from "e2e";
+import { withAppduct } from "@appduct/e2e";
+
+export const test = withAppduct(base);
+```
+
+`base` can also be an engine's `test`, such as the one from `@e2e-dev/mobile`, or a `test` you already extended with fixtures of your own. Then write tests with it:
+
+```ts
+// tests/cart.e2e.ts
+import { expect } from "e2e";
+import { test } from "./fixtures.ts";
+
+test("a seeded cart checks out", async ({ app, appduct, screen }) => {
+  await app.open();
+  await appduct.call("seed_cart", { items: 3 });
+
+  await screen.getByRole("button", { name: "Check out" }).tap();
+
+  expect(await appduct.call("order_status")).toEqual({ status: "paid" });
+});
+```
+
+The first `appduct` call in a test connects to the app the test opened. A test that never uses `appduct` doesn't connect.
+
+## Let the agent call your tools
+
+Add `appductTools()` to an agent's `tools` in `e2e.config.ts`:
+
+```ts
+import type { E2EConfig } from "e2e";
+import { appductTools } from "@appduct/e2e";
+
+export default {
+  // targets: …
+  agents: { default: { model, tools: appductTools() } },
+} satisfies E2EConfig;
+```
+
+The agent gets `appduct_tools`, which lists the app's tools, and `appduct_call`, which calls one. They work in tests written with a `test` from `withAppduct`.
+
+## The `appduct` fixture
+
+| Member | What it does |
+| --- | --- |
+| `call(name, args?, options?)` | Calls a tool and returns its result. Waits up to 10 seconds for a tool the app hasn't registered yet. |
+| `tools()` | Lists the app's tools. Waits up to 10 seconds for the app to register its first. |
+| `waitForEvent(name, options?)` | Resolves with the next event the app posts under `name`. |
+
+Errors are `AppductError`s from `appduct/client`, with the same `type` the CLI reports.
+
+## Things to know
+
+- **The connection lasts as long as the app does.** A test that keeps the app running, such as the next test in a `serial` group, reuses the previous test's connection. After `app.open()`, `app.restart()` or a reload, the next call connects to the new app and ends the old connection, so `appduct sessions ls` doesn't fill up with dead sessions.
+- **A new iOS simulator asks once before the first link opens the app.** The fixture accepts iOS's "Open in …?" question for you, which shows as a `device.alert` step in that test's report. The simulator doesn't ask again.
+- **Agent steps that call `appduct_call` run live.** e2e can't replay a call that may change app state from its cache.
+
+## Made with ❤️ at Callstack
+
+`appduct` is an open source project and will always remain free to use. If you think it's cool, please star it 🌟. [Callstack][callstack-readme-with-love] is a group of React and React Native geeks, contact us at [hello@callstack.com](mailto:hello@callstack.com) if you need any help with these or just want to say hi!
+
+Like the project? ⚛️ [Join the team](https://callstack.com/careers/?utm_campaign=Senior_RN&utm_source=github&utm_medium=readme) who does amazing stuff for clients and drives React Native Open Source! 🔥
+
+[callstack-readme-with-love]: https://callstack.com/?utm_source=github.com&utm_medium=referral&utm_campaign=appduct&utm_term=readme-with-love

package/dist/agent-tools.d.ts

@@ -0,0 +1,11 @@
+import type { Appduct } from "./session.js";
+/** Points the agent tools at `session` until the returned function is called. */
+export declare const offerToAgent: (session: Appduct) => (() => void);
+/**
+ * Tools for e2e's agent that call the tools the app registered with Appduct. Add them to an
+ * agent's `tools` in `e2e.config.ts`; they work in tests written with a `test` from `withAppduct`.
+ */
+export declare const appductTools: () => {
+    appduct_tools: import("e2e/agent").DefinedTool;
+    appduct_call: import("e2e/agent").DefinedTool;
+};

package/dist/agent-tools.js

@@ -0,0 +1,49 @@
+import { jsonSchema, tool } from "ai";
+import { defineTool } from "e2e/agent";
+/**
+ * The session of the running test; e2e runs one test at a time in a worker. It lives on
+ * `globalThis` so a second copy of this module, such as one the config loads through another path,
+ * sees the same session.
+ */
+const SLOT = Symbol.for("@appduct/e2e/session");
+const slot = globalThis;
+/** Points the agent tools at `session` until the returned function is called. */
+export const offerToAgent = (session) => {
+    slot[SLOT] = session;
+    return () => {
+        if (slot[SLOT] === session)
+            delete slot[SLOT];
+    };
+};
+const session = () => {
+    const current = slot[SLOT];
+    if (!current)
+        throw new Error("No Appduct session in this test. Write the test with a `test` from `withAppduct`.");
+    return current;
+};
+/**
+ * Tools for e2e's agent that call the tools the app registered with Appduct. Add them to an
+ * agent's `tools` in `e2e.config.ts`; they work in tests written with a `test` from `withAppduct`.
+ */
+export const appductTools = () => ({
+    appduct_tools: defineTool(tool({
+        description: "List the tools the app under test registered with Appduct: what each one does and the arguments it takes. Use one with appduct_call to read or set app state directly instead of through the screen.",
+        inputSchema: jsonSchema({ type: "object", properties: {}, additionalProperties: false }),
+        execute: async () => session().tools(),
+    }), { mutates: false }),
+    appduct_call: defineTool(tool({
+        description: "Call a tool the app under test registered with Appduct and get its result. List the tools with appduct_tools first.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                name: { type: "string", description: "The tool's name, as appduct_tools lists it." },
+                args: { type: "object", description: "The tool's arguments, matching its input schema." },
+            },
+            required: ["name"],
+            additionalProperties: false,
+        }),
+        execute: async ({ name, args }) => session().call(name, args),
+    }), 
+    // A tool may change app state, which e2e cannot replay from its cache.
+    { mutates: true }),
+});

package/dist/daemon.d.ts

@@ -0,0 +1,18 @@
+import { type AppClient } from "appduct/client";
+/** The Appduct daemon, as pairing uses it. */
+export type Daemon = {
+    /** A link that opens the app and pairs it, valid for `ttlSeconds`. */
+    deviceLink(ttlSeconds: number): Promise<{
+        sessionId: string;
+        deepLink: string;
+    }>;
+    /** A link for the page at `url`, and the script that connects an open page to it. */
+    webLink(url: string, ttlSeconds: number): Promise<{
+        sessionId: string;
+        script: string;
+    }>;
+    /** Resolves once the app claims `sessionId`; rejects with `"timeout"` after `timeoutMs`. */
+    claim(sessionId: string, timeoutMs: number): Promise<AppClient>;
+};
+/** The daemon `appduct/client` reaches, started on first use. */
+export declare const appductDaemon: Daemon;

package/dist/daemon.js

@@ -0,0 +1,7 @@
+import { link, waitForSession } from "appduct/client";
+/** The daemon `appduct/client` reaches, started on first use. */
+export const appductDaemon = {
+    deviceLink: (ttlSeconds) => link({ ttlSeconds }),
+    webLink: (url, ttlSeconds) => link({ target: "web", url, ttlSeconds }),
+    claim: (sessionId, timeoutMs) => waitForSession(sessionId, { timeoutMs }),
+};

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `@appduct/e2e`: Appduct in e2e (https://github.com/tester-army/e2e) tests. `withAppduct(test)`
+ * gives every test an `appduct` fixture that calls the app's tools, and `appductTools()` gives
+ * e2e's agent the same reach.
+ *
+ * ```ts
+ * import { test as base } from "e2e";
+ * import { withAppduct } from "@appduct/e2e";
+ *
+ * const test = withAppduct(base);
+ *
+ * test("checks out", async ({ app, appduct, agent }) => {
+ *   await app.open();
+ *   await appduct.call("seed_cart", { sku: "SHIRT" });
+ *   await agent.act("check out");
+ *   expect(await appduct.call("order_status")).toEqual({ status: "paid" });
+ * });
+ * ```
+ */
+import type { TestAPI, TestFixtures } from "e2e";
+import { type Appduct } from "./session.js";
+export { appductTools } from "./agent-tools.js";
+export type { Appduct, EventWait } from "./session.js";
+/**
+ * Adds an `appduct` fixture to `base`: the app's Appduct session, connected on first use and kept
+ * for the next test while the app stays connected. `base` is
+ * e2e's `test`, an engine's typed `test`, or one you already extended.
+ */
+export declare const withAppduct: <Fixtures extends TestFixtures>(base: TestAPI<Fixtures>) => TestAPI<Fixtures & {
+    appduct: Appduct;
+}>;

package/dist/index.js

@@ -0,0 +1,40 @@
+import { offerToAgent } from "./agent-tools.js";
+import { appductDaemon } from "./daemon.js";
+import { pairWith } from "./pairing.js";
+import { createSessions } from "./session.js";
+export { appductTools } from "./agent-tools.js";
+const clock = {
+    now: () => Date.now(),
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+};
+/** One per worker process, shared by every `withAppduct` test in it. */
+const sessions = createSessions(clock);
+/** Reads the engine's fixture for the platform only when pairing, since e2e acquires fixtures on access. */
+const targetOf = (fixtures) => {
+    const { platform } = fixtures;
+    if (platform === "web")
+        return { platform, browser: fixtures.browser };
+    if (platform === "ios" || platform === "android")
+        return { platform, device: fixtures.device };
+    throw new Error(`Appduct pairs with web, iOS and Android targets, not "${platform}".`);
+};
+/**
+ * Adds an `appduct` fixture to `base`: the app's Appduct session, connected on first use and kept
+ * for the next test while the app stays connected. `base` is
+ * e2e's `test`, an engine's typed `test`, or one you already extended.
+ */
+export const withAppduct = (base) => {
+    const appduct = async (fixtures, use) => {
+        const session = sessions.forTest(() => pairWith(targetOf(fixtures), appductDaemon, clock));
+        const withdraw = offerToAgent(session);
+        try {
+            await use(session);
+        }
+        finally {
+            withdraw();
+        }
+    };
+    // The mapped definition type cannot tell that `appduct` is absent from a generic `Fixtures`; a
+    // base that has one fails at import with e2e's own COLLECTION_ERROR.
+    return base.extend({ appduct });
+};

package/dist/memory-daemon.d.ts

@@ -0,0 +1,18 @@
+import type { AppClient } from "appduct/client";
+import type { Daemon } from "./daemon.js";
+/** A daemon in memory: the test decides when an app claims a link or a claim wait runs out. */
+export declare const createMemoryDaemon: () => {
+    daemon: Daemon;
+    /** Every link minted, oldest first. */
+    links: {
+        sessionId: string;
+        ttlSeconds: number;
+        url?: string;
+    }[];
+    /** The `timeoutMs` each claim wait was given. */
+    claimTimeouts: Map<string, number>;
+    /** The app claims `sessionId`, before or after anyone waits for it. */
+    appClaims: (sessionId: string, client: AppClient) => void;
+    /** The wait for `sessionId` runs out. */
+    expire: (sessionId: string, error: unknown) => void;
+};

package/dist/memory-daemon.js

@@ -0,0 +1,45 @@
+/** A daemon in memory: the test decides when an app claims a link or a claim wait runs out. */
+export const createMemoryDaemon = () => {
+    const claims = new Map();
+    const links = [];
+    const claimTimeouts = new Map();
+    const claimOf = (sessionId) => {
+        let claim = claims.get(sessionId);
+        if (!claim) {
+            let resolve;
+            let reject;
+            const promise = new Promise((res, rej) => ((resolve = res), (reject = rej)));
+            promise.catch(() => undefined); // a claim nobody waits for must not fail the test run
+            claim = { promise, resolve, reject };
+            claims.set(sessionId, claim);
+        }
+        return claim;
+    };
+    const daemon = {
+        deviceLink: async (ttlSeconds) => {
+            const sessionId = `s${links.length + 1}`;
+            links.push({ sessionId, ttlSeconds });
+            return { sessionId, deepLink: `myapp:///?appduct=${sessionId}` };
+        },
+        webLink: async (url, ttlSeconds) => {
+            const sessionId = `s${links.length + 1}`;
+            links.push({ sessionId, ttlSeconds, url });
+            return { sessionId, script: `connect("${sessionId}")` };
+        },
+        claim: (sessionId, timeoutMs) => {
+            claimTimeouts.set(sessionId, timeoutMs);
+            return claimOf(sessionId).promise;
+        },
+    };
+    return {
+        daemon,
+        /** Every link minted, oldest first. */
+        links,
+        /** The `timeoutMs` each claim wait was given. */
+        claimTimeouts,
+        /** The app claims `sessionId`, before or after anyone waits for it. */
+        appClaims: (sessionId, client) => claimOf(sessionId).resolve(client),
+        /** The wait for `sessionId` runs out. */
+        expire: (sessionId, error) => claimOf(sessionId).reject(error),
+    };
+};

package/dist/pairing.d.ts

@@ -0,0 +1,22 @@
+import { type AppClient } from "appduct/client";
+import type { Daemon } from "./daemon.js";
+import type { Clock } from "./session.js";
+/** The part of e2e's `browser` fixture pairing uses. */
+export type PairingBrowser = {
+    url(): Promise<string>;
+    evaluate(script: string): Promise<unknown>;
+};
+/** The part of e2e's `device` fixture pairing uses. */
+export type PairingDevice = {
+    openLink(url: string): Promise<void>;
+    alert(action: "accept"): Promise<void>;
+};
+export type PairingTarget = {
+    platform: "web";
+    browser: PairingBrowser;
+} | {
+    platform: "ios" | "android";
+    device: PairingDevice;
+};
+/** Hands the app under test a fresh link and resolves once the app has claimed it. */
+export declare const pairWith: (target: PairingTarget, daemon: Daemon, clock: Clock) => Promise<AppClient>;

package/dist/pairing.js

@@ -0,0 +1,37 @@
+import { AppductError } from "appduct/client";
+/** A device may still be launching the app; a page that loads `@appduct/web` connects at once. */
+const DEVICE_CLAIM_SECONDS = 60;
+const WEB_CLAIM_SECONDS = 10;
+/** How long an iOS app gets to claim before pairing looks for iOS's "Open in …?" question. */
+const PROMPT_WAIT_MS = 2_000;
+/** Connects the page in the test's browser. */
+const linkPage = async (browser, daemon) => {
+    // The link lasts only as long as the wait, so a failed pairing leaves nothing behind.
+    const { sessionId, script } = await daemon.webLink(await browser.url(), WEB_CLAIM_SECONDS);
+    await browser.evaluate(`(${script}, null)`);
+    return daemon.claim(sessionId, WEB_CLAIM_SECONDS * 1000).catch((error) => {
+        if (!(error instanceof AppductError && error.type === "timeout"))
+            throw error;
+        throw new AppductError("timeout", `The page did not connect to Appduct within ${WEB_CLAIM_SECONDS} s. Check that it loads @appduct/web from a development build.`);
+    });
+};
+/**
+ * Has e2e open the app's deep link, which launches the app if it is not running. A simulator asks
+ * "Open in …?" for the first link it opens into an app and not again once accepted, so the question
+ * is accepted only when the app has not claimed in time.
+ */
+const linkApp = async (target, daemon, clock) => {
+    const { sessionId, deepLink } = await daemon.deviceLink(DEVICE_CLAIM_SECONDS);
+    await target.device.openLink(deepLink);
+    const claimed = daemon.claim(sessionId, DEVICE_CLAIM_SECONDS * 1000);
+    if (target.platform === "ios") {
+        const settled = claimed.then(() => true, () => true);
+        if (!(await Promise.race([settled, clock.sleep(PROMPT_WAIT_MS).then(() => false)]))) {
+            // agent-device can report a failure for a question it did accept, so the claim decides.
+            await target.device.alert("accept").catch(() => undefined);
+        }
+    }
+    return claimed;
+};
+/** Hands the app under test a fresh link and resolves once the app has claimed it. */
+export const pairWith = (target, daemon, clock) => target.platform === "web" ? linkPage(target.browser, daemon) : linkApp(target, daemon, clock);

package/dist/session.d.ts

@@ -0,0 +1,23 @@
+import { type AppClient, type CallOptions, type FullAppEvent, type ListedToolDescriptor, type WaitForEventOptions } from "appduct/client";
+/** The app's Appduct session in one e2e test, paired the first time a test or agent step uses it. */
+export type Appduct = {
+    /** Calls a tool the app registered, waiting up to 10 s for a tool the app has not registered yet. */
+    call(name: string, args?: Record<string, unknown>, options?: CallOptions): Promise<unknown>;
+    /** The tools the app registered, waiting up to 10 s for the app to register its first. */
+    tools(): Promise<ListedToolDescriptor[]>;
+    /** Resolves with the next event the app posts under `name`. */
+    waitForEvent<TPayload = unknown>(name: string, options?: EventWait): Promise<FullAppEvent<TPayload>>;
+};
+/** How long to wait and which events count; the payload always arrives in full. */
+export type EventWait = Omit<WaitForEventOptions, "payloadMaxBytes">;
+export type Clock = {
+    now(): number;
+    sleep(ms: number): Promise<void>;
+};
+/**
+ * The worker's Appduct session, kept across tests: e2e runs one test at a time in a worker, and a
+ * test that leaves the app running hands the next one an app that is still connected.
+ */
+export declare const createSessions: (clock: Clock) => {
+    forTest: (pair: () => Promise<AppClient>) => Appduct;
+};

package/dist/session.js

@@ -0,0 +1,93 @@
+import { AppductError } from "appduct/client";
+/** An app registers its tools just after it claims a session, and a screen may register more as it opens. */
+const TOOL_WAIT_MS = 10_000;
+const POLL_MS = 50;
+const isGone = (error) => error instanceof AppductError &&
+    (error.type === "session_suspended" || error.type === "session_not_active" || error.type === "unknown_session");
+/** Ends a session that is no longer worth keeping. The daemon may have forgotten it already. */
+const discard = async (client) => {
+    await client.revoke().catch(() => undefined);
+    client.close(); // only now: closing drops a revoke still on its way
+};
+/**
+ * The worker's Appduct session, kept across tests: e2e runs one test at a time in a worker, and a
+ * test that leaves the app running hands the next one an app that is still connected.
+ */
+export const createSessions = (clock) => {
+    let kept;
+    /** The kept session while the app is still connected to it, else a newly paired one. */
+    const resume = async (pair) => {
+        const previous = kept;
+        kept = undefined;
+        if (previous) {
+            // Anything but `active` means the app went away: relaunched, reloaded or closed.
+            if ((await previous.state().catch(() => undefined)) === "active")
+                return (kept = previous);
+            await discard(previous);
+        }
+        return (kept = await pair());
+    };
+    /**
+     * One test's view of the session. It connects on first use, reusing the kept session when it can,
+     * and pairs again once if the session goes away during the test.
+     */
+    const forTest = (pair) => {
+        let current;
+        const connected = () => {
+            if (!current) {
+                const attempt = resume(pair);
+                attempt.catch(() => {
+                    if (current === attempt)
+                        current = undefined; // so the next use tries again
+                });
+                current = attempt;
+            }
+            return current;
+        };
+        const withClient = async (use) => {
+            const attempt = connected();
+            const client = await attempt;
+            try {
+                return await use(client);
+            }
+            catch (error) {
+                if (!isGone(error))
+                    throw error;
+                if (current === attempt)
+                    current = undefined; // a concurrent call may have reconnected already
+                return use(await connected());
+            }
+        };
+        return {
+            // Each wait starts at the app's first answer, so the time pairing took does not count.
+            call: async (name, args = {}, options) => {
+                let deadline;
+                for (;;) {
+                    try {
+                        return await withClient((client) => client.call(name, args, options));
+                    }
+                    catch (error) {
+                        if (!(error instanceof AppductError && error.type === "tool_not_found"))
+                            throw error;
+                        deadline ??= clock.now() + TOOL_WAIT_MS;
+                        if (clock.now() >= deadline)
+                            throw error;
+                        await clock.sleep(POLL_MS);
+                    }
+                }
+            },
+            tools: async () => {
+                let deadline;
+                for (;;) {
+                    const tools = await withClient((client) => client.tools());
+                    deadline ??= clock.now() + TOOL_WAIT_MS;
+                    if (tools.length > 0 || clock.now() >= deadline)
+                        return tools;
+                    await clock.sleep(POLL_MS);
+                }
+            },
+            waitForEvent: (name, options) => withClient((client) => client.waitForEvent(name, options)),
+        };
+    };
+    return { forTest };
+};

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@appduct/e2e",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.0",
+  "description": "Use Appduct in e2e tests: call your app's tools from a test or let e2e's agent call them.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/callstackincubator/appduct"
+  },
+  "bugs": {
+    "url": "https://github.com/callstackincubator/appduct/issues"
+  },
+  "author": "Szymon Chmal <szymon@chmal.it> (V3RON)",
+  "license": "MIT",
+  "dependencies": {
+    "appduct": "0.15.1"
+  },
+  "peerDependencies": {
+    "ai": "^7.0.0",
+    "e2e": ">=0.21.0 <1"
+  },
+  "devDependencies": {
+    "@e2e-dev/mobile": "0.12.3",
+    "@e2e-dev/web": "0.15.2",
+    "@types/node": "^22.10.0",
+    "ai": "^7.0.0",
+    "e2e": "0.21.2",
+    "typescript": "~5.9.2"
+  },
+  "homepage": "https://github.com/callstackincubator/appduct/tree/main/packages/e2e#readme",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "appduct",
+    "e2e",
+    "testing"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "lint": "eslint src",
+    "test": "vitest run --config ../../vitest.config.ts src",
+    "typecheck": "tsc -p tsconfig.json"
+  }
 }