@molecule/app-e2e-fixtures-default 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,154 +1,114 @@
 /**
- * Shared Playwright `test` + `expect` with auto-attached browser
- * console-error / pageerror guard.
+ * The `@playwright/test` drop-in for molecule apps: Playwright's `test`,
+ * `expect` and `page`, with the browser supplied by the bonded e2e provider
+ * and a console-error guard on every test.
  *
- * Every fleet app's e2e specs import `test` and `expect` from this
- * module (re-exported through their per-app `_helpers.ts`) instead of
- * `@playwright/test` directly. The custom `test` includes a
- * `consoleGuard` fixture with `{ auto: true }`, so every test
- * automatically subscribes to the browser's `pageerror` event and
- * `console.error` messages, then asserts the buffer is empty at test
- * teardown.
+ * Import `test` and `expect` from here instead of `@playwright/test` and
+ * write ordinary Playwright specs. Which browser runs them is the e2e bond
+ * (`@molecule/app-e2e`):
  *
- * This catches the failure mode where React (or any other client-side
- * module) throws on mount but the spec only asserts against
- * `page.request.get/post`, leaving the test green while the rendered
- * page is blank. A single quill-delta ESM/CJS interop error sat for
- * four days like this before we noticed — the replay videos were
- * 17 KB of nothing and the JSON reported PASS.
+ * - **`@molecule/app-e2e-preview`** drives the LIVE PREVIEW the molecule.dev
+ *   IDE is already showing — the page the person is looking at, in their own
+ *   browser — over a WebSocket through the dev server. No browser binary in
+ *   the sandbox, nothing to download. This is what a molecule sandbox uses.
+ * - **`@molecule/app-e2e-playwright`** launches real Playwright browsers. This
+ *   is what your own machine and CI use.
  *
- * To intentionally let a known error through (rare — almost always a
- * smell that should be fixed in the app), use
- * `test.info().annotations.push({ type: 'allow-console-error', description: 'why' })`
- * inside the test body BEFORE the error fires. The `description` is
- * matched against the error text as a regular expression; if it is not
- * a valid regex it is matched as a plain substring instead (so literal
- * error text with `[`/`(` can be pasted verbatim). An annotation with
- * no description allows every error — always provide one.
+ * The same spec file runs unchanged in both. The provider is picked by
+ * `resolveE2EProviderName()`: `MOL_E2E_PROVIDER` when set, otherwise `preview`
+ * inside a molecule sandbox (the `/etc/mol/app-root` marker exists) and
+ * `playwright` everywhere else. The scaffolded `e2e/bonds.ts` bonds the
+ * matching provider (and `test` bonds it by name as a fallback); `test` reads
+ * the same answer to decide whether to launch a browser.
  *
- * A small, fixed set of browser-noise patterns are ALWAYS ignored regardless
- * of `allow-console-error` (Vite HMR reconnect chatter, service-worker 404s
- * in headless Chrome, and a real Chrome DevTools "failed to load SourceMap"
- * message for any `https://`-hosted bundle — e.g. Stripe/Google Maps CDN
- * scripts shipped without source maps). That last pattern is verified
- * against the actual Chrome message text and constrained to `https://` so it
- * can never silence a genuinely broken source map in the app's OWN bundle
- * (served over plain `http://localhost` in dev/preview).
+ * Every test also carries the console-error guard: the page's `pageerror`
+ * and `console.error` events fail the test at teardown, so a spec that only
+ * asserts on `page.request` cannot stay green while the rendered page is
+ * blank. Allow a known error with
+ * `test.info().annotations.push({ type: 'allow-console-error', description: '<regex>' })`.
  *
  * @example
  * ```ts
- * // In fleet apps, the per-app `./_helpers.ts` re-exports these:
- * import { test, expect } from '@molecule/app-e2e-fixtures-default'
+ * // e2e/bonds.ts — scaffolded; wires the provider for THIS environment
+ * import { resolveE2EProviderName, setProvider } from '@molecule/app-e2e'
+ * import { provider as playwright } from '@molecule/app-e2e-playwright'
+ * import { provider as preview } from '@molecule/app-e2e-preview'
  *
- * test('login lands on dashboard', async ({ page }) => {
- *   await page.goto('/login')
- *   await page.getByLabel(/email/i).fill('user@example.com')
- *   // ...
+ * setProvider(resolveE2EProviderName() === 'preview' ? preview : playwright)
+ *
+ * // e2e/post.spec.ts — an ordinary Playwright spec
+ * import { expect, test } from '@molecule/app-e2e-fixtures-default'
+ *
+ * import './bonds.js'
+ *
+ * test('the phone layout keeps the prose large', async ({ page }) => {
+ *   await page.setViewportSize({ width: 390, height: 844 })
+ *   await page.goto('/blog/hello/')
+ *   const prose = page.locator('article p').first()
+ *   const size = await prose.evaluate((el) => parseFloat(getComputedStyle(el).fontSize))
+ *   expect(size).toBeGreaterThanOrEqual(18)
+ *   await expect(page.getByRole('switch', { name: /summar/i })).toBeVisible()
  * })
  * ```
  *
+ * @remarks
+ * - **What works over the preview** (the `@molecule/app-e2e-preview` bond):
+ *   `page.goto/reload/goBack/goForward/url/title/content`,
+ *   `page.evaluate/$eval/$$eval`, `page.locator` and every `getBy*` (role
+ *   with name/level/checked/pressed/expanded/selected, text, label,
+ *   placeholder, title, alt text, test id), `first/last/nth/filter/count/all`,
+ *   `click/dblclick/hover/tap/fill/clear/type/press/check/uncheck/setChecked/
+ *   selectOption/focus/blur/dispatchEvent/scrollIntoViewIfNeeded`,
+ *   `textContent/innerText/innerHTML/inputValue/getAttribute/isVisible/isHidden/
+ *   isEnabled/isDisabled/isEditable/isChecked/boundingBox/evaluate/evaluateAll/
+ *   waitFor`, `page.setViewportSize/viewportSize`, `page.mouse.*`,
+ *   `page.keyboard.*`, `page.request.get/post/put/patch/delete/fetch` (runs
+ *   `fetch` inside the page, cookies included), `waitForSelector/waitForURL/
+ *   waitForFunction/waitForLoadState/waitForTimeout`, `page.on('console' |
+ *   'pageerror' | 'dialog' | 'close')`, and `expect(locator)` with
+ *   `toBeVisible/toBeHidden/toBeAttached/toHaveCount/toHaveText/toContainText/
+ *   toHaveAttribute/toHaveClass/toContainClass/toHaveCSS/toHaveValue/toHaveId/
+ *   toBeChecked/toBeEnabled/toBeDisabled/toBeEditable/toBeEmpty/toBeFocused/
+ *   toBeInViewport/toHaveAccessibleName/toHaveRole` (+ `.not`, `expect.soft`,
+ *   `expect.configure`), `expect(page).toHaveTitle/toHaveURL`.
+ * - **The escape hatch is `page.evaluate()`.** Anything the list above does
+ *   not cover — a computed style, a scroll position, `matchMedia`, a
+ *   `fetch` — is one `evaluate` away; the function runs inside the real page
+ *   and returns JSON.
+ * - **Not available over the preview**, and the method THROWS naming the
+ *   alternative: screenshots and `toHaveScreenshot` (assert layout with
+ *   `boundingBox()` and computed styles instead), `page.route/waitForResponse/
+ *   waitForRequest` (read the response with `page.request` or `fetch` in
+ *   `evaluate`), element handles (`$`, `$$`, `elementHandle` — use locators),
+ *   `setInputFiles`, `dragTo`, iframes inside the preview, `emulateMedia`,
+ *   `addInitScript/exposeFunction`, `context.cookies/storageState` (read
+ *   `document.cookie`/`localStorage` in `evaluate`). The playwright bond
+ *   supports all of them.
+ * - **Viewport.** `page.setViewportSize` asks the IDE to resize the preview
+ *   frame and throws if the host did not (a preview opened in a plain tab
+ *   keeps the tab's width). Test phone layouts at 390×844 this way.
+ * - **Events.** `page.on('response')`/`'request'` never fire over the preview
+ *   (a one-time warning says so); `'console'` and `'pageerror'` do, so the
+ *   console-error guard works there too.
+ * - **The person's browser is the renderer.** If every tab showing the
+ *   preview is closed or asleep, actions wait for a page to reconnect and
+ *   then time out with a message saying so. Keep the IDE tab open (the IDE
+ *   holds a screen wake lock while a build runs) or open the preview URL in
+ *   any other tab — any connected viewer will do.
+ * - `createEvaluatePage()` is how a bond that can only run code inside a page
+ *   (an `E2ETransport`) gets the whole Playwright-shaped page; the preview
+ *   bond uses it, and so can any future one.
+ * - `@playwright/test` is a peer dependency: it supplies the runner
+ *   (`npx playwright test`), `expect` for plain values, and the `Page` types.
+ *   It never downloads browsers on install; only the playwright bond needs
+ *   `npx playwright install`.
+ *
  * @module
  */
