ohos-playwright 0.3.2 → 0.3.4

package/README.md

@@ -37,24 +37,43 @@ The following Playwright APIs have been validated on ArkWeb / HarmonyOS 6.1 (Chr
 
 | Category | APIs |
 |---|---|
-| Network interception | `page.route()`, `route.fulfill()`, `route.abort()`, `page.unroute()` |
+| Network interception | `page.route()`, `context.route()`, `route.fulfill()`, `route.abort()`, `page.unroute()` — `page.route` takes priority over `context.route` |
 | Network headers | `page.setExtraHTTPHeaders()` — custom headers reach the server |
 | Network conditions | `context.setOffline(true / false)` — actually applies (`ERR_INTERNET_DISCONNECTED` ↔ reachable) |
+| Network events | `page.on('request')`, `page.on('response')`, `page.on('requestfinished')`, `page.on('requestfailed')` |
+| Network intercept wait | `page.waitForRequest()`, `page.waitForResponse()` — string URL, glob, and predicate all work |
 | Screenshot | `page.screenshot({ type: 'jpeg' \| 'png' })`, `locator.screenshot()` |
 | PDF | `page.pdf()` — Chromium-only API, implemented by ArkWeb (produces a valid `%PDF` document) |
 | Tracing | `context.tracing.start()` / `stop({ path })` — works under `connectOverCDP`; the resulting zip contains trace + screenshots + source maps |
+| Coverage | `page.coverage.startJSCoverage()` / `stopJSCoverage()`, `startCSSCoverage()` / `stopCSSCoverage()` — returns per-page entries with ranges |
 | Geolocation | `context.setGeolocation()`, `context.grantPermissions(['geolocation'])` |
 | Device emulation | `emulateDevice` fixture (see below — `isMobile: false` for a precise viewport) |
 | Input | `locator.fill()`, `locator.type()`, `keyboard.press()`, `page.selectOption()` |
+| Keyboard combos | `keyboard.press('Control+a')`, `'Shift+Tab'`, `'Control+z'`, `'Shift+ArrowRight'`, `'Alt+ArrowLeft'` — modifier combinations work |
+| Checkbox | `locator.check()`, `locator.uncheck()`, `locator.setChecked()` — disabled elements correctly rejected |
 | Drag & drop | `locator.dragTo()` — triggers a `drop` event |
+| Scroll | `page.mouse.wheel()` — scrolls correctly; `page.evaluate(() => el.scrollTo(...))` also works |
 | File upload | `page.setInputFiles()` — fires `change`, file content readable |
 | Cookies | `context.addCookies()`, `context.cookies()`, `context.clearCookies()` |
 | Dialog | `page.on('dialog')`, `dialog.accept()`, `dialog.dismiss()`, `dialog.message()`, `dialog.type()` |
 | Popup | `context.waitForEvent('page')` + `window.open()` — stub Page with `url()`, `waitForLoadState()`, `close()` |
 | Page events | `page.on('pageerror')`, `page.on('console')`, `page.on('download')` |
+| Script / style injection | `page.addScriptTag({ content \| path \| type:'module' })`, `page.addStyleTag({ content })` |
+| Init script | `page.addInitScript()` — function or string, persists across `goto()` navigations |
+| Expose to page | `page.exposeFunction()`, `page.exposeBinding()` — persists across navigations; `handle` mode not supported |
+| Navigation wait | `page.waitForURL()` — string, glob, RegExp, and `history.pushState` client-side navigation |
 | Frames | `page.frames()`, `page.mainFrame()`, `frame.url()` |
 | Viewport | `page.viewportSize()` (pre-fetched via `Page.getLayoutMetrics` for reused CDP tabs), `page.setViewportSize()` (applies precisely) |
 | Media emulation | `page.emulateMedia({ colorScheme })` |
+| Web workers | `page.workers()` — returns the list of active workers |
+| WebSocket | `page.routeWebSocket()` (requires Playwright ≥ 1.48) — intercepts WebSocket connections |
+| Accessibility (CDP) | `newCDPSession` + `Accessibility.getFullAXTree` — returns the full AX node tree |
+| Navigation history | `page.goBack()`, `page.goForward()` — implemented via `history.back/forward()` + CDP polling; returns when the history index changes |
+| Hover events | `locator.hover()` — fires `mouseover` / `mouseenter` event listeners **and** activates the CSS `:hover` pseudo-class via the real `Input.dispatchMouseEvent` path. Falls back to JS-only dispatch (DOM events without `:hover`) if Playwright's `boundingBox()` hangs for more than 5 s. |
+| Locale (partial) | `emulateLocale(tag)` fixture — rewrites `navigator.language` / `navigator.languages` via `addInitScript`; does not affect HTTP `Accept-Language` or browser UI locale |
+| User-Agent | `emulateDevice({ userAgent })` — overrides both `navigator.userAgent` and the outgoing HTTP `User-Agent` header; call before `page.goto()` for the override to take effect. (`context.setExtraHTTPHeaders({ 'User-Agent': ... })` does **not** override UA — ArkWeb preserves the browser default there.) |
+| Service Workers | `navigator.serviceWorker.register()` — works on HTTPS pages; `navigator.serviceWorker` is `undefined` on non-secure origins (`data:`, `about:blank`) as in all browsers |
+| Clipboard | `navigator.clipboard.writeText()` / `readText()` — works on HTTPS pages after `context.grantPermissions(['clipboard-read', 'clipboard-write'])`; unavailable on non-secure origins |
 
 ### `emulateDevice` fixture
 
@@ -78,7 +97,9 @@ test('precise viewport', async ({ page, emulateDevice }) => {
 `emulateDevice` settings persist for the lifetime of the page. Call it again with `{ viewport: { width: 1280, height: 720 }, isMobile: false }` to restore defaults.
 
 > **⚠️ `isMobile: true` does not produce a precise viewport on ArkWeb.**
-> When `Emulation.setDeviceMetricsOverride` is called with `mobile: true`, ArkWeb enables its mobile layout-viewport compatibility path and renders at the 980px default mobile layout viewport — the passed `width`/`height` are effectively ignored (`window.innerWidth` reads 980 regardless). `deviceScaleFactor` has no effect on this. Use `isMobile: false` when you need an exact pixel viewport. Note that `userAgent` is also not applied (`Emulation.setUserAgentOverride` is acked but ignored by ArkWeb); the browser UA cannot be changed via CDP.
+> When `Emulation.setDeviceMetricsOverride` is called with `mobile: true`, ArkWeb enables its mobile layout-viewport compatibility path and renders at the 980px default mobile layout viewport — the passed `width`/`height` are effectively ignored (`window.innerWidth` reads 980 regardless). `deviceScaleFactor` has no effect on this. Use `isMobile: false` when you need an exact pixel viewport.
+>
+> **`userAgent` override applies to both JS and HTTP layers.** Call `await emulateDevice({ userAgent: '...' })` before `page.goto(url)` — `navigator.userAgent` on the destination page will reflect the override, and the outgoing HTTP `User-Agent` header is rewritten as well. Use `emulateDevice` rather than `context.setExtraHTTPHeaders({ 'User-Agent': ... })` — the latter does not override UA on ArkWeb.
 
 ### `tap` fixture
 
@@ -100,16 +121,13 @@ Coordinates are CSS pixels relative to the viewport (same as `touchscreen.tap`).
 ## Limitations
 
 - **Chromium only.** firefox and webkit aren't available on HarmonyOS.
-- **One context, one page.** `newContext()` / `newPage()` aren't supported (both throw an explicit error). Isolate tests with `localStorage.clear()` + `page.reload()`. For device emulation use the `emulateDevice` fixture instead of `browser.newContext({ ...device })`.
-- **`locator.hover()` hangs** on ArkWeb (CDP `Input.dispatchMouseEvent` mouseMoved blocks until the Playwright timeout). Use `:focus`-driven styles or a direct `click()` instead of hover-driven assertions.
-- **`page.goBack()` / `page.goForward()` hang** (CDP history navigation never resolves). Re-navigate with `page.goto()` instead.
-- **`Emulation.setUserAgentOverride` is ignored** — the command is acked but `navigator.userAgent` is unchanged. The browser UA cannot be changed via CDP.
-- **`mouse.wheel()` is a no-op** — the command succeeds but `scrollTop` stays 0. Scroll via `page.evaluate(() => el.scrollTo(...))`.
-- **Service Workers unavailable** — `navigator.serviceWorker` is `undefined` on ArkWeb; PWA / SW-based tests are not possible.
-- **`page.workers()` returns empty** for web workers — CDP does not auto-attach worker targets. The workers themselves run fine (messages reach the main page), only the listing is affected.
-- **Clipboard is a false positive** — `navigator.clipboard.writeText/readText` do not throw but `readText` returns `undefined`. Don't assert on clipboard contents.
+- **Multi-context / multi-page is opt-in.** By default the adapter intercepts `browser.newContext()` with a friendly error. The root cause: ArkWeb's `Target.createTarget` returns a target with `type: 'other'`, not `'page'`, so Playwright's `crBrowser._onAttachedToTarget` skips it and `ctx.newPage()` throws `Cannot read properties of undefined (reading '_page')`. To opt in, set `process.env.PW_CHROMIUM_ATTACH_TO_OTHER = '1'` **before** importing `@playwright/test` — Playwright's upstream escape hatch then treats `'other'` targets as pages and `browser.newContext()` / `ctx.newPage()` work normally. Trade-off: ArkWeb's internal `'other'` targets (shared workers, etc.) also get treated as pages, which can perturb tests that use `touchscreen.tap()` or `context.recordHar()`. For single-context tests (the common case) leave the env unset and isolate with `localStorage.clear()` + `page.reload()`. For device emulation use the `emulateDevice` fixture instead of `browser.newContext({ ...device })`.
+- **HTTP `User-Agent` header can be changed via CDP, but not via `setExtraHTTPHeaders`.** `Emulation.setUserAgentOverride` (sent by `emulateDevice({ userAgent })`) rewrites both `navigator.userAgent` and the outgoing HTTP UA header — call it before `page.goto()` so it applies to the destination page. `context.setExtraHTTPHeaders({ 'User-Agent': '...' })` does **not** override UA on ArkWeb (the header is preserved as browser default).
+- **`locator.hover()` activates CSS `:hover` on typical pages.** The fixture goes through the real `Input.dispatchMouseEvent` path via `page.mouse.move`. On pages where Playwright's `boundingBox()` hangs (e.g. some MutationObserver configurations), it falls back to a JS `mouseover` dispatch after a 5 s timeout — DOM listeners still fire but `:hover` will not activate in that fallback path.
+- **`page.mouse.move()` / `page.mouse.down()` / `page.mouse.up()` work normally.** DOM listeners receive `mousemove` / `mousedown` / `mouseup` / `click` in ArkWeb just as they do on stock Chromium. A previously documented narrow edge case (data: URL with embedded newlines AND a shared function reference registered for multiple event types) could not be reproduced in the v0.3.3 reaudit. The `mouseMove` / `mouseDown` / `mouseUp` fixtures remain in the API surface for backward compatibility but are no longer needed for normal use.
 - **`emulateDevice({ isMobile: true })` does not apply the viewport** — see the note in the `emulateDevice` fixture section above.
-- **`process.platform` reads `'linux'`** during the run — we patch it because Playwright's hostPlatform detection only branches on linux/darwin/win32 and falls through to `<unknown>` on openharmony. For real platform checks use `process.env.OHOS_PW_HOST`.
+- **`exposeBinding({ handle: true })` is not supported.** Playwright 1.60's public `exposeBinding` signature is `(name, callback)` — the third `{ handle }` argument is silently ignored. The callback receives a serialized form of the argument (DOM nodes arrive as the string `"ref: <Node>"`), not a JSHandle. Use `exposeFunction` or a plain `exposeBinding` callback that reads element properties directly and returns a by-value object.
+- **`process.platform` reads `'linux'`** during the run — Playwright's `calculatePlatform()` only branches on linux/darwin/win32 (falls through to `<unknown>` on openharmony), and 20+ other sites in `playwright-core` read `process.platform` directly (UA string assembly, headful window insets, modifier keys, registry). The adapter patches `process.platform` to `'linux'` and pins `PLAYWRIGHT_HOST_PLATFORM_OVERRIDE=ubuntu24.04-arm64` for `calculatePlatform()`. For real platform checks use `process.env.OHOS_PW_HOST`.
 
 ## Environment variables
 
@@ -122,6 +140,34 @@ Coordinates are CSS pixels relative to the viewport (same as `touchscreen.tap`).
 | `OHOS_PW_INFO_PATH` | `<tmpdir>/ohos-playwright-cdp.json` |
 | `OHOS_PW_UI_HOST` | `0.0.0.0` — used when `--ui` is passed without `--ui-host` on an OHOS device |
 | `OHOS_PW_UI_PORT` | `8765` — used when `--ui` is passed without `--ui-port` on an OHOS device |
+| `OHOS_PW_CDP_URL` | unset — when set, overrides the hdc-derived CDP endpoint entirely (e.g. `http://192.168.1.10:9222`) — used for LAN Chrome A/B comparison runs |
+
+### LAN Chrome A/B comparison
+
+`OHOS_PW_CDP_URL` lets you point the probe runner at an arbitrary CDP endpoint — useful for confirming whether a behaviour is an ArkWeb-specific gap or a general Chromium/CDP constraint.
+
+**Windows Chrome setup** (PowerShell / cmd):
+
+```
+chrome.exe --remote-debugging-port=9222 --remote-debugging-address=0.0.0.0 ^
+  --user-data-dir=C:\cdp-profile --remote-allow-origins=* about:blank
+```
+
+> Binding to the LAN IP directly (e.g. `--remote-debugging-address=192.168.1.10`) is more reliable than `0.0.0.0` with Chrome ≥ M111. SSH tunnel fallback: `ssh -L 9222:127.0.0.1:9222 <windows-host>` then use `http://127.0.0.1:9222`.
+
+**Running the Chrome leg** — must be from a **non-OpenHarmony host** so the adapter loader does not apply ArkWeb-specific fixture overrides:
+
+```bash
+OHOS_PW_CDP_URL=http://192.168.1.10:9222 npx playwright test probes/ab-baseline.spec.ts
+```
+
+**ArkWeb leg** (from the HarmonyPC host, as usual):
+
+```bash
+./dist/cli.mjs test --config=probes/playwright.config.ts probes/ab-baseline.spec.ts
+```
+
+Compare the `[PROBE ab-baseline]` log lines between the two runs to isolate ArkWeb-specific behaviour.
 
 ### `--ui` and `--debug` on an OHOS device
 

package/dist/fixture.d.mts

@@ -26,7 +26,13 @@ export interface StorageState {
 export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & {
     emulateDevice: (descriptor: DeviceDescriptor) => Promise<void>;
     tap: (x: number, y: number) => Promise<void>;
+    mouseMove: (x: number, y: number, opts?: {
+        steps?: number;
+    }) => Promise<void>;
+    mouseDown: (x: number, y: number) => Promise<void>;
+    mouseUp: (x: number, y: number) => Promise<void>;
     saveStorageState: (origin?: string) => Promise<StorageState>;
     loadStorageState: (state: StorageState) => Promise<void>;
+    emulateLocale: (locale: string) => Promise<void>;
 }, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
 export { expect } from '@playwright/test';

package/dist/fixture.mjs

@@ -2,6 +2,17 @@ import { readFileSync } from 'node:fs';
 import { test as base, chromium } from '@playwright/test';
 import { INFO_PATH } from "./info-path.mjs";
 function readInfo() {
+    const cdpUrl = process.env.OHOS_PW_CDP_URL;
+    if (cdpUrl) {
+        return {
+            port: 0,
+            pid: 0,
+            socket: '',
+            endpoint: cdpUrl,
+            openedNewTab: false,
+            launchUrl: process.env.OHOS_PW_LAUNCH_URL ?? 'about:blank',
+        };
+    }
     return JSON.parse(readFileSync(INFO_PATH, 'utf8'));
 }
 function readEndpoint() { return readInfo().endpoint; }
@@ -9,24 +20,30 @@ export const test = base.extend({
     browser: [
         async ({}, use) => {
             const browser = await chromium.connectOverCDP(readEndpoint());
-            // ArkWeb CDP does not implement Target.createBrowserContext — connectOverCDP
-            // reuses the single existing context. browser.newContext() returns without
-            // throwing but produces an empty shell (0 pages) that silently fails every
-            // subsequent operation. Intercept and throw an explicit, actionable error
-            // so users aren't misled by the false-positive success.
-            const origNewContext = browser.newContext.bind(browser);
-            browser.newContext = (() => {
-                throw new Error('browser.newContext() is not supported in ArkWeb CDP mode (single context only). ' +
-                    'Tests share one context and one page — isolate with localStorage.clear() + page.reload(). ' +
-                    'See ohos-playwright README "Limitations" section.');
-            });
-            try {
-                await use(browser);
+            // ArkWeb's Target.createTarget returns type='other', so Playwright's
+            // crBrowser._onAttachedToTarget skips it and ctx.newPage() throws
+            // "Cannot read properties of undefined (reading '_page')". The upstream
+            // PW_CHROMIUM_ATTACH_TO_OTHER=1 escape hatch fixes newContext/newPage
+            // but also makes Playwright treat internal "other" targets as pages
+            // (perturbs touchscreen / recordHar). When the user has not opted in,
+            // intercept browser.newContext() with a friendly, actionable error.
+            if (!process.env.PW_CHROMIUM_ATTACH_TO_OTHER) {
+                const origNewContext = browser.newContext.bind(browser);
+                browser.newContext = (() => {
+                    throw new Error('browser.newContext() is not supported on ArkWeb unless you opt in via ' +
+                        'process.env.PW_CHROMIUM_ATTACH_TO_OTHER=\'1\' before importing @playwright/test. ' +
+                        'See ohos-playwright README "Limitations" → "Multi-context" for trade-offs.');
+                });
+                try {
+                    await use(browser);
+                }
+                finally {
+                    ;
+                    browser.newContext = origNewContext;
+                }
             }
-            finally {
-                // Restore in case the browser object is reused across workers.
-                ;
-                browser.newContext = origNewContext;
+            else {
+                await use(browser);
             }
         },
         { scope: 'worker' },
@@ -69,20 +86,122 @@ export const test = base.extend({
         // viewport size and viewportSize() returns null. Pre-fetch via CDP.
         const session = await context.newCDPSession(page);
         try {
-            const { cssVisualViewport } = await session.send('Page.getLayoutMetrics');
-            const cached = {
-                width: Math.round(cssVisualViewport.clientWidth),
-                height: Math.round(cssVisualViewport.clientHeight),
-            };
-            const origViewportSize = page.viewportSize.bind(page);
-            page.viewportSize = () => origViewportSize() ?? cached;
-        }
-        catch {
-            // Non-critical — viewportSize() will still return null if CDP call fails.
+            try {
+                const { cssVisualViewport } = await session.send('Page.getLayoutMetrics');
+                const cached = {
+                    width: Math.round(cssVisualViewport.clientWidth),
+                    height: Math.round(cssVisualViewport.clientHeight),
+                };
+                const origViewportSize = page.viewportSize.bind(page);
+                page.viewportSize = () => origViewportSize() ?? cached;
+            }
+            catch {
+                // Non-critical — viewportSize() will still return null if CDP call fails.
+            }
+            // Bring the tab to foreground so Input.dispatchMouseEvent reaches DOM listeners.
+            // page.mouse.move/down/up events are silently dropped when the tab is not active.
+            try {
+                const targets = await session.send('Target.getTargets');
+                const pageTarget = targets.targetInfos.find((t) => t.type === 'page' && t.url === page.url());
+                if (pageTarget) {
+                    await session.send('Target.activateTarget', { targetId: pageTarget.targetId });
+                }
+            }
+            catch {
+                // Non-fatal: some ArkWeb versions may not support Target.activateTarget.
+            }
         }
         finally {
             await session.detach();
         }
+        // Override goBack: Page.navigateToHistoryEntry hangs in ArkWeb (never resolves).
+        // ArkWeb also does not emit Page.frameNavigated for history navigation, so waitForURL
+        // never fires. Poll Page.getNavigationHistory.currentIndex instead.
+        ;
+        page.goBack = async (options) => {
+            const timeout = options?.timeout ?? 30000;
+            const s = await page.context().newCDPSession(page);
+            try {
+                const nav = await s.send('Page.getNavigationHistory');
+                const prevIndex = nav.currentIndex;
+                if (prevIndex <= 0)
+                    return null;
+                await page.evaluate(() => history.back());
+                const deadline = Date.now() + timeout;
+                while (Date.now() < deadline) {
+                    const nav2 = await s.send('Page.getNavigationHistory');
+                    if (nav2.currentIndex < prevIndex)
+                        break;
+                    await new Promise(r => setTimeout(r, 80));
+                }
+                if (Date.now() >= deadline)
+                    throw new Error(`page.goBack: Timeout ${timeout}ms exceeded`);
+            }
+            finally {
+                await s.detach();
+            }
+            return null;
+        };
+        page.goForward = async (options) => {
+            const timeout = options?.timeout ?? 30000;
+            const s = await page.context().newCDPSession(page);
+            try {
+                const nav = await s.send('Page.getNavigationHistory');
+                const prevIndex = nav.currentIndex;
+                if (prevIndex >= nav.entries.length - 1)
+                    return null;
+                await page.evaluate(() => history.forward());
+                const deadline = Date.now() + timeout;
+                while (Date.now() < deadline) {
+                    const nav2 = await s.send('Page.getNavigationHistory');
+                    if (nav2.currentIndex > prevIndex)
+                        break;
+                    await new Promise(r => setTimeout(r, 80));
+                }
+                if (Date.now() >= deadline)
+                    throw new Error(`page.goForward: Timeout ${timeout}ms exceeded`);
+            }
+            finally {
+                await s.detach();
+            }
+            return null;
+        };
+        // Override locator().hover() to bypass Playwright's internal visibility check
+        // (which can hang on ArkWeb), but still go through the real Input.dispatchMouseEvent
+        // path so the pointer position is set and CSS :hover activates. The earlier
+        // JS-dispatch workaround was disproved by the 2026-06-27 reaudit — ab-hover-css
+        // shows the native path delivers both DOM events and :hover activation.
+        const savedLocator = page['locator'];
+        const origLocator = page.locator.bind(page);
+        page.locator = (...args) => {
+            const loc = origLocator(...args);
+            loc.hover = async (_options) => {
+                // Try the real Input.dispatchMouseEvent path first (activates :hover).
+                // Some pages (e.g. ones with MutationObservers that re-enter layout) can
+                // make Playwright's evaluate/boundingBox hang on ArkWeb; fall back to a
+                // JS-only dispatch with a tight timeout so hover() at least returns and
+                // DOM listeners fire.
+                const viaRealMouse = await Promise.race([
+                    (async () => {
+                        const box = await loc.boundingBox();
+                        if (!box)
+                            return false;
+                        await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+                        return true;
+                    })(),
+                    new Promise(r => setTimeout(() => r(false), 5000)),
+                ]);
+                if (!viaRealMouse) {
+                    await Promise.race([
+                        loc.evaluate((el) => {
+                            el.dispatchEvent(new MouseEvent('mouseover', { bubbles: true, cancelable: true }));
+                        }),
+                        new Promise(r => setTimeout(r, 2000)),
+                    ]).catch(() => { });
+                }
+            };
+            return loc;
+        };
         // ArkWeb's new tab from window.open() is invisible to CDP (Target.createTarget hangs,
         // Target.targetCreated never fires). Intercept via an init script:
         //   - queue the URL for our poller
@@ -144,6 +263,7 @@ export const test = base.extend({
         finally {
             clearInterval(popupPoller);
             page.evaluate = savedEvaluate;
+            page.locator = savedLocator;
             // Reset the test tab to about:blank so it's clean for the next test.
             // page.close() sends Target.closeTarget which terminates the ArkWeb
             // DevTools socket — use goto instead to keep the connection alive.
@@ -171,7 +291,9 @@ export const test = base.extend({
                         'default mobile layout viewport; the passed width/height will NOT apply. ' +
                         'Use isMobile: false for a precise viewport.');
                 }
-                // ArkWeb note: setUserAgentOverride is acked but ignored — UA cannot be changed via CDP.
+                // ArkWeb note: setUserAgentOverride takes effect after the next page.goto() — the override
+                // applies to the destination page's navigator.userAgent but not the currently-loaded page.
+                // The HTTP User-Agent header is also not changed by ArkWeb's UA override.
                 await session.send('Emulation.setDeviceMetricsOverride', {
                     width: descriptor.viewport.width,
                     height: descriptor.viewport.height,
@@ -217,6 +339,45 @@ export const test = base.extend({
             }
         });
     },
+    mouseMove: async ({ page }, use) => {
+        // ArkWeb CDP limitation: events dispatched via locator.evaluate() only reach
+        // page-script listeners if the listener body contains no closure references and
+        // the element has only a single addEventListener call. Any script complexity
+        // (outer variable declarations, multiple listeners) causes ArkWeb to route the
+        // callback into an isolated CDP execution context where closures are inaccessible,
+        // silently suppressing the event. For typical web applications this fixture
+        // will not deliver events. Prefer locator.click() / locator.fill() where possible.
+        await use(async (x, y, opts) => {
+            const steps = Math.max(1, opts?.steps ?? 1);
+            for (let i = 0; i < steps; i++) {
+                await page.locator(':root').evaluate((root, [x, y]) => {
+                    const el = root.ownerDocument.elementFromPoint(x, y);
+                    if (el)
+                        el.dispatchEvent(new MouseEvent('mousemove', { bubbles: true, cancelable: true, clientX: x, clientY: y }));
+                }, [x, y]);
+            }
+        });
+    },
+    mouseDown: async ({ page }, use) => {
+        await use(async (x, y) => {
+            await page.locator(':root').evaluate((root, [x, y]) => {
+                const el = root.ownerDocument.elementFromPoint(x, y);
+                if (el)
+                    el.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true, clientX: x, clientY: y, button: 0, buttons: 1 }));
+            }, [x, y]);
+        });
+    },
+    mouseUp: async ({ page }, use) => {
+        await use(async (x, y) => {
+            await page.locator(':root').evaluate((root, [x, y]) => {
+                const el = root.ownerDocument.elementFromPoint(x, y);
+                if (el) {
+                    el.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true, clientX: x, clientY: y, button: 0 }));
+                    el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, clientX: x, clientY: y, button: 0 }));
+                }
+            }, [x, y]);
+        });
+    },
     saveStorageState: async ({ page, context }, use) => {
         await use(async (origin) => {
             const derivedOrigin = origin ?? new URL(page.url()).origin;
@@ -251,6 +412,20 @@ export const test = base.extend({
             return { cookies, origins: [{ origin: derivedOrigin, localStorage }] };
         });
     },
+    emulateLocale: async ({ page }, use) => {
+        await use(async (locale) => {
+            await page.addInitScript((loc) => {
+                try {
+                    Object.defineProperty(navigator, 'language', { get: () => loc, configurable: true });
+                }
+                catch { }
+                try {
+                    Object.defineProperty(navigator, 'languages', { get: () => [loc], configurable: true });
+                }
+                catch { }
+            }, locale);
+        });
+    },
     loadStorageState: async ({ page, context }, use) => {
         await use(async (state) => {
             if (state.cookies?.length)

package/dist/loader.mjs

@@ -3,12 +3,18 @@ import { pathToFileURL } from 'node:url';
 const FIXTURE_URL = pathToFileURL(resolvePath(import.meta.dirname, 'fixture.mjs')).href;
 const TARGET = '@playwright/test';
 const TEST_FILE = /\.(spec|test)\.[mc]?[tj]sx?$/;
+// Also intercept from fixture helper files (e.g. fixtures.ts, fixtures.mts) that
+// live outside our own compiled dist/ — this covers the common pattern where spec
+// files delegate to a shared fixtures.ts that itself imports @playwright/test.
+const FIXTURE_HELPER = /\bfixtures?\.[mc]?[tj]sx?$/;
+const OWN_DIST_URL = pathToFileURL(resolvePath(import.meta.dirname) + '/').href;
 const PACKAGE_ROOT_URL = pathToFileURL(resolvePath(import.meta.dirname, '..') + '/').href;
 const PROJECT_ANCHOR = pathToFileURL(resolvePath(process.cwd(), 'noop.mjs')).href;
 export async function resolve(specifier, context, nextResolve) {
     if (specifier === TARGET) {
         const parent = context.parentURL ?? '';
-        if (TEST_FILE.test(parent)) {
+        const isFromOwnDist = parent.startsWith(OWN_DIST_URL);
+        if (TEST_FILE.test(parent) || (FIXTURE_HELPER.test(parent) && !isFromOwnDist)) {
             const result = await nextResolve(FIXTURE_URL, context);
             return { url: result.url };
         }

package/dist/register.mjs

@@ -7,11 +7,33 @@ if (process.platform === 'openharmony') {
     // downstream (notably withOpenHarmony in the user's config) should consult
     // OHOS_PW_HOST instead of process.platform, which is about to read 'linux'.
     process.env.OHOS_PW_HOST = '1';
-    // Playwright's hostPlatform detection only branches on linux/darwin/win32.
-    // On OpenHarmony it falls through to "<unknown>" and various code paths
-    // break. We connect over CDP and never touch Playwright's bundled browser
-    // binaries, so it's safe to advertise linux for the duration of this
-    // process.
+    // Playwright's calculatePlatform() (hostPlatform.ts:40) only branches on
+    // linux/darwin/win32 — on OpenHarmony it falls through to "<unknown>" and
+    // registry/hostPlatform consumers break. PLAYWRIGHT_HOST_PLATFORM_OVERRIDE
+    // (hostPlatform.ts:41) is the upstream escape hatch; pin to ubuntu24.04-arm64
+    // to skip the distro probing that would also reach "<unknown>".
+    process.env.PLAYWRIGHT_HOST_PLATFORM_OVERRIDE ??= 'ubuntu24.04-arm64';
+    // Beyond calculatePlatform(), playwright-core has 20+ direct process.platform
+    // reads on hot paths (userAgent.ts:39 UA string, crPage.ts:940 headful
+    // insets, input.ts:182 modifier key, registry/index.ts:479 Unsupported
+    // platform, tracing.ts:120 trace metadata). The env override above cannot
+    // reach those — we still must advertise 'linux' for the duration of this
+    // process. Safe because we connect over CDP and never touch Playwright's
+    // bundled browser binaries. Clean fix requires upstream openharmony branch.
     Object.defineProperty(process, 'platform', { value: 'linux' });
+    // ArkWeb's Target.createTarget returns a target with type='other', not
+    // 'page'. Playwright's crBrowser._onAttachedToTarget (crBrowser.ts:191)
+    // only registers 'page' targets into _crPages — 'other' targets get
+    // detached and ctx.newPage() throws "Cannot read properties of undefined
+    // (reading '_page')".
+    //
+    // PW_CHROMIUM_ATTACH_TO_OTHER (crBrowser.ts:181) is playwright's upstream
+    // escape hatch: treat type='other' as page so newContext/newPage work.
+    // It's opt-in (not set here by default) because it also makes Playwright
+    // treat ArkWeb's internal "other" targets (shared workers, etc.) as pages,
+    // which perturbs page-list assumptions in tests that use touchscreen /
+    // recordHar. Users who need multi-context set it explicitly:
+    //   process.env.PW_CHROMIUM_ATTACH_TO_OTHER = '1'
+    // before importing @playwright/test.
     register('./loader.mjs', import.meta.url);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohos-playwright",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Playwright adapter for OpenHarmony / ArkWeb via hdc + CDP",
   "license": "MIT",
   "author": "social4hyq",