@win-auto/core 0.1.2

package/README.md

@@ -0,0 +1,80 @@
+# win-auto-core
+
+[![npm version](https://img.shields.io/npm/v/win-auto-core.svg)](https://www.npmjs.com/package/win-auto-core)
+
+Core TypeScript API for Windows desktop automation.
+
+## Installation
+
+```bash
+npm install win-auto-core
+```
+
+## Quick Start
+
+```typescript
+import { Automation } from 'win-auto-core';
+
+const automation = new Automation();
+const app = await automation.launch('C:\\Windows\\System32\\notepad.exe');
+const textbox = await app.find({ role: 'textbox' });
+await textbox?.type('Hello from win-auto!');
+```
+
+## API
+
+### Automation
+
+Main entry point.
+
+```typescript
+const automation = new Automation();
+const app = await automation.launch(executablePath);
+```
+
+### App
+
+Launched application instance.
+
+```typescript
+const mainWindow = await app.getMainWindow();
+const element = await app.find({ role: 'button', name: 'OK' });
+```
+
+### Window
+
+Window in the application.
+
+```typescript
+const element = await window.findElement({ role: 'textbox' });
+```
+
+### Element
+
+UI element for interaction.
+
+```typescript
+await element.typeText('Hello');
+await element.click();
+```
+
+## Testing Support
+
+Export testing utilities:
+
+```typescript
+import { setupAutomation } from 'win-auto-core/testing';
+```
+
+## Requirements
+
+- Windows 10/11
+- Node.js 18+
+
+## Documentation
+
+See the [main README](../../README.md) for complete documentation, examples, and troubleshooting.
+
+## License
+
+MIT

package/dist/api/app.d.ts

@@ -0,0 +1,20 @@
+import { Window } from "./window";
+import { Element } from "./element";
+export declare class App {
+    readonly processId: number;
+    readonly executablePath: string;
+    readonly title: string;
+    constructor(processId: number, executablePath: string, title: string);
+    listWindows(): Promise<Window[]>;
+    getMainWindow(): Promise<Window | null>;
+    waitForMainWindow(options?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }): Promise<Window>;
+    find(selector: {
+        automationId?: string;
+        name?: string;
+        role?: string;
+    }): Promise<Element | null>;
+    close(): Promise<void>;
+}

package/dist/api/app.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const window_1 = require("./window");
+const loadNative_1 = require("../native/loadNative");
+class App {
+    processId;
+    executablePath;
+    title;
+    constructor(processId, executablePath, title) {
+        this.processId = processId;
+        this.executablePath = executablePath;
+        this.title = title;
+    }
+    async listWindows() {
+        const handles = await (0, loadNative_1.loadNativeBindings)().enumerateWindows(this.processId);
+        return handles.map((handle) => new window_1.Window(handle, this.processId));
+    }
+    async getMainWindow() {
+        const windows = await this.listWindows();
+        if (windows.length === 0) {
+            return null;
+        }
+        return windows[0];
+    }
+    async waitForMainWindow(options) {
+        const timeoutMs = options?.timeoutMs ?? 10_000;
+        const intervalMs = options?.intervalMs ?? 100;
+        const maxAttempts = Math.max(1, Math.ceil(timeoutMs / intervalMs));
+        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+            const window = await this.getMainWindow();
+            if (window) {
+                return window;
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+        throw new Error(`No top-level window found for process ${this.processId} within ${timeoutMs}ms.`);
+    }
+    async find(selector) {
+        const mainWindow = await this.getMainWindow();
+        if (!mainWindow) {
+            return null;
+        }
+        return mainWindow.findElement(selector);
+    }
+    async close() {
+        await (0, loadNative_1.loadNativeBindings)().closeApp(this.processId);
+    }
+}
+exports.App = App;

package/dist/api/automation.d.ts

@@ -0,0 +1,9 @@
+import { App } from "./app";
+import type { AppSelector, LaunchOptions } from "./types";
+export declare class Automation {
+    launch(executablePath: string): Promise<App>;
+    launchApp(options: LaunchOptions): Promise<App>;
+    connectApp(selector: AppSelector): Promise<App>;
+    pingNative(): string;
+    debugDiscovery(processId: number): import("./types").WindowDebugInfo[];
+}

package/dist/api/automation.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Automation = void 0;
+const app_1 = require("./app");
+const classNames_1 = require("../native/classNames");
+const loadNative_1 = require("../native/loadNative");
+class Automation {
+    async launch(executablePath) {
+        return this.launchApp({ executablePath });
+    }
+    async launchApp(options) {
+        const native = (0, loadNative_1.loadNativeBindings)();
+        if (native.setAppConfig) {
+            const classNames = options.executablePath.toLowerCase().includes("notepad.exe")
+                ? classNames_1.DEFAULT_NOTEPAD_CLASS_NAMES
+                : [];
+            native.setAppConfig(options.executablePath, classNames);
+        }
+        const processId = await native.launch(options.executablePath);
+        return new app_1.App(processId, options.executablePath, options.title ?? "Launched App");
+    }
+    async connectApp(selector) {
+        if (!selector.processId) {
+            throw new Error("connectApp currently requires processId for the native backend.");
+        }
+        return new app_1.App(selector.processId, selector.executablePath ?? "unknown", selector.title ?? "Connected App");
+    }
+    pingNative() {
+        return (0, loadNative_1.loadNativeBindings)().ping();
+    }
+    debugDiscovery(processId) {
+        const native = (0, loadNative_1.loadNativeBindings)();
+        if (!native.debugDiscovery) {
+            throw new Error("debugDiscovery is not available in the loaded native module.");
+        }
+        return native.debugDiscovery(processId);
+    }
+}
+exports.Automation = Automation;

package/dist/api/element.d.ts

@@ -0,0 +1,10 @@
+export declare class Element {
+    readonly handle: string;
+    private readonly windowHandle;
+    constructor(handle: string, windowHandle: string);
+    click(): Promise<void>;
+    typeText(text: string): Promise<void>;
+    type(text: string): Promise<void>;
+    getText(): Promise<string>;
+    exists(): Promise<boolean>;
+}

package/dist/api/element.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Element = void 0;
+const loadNative_1 = require("../native/loadNative");
+class Element {
+    handle;
+    windowHandle;
+    constructor(handle, windowHandle) {
+        this.handle = handle;
+        this.windowHandle = windowHandle;
+    }
+    async click() {
+        await Promise.resolve();
+    }
+    async typeText(text) {
+        await (0, loadNative_1.loadNativeBindings)().typeText(this.handle, text);
+    }
+    async type(text) {
+        return this.typeText(text);
+    }
+    async getText() {
+        // Minimal backend currently supports writing text only.
+        return "";
+    }
+    async exists() {
+        const candidate = await (0, loadNative_1.loadNativeBindings)().findElement(this.windowHandle);
+        return candidate === this.handle;
+    }
+}
+exports.Element = Element;

package/dist/api/testAutomation.d.ts

@@ -0,0 +1,8 @@
+import { Automation } from "./automation";
+import type { LaunchOptions } from "./types";
+import type { App } from "./app";
+export declare function trackApp(app: App): App;
+export declare function closeTrackedApps(): Promise<void>;
+export declare class TestAutomation extends Automation {
+    launchApp(options: LaunchOptions): Promise<App>;
+}

package/dist/api/testAutomation.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestAutomation = void 0;
+exports.trackApp = trackApp;
+exports.closeTrackedApps = closeTrackedApps;
+const automation_1 = require("./automation");
+const launchedApps = new Set();
+function trackApp(app) {
+    launchedApps.add(app);
+    return app;
+}
+async function closeTrackedApps() {
+    const apps = [...launchedApps];
+    launchedApps.clear();
+    await Promise.all(apps.map(async (app) => {
+        try {
+            await app.close();
+        }
+        catch {
+            // Best-effort cleanup between tests.
+        }
+    }));
+}
+class TestAutomation extends automation_1.Automation {
+    async launchApp(options) {
+        const app = await super.launchApp(options);
+        return trackApp(app);
+    }
+}
+exports.TestAutomation = TestAutomation;

package/dist/api/types.d.ts

@@ -0,0 +1,36 @@
+export type AppSelector = {
+    executablePath?: string;
+    processId?: number;
+    title?: string;
+};
+export type LaunchOptions = {
+    executablePath: string;
+    args?: string[];
+    title?: string;
+};
+export type ElementSelector = {
+    automationId?: string;
+    name?: string;
+    role?: string;
+};
+export type WindowDebugInfo = {
+    hwnd: string;
+    pid: number;
+    className: string;
+    title: string;
+    visible: boolean;
+    ownerInvalid: boolean;
+    matchesTargetPid: boolean;
+    passesTopLevelVisible: boolean;
+    processImage: string;
+};
+export type NativeBindings = {
+    ping: () => string;
+    setAppConfig?: (executable: string, classNames: string[]) => void;
+    launch: (executablePath?: string | null) => Promise<number>;
+    enumerateWindows: (processId: number) => Promise<string[]>;
+    debugDiscovery?: (processId: number) => WindowDebugInfo[];
+    findElement: (windowHandle: string, classNames?: string[] | null, automationId?: string | null, name?: string | null, role?: string | null) => Promise<string | null>;
+    typeText: (elementHandle: string, text: string) => Promise<void>;
+    closeApp: (processId: number) => Promise<void>;
+};

package/dist/api/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/window.d.ts

@@ -0,0 +1,11 @@
+import type { ElementSelector } from "./types";
+import { Element } from "./element";
+export declare class Window {
+    readonly handle: string;
+    readonly processId: number;
+    constructor(handle: string, processId: number);
+    findElement(selector: ElementSelector): Promise<Element | null>;
+    find(selector: ElementSelector): Promise<Element | null>;
+    findElements(selector: ElementSelector): Promise<Element[]>;
+    focus(): Promise<void>;
+}

package/dist/api/window.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Window = void 0;
+const element_1 = require("./element");
+const classNames_1 = require("../native/classNames");
+const loadNative_1 = require("../native/loadNative");
+class Window {
+    handle;
+    processId;
+    constructor(handle, processId) {
+        this.handle = handle;
+        this.processId = processId;
+    }
+    async findElement(selector) {
+        const elementHandle = await (0, loadNative_1.loadNativeBindings)().findElement(this.handle, (0, classNames_1.classNamesForSelector)(selector), selector.automationId, selector.name, selector.role);
+        if (!elementHandle) {
+            return null;
+        }
+        return new element_1.Element(elementHandle, this.handle);
+    }
+    async find(selector) {
+        return this.findElement(selector);
+    }
+    async findElements(selector) {
+        const element = await this.findElement(selector);
+        return element ? [element] : [];
+    }
+    async focus() {
+        // Focus support is intentionally minimal for the initial native backend.
+        await Promise.resolve();
+    }
+}
+exports.Window = Window;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { Automation } from "./api/automation";
+export { App } from "./api/app";
+export { Window } from "./api/window";
+export { Element } from "./api/element";
+export { TestAutomation, trackApp, closeTrackedApps } from "./api/testAutomation";
+export type { AppSelector, ElementSelector, LaunchOptions } from "./api/types";

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeTrackedApps = exports.trackApp = exports.TestAutomation = exports.Element = exports.Window = exports.App = exports.Automation = void 0;
+var automation_1 = require("./api/automation");
+Object.defineProperty(exports, "Automation", { enumerable: true, get: function () { return automation_1.Automation; } });
+var app_1 = require("./api/app");
+Object.defineProperty(exports, "App", { enumerable: true, get: function () { return app_1.App; } });
+var window_1 = require("./api/window");
+Object.defineProperty(exports, "Window", { enumerable: true, get: function () { return window_1.Window; } });
+var element_1 = require("./api/element");
+Object.defineProperty(exports, "Element", { enumerable: true, get: function () { return element_1.Element; } });
+var testAutomation_1 = require("./api/testAutomation");
+Object.defineProperty(exports, "TestAutomation", { enumerable: true, get: function () { return testAutomation_1.TestAutomation; } });
+Object.defineProperty(exports, "trackApp", { enumerable: true, get: function () { return testAutomation_1.trackApp; } });
+Object.defineProperty(exports, "closeTrackedApps", { enumerable: true, get: function () { return testAutomation_1.closeTrackedApps; } });

package/dist/mock/mockRuntime.d.ts

@@ -0,0 +1,31 @@
+import type { ElementSelector, LaunchOptions } from "../api/types";
+export type MockElementRecord = {
+    id: string;
+    selector: ElementSelector;
+    text: string;
+};
+export type MockWindowRecord = {
+    id: string;
+    title: string;
+    elements: MockElementRecord[];
+};
+export type MockAppRecord = {
+    id: string;
+    executablePath: string;
+    title: string;
+    windows: MockWindowRecord[];
+};
+export declare class MockRuntime {
+    private appCounter;
+    private windowCounter;
+    private elementCounter;
+    private apps;
+    launchApp(options: LaunchOptions): Promise<MockAppRecord>;
+    listApps(): Promise<MockAppRecord[]>;
+    getAppById(appId: string): Promise<MockAppRecord | null>;
+    closeApp(appId: string): Promise<void>;
+    findElement(windowRecord: MockWindowRecord, selector: ElementSelector): Promise<MockElementRecord | null>;
+    listElements(windowRecord: MockWindowRecord, selector: ElementSelector): Promise<MockElementRecord[]>;
+    setElementText(windowRecord: MockWindowRecord, elementId: string, text: string): Promise<void>;
+}
+export declare const runtime: MockRuntime;

package/dist/mock/mockRuntime.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtime = exports.MockRuntime = void 0;
+const DELAY_MS = 15;
+function wait() {
+    return new Promise((resolve) => setTimeout(resolve, DELAY_MS));
+}
+function selectorMatches(recordSelector, query) {
+    if (query.automationId && recordSelector.automationId !== query.automationId) {
+        return false;
+    }
+    if (query.name && recordSelector.name !== query.name) {
+        return false;
+    }
+    if (query.role && recordSelector.role !== query.role) {
+        return false;
+    }
+    return true;
+}
+class MockRuntime {
+    appCounter = 1;
+    windowCounter = 1;
+    elementCounter = 1;
+    apps = new Map();
+    async launchApp(options) {
+        await wait();
+        const appId = `app-${this.appCounter++}`;
+        const windowId = `win-${this.windowCounter++}`;
+        const defaultElement = {
+            id: `el-${this.elementCounter++}`,
+            selector: { automationId: "main-input", name: "Main Input", role: "textbox" },
+            text: ""
+        };
+        const app = {
+            id: appId,
+            executablePath: options.executablePath,
+            title: options.title ?? "Mock App",
+            windows: [{ id: windowId, title: options.title ?? "Main Window", elements: [defaultElement] }]
+        };
+        this.apps.set(appId, app);
+        return app;
+    }
+    async listApps() {
+        await wait();
+        return [...this.apps.values()];
+    }
+    async getAppById(appId) {
+        await wait();
+        return this.apps.get(appId) ?? null;
+    }
+    async closeApp(appId) {
+        await wait();
+        this.apps.delete(appId);
+    }
+    async findElement(windowRecord, selector) {
+        await wait();
+        const match = windowRecord.elements.find((record) => selectorMatches(record.selector, selector));
+        return match ?? null;
+    }
+    async listElements(windowRecord, selector) {
+        await wait();
+        return windowRecord.elements.filter((record) => selectorMatches(record.selector, selector));
+    }
+    async setElementText(windowRecord, elementId, text) {
+        await wait();
+        const element = windowRecord.elements.find((record) => record.id === elementId);
+        if (!element) {
+            throw new Error(`Element not found: ${elementId}`);
+        }
+        element.text = text;
+    }
+}
+exports.MockRuntime = MockRuntime;
+exports.runtime = new MockRuntime();

package/dist/mock/mockRuntime.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mock/mockRuntime.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const automation_1 = require("../api/automation");
+const nativeMock = {
+    ping: vitest_1.vi.fn(() => "ok"),
+    launch: vitest_1.vi.fn(async () => 4242),
+    enumerateWindows: vitest_1.vi.fn(async () => ["100"]),
+    findElement: vitest_1.vi.fn(async () => "200"),
+    typeText: vitest_1.vi.fn(async () => undefined)
+};
+vitest_1.vi.mock("../native/loadNative", () => ({
+    loadNativeBindings: () => nativeMock
+}));
+(0, vitest_1.describe)("native API wrapper", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.it)("keeps async object flow through native bindings", async () => {
+        const automation = new automation_1.Automation();
+        const app = await automation.launchApp({
+            executablePath: "C:\\Windows\\System32\\notepad.exe",
+            title: "Notepad"
+        });
+        const window = await app.getMainWindow();
+        const element = await window?.findElement({ role: "textbox" });
+        await element?.typeText("hello");
+        (0, vitest_1.expect)(app.processId).toBe(4242);
+        (0, vitest_1.expect)(nativeMock.launch).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(nativeMock.enumerateWindows).toHaveBeenCalledWith(4242);
+        (0, vitest_1.expect)(nativeMock.findElement).toHaveBeenCalled();
+        (0, vitest_1.expect)(nativeMock.typeText).toHaveBeenCalledWith("200", "hello");
+    });
+});