-import { expect, test as base } from '@playwright/test';
-/** Substrings that are always ignored — browser noise that doesn't reflect app bugs. */
-const ALWAYS_IGNORE = [
-    // Vite HMR dev-only websocket reconnect warnings — happen on the
-    // test runner's first poll before vite is fully booted; harmless.
-    /\[vite\].*connecting/i,
-    /\[vite\].*server connection lost/i,
-    // Service worker registration failures in headless Chrome — VitePWA
-    // tries to register at /sw.js but our smoke build emits to /workbox-*
-    // and Playwright fixtures the user-agent. Cosmetic.
-    /service worker.*404/i,
-    // Chrome DevTools' own probe for source maps on third-party CDN bundles
-    // we don't ship maps for (Stripe, Google Maps, etc). Two bugs fixed here,
-    // both verified against a headless Chromium probe + the real reported
-    // message text (not guessed): (1) the verb was wrong — real Chrome output
-    // is "DevTools failed to load SourceMap: Could not load content for
-    // <url>: ...", not "failed to fetch source map", so the old pattern never
-    // matched real Chrome text at all; (2) the host check (`.cdn.`) doesn't
-    // match real vendor hosts (js.stripe.com, maps.googleapis.com contain no
-    // '.cdn.' substring). Now matches any `https://`-hosted source map
-    // (third-party CDN bundles are always TLS; the app's own dev/preview
-    // server is plain `http://localhost`, so same-origin source-map issues
-    // are never accidentally silenced by this pattern).
-    // NOTE (verified, not assumed): a probe with a broken `sourceMappingURL`
-    // produced ZERO console messages via `page.on('console')` under plain
-    // Playwright automation (with and without tracing) — Chrome only fetches
-    // source maps when a DevTools Sources panel is actually attached, which a
-    // headless Playwright run never does. So this entry currently matches
-    // nothing observed in practice; it is defense-in-depth against a future
-    // Chrome/Playwright behavior change, not an active filter today.
-    /devtools failed to load source ?map.*https:\/\//i,
-];
-/**
- * Custom Playwright `test` with an auto-attached browser console-error
- * guard. Drop-in replacement for `import { test } from '@playwright/test'`.
- */
-export const test = base.extend({
-    consoleGuard: [
-        async ({ page }, use, testInfo) => {
-            const buffer = [];
-            // Each allow-console-error description is tried as a regex; an invalid
-            // pattern (e.g. verbatim error text containing `[` or `(`) falls back to
-            // plain substring matching instead of throwing from inside the guard.
-            const matchesAllowed = (text, description) => {
-                if (description === undefined)
-                    return true; // no description = allow everything
-                try {
-                    return new RegExp(description).test(text);
-                }
-                catch (_error) {
-                    // Invalid regex — treat the description as a literal substring.
-                    return text.includes(description);
-                }
-            };
-            const shouldIgnore = (text) => {
-                if (ALWAYS_IGNORE.some((re) => re.test(text)))
-                    return true;
-                return testInfo.annotations
-                    .filter((a) => a.type === 'allow-console-error')
-                    .some((a) => matchesAllowed(text, a.description));
-            };
-            const onPageError = (err) => {
-                const text = err.message || String(err);
-                if (shouldIgnore(text))
-                    return;
-                buffer.push({ type: 'pageerror', text });
-            };
-            const onConsole = (msg) => {
-                if (msg.type() !== 'error')
-                    return;
-                const text = msg.text();
-                if (shouldIgnore(text))
-                    return;
-                const loc = msg.location();
-                buffer.push({
-                    type: 'console.error',
-                    text,
-                    location: loc?.url ? `${loc.url}:${loc.lineNumber}` : undefined,
-                });
-            };
-            page.on('pageerror', onPageError);
-            page.on('console', onConsole);
-            try {
-                await use();
-            }
-            finally {
-                page.off('pageerror', onPageError);
-                page.off('console', onConsole);
-            }
-            if (buffer.length > 0) {
-                const lines = buffer
-                    .map((e) => `  - [${e.type}] ${e.text}${e.location ? `  (${e.location})` : ''}`)
-                    .join('\n');
-                throw new Error(`Browser console error(s) during test (${buffer.length}):\n${lines}\n\n` +
-                    `If this error is genuinely expected, add\n` +
-                    `  test.info().annotations.push({ type: 'allow-console-error', description: '<regex>' })\n` +
-                    `to the test body BEFORE the error fires.`);
-            }
-        },
-        { auto: true },
-    ],
-});
-export { expect };
+export * from './console-guard.js';
+export * from './expect.js';
+export * from './page.js';
+export * from './playwright.js';
+export * from './runtime.js';
+export * from './test.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AAEH,cAAc,oBAAoB,CAAA;AAClC,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA;AACzB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,WAAW,CAAA"}

