@allwright.dev/vitest 0.1.23 → 0.1.25

package/README.md

@@ -1,7 +1,7 @@
 # @allwright.dev/vitest
 
 Vitest fixtures for allwright with Playwright-style `browser` and `page`
-injection, plus Android, iOS, and macOS app fixtures for native and hybrid tests.
+injection, plus Android, iOS, macOS, and Windows app fixtures for native and hybrid tests.
 
 Wrap the Vitest configuration with `allwrightVitestConfig`. It starts Allwright once before workers run and shuts it down once after the complete test run. Existing user global setup files remain supported and run after Allwright starts, then tear down before Allwright stops.
 
@@ -44,10 +44,19 @@ test("opens an iOS app", async ({ iosApp }) => {
 test("opens a macOS app", async ({ macosApp }) => {
   await macosApp.getByRole("button", { name: "New Document", exact: true }).click();
 });
+
+test("opens a Windows app", async ({ windowsApp }) => {
+  await windowsApp.getByRole("textbox").fill("Hello from Allwright");
+});
 ```
 
-Checked-in example specs live in [examples/basic.spec.ts](./examples/basic.spec.ts)
-and [examples/ios-flights.spec.ts](./examples/ios-flights.spec.ts).
+Checked-in example specs cover every implemented surface:
+[Web](./examples/basic.spec.ts), [Android](./examples/android-flights.spec.ts),
+[iOS](./examples/ios-flights.spec.ts),
+[macOS](./examples/macos-calculator.spec.ts), and
+[Windows](./examples/windows-notepad.spec.ts). Native specs use the app target
+configured for their surface in `allwright.config.yaml` or
+`allwright.config.json`.
 
 The fixture package reads the shared stack-agnostic config format through `@allwright.dev/core`.
 Use `allwright.config.yaml` by default, or `allwright.config.json` if you prefer. Both follow the same root schema in `allwright.schema.json`.
@@ -167,11 +176,35 @@ test("opens a document window", async ({ macosApp }) => {
 Use `ALLWRIGHT_MAC_AGENT_ENDPOINT` for an external agent or
 `ALLWRIGHT_MAC_APP_ID` to override the configured bundle identifier.
 
+Windows apps use an executable path, command name, or packaged-app AUMID. The
+fixture starts the bundled FlaUI UIA3 agent and launches the app lazily:
+
+```yaml
+# allwright.config.yaml
+desktop:
+  windows:
+    app:
+      id: notepad.exe
+```
+
+```ts
+import { expect, test } from "@allwright.dev/vitest";
+
+test("edits a document", async ({ windowsApp }) => {
+  await windowsApp.getByRole("textbox").fill("Hello from Allwright");
+  await expect(windowsApp.getByRole("textbox")).toContainText("Hello");
+});
+```
+
+Use `ALLWRIGHT_WINDOWS_AGENT_ENDPOINT` for an external agent or
+`ALLWRIGHT_WINDOWS_APP_ID` to override the configured application identifier.
+
 Fixtures are lazy on first use. Injecting `browser`, `page`, `android`,
-`androidApp`, `ios`, `iosApp`, `macos`, or `macosApp` does not launch or connect
-immediately; the underlying session is created only when the test first
-performs an action through that fixture. Sync metadata properties are only
-available after the lazy fixture has been realized by a prior awaited call.
+`androidApp`, `ios`, `iosApp`, `macos`, `macosApp`, `windows`, or `windowsApp`
+does not launch or connect immediately; the underlying session is created only
+when the test first performs an action through that fixture. Sync metadata
+properties are only available after the lazy fixture has been realized by a
+prior awaited call.
 
 Available fixtures:
 
@@ -183,13 +216,16 @@ Available fixtures:
 - `iosApp`: launched iOS app page
 - `macos`: connected macOS desktop session
 - `macosApp`: launched macOS app page
+- `windows`: connected Windows desktop session
+- `windowsApp`: launched Windows app page
 
 `androidApp` launches using `allwright.android.launchOptions` first, then falls back to `config.mobile.android`.
 `iosApp` does the same with `allwright.ios.launchOptions` and `config.mobile.ios`.
 `macosApp` does the same with `allwright.macos.launchOptions` and `config.desktop.mac`.
+`windowsApp` does the same with `allwright.windows.launchOptions` and `config.desktop.windows`.
 
-Android, iOS, and macOS apps and locators support the native action and expectation
-subset: `click`, `count`, `focus`, `fill`, `press`, `textContent`, `innerText`,
+Android, iOS, macOS, and Windows apps and locators support the native action and
+expectation subset: `click`, `count`, `focus`, `fill`, `press`, `textContent`, `innerText`,
 `waitForSelector`, and `screenshot`. Mobile expectations provide `toHaveText`,
 `toContainText`, `toHaveCount`, and `toBeVisible` with the same retry controls
 as web fixtures. Hover and highlight remain web-only.
@@ -253,13 +289,18 @@ await expect(page.locator('select')).toHaveSelectedOptions(['a', 'b']);
 await expect(page.locator('select')).toHaveSelectedOptions([{ value: 'a', label: /Alpha/ }]);
 await expect(page.locator('textarea')).toHaveSelectedText('selected words');
 await expect(page.locator('input[type=checkbox]')).toBeChecked();
+await expect(page.locator('button[type=submit]')).toBeEnabled();
+await expect(page.locator('input')).toBeEditable();
+await expect(page.locator('input')).toBeFocused();
+await expect(page.locator('.spinner')).toBeHidden();
+await expect(page.locator('main')).toBeAttached();
 await expect(page.locator('h1')).toHaveText('Welcome');
 await expect(page.locator('a')).toHaveAttribute('href', /dashboard/);
 await expect(page.locator('button')).toHaveBoundingBox({ width: 100, height: 40 });
 await expect(page.locator('input[type=radio]')).not().toBeChecked();
 ```
 
-Every element matcher also has a page form, such as `expect(page).toHaveValue('#name', 'Alice')` or `expect(page).toHaveAttribute('a', 'href', '/home')`. These state matchers are web-only; Android retains its text/count/visibility matchers.
+Every element matcher also has a page/app form, such as `expect(page).toHaveValue('#name', 'Alice')` or `expect(androidApp).toBeEnabled('text="Continue"')`. Value, checked-state, attribute, bounding-box, attached/hidden, enabled/disabled, focused, and editable matchers work across web, Android, iOS, macOS, and Windows. URL, selected-option, and selected-text matchers remain web-only.
 
 All Allwright page/app/locator expectations retry until they match or the timeout expires, including `.not` and `.not()`. Defaults come from the shared assertion configuration, falling back to 5 seconds and a 100 ms interval. Override these with `{ timeoutMs, intervalMs }`. In-flight reads and nested command timeout hints are bounded by the remaining assertion budget; `timeoutMs: 0` makes one observation without polling. Ordinary assertions on already captured values, such as `expect(await page.url()).toBe(...)`, use standard Vitest behavior and do not re-read the page.
 

package/dist/expectations.d.ts

@@ -15,6 +15,16 @@ export interface MobilePageExpectMatchers {
     toContainText(selector: string, expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
     toHaveCount(selector: string, expected: number, options?: RetryExpectationOptions): Promise<void>;
     toBeVisible(selector: string, options?: VisibleExpectationOptions): Promise<void>;
+    toBeHidden(selector: string, options?: VisibleExpectationOptions): Promise<void>;
+    toBeAttached(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toBeEnabled(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toBeDisabled(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toBeFocused(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toBeEditable(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toHaveValue(selector: string, expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
+    toBeChecked(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toHaveAttribute(selector: string, name: string, expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
+    toHaveBoundingBox(selector: string, expected: Partial<BoundingBox> | null, options?: TextExpectationOptions): Promise<void>;
 }
 export interface MobileLocatorExpectMatchers {
     readonly not: MobileLocatorExpectMatchers & (() => MobileLocatorExpectMatchers);
@@ -22,6 +32,16 @@ export interface MobileLocatorExpectMatchers {
     toContainText(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
     toHaveCount(expected: number, options?: RetryExpectationOptions): Promise<void>;
     toBeVisible(options?: VisibleExpectationOptions): Promise<void>;
+    toBeHidden(options?: VisibleExpectationOptions): Promise<void>;
+    toBeAttached(options?: TextExpectationOptions): Promise<void>;
+    toBeEnabled(options?: TextExpectationOptions): Promise<void>;
+    toBeDisabled(options?: TextExpectationOptions): Promise<void>;
+    toBeFocused(options?: TextExpectationOptions): Promise<void>;
+    toBeEditable(options?: TextExpectationOptions): Promise<void>;
+    toHaveValue(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
+    toBeChecked(options?: TextExpectationOptions): Promise<void>;
+    toHaveAttribute(name: string, expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
+    toHaveBoundingBox(expected: Partial<BoundingBox> | null, options?: TextExpectationOptions): Promise<void>;
 }
 export type SelectedOptionExpectation = string | RegExp | {
     value?: string | RegExp;
@@ -30,22 +50,14 @@ export type SelectedOptionExpectation = string | RegExp | {
 };
 export interface LocatorExpectMatchers extends MobileLocatorExpectMatchers {
     readonly not: LocatorExpectMatchers & (() => LocatorExpectMatchers);
-    toHaveValue(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
     toHaveSelectedOptions(expected: SelectedOptionExpectation[], options?: TextExpectationOptions): Promise<void>;
     toHaveSelectedText(expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
-    toBeChecked(options?: TextExpectationOptions): Promise<void>;
-    toHaveAttribute(name: string, expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
-    toHaveBoundingBox(expected: Partial<BoundingBox> | null, options?: TextExpectationOptions): Promise<void>;
 }
 export interface PageExpectMatchers extends MobilePageExpectMatchers {
     readonly not: PageExpectMatchers & (() => PageExpectMatchers);
     toHaveURL(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
-    toHaveValue(selector: string, expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
     toHaveSelectedOptions(selector: string, expected: SelectedOptionExpectation[], options?: TextExpectationOptions): Promise<void>;
     toHaveSelectedText(selector: string, expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
-    toBeChecked(selector: string, options?: TextExpectationOptions): Promise<void>;
-    toHaveAttribute(selector: string, name: string, expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
-    toHaveBoundingBox(selector: string, expected: Partial<BoundingBox> | null, options?: TextExpectationOptions): Promise<void>;
 }
 type Defaults = () => RetryExpectationOptions;
 type AnyLocator = Locator | NativeAppLocator;

package/dist/expectations.js

@@ -57,11 +57,20 @@ async function isVisible(locator, command) {
         return true;
     }
     catch (error) {
-        if (error instanceof Error && error.message.startsWith("selector found but not visible: "))
+        if (error instanceof Error && (error.message.startsWith("selector found but not visible: ")
+            || error.message.includes("did not become visible")))
             return false;
         throw error;
     }
 }
+async function nativeOrWebState(locator, state, command) {
+    const attribute = "filter" in locator ? `__allwright_state_${state}` : state;
+    const value = await locator.getAttribute(attribute, command);
+    if (value !== "true" && value !== "false") {
+        throw new Error(`Element did not expose a ${state} state`);
+    }
+    return value === "true";
+}
 export function createLocatorExpect(locator, defaults, negated = false) {
     const assertion = (value) => negated ? vitestExpect(value).not : vitestExpect(value);
     const common = {
@@ -94,18 +103,64 @@ export function createLocatorExpect(locator, defaults, negated = false) {
                 assertion(await isVisible(locator, command)).toBe(true);
             }, options, defaults());
         },
+        async toBeHidden(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion(await isVisible(locator, command)).toBe(false);
+            }, options, defaults());
+        },
+        async toBeAttached(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion((await locator.count(command)) > 0).toBe(true);
+            }, options, defaults());
+        },
+        async toBeEnabled(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion(await nativeOrWebState(locator, "enabled", command)).toBe(true);
+            }, options, defaults());
+        },
+        async toBeDisabled(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion(await nativeOrWebState(locator, "enabled", command)).toBe(false);
+            }, options, defaults());
+        },
+        async toBeFocused(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion(await nativeOrWebState(locator, "focused", command)).toBe(true);
+            }, options, defaults());
+        },
+        async toBeEditable(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion(await nativeOrWebState(locator, "editable", command)).toBe(true);
+            }, options, defaults());
+        },
+        async toHaveValue(expected, options = {}) {
+            await retryExpectation(async (command) => assertion(await locator.inputValue(command)).toEqual(expectedText(expected)), options, defaults());
+        },
+        async toBeChecked(options = {}) {
+            await retryExpectation(async (command) => assertion(await locator.isChecked(command)).toBe(true), options, defaults());
+        },
+        async toHaveAttribute(name, expected, options = {}) {
+            await retryExpectation(async (command) => assertion(await locator.getAttribute(name, command)).toEqual(expectedText(expected)), options, defaults());
+        },
+        async toHaveBoundingBox(expected, options = {}) {
+            await retryExpectation(async (command) => assertion(await locator.boundingBox(command)).toEqual(expected === null ? null : vitestExpect.objectContaining(expected)), options, defaults());
+        },
     };
-    if (!("inputValue" in locator))
+    if (!("selectedOptions" in locator))
         return common;
     const web = {
         toHaveText: common.toHaveText,
         toContainText: common.toContainText,
         toHaveCount: common.toHaveCount,
         toBeVisible: common.toBeVisible,
+        toBeHidden: common.toBeHidden,
+        toBeAttached: common.toBeAttached,
+        toBeEnabled: common.toBeEnabled,
+        toBeDisabled: common.toBeDisabled,
+        toBeFocused: common.toBeFocused,
+        toBeEditable: common.toBeEditable,
         get not() { return callableMatchers(createLocatorExpect(locator, defaults, !negated)); },
-        async toHaveValue(expected, options = {}) {
-            await retryExpectation(async (command) => assertion(await locator.inputValue(command)).toEqual(expectedText(expected)), options, defaults());
-        },
+        toHaveValue: common.toHaveValue,
         async toHaveSelectedOptions(expected, options = {}) {
             await retryExpectation(async (command) => {
                 const wanted = expected.map(option => {
@@ -123,15 +178,9 @@ export function createLocatorExpect(locator, defaults, negated = false) {
         async toHaveSelectedText(expected, options = {}) {
             await retryExpectation(async (command) => assertion(await locator.selectedText(command)).toEqual(expectedText(expected)), options, defaults());
         },
-        async toBeChecked(options = {}) {
-            await retryExpectation(async (command) => assertion(await locator.isChecked(command)).toBe(true), options, defaults());
-        },
-        async toHaveAttribute(name, expected, options = {}) {
-            await retryExpectation(async (command) => assertion(await locator.getAttribute(name, command)).toEqual(expectedText(expected)), options, defaults());
-        },
-        async toHaveBoundingBox(expected, options = {}) {
-            await retryExpectation(async (command) => assertion(await locator.boundingBox(command)).toEqual(expected === null ? null : vitestExpect.objectContaining(expected)), options, defaults());
-        },
+        toBeChecked: common.toBeChecked,
+        toHaveAttribute: common.toHaveAttribute,
+        toHaveBoundingBox: common.toHaveBoundingBox,
     };
     return web;
 }
@@ -143,6 +192,16 @@ export function createPageExpect(page, defaults, negated = false) {
         toContainText: (selector, expected, options) => matcher(selector).toContainText(expected, options),
         toHaveCount: (selector, expected, options) => matcher(selector).toHaveCount(expected, options),
         toBeVisible: (selector, options) => matcher(selector).toBeVisible(options),
+        toBeHidden: (selector, options) => matcher(selector).toBeHidden(options),
+        toBeAttached: (selector, options) => matcher(selector).toBeAttached(options),
+        toBeEnabled: (selector, options) => matcher(selector).toBeEnabled(options),
+        toBeDisabled: (selector, options) => matcher(selector).toBeDisabled(options),
+        toBeFocused: (selector, options) => matcher(selector).toBeFocused(options),
+        toBeEditable: (selector, options) => matcher(selector).toBeEditable(options),
+        toHaveValue: (selector, expected, options) => matcher(selector).toHaveValue(expected, options),
+        toBeChecked: (selector, options) => matcher(selector).toBeChecked(options),
+        toHaveAttribute: (selector, name, expected, options) => matcher(selector).toHaveAttribute(name, expected, options),
+        toHaveBoundingBox: (selector, expected, options) => matcher(selector).toHaveBoundingBox(expected, options),
     };
     if (!("url" in page))
         return common;
@@ -152,6 +211,12 @@ export function createPageExpect(page, defaults, negated = false) {
         toContainText: common.toContainText,
         toHaveCount: common.toHaveCount,
         toBeVisible: common.toBeVisible,
+        toBeHidden: common.toBeHidden,
+        toBeAttached: common.toBeAttached,
+        toBeEnabled: common.toBeEnabled,
+        toBeDisabled: common.toBeDisabled,
+        toBeFocused: common.toBeFocused,
+        toBeEditable: common.toBeEditable,
         get not() { return callableMatchers(createPageExpect(page, defaults, !negated)); },
         async toHaveURL(expected, options = {}) {
             await retryExpectation(async (command) => {
@@ -159,12 +224,12 @@ export function createPageExpect(page, defaults, negated = false) {
                 (negated ? vitestExpect(url).not : vitestExpect(url)).toEqual(expectedText(expected));
             }, options, defaults());
         },
-        toHaveValue: (selector, expected, options) => webMatcher(selector).toHaveValue(expected, options),
+        toHaveValue: common.toHaveValue,
         toHaveSelectedOptions: (selector, expected, options) => webMatcher(selector).toHaveSelectedOptions(expected, options),
         toHaveSelectedText: (selector, expected, options) => webMatcher(selector).toHaveSelectedText(expected, options),
-        toBeChecked: (selector, options) => webMatcher(selector).toBeChecked(options),
-        toHaveAttribute: (selector, name, expected, options) => webMatcher(selector).toHaveAttribute(name, expected, options),
-        toHaveBoundingBox: (selector, expected, options) => webMatcher(selector).toHaveBoundingBox(expected, options),
+        toBeChecked: common.toBeChecked,
+        toHaveAttribute: common.toHaveAttribute,
+        toHaveBoundingBox: common.toHaveBoundingBox,
     };
     return web;
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { PageExpectMatchers, LocatorExpectMatchers, MobilePageExpectMatchers, MobileLocatorExpectMatchers } from "./expectations.js";
 export type { RetryExpectationOptions, TextExpectationOptions, VisibleExpectationOptions, SelectedOptionExpectation, PageExpectMatchers, LocatorExpectMatchers, MobilePageExpectMatchers, MobileLocatorExpectMatchers } from "./expectations.js";
-import { type MobileAndroidConnectOptions, type MobileAndroidDevice, type MobileAndroidLaunchOptions, type MobileAndroidApp, type NativeApp, type NativeAppLocator, type MobileIosConnectOptions, type MobileIosDevice, type MobileIosLaunchOptions, type MobileIosApp, type DesktopMacApp, type DesktopMacConnectOptions, type DesktopMacDesktop, type DesktopMacLaunchOptions, type Browser, type BrowserKind, type LaunchOptions, type Locator, type Page } from "@allwright.dev/core";
+import { type MobileAndroidConnectOptions, type MobileAndroidDevice, type MobileAndroidLaunchOptions, type MobileAndroidApp, type NativeApp, type NativeAppLocator, type MobileIosConnectOptions, type MobileIosDevice, type MobileIosLaunchOptions, type MobileIosApp, type DesktopMacApp, type DesktopMacConnectOptions, type DesktopMacDesktop, type DesktopMacLaunchOptions, type DesktopWindowsApp, type DesktopWindowsConnectOptions, type DesktopWindowsDesktop, type DesktopWindowsLaunchOptions, type Browser, type BrowserKind, type LaunchOptions, type Locator, type Page } from "@allwright.dev/core";
 import { expect as vitestExpect, type Assertion } from "vitest";
 export interface AllwrightVitestOptions {
     launchOptions?: LaunchOptions;
@@ -19,6 +19,10 @@ export interface AllwrightVitestOptions {
         connectOptions?: DesktopMacConnectOptions;
         launchOptions?: DesktopMacLaunchOptions;
     };
+    windows?: {
+        connectOptions?: DesktopWindowsConnectOptions;
+        launchOptions?: DesktopWindowsLaunchOptions;
+    };
     configFile?: string;
     suite?: string;
 }
@@ -31,6 +35,8 @@ export interface AllwrightVitestFixtures {
     iosApp: MobileIosApp;
     macos: DesktopMacDesktop;
     macosApp: DesktopMacApp;
+    windows: DesktopWindowsDesktop;
+    windowsApp: DesktopWindowsApp;
 }
 interface LazyResource<T> {
     peek(): T | null;
@@ -46,11 +52,14 @@ export declare const test: import("vitest").TestAPI<{
     iosApp: NativeApp;
     macos: DesktopMacDesktop;
     macosApp: NativeApp;
+    windows: DesktopWindowsDesktop;
+    windowsApp: NativeApp;
     allwright: AllwrightVitestOptions;
     _browserResource: LazyResource<Browser>;
     _androidResource: LazyResource<MobileAndroidDevice>;
     _iosResource: LazyResource<MobileIosDevice>;
     _macosResource: LazyResource<DesktopMacDesktop>;
+    _windowsResource: LazyResource<DesktopWindowsDesktop>;
 }>;
 type VitestExpect = typeof vitestExpect;
 interface AllwrightExpect extends VitestExpect {

package/dist/index.js

@@ -7,6 +7,8 @@ const DEFAULT_IOS_CONNECT_TIMEOUT_MS = 30_000;
 const DEFAULT_IOS_LAUNCH_TIMEOUT_MS = 60_000;
 const DEFAULT_MACOS_CONNECT_TIMEOUT_MS = 30_000;
 const DEFAULT_MACOS_LAUNCH_TIMEOUT_MS = 60_000;
+const DEFAULT_WINDOWS_CONNECT_TIMEOUT_MS = 30_000;
+const DEFAULT_WINDOWS_LAUNCH_TIMEOUT_MS = 60_000;
 function createLazyResource(factory) {
     let value = null;
     let promise = null;
@@ -66,6 +68,9 @@ function createLazyLocator(pageResource, selectorFactory) {
         async click(options) {
             return (await pageResource.get()).locator(await selectorFactory()).click(options);
         },
+        async dblclick(options) {
+            return (await pageResource.get()).locator(await selectorFactory()).dblclick(options);
+        },
         async count(options) {
             return (await pageResource.get()).locator(await selectorFactory()).count(options);
         },
@@ -176,6 +181,9 @@ function createLazyPage(pageResource) {
         async click(selector, options) {
             return (await pageResource.get()).click(selector, options);
         },
+        async dblclick(selector, options) {
+            return (await pageResource.get()).dblclick(selector, options);
+        },
         async count(selector, options) {
             return (await pageResource.get()).count(selector, options);
         },
@@ -384,6 +392,18 @@ function createLazyMobileApp(appResource) {
         async innerText(selector, options) {
             return (await appResource.get()).innerText(selector, options);
         },
+        async inputValue(selector, options) {
+            return (await appResource.get()).inputValue(selector, options);
+        },
+        async isChecked(selector, options) {
+            return (await appResource.get()).isChecked(selector, options);
+        },
+        async getAttribute(selector, name, options) {
+            return (await appResource.get()).getAttribute(selector, name, options);
+        },
+        async boundingBox(selector, options) {
+            return (await appResource.get()).boundingBox(selector, options);
+        },
         async waitForSelector(selector, options) {
             return (await appResource.get()).waitForSelector(selector, options);
         },
@@ -425,6 +445,18 @@ function createLazyMobileLocator(appResource, selectorFactory) {
         async innerText(options) {
             return (await appResource.get()).locator(await selectorFactory()).innerText(options);
         },
+        async inputValue(options) {
+            return (await appResource.get()).locator(await selectorFactory()).inputValue(options);
+        },
+        async isChecked(options) {
+            return (await appResource.get()).locator(await selectorFactory()).isChecked(options);
+        },
+        async getAttribute(name, options) {
+            return (await appResource.get()).locator(await selectorFactory()).getAttribute(name, options);
+        },
+        async boundingBox(options) {
+            return (await appResource.get()).locator(await selectorFactory()).boundingBox(options);
+        },
         async waitFor(options) {
             return (await appResource.get()).locator(await selectorFactory()).waitFor(options);
         },
@@ -495,6 +527,20 @@ function createLazyMacosDesktop(desktopResource) {
         },
     };
 }
+function createLazyWindowsDesktop(desktopResource) {
+    const initialAppResource = createLazyResource(async () => (await desktopResource.get()).app());
+    return {
+        get sessionId() {
+            return getLazySyncProperty(desktopResource, "sessionId");
+        },
+        app() {
+            return createLazyMobileApp(initialAppResource);
+        },
+        async launch(options) {
+            return (await desktopResource.get()).launch(options);
+        },
+    };
+}
 export const test = base.extend({
     allwright: async ({}, use) => {
         await use({});
@@ -540,6 +586,14 @@ export const test = base.extend({
         const macosResource = createLazyResource(async () => desktop.mac.connect(resolveMacosConnectOptions(config, allwright)));
         await use(macosResource);
     },
+    _windowsResource: async ({ allwright }, use) => {
+        const config = resolveVitestConfig(allwright);
+        if (config.serverAddr) {
+            setServerAddr(config.serverAddr);
+        }
+        const windowsResource = createLazyResource(async () => desktop.windows.connect(resolveWindowsConnectOptions(config, allwright)));
+        await use(windowsResource);
+    },
     browser: async ({ _browserResource }, use) => {
         try {
             await use(createLazyBrowser(_browserResource));
@@ -584,6 +638,17 @@ export const test = base.extend({
         });
         await use(createLazyMobileApp(appResource));
     },
+    windows: async ({ _windowsResource }, use) => {
+        await use(createLazyWindowsDesktop(_windowsResource));
+    },
+    windowsApp: async ({ _windowsResource, allwright }, use) => {
+        const appResource = createLazyResource(async () => {
+            const config = resolveVitestConfig(allwright);
+            const launchOptions = resolveWindowsLaunchOptions(config, allwright);
+            return (await _windowsResource.get()).launch(launchOptions);
+        });
+        await use(createLazyMobileApp(appResource));
+    },
 });
 function isPage(value) {
     return !!value && typeof value === "object" && typeof value.locator === "function";
@@ -689,6 +754,28 @@ function resolveMacosLaunchOptions(config, options) {
             DEFAULT_MACOS_LAUNCH_TIMEOUT_MS,
     };
 }
+function resolveWindowsConnectOptions(config, options) {
+    return {
+        agentEndpoint: options.windows?.connectOptions?.agentEndpoint ??
+            process.env.ALLWRIGHT_WINDOWS_AGENT_ENDPOINT,
+        timeoutMs: options.windows?.connectOptions?.timeoutMs ??
+            DEFAULT_WINDOWS_CONNECT_TIMEOUT_MS,
+    };
+}
+function resolveWindowsLaunchOptions(config, options) {
+    const appId = options.windows?.launchOptions?.appId ??
+        process.env.ALLWRIGHT_WINDOWS_APP_ID ??
+        config.desktop.windows?.appId;
+    if (!appId) {
+        throw new Error("windowsApp fixture requires Windows launch options with `appId`, or config.desktop.windows.app configured");
+    }
+    return {
+        appId,
+        terminateRunning: options.windows?.launchOptions?.terminateRunning ?? false,
+        timeoutMs: options.windows?.launchOptions?.timeoutMs ??
+            DEFAULT_WINDOWS_LAUNCH_TIMEOUT_MS,
+    };
+}
 let activeExpectDefaults = {};
 function currentExpectDefaults() {
     return activeExpectDefaults;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allwright.dev/vitest",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "Vitest fixtures for the allwright TypeScript client.",
   "license": "MIT",
   "type": "module",
@@ -47,7 +47,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@allwright.dev/core": "0.1.23"
+    "@allwright.dev/core": "0.1.25"
   },
   "devDependencies": {
     "typescript": "^5.9.2",