package/dist/native/classNames.d.ts

@@ -0,0 +1,3 @@
+import type { ElementSelector } from "../api/types";
+export declare function classNamesForSelector(selector: ElementSelector): string[] | undefined;
+export declare const DEFAULT_NOTEPAD_CLASS_NAMES: string[];

package/dist/native/classNames.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_NOTEPAD_CLASS_NAMES = void 0;
+exports.classNamesForSelector = classNamesForSelector;
+const TEXTBOX_CLASS_NAMES = ["Edit", "RichEditD2DPT", "Scintilla"];
+function classNamesForSelector(selector) {
+    if (selector.role === "textbox") {
+        return TEXTBOX_CLASS_NAMES;
+    }
+    return undefined;
+}
+exports.DEFAULT_NOTEPAD_CLASS_NAMES = TEXTBOX_CLASS_NAMES;

package/dist/native/loadNative.d.ts

@@ -0,0 +1,2 @@
+import type { NativeBindings } from "../api/types";
+export declare function loadNativeBindings(): NativeBindings;

package/dist/native/loadNative.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadNativeBindings = loadNativeBindings;
+const node_path_1 = __importDefault(require("node:path"));
+const nativeSearchPaths = [
+    "../../../../native/win-auto-native/win-auto-native.win32-x64-msvc.node",
+    "../../../../native/win-auto-native/win-auto-native.win32-arm64-msvc.node",
+    "../../../../native/win-auto-native/win_auto_native.node",
+    "../../../../native/win-auto-native/index.node",
+    "../../../../native/win-auto-native/index.js",
+    "../../../../native/win-auto-native"
+];
+function loadNativeBindings() {
+    for (const relativePath of nativeSearchPaths) {
+        const resolvedPath = node_path_1.default.resolve(__dirname, relativePath);
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const mod = require(resolvedPath);
+            if (typeof mod.ping === "function" &&
+                typeof mod.launch === "function" &&
+                typeof mod.enumerateWindows === "function" &&
+                typeof mod.findElement === "function" &&
+                typeof mod.typeText === "function" &&
+                typeof mod.closeApp === "function") {
+                return mod;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error("Native module not found. Run `npm run build:native` at workspace root before calling native functions.");
+}

package/dist/testing/context.d.ts

@@ -0,0 +1 @@
+export { trackApp, closeTrackedApps } from "../api/testAutomation";

package/dist/testing/context.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeTrackedApps = exports.trackApp = void 0;
+var testAutomation_1 = require("../api/testAutomation");
+Object.defineProperty(exports, "trackApp", { enumerable: true, get: function () { return testAutomation_1.trackApp; } });
+Object.defineProperty(exports, "closeTrackedApps", { enumerable: true, get: function () { return testAutomation_1.closeTrackedApps; } });

package/dist/testing/globals.d.ts

@@ -0,0 +1,8 @@
+import type { it as winAutoIt } from "./vitest";
+import type { describe as vitestDescribe, expect as vitestExpect } from "vitest";
+declare global {
+    const describe: typeof vitestDescribe;
+    const it: typeof winAutoIt;
+    const expect: typeof vitestExpect;
+}
+export {};

package/dist/testing/globals.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/testing/index.d.ts

@@ -0,0 +1,6 @@
+import "./globals";
+export { describe } from "vitest";
+export { it } from "./vitest";
+export { expect, vi, beforeEach, afterEach, beforeAll, afterAll } from "vitest";
+export { TestAutomation, trackApp, closeTrackedApps } from "../api/testAutomation";
+export { installTestGlobals } from "./installGlobals";

package/dist/testing/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installTestGlobals = exports.closeTrackedApps = exports.trackApp = exports.TestAutomation = exports.afterAll = exports.beforeAll = exports.afterEach = exports.beforeEach = exports.vi = exports.expect = exports.it = exports.describe = void 0;
+require("./globals");
+var vitest_1 = require("vitest");
+Object.defineProperty(exports, "describe", { enumerable: true, get: function () { return vitest_1.describe; } });
+var vitest_2 = require("./vitest");
+Object.defineProperty(exports, "it", { enumerable: true, get: function () { return vitest_2.it; } });
+var vitest_3 = require("vitest");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return vitest_3.expect; } });
+Object.defineProperty(exports, "vi", { enumerable: true, get: function () { return vitest_3.vi; } });
+Object.defineProperty(exports, "beforeEach", { enumerable: true, get: function () { return vitest_3.beforeEach; } });
+Object.defineProperty(exports, "afterEach", { enumerable: true, get: function () { return vitest_3.afterEach; } });
+Object.defineProperty(exports, "beforeAll", { enumerable: true, get: function () { return vitest_3.beforeAll; } });
+Object.defineProperty(exports, "afterAll", { enumerable: true, get: function () { return vitest_3.afterAll; } });
+var testAutomation_1 = require("../api/testAutomation");
+Object.defineProperty(exports, "TestAutomation", { enumerable: true, get: function () { return testAutomation_1.TestAutomation; } });
+Object.defineProperty(exports, "trackApp", { enumerable: true, get: function () { return testAutomation_1.trackApp; } });
+Object.defineProperty(exports, "closeTrackedApps", { enumerable: true, get: function () { return testAutomation_1.closeTrackedApps; } });
+var installGlobals_1 = require("./installGlobals");
+Object.defineProperty(exports, "installTestGlobals", { enumerable: true, get: function () { return installGlobals_1.installTestGlobals; } });