package/dist/page.d.ts

@@ -0,0 +1,370 @@
+/**
+ * A Playwright-shaped `Page` built on an {@link E2ETransport} — the driver
+ * half of the runtime in `runtime.ts`. Bonds that can only run code inside a
+ * page (the live preview) get the whole documented subset from this file.
+ *
+ * @module
+ */
+import type { BrowserContext, Frame, Page } from '@playwright/test';
+import type { E2EPageOptions, E2ETransport, E2EViewport } from '@molecule/app-e2e';
+import { type LocatorStep, type TextMatch } from './runtime.js';
+/** Brand on locators created here (the `expect` wrapper routes on it). */
+export declare const E2E_LOCATOR: unique symbol;
+/** Brand on pages created here. */
+export declare const E2E_PAGE: unique symbol;
+type Dict = Record<string, unknown>;
+type Listener = (payload: unknown) => void;
+declare const toMatch: (value: string | RegExp, opts?: {
+    exact?: boolean;
+    ignoreCase?: boolean;
+}) => TextMatch;
+/** Full-text match (expect's toHaveText): a string must equal the whole text; a RegExp tests it. */
+declare const toFull: (value: string | RegExp, opts?: {
+    ignoreCase?: boolean;
+}) => TextMatch;
+/** A Playwright-shaped Locator: a lazy chain of steps resolved inside the page on every action. */
+declare class LocatorImpl {
+    private readonly owner;
+    readonly steps: LocatorStep[];
+    readonly [E2E_LOCATOR] = true;
+    constructor(owner: PageImpl, steps: LocatorStep[]);
+    /** A new locator with more steps (locators are immutable). */
+    private extend;
+    /** Steps for a selector string (parsed in the page) or another locator. */
+    private stepsOf;
+    /** The filter steps a `filter()` / `locator()` options object adds. */
+    private filterStep;
+    /** Playwright's `locator()`: narrow to descendants matching a selector, with optional `hasText` / `has` filters. */
+    locator(sel: string | LocatorImpl, opts?: {
+        hasText?: string | RegExp;
+        hasNotText?: string | RegExp;
+        has?: LocatorImpl;
+        hasNot?: LocatorImpl;
+    }): LocatorImpl;
+    /** Playwright's `getByRole()`: by ARIA role, with accessible-name, heading-level and state options. */
+    getByRole(role: string, opts?: Dict): LocatorImpl;
+    /** Playwright's `getByText()`: the smallest elements whose text matches. */
+    getByText(text: string | RegExp, opts?: {
+        exact?: boolean;
+    }): LocatorImpl;
+    /** Playwright's `getByLabel()`: form controls by their label text (also `aria-label`). */
+    getByLabel(text: string | RegExp, opts?: {
+        exact?: boolean;
+    }): LocatorImpl;
+    /** Playwright's `getByPlaceholder()`. */
+    getByPlaceholder(text: string | RegExp, opts?: {
+        exact?: boolean;
+    }): LocatorImpl;
+    /** Playwright's `getByTitle()`. */
+    getByTitle(text: string | RegExp, opts?: {
+        exact?: boolean;
+    }): LocatorImpl;
+    /** Playwright's `getByAltText()`. */
+    getByAltText(text: string | RegExp, opts?: {
+        exact?: boolean;
+    }): LocatorImpl;
+    /** Playwright's `getByTestId()` on the configured test-id attribute (default `data-testid`). */
+    getByTestId(id: string | RegExp): LocatorImpl;
+    /** Playwright's `locator.filter()`: keep matches by text, by a descendant locator, or by visibility. */
+    filter(opts?: {
+        hasText?: string | RegExp;
+        hasNotText?: string | RegExp;
+        has?: LocatorImpl;
+        hasNot?: LocatorImpl;
+        visible?: boolean;
+    }): LocatorImpl;
+    /** The first match. */
+    first(): LocatorImpl;
+    /** The last match. */
+    last(): LocatorImpl;
+    /** The i-th match (a negative index counts from the end). */
+    nth(i: number): LocatorImpl;
+    /** The page this belongs to (null for a console message over the preview). */
+    page(): Page;
+    /** The locator chain, Playwright-style, for error messages. */
+    toString(): string;
+    /** The locator chain as text. */
+    describe(): string;
+    /** Run one runtime call for this locator. */
+    private call;
+    /** Turn a runtime reply into a value, throwing strict-mode, timeout or plain errors. */
+    private unwrap;
+    /** Run a single-target action with auto-wait and actionability checks. */
+    private act;
+    /** Read one value from the single strict target. */
+    private read;
+    /** Playwright's `click()`: waits until the element is visible, enabled and not covered, then clicks its centre (or `position`). */
+    click(opts?: Dict): Promise<void>;
+    /** Playwright's `dblclick()`. */
+    dblclick(opts?: Dict): Promise<void>;
+    /** Playwright's `hover()`: moves the pointer over the element. */
+    hover(opts?: Dict): Promise<void>;
+    /** Playwright's `tap()`: touch events followed by a click. */
+    tap(opts?: Dict): Promise<void>;
+    /** Playwright's `fill()`: focuses, replaces the value through the native setter and fires `input` / `change`. */
+    fill(value: string, opts?: Dict): Promise<void>;
+    /** Playwright's `clear()`: fills with an empty string. */
+    clear(opts?: Dict): Promise<void>;
+    /** Playwright's `type()`: presses each character in turn (or, on a console message, its level). */
+    type(text: string, opts?: Dict): Promise<void>;
+    /** Playwright's `pressSequentially()`: presses each character in turn. */
+    pressSequentially(text: string, opts?: Dict): Promise<void>;
+    /** Playwright's `press()`: a key or chord (`Enter`, `Control+a`); Enter submits a form. */
+    press(key: string, opts?: Dict): Promise<void>;
+    /** Playwright's `check()`: clicks until checked (or, on the page, throws on a failed runtime reply). */
+    check(opts?: Dict): Promise<void>;
+    /** Playwright's `uncheck()`: clicks until unchecked. */
+    uncheck(opts?: Dict): Promise<void>;
+    /** Playwright's `setChecked()`. */
+    setChecked(checked: boolean, opts?: Dict): Promise<void>;
+    /** Playwright's `selectOption()`: by value, label or index; returns the selected values. */
+    selectOption(values: unknown, opts?: Dict): Promise<string[]>;
+    /** Playwright's `focus()`. */
+    focus(opts?: Dict): Promise<void>;
+    /** Playwright's `blur()`. */
+    blur(opts?: Dict): Promise<void>;
+    /** Playwright's `dispatchEvent()`: a synthetic event of the given type. */
+    dispatchEvent(type: string, init?: Dict, opts?: Dict): Promise<void>;
+    /** Playwright's `scrollIntoViewIfNeeded()`. */
+    scrollIntoViewIfNeeded(opts?: Dict): Promise<void>;
+    /** No-op over the preview: nothing to paint. */
+    highlight(): Promise<void>;
+    /** Playwright's `count()`: how many elements match right now. */
+    count(): Promise<number>;
+    /** Playwright's `all()`: one locator per current match. */
+    all(): Promise<LocatorImpl[]>;
+    /** Playwright's `allTextContents()`. */
+    allTextContents(): Promise<string[]>;
+    /** Playwright's `allInnerTexts()`. */
+    allInnerTexts(): Promise<string[]>;
+    /** Playwright's `textContent()` (strict: exactly one match). */
+    textContent(opts?: Dict): Promise<string | null>;
+    /** Playwright's `innerText()`. */
+    innerText(opts?: Dict): Promise<string>;
+    /** Playwright's `innerHTML()`. */
+    innerHTML(opts?: Dict): Promise<string>;
+    /** Playwright's `inputValue()` for inputs, textareas and selects. */
+    inputValue(opts?: Dict): Promise<string>;
+    /** Playwright's `getAttribute()`. */
+    getAttribute(name: string, opts?: Dict): Promise<string | null>;
+    /** Playwright's `isVisible()`: false when nothing matches; no waiting. */
+    isVisible(): Promise<boolean>;
+    /** Playwright's `isHidden()`: true when nothing matches; no waiting. */
+    isHidden(): Promise<boolean>;
+    /** Playwright's `isEnabled()`. */
+    isEnabled(opts?: Dict): Promise<boolean>;
+    /** Playwright's `isDisabled()`. */
+    isDisabled(opts?: Dict): Promise<boolean>;
+    /** Playwright's `isEditable()`. */
+    isEditable(opts?: Dict): Promise<boolean>;
+    /** Playwright's `isChecked()` for checkboxes, radios and switches. */
+    isChecked(opts?: Dict): Promise<boolean>;
+    /** Playwright's `boundingBox()`: the element's rect, or null when it is not visible. */
+    boundingBox(opts?: Dict): Promise<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    /** Playwright's `evaluate()`: runs the function inside the page and returns JSON. */
+    evaluate(fn: unknown, arg?: unknown, opts?: Dict): Promise<unknown>;
+    /** Playwright's `locator.evaluateAll()`: runs `fn(elements, arg)` inside the page. */
+    evaluateAll(fn: unknown, arg?: unknown): Promise<unknown>;
+    /** Playwright's `waitFor()`: until attached, detached, visible or hidden. */
+    waitFor(opts?: {
+        state?: 'attached' | 'detached' | 'visible' | 'hidden';
+        timeout?: number;
+    }): Promise<void>;
+    /** One probe for the expect matchers; the wrapper polls it. */
+    probe(matcher: string, args: Dict): Promise<Dict>;
+}
+interface DialogImpl {
+    type(): string;
+    message(): string;
+    defaultValue(): string;
+    accept(text?: string): Promise<void>;
+    dismiss(): Promise<void>;
+}
+/** A Playwright-shaped Page over an `E2ETransport`; `createEvaluatePage` wraps it in a Proxy. */
+declare class PageImpl {
+    private readonly transport;
+    private readonly options;
+    readonly [E2E_PAGE] = true;
+    defaultTimeout: number;
+    navigationTimeout: number;
+    readonly testIdAttribute: string;
+    private viewport;
+    private closed;
+    private proxy;
+    private readonly listeners;
+    private readonly warned;
+    private readonly unsubscribe;
+    readonly mouse: Dict;
+    readonly keyboard: Dict;
+    readonly touchscreen: Dict;
+    readonly request: Dict;
+    constructor(transport: E2ETransport, options: E2EPageOptions);
+    /** The bond's name, for error messages. */
+    get bondName(): string;
+    /** The branded Page proxy. */
+    asPage(): Page;
+    /** Called once by `createEvaluatePage` with the proxy that wraps this instance. */
+    attachProxy(proxy: Page): void;
+    /** Fire the listeners of one event. */
+    private emit;
+    /** Playwright's `check()`: clicks until checked (or, on the page, throws on a failed runtime reply). */
+    private check;
+    /** Run a runtime call inside the page, installing the runtime on a fresh document. */
+    rt(fn: string, args: unknown[], timeout?: number): Promise<Dict>;
+    /** Resolve a spec URL against `baseURL` when it is relative. */
+    private resolveUrl;
+    /** Playwright's `page.goto()`: navigate and wait for the new document to load. */
+    goto(url: string, opts?: {
+        timeout?: number;
+    }): Promise<null>;
+    /** Playwright's `page.reload()`. */
+    reload(opts?: {
+        timeout?: number;
+    }): Promise<null>;
+    /** Playwright's `page.goBack()`. */
+    goBack(opts?: {
+        timeout?: number;
+    }): Promise<null>;
+    /** Playwright's `page.goForward()`. */
+    goForward(opts?: {
+        timeout?: number;
+    }): Promise<null>;
+    /** Playwright's `url()`: the last known URL (or, on a response, its final URL). */
+    url(): string;
+    /** Playwright's `page.title()`. */
+    title(): Promise<string>;
+    /** Playwright's `page.content()`: the document's HTML. */
+    content(): Promise<string>;
+    /** Playwright's `waitForLoadState()`: until the document is complete (plus a quiet moment for `networkidle`). */
+    waitForLoadState(state?: string, opts?: {
+        timeout?: number;
+    }): Promise<void>;
+    /** Playwright's `waitForURL()`: a string (full URL or path), RegExp or predicate. */
+    waitForURL(url: string | RegExp | ((u: URL) => boolean), opts?: {
+        timeout?: number;
+    }): Promise<void>;
+    /** Playwright's `waitForTimeout()`. */
+    waitForTimeout(ms: number): Promise<void>;
+    /** Playwright's `waitForFunction()`: polls the function inside the page until it returns a truthy value. */
+    waitForFunction(fn: unknown, arg?: unknown, opts?: {
+        timeout?: number;
+        polling?: number | 'raf';
+    }): Promise<unknown>;
+    /** Playwright's `waitForSelector()`; returns the locator (element handles are not available). */
+    waitForSelector(selector: string, opts?: {
+        state?: 'attached' | 'detached' | 'visible' | 'hidden';
+        timeout?: number;
+    }): Promise<LocatorImpl | null>;
+    /** Playwright's `evaluate()`: runs the function inside the page and returns JSON. */
+    evaluate(fn: unknown, arg?: unknown): Promise<unknown>;
+    /** Playwright's `$eval()`. */
+    $eval(selector: string, fn: unknown, arg?: unknown): Promise<unknown>;
+    /** Playwright's `$$eval()`. */
+    $$eval(selector: string, fn: unknown, arg?: unknown): Promise<unknown>;
+    /** Playwright's `addStyleTag()` (inline content). */
+    addStyleTag(opts: {
+        content?: string;
+        url?: string;
+    }): Promise<null>;
+    /** Playwright's `addScriptTag()`. */
+    addScriptTag(opts: {
+        content?: string;
+        url?: string;
+        type?: string;
+    }): Promise<null>;
+    /** Playwright's `locator()`: narrow to descendants matching a selector, with optional `hasText` / `has` filters. */
+    locator(sel: string | LocatorImpl, opts?: {
+        hasText?: string | RegExp;
+        hasNotText?: string | RegExp;
+        has?: LocatorImpl;
+        hasNot?: LocatorImpl;
+    }): LocatorImpl;
+    /** Playwright's `getByRole()`: by ARIA role, with accessible-name, heading-level and state options. */
+    getByRole(role: string, opts?: Dict): LocatorImpl;
+    /** Playwright's `getByText()`: the smallest elements whose text matches. */
+    getByText(text: string | RegExp, opts?: {
+        exact?: boolean;
+    }): LocatorImpl;
+    /** Playwright's `getByLabel()`: form controls by their label text (also `aria-label`). */
+    getByLabel(text: string | RegExp, opts?: {
+        exact?: boolean;
+    }): LocatorImpl;
+    /** Playwright's `getByPlaceholder()`. */
+    getByPlaceholder(text: string | RegExp, opts?: {
+        exact?: boolean;
+    }): LocatorImpl;
+    /** Playwright's `getByTitle()`. */
+    getByTitle(text: string | RegExp, opts?: {
+        exact?: boolean;
+    }): LocatorImpl;
+    /** Playwright's `getByAltText()`. */
+    getByAltText(text: string | RegExp, opts?: {
+        exact?: boolean;
+    }): LocatorImpl;
+    /** Playwright's `getByTestId()` on the configured test-id attribute (default `data-testid`). */
+    getByTestId(id: string | RegExp): LocatorImpl;
+    /** Playwright's `setViewportSize()`: asks the host to resize the frame; throws when it did not. */
+    setViewportSize(size: E2EViewport): Promise<void>;
+    /** Apply the configured viewport without failing the test when the host cannot resize (used once at connect). */
+    applyInitialViewport(): Promise<void>;
+    /** Playwright's `viewportSize()`. */
+    viewportSize(): E2EViewport | null;
+    /** Log a warning once per key. */
+    private warnOnce;
+    /** Playwright's `page.on()`: console, pageerror, dialog, close and load fire over the preview; network events never do (warned once). */
+    on(event: string, fn: Listener): Page;
+    /** Alias of `on()`. */
+    addListener(event: string, fn: Listener): Page;
+    /** Playwright's `page.once()`. */
+    once(event: string, fn: Listener): Page;
+    /** Playwright's `page.off()`. */
+    off(event: string, fn: Listener): Page;
+    /** Alias of `off()`. */
+    removeListener(event: string, fn: Listener): Page;
+    /** Playwright's `removeAllListeners()`. */
+    removeAllListeners(event?: string): Page;
+    /** Called by a transport that forwards dialogs (the preview client auto-accepts them). */
+    emitDialog(dialog: DialogImpl): void;
+    /** Playwright's `page.close()`: releases the transport. */
+    close(): Promise<void>;
+    /** Playwright's `isClosed()`. */
+    isClosed(): boolean;
+    /** No-op over the preview: the page is already in front. */
+    bringToFront(): Promise<void>;
+    /** Playwright's `setDefaultTimeout()`. */
+    setDefaultTimeout(ms: number): void;
+    /** Playwright's `setDefaultNavigationTimeout()`. */
+    setDefaultNavigationTimeout(ms: number): void;
+    /** No-op: there is no inspector to pause in. */
+    pause(): Promise<void>;
+    /** The page itself, standing in for the main frame. */
+    mainFrame(): Frame;
+    /** The main frame only. */
+    frames(): Frame[];
+    /** Always empty over the preview. */
+    workers(): unknown[];
+    /** Always null over the preview. */
+    opener(): null;
+    /** Always null: no recording over the preview. */
+    video(): null;
+    /** A minimal BrowserContext: pages, timeouts and no-op tracing; the rest throws naming the alternative. */
+    context(): BrowserContext;
+}
+/**
+ * Build a Playwright-shaped `Page` over a transport. Bonds call this from
+ * `connect()`; the returned object carries the documented subset and throws an
+ * {@link E2EUnsupportedError} naming the alternative for the rest.
+ */
+export declare const createEvaluatePage: (transport: E2ETransport, options?: E2EPageOptions) => Promise<Page>;
+/** Whether a value is a locator built by {@link createEvaluatePage}. */
+export declare const isE2ELocator: (value: unknown) => value is LocatorImpl;
+/** Whether a value is a page built by {@link createEvaluatePage}. */
+export declare const isE2EPage: (value: unknown) => value is PageImpl;
+export type { LocatorImpl as E2ELocatorImpl, PageImpl as E2EPageImpl };
+export { toMatch as textMatch, toFull as textMatchFull };
+//# sourceMappingURL=page.d.ts.map