package/dist/testing/installGlobals.d.ts

@@ -0,0 +1,3 @@
+import "./setup";
+/** Installs win-auto describe/it/expect on globalThis (also runs automatically via testing/setup). */
+export declare function installTestGlobals(): void;

package/dist/testing/installGlobals.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installTestGlobals = installTestGlobals;
+require("./setup");
+/** Installs win-auto describe/it/expect on globalThis (also runs automatically via testing/setup). */
+function installTestGlobals() {
+    // setup.ts assigns globals on import.
+}

package/dist/testing/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/testing/setup.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const context_1 = require("./context");
+const vitest_2 = require("./vitest");
+(0, vitest_1.afterEach)(async () => {
+    await (0, context_1.closeTrackedApps)();
+});
+const globals = globalThis;
+globals.describe = vitest_1.describe;
+globals.it = vitest_2.it;
+globals.expect = vitest_1.expect;

package/dist/testing/testAutomation.d.ts

@@ -0,0 +1,6 @@
+import { Automation } from "../api/automation";
+import type { LaunchOptions } from "../api/types";
+import type { App } from "../api/app";
+export declare class TestAutomation extends Automation {
+    launchApp(options: LaunchOptions): Promise<App>;
+}

package/dist/testing/testAutomation.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestAutomation = void 0;
+const automation_1 = require("../api/automation");
+const context_1 = require("./context");
+class TestAutomation extends automation_1.Automation {
+    async launchApp(options) {
+        const app = await super.launchApp(options);
+        return (0, context_1.trackApp)(app);
+    }
+}
+exports.TestAutomation = TestAutomation;

package/dist/testing/vitest.d.ts

@@ -0,0 +1,2 @@
+import { it as vitestIt } from "vitest";
+export declare const it: typeof vitestIt;

package/dist/testing/vitest.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.it = void 0;
+const vitest_1 = require("vitest");
+const DEFAULT_TEST_TIMEOUT_MS = 30_000;
+exports.it = Object.assign((name, fn, timeout) => (0, vitest_1.it)(name, fn, timeout ?? DEFAULT_TEST_TIMEOUT_MS), vitest_1.it);

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@win-auto/core",
+  "version": "0.1.2",
+  "description": "Core TypeScript API for Windows desktop automation.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mihailDamchevski/win-auto.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/mihailDamchevski/win-auto/issues"
+  },
+  "homepage": "https://github.com/mihailDamchevski/win-auto/tree/main/packages/core#readme",
+  "license": "MIT",
+  "author": "Your Name",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "default": "./dist/testing/index.js"
+    },
+    "./testing/setup": {
+      "types": "./dist/testing/setup.d.ts",
+      "default": "./dist/testing/setup.js"
+    },
+    "./testing/globals": {
+      "types": "./dist/testing/globals.d.ts",
+      "default": "./dist/testing/globals.js"
+    }
+  },
+  "dependencies": {
+    "win-auto-native": "0.1.3"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "vitest": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "vitest": "^3.1.1"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run src/mock/mockRuntime.test.ts",
+    "prepublishOnly": "npm run build",
+    "prepack": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}