@react-three-dom/playwright 0.1.2 → 0.3.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _playwright_test from '@playwright/test';
-import { Page } from '@playwright/test';
+import { Page, Locator } from '@playwright/test';
 
 interface ObjectMetadata {
     uuid: string;
@@ -12,6 +12,10 @@ interface ObjectMetadata {
     vertexCount?: number;
     triangleCount?: number;
     instanceCount?: number;
+    fov?: number;
+    near?: number;
+    far?: number;
+    zoom?: number;
     position: [number, number, number];
     rotation: [number, number, number];
     scale: [number, number, number];
@@ -19,6 +23,10 @@ interface ObjectMetadata {
     childrenUuids: string[];
     boundsDirty: boolean;
 }
+/** Options for inspect(). Set includeGeometryData: true to get vertex/index buffers (higher cost). */
+interface InspectOptions {
+    includeGeometryData?: boolean;
+}
 interface ObjectInspection {
     metadata: ObjectMetadata;
     worldMatrix: number[];
@@ -39,6 +47,10 @@ interface ObjectInspection {
             center: [number, number, number];
             radius: number;
         };
+        /** Vertex positions (x,y,z per vertex). Only when inspect(..., { includeGeometryData: true }). */
+        positionData?: number[];
+        /** Triangle indices. Only when inspect(..., { includeGeometryData: true }) and geometry is indexed. */
+        indexData?: number[];
     };
     material?: {
         type: string;
@@ -67,6 +79,138 @@ interface SceneSnapshot {
     objectCount: number;
     tree: SnapshotNode;
 }
+interface CameraState {
+    type: string;
+    position: [number, number, number];
+    rotation: [number, number, number];
+    target: [number, number, number];
+    fov?: number;
+    near: number;
+    far: number;
+    zoom: number;
+    aspect?: number;
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+interface BridgeDiagnostics {
+    version: string;
+    ready: boolean;
+    error?: string;
+    objectCount: number;
+    meshCount: number;
+    groupCount: number;
+    lightCount: number;
+    cameraCount: number;
+    materializedDomNodes: number;
+    maxDomNodes: number;
+    canvasWidth: number;
+    canvasHeight: number;
+    webglRenderer: string;
+    dirtyQueueSize: number;
+}
+declare global {
+    interface Window {
+        __R3F_DOM_DEBUG__?: boolean;
+    }
+}
+
+/**
+ * @module reporter
+ *
+ * Rich terminal reporter for Playwright tests. Outputs ANSI-colored status
+ * messages for bridge lifecycle events (waiting, connected, error), scene
+ * readiness, object lookups (with fuzzy-match suggestions on miss),
+ * interaction timings, assertion failures, and full bridge diagnostics.
+ */
+
+/**
+ * Formatted terminal reporter for react-three-dom Playwright tests.
+ * Logs bridge lifecycle, scene readiness, interaction timings, assertion
+ * failures, and full diagnostics with ANSI colors.
+ */
+declare class R3FReporter {
+    private readonly _page;
+    private _enabled;
+    private _canvasId?;
+    constructor(_page: Page, enabled?: boolean, canvasId?: string);
+    logBridgeWaiting(): void;
+    logBridgeConnected(diag?: BridgeDiagnostics): void;
+    logBridgeError(error: string): void;
+    logSceneReady(objectCount: number): void;
+    logObjectFound(idOrUuid: string, type: string, name?: string): void;
+    logObjectNotFound(idOrUuid: string, suggestions?: Array<{
+        testId?: string;
+        name: string;
+        uuid: string;
+    }>): void;
+    logInteraction(action: string, idOrUuid: string, extra?: string): void;
+    logInteractionDone(action: string, idOrUuid: string, durationMs: number): void;
+    logAssertionFailure(matcherName: string, id: string, detail: string, diag?: BridgeDiagnostics): void;
+    logDiagnostics(): Promise<void>;
+    fetchDiagnostics(): Promise<BridgeDiagnostics | null>;
+    fetchFuzzyMatches(query: string, limit?: number): Promise<Array<{
+        testId?: string;
+        name: string;
+        uuid: string;
+    }>>;
+    private _printDiagnosticsSummary;
+    private _printDiagnosticsFull;
+}
+
+/**
+ * @module diffSnapshots
+ *
+ * Pure scene-diff utility. Compares two {@link SceneSnapshot}s by UUID and
+ * returns added nodes, removed nodes, and per-field property changes
+ * (name, type, testId, visible, position, rotation, scale).
+ *
+ * Stateless and side-effect-free — safe to call from any context.
+ */
+
+/** Describes a single property change on an object that exists in both snapshots. */
+interface SceneDiffChange {
+    uuid: string;
+    field: string;
+    from: unknown;
+    to: unknown;
+}
+/** Result of diffing two scene snapshots. */
+interface SceneDiff {
+    /** Nodes present in `after` but not in `before` (from `after` tree). */
+    added: SnapshotNode[];
+    /** Nodes present in `before` but not in `after` (from `before` tree). */
+    removed: SnapshotNode[];
+    /** Property changes for nodes that exist in both; each entry is one field that changed. */
+    changed: SceneDiffChange[];
+}
+/**
+ * Compare two scene snapshots and return added nodes, removed nodes, and
+ * property changes for nodes that exist in both.
+ *
+ * - **added**: nodes in `after` whose uuid was not in `before`.
+ * - **removed**: nodes in `before` whose uuid was not in `after`.
+ * - **changed**: for each uuid present in both, lists field-level changes
+ *   (name, type, testId, visible, position, rotation, scale).
+ */
+declare function diffSnapshots(before: SceneSnapshot, after: SceneSnapshot): SceneDiff;
+
+/**
+ * @module waiters
+ *
+ * Polling-based wait utilities for Playwright tests. Each waiter polls the
+ * `window.__R3F_DOM__` bridge until a condition is met or a timeout fires.
+ *
+ * - {@link waitForSceneReady} — bridge ready + object count stabilised
+ * - {@link waitForObject} — bridge ready + specific object exists
+ * - {@link waitForIdle} — no property changes for N consecutive frames
+ * - {@link waitForNewObject} — new object(s) appear after a baseline snapshot
+ * - {@link waitForObjectRemoved} — object no longer in the scene
+ *
+ * All waiters fail fast with a rich diagnostic if the bridge reports an
+ * `_error` state, preventing silent timeouts.
+ */
 
 interface WaitForSceneReadyOptions {
     /** How many consecutive stable polls are required. Default: 3 */
@@ -77,10 +221,15 @@ interface WaitForSceneReadyOptions {
     timeout?: number;
 }
 /**
- * Wait until `window.__R3F_DOM__` is available and the scene's object count
- * has stabilised (no additions or removals) over several consecutive checks.
+ * Wait until `window.__R3F_DOM__` is available, `_ready === true`, and the
+ * scene's object count has stabilised over several consecutive checks.
+ *
+ * If the bridge exists but `_ready` is false and `_error` is set, this
+ * fails immediately with a rich diagnostic message instead of timing out.
  */
-declare function waitForSceneReady(page: Page, options?: WaitForSceneReadyOptions): Promise<void>;
+declare function waitForSceneReady(page: Page, options?: WaitForSceneReadyOptions & {
+    canvasId?: string;
+}): Promise<void>;
 interface WaitForObjectOptions {
     /** Time to wait for the bridge to appear. Default: 30_000 */
     bridgeTimeout?: number;
@@ -90,14 +239,18 @@ interface WaitForObjectOptions {
     pollIntervalMs?: number;
 }
 /**
- * Wait until `window.__R3F_DOM__` is available and an object with the given
+ * Wait until `window.__R3F_DOM__` is ready and an object with the given
  * testId or uuid exists in the scene.
  *
  * Use this instead of `waitForSceneReady` when the scene object count never
  * stabilizes (e.g. continuous loading, animations adding/removing objects,
  * or GLTF/models loading asynchronously).
+ *
+ * Fails fast if the bridge reports `_ready: false` with an `_error`.
  */
-declare function waitForObject(page: Page, idOrUuid: string, options?: WaitForObjectOptions): Promise<void>;
+declare function waitForObject(page: Page, idOrUuid: string, options?: WaitForObjectOptions & {
+    canvasId?: string;
+}): Promise<void>;
 interface WaitForIdleOptions {
     /** Number of consecutive idle frames required. Default: 10 */
     idleFrames?: number;
@@ -111,46 +264,317 @@ interface WaitForIdleOptions {
  * This works by taking successive snapshots and comparing them. When the
  * JSON representation is unchanged for `idleFrames` consecutive rAF
  * callbacks, the scene is considered idle.
+ *
+ * Checks `_ready === true` before starting. Fails fast if `_error` is set.
+ */
+declare function waitForIdle(page: Page, options?: WaitForIdleOptions & {
+    canvasId?: string;
+}): Promise<void>;
+interface WaitForNewObjectOptions {
+    /**
+     * Only consider new objects of this Three.js type (e.g. "Mesh", "Line").
+     * If not set, any new object type qualifies.
+     */
+    type?: string;
+    /**
+     * If provided, the new object's name must contain this substring.
+     * Useful for apps that name objects predictably (e.g. "stroke-", "wall-").
+     */
+    nameContains?: string;
+    /**
+     * Poll interval in ms. Default: 100
+     */
+    pollIntervalMs?: number;
+    /**
+     * Overall timeout in ms. Default: 10_000
+     */
+    timeout?: number;
+}
+/** Result returned when new objects are detected. */
+interface WaitForNewObjectResult {
+    /** Metadata of all newly added objects (matching the filter). */
+    newObjects: ObjectMetadata[];
+    /** UUIDs of the newly added objects. */
+    newUuids: string[];
+    /** Total number of new objects detected. */
+    count: number;
+}
+/**
+ * Wait until one or more new objects appear in the scene that were not present
+ * at the time this function was called.
+ *
+ * This is designed for drawing/annotation apps where user interactions
+ * (like `drawPath`) create new Three.js objects asynchronously.
+ *
+ * @param page      Playwright Page instance
+ * @param options   Filter and timing options
+ * @returns         Metadata of the newly added object(s)
+ * @throws          If no new objects appear within the timeout
+ *
+ * @example
+ * ```typescript
+ * // Draw a stroke, then wait for the new Line object
+ * const before = await r3f.getCount();
+ * await r3f.drawPath(points);
+ * const result = await waitForNewObject(page, { type: 'Line' });
+ * expect(result.count).toBe(1);
+ * ```
  */
-declare function waitForIdle(page: Page, options?: WaitForIdleOptions): Promise<void>;
+declare function waitForNewObject(page: Page, options?: WaitForNewObjectOptions & {
+    canvasId?: string;
+}): Promise<WaitForNewObjectResult>;
+interface WaitForObjectRemovedOptions {
+    /** Time to wait for the bridge to appear. Default: 30_000 */
+    bridgeTimeout?: number;
+    /** Poll interval in ms. Default: 100 */
+    pollIntervalMs?: number;
+    /** Overall timeout in ms (after bridge is ready). Default: 10_000 */
+    timeout?: number;
+}
+/**
+ * Wait until the bridge is ready and an object with the given testId or uuid
+ * is no longer in the scene. Use for delete flows (e.g. user deletes an object,
+ * then you assert it's gone).
+ *
+ * @param page      Playwright Page instance
+ * @param idOrUuid  testId or uuid of the object that should be removed
+ * @param options   Timing options
+ * @throws          If the object is still present after the timeout
+ *
+ * @example
+ * ```ts
+ * await r3f.click('delete-button');
+ * await r3f.waitForObjectRemoved('item-to-delete');
+ * await expect(r3f).not.toExist('item-to-delete');
+ * ```
+ */
+declare function waitForObjectRemoved(page: Page, idOrUuid: string, options?: WaitForObjectRemovedOptions & {
+    canvasId?: string;
+}): Promise<void>;
 
+/** Options for R3FFixture constructor. */
+interface R3FFixtureOptions {
+    /** Auto-enable debug logging (forwards browser [r3f-dom:*] logs to test terminal). */
+    debug?: boolean;
+    /**
+     * Enable rich diagnostic reporting in the terminal.
+     * Logs bridge status, scene readiness, interaction details, and
+     * failure context automatically. Default: true.
+     */
+    report?: boolean;
+    /** Target a specific canvas by its canvasId. When omitted, uses the default bridge. */
+    canvasId?: string;
+}
+/**
+ * Main API object provided to Playwright tests for interacting with a
+ * react-three-dom scene. Wraps queries, interactions, waiters, snapshot
+ * diffing, and rich terminal diagnostics. Supports multi-canvas apps
+ * via {@link R3FFixture.forCanvas}.
+ */
 declare class R3FFixture {
     private readonly _page;
-    constructor(_page: Page);
+    private _debugListenerAttached;
+    private readonly _reporter;
+    /** Canvas ID for multi-canvas apps. Undefined = default bridge. */
+    readonly canvasId?: string;
+    constructor(_page: Page, opts?: R3FFixtureOptions);
     /** The underlying Playwright Page. */
     get page(): Page;
+    /** Access the reporter for custom diagnostic logging. */
+    get reporter(): R3FReporter;
+    /**
+     * Create a scoped fixture targeting a specific canvas instance.
+     * All queries, interactions, and assertions on the returned fixture
+     * will use `window.__R3F_DOM_INSTANCES__[canvasId]` instead of
+     * `window.__R3F_DOM__`.
+     *
+     * @example
+     * ```typescript
+     * const mainR3f = r3f.forCanvas('main-viewport');
+     * const minimapR3f = r3f.forCanvas('minimap');
+     * await mainR3f.click('building-42');
+     * await expect(minimapR3f).toExist('building-42-marker');
+     * ```
+     */
+    forCanvas(canvasId: string): R3FFixture;
+    /**
+     * List all active canvas IDs registered on the page.
+     * Returns an empty array if only the default (unnamed) bridge is active.
+     */
+    getCanvasIds(): Promise<string[]>;
+    /**
+     * Enable debug logging. Turns on `window.__R3F_DOM_DEBUG__` in the browser
+     * and forwards all `[r3f-dom:*]` console messages to the Node.js test terminal.
+     *
+     * Call before `page.goto()` to capture setup logs, or after to capture
+     * interaction logs.
+     */
+    enableDebug(): Promise<void>;
+    private _attachDebugListener;
     /** Get object metadata by testId or uuid. Returns null if not found. */
     getObject(idOrUuid: string): Promise<ObjectMetadata | null>;
-    /** Get heavy inspection data (Tier 2) by testId or uuid. */
-    inspect(idOrUuid: string): Promise<ObjectInspection | null>;
+    /** Get object metadata by testId (userData.testId). Returns null if not found. */
+    getByTestId(testId: string): Promise<ObjectMetadata | null>;
+    /** Get object metadata by UUID. Returns null if not found. */
+    getByUuid(uuid: string): Promise<ObjectMetadata | null>;
+    /** Get all objects with the given name (names are not unique in Three.js). */
+    getByName(name: string): Promise<ObjectMetadata[]>;
+    /** Get direct children of an object by testId or uuid. */
+    getChildren(idOrUuid: string): Promise<ObjectMetadata[]>;
+    /** Get parent of an object by testId or uuid. Returns null if root or not found. */
+    getParent(idOrUuid: string): Promise<ObjectMetadata | null>;
+    /** Get heavy inspection data (Tier 2) by testId or uuid. Pass { includeGeometryData: true } to include vertex positions and triangle indices. */
+    inspect(idOrUuid: string, options?: {
+        includeGeometryData?: boolean;
+    }): Promise<ObjectInspection | null>;
+    /**
+     * Get world-space position [x, y, z] of an object (from its world matrix).
+     * Use for nested objects where local position differs from world position.
+     */
+    getWorldPosition(idOrUuid: string): Promise<[number, number, number] | null>;
     /** Take a full scene snapshot. */
     snapshot(): Promise<SceneSnapshot | null>;
+    /**
+     * Compare two scene snapshots: returns added nodes, removed nodes, and
+     * property changes (name, type, testId, visible, position, rotation, scale).
+     * Use after taking snapshots before/after an action to assert on scene changes.
+     */
+    diffSnapshots(before: SceneSnapshot, after: SceneSnapshot): SceneDiff;
+    /**
+     * Run an async action and return how many objects were added and removed
+     * compared to before the action. Uses snapshots before/after so add and
+     * remove are both counted correctly when both happen.
+     */
+    trackObjectCount(action: () => Promise<void>): Promise<{
+        added: number;
+        removed: number;
+    }>;
     /** Get the total number of tracked objects. */
     getCount(): Promise<number>;
-    /** Click a 3D object by testId or uuid. */
-    click(idOrUuid: string): Promise<void>;
-    /** Double-click a 3D object by testId or uuid. */
-    doubleClick(idOrUuid: string): Promise<void>;
-    /** Right-click / context-menu a 3D object by testId or uuid. */
-    contextMenu(idOrUuid: string): Promise<void>;
-    /** Hover over a 3D object by testId or uuid. */
-    hover(idOrUuid: string): Promise<void>;
-    /** Drag a 3D object with a world-space delta vector. */
+    /**
+     * Return a Playwright locator for the R3F canvas element the bridge is attached to.
+     * The canvas has `data-r3f-canvas` set by the bridge (value is the canvasId or "true").
+     */
+    getCanvasLocator(): Locator;
+    /**
+     * Get all objects of a given Three.js type (e.g. "Mesh", "Group", "Line").
+     */
+    getByType(type: string): Promise<ObjectMetadata[]>;
+    /**
+     * Get all objects with a given geometry type (e.g. "BoxGeometry", "BufferGeometry").
+     */
+    getByGeometryType(type: string): Promise<ObjectMetadata[]>;
+    /**
+     * Get all objects with a given material type (e.g. "MeshStandardMaterial").
+     */
+    getByMaterialType(type: string): Promise<ObjectMetadata[]>;
+    /**
+     * Get objects that have a specific userData key (and optionally matching value).
+     */
+    getByUserData(key: string, value?: unknown): Promise<ObjectMetadata[]>;
+    /**
+     * Count objects of a given Three.js type.
+     */
+    getCountByType(type: string): Promise<number>;
+    /**
+     * Batch lookup: get metadata for multiple objects by testId or uuid in a
+     * single browser round-trip.
+     */
+    getObjects(ids: string[]): Promise<Record<string, ObjectMetadata | null>>;
+    /**
+     * Log the scene tree to the test terminal for debugging.
+     *
+     * Prints a human-readable tree like:
+     * ```
+     * Scene "root"
+     * ├─ Mesh "chair-primary" [testId: chair-primary] visible
+     * │  └─ BoxGeometry
+     * ├─ DirectionalLight "sun-light" [testId: sun-light] visible
+     * └─ Group "furniture"
+     *    ├─ Mesh "table-top" [testId: table-top] visible
+     *    └─ Mesh "vase" [testId: vase] visible
+     * ```
+     */
+    logScene(): Promise<void>;
+    /**
+     * Click a 3D object by testId or uuid.
+     * Auto-waits for the bridge and the object to exist before clicking.
+     * @param timeout  Optional auto-wait timeout in ms. Default: 5000
+     */
+    click(idOrUuid: string, timeout?: number): Promise<void>;
+    /**
+     * Double-click a 3D object by testId or uuid.
+     * Auto-waits for the object to exist.
+     */
+    doubleClick(idOrUuid: string, timeout?: number): Promise<void>;
+    /**
+     * Right-click / context-menu a 3D object by testId or uuid.
+     * Auto-waits for the object to exist.
+     */
+    contextMenu(idOrUuid: string, timeout?: number): Promise<void>;
+    /**
+     * Hover over a 3D object by testId or uuid.
+     * Auto-waits for the object to exist.
+     */
+    hover(idOrUuid: string, timeout?: number): Promise<void>;
+    /**
+     * Unhover / pointer-leave — resets hover state by moving pointer off-canvas.
+     * Auto-waits for the bridge to be ready.
+     */
+    unhover(timeout?: number): Promise<void>;
+    /**
+     * Drag a 3D object with a world-space delta vector.
+     * Auto-waits for the object to exist.
+     */
     drag(idOrUuid: string, delta: {
         x: number;
         y: number;
         z: number;
-    }): Promise<void>;
-    /** Dispatch a wheel/scroll event on a 3D object. */
+    }, timeout?: number): Promise<void>;
+    /**
+     * Dispatch a wheel/scroll event on a 3D object.
+     * Auto-waits for the object to exist.
+     */
     wheel(idOrUuid: string, options?: {
         deltaY?: number;
         deltaX?: number;
-    }): Promise<void>;
-    /** Click empty space to trigger onPointerMissed handlers. */
-    pointerMiss(): Promise<void>;
+    }, timeout?: number): Promise<void>;
+    /**
+     * Click empty space to trigger onPointerMissed handlers.
+     * Auto-waits for the bridge to be ready.
+     */
+    pointerMiss(timeout?: number): Promise<void>;
+    /**
+     * Draw a freeform path on the canvas. Dispatches pointerdown → N × pointermove → pointerup.
+     * Designed for canvas drawing/annotation/whiteboard apps.
+     * Auto-waits for the bridge to be ready.
+     *
+     * @param points  Array of screen-space points (min 2). { x, y } in CSS pixels relative to canvas.
+     * @param options Drawing options (stepDelayMs, pointerType, clickAtEnd)
+     * @param timeout Optional auto-wait timeout in ms. Default: 5000
+     * @returns       { eventCount, pointCount }
+     */
+    drawPath(points: Array<{
+        x: number;
+        y: number;
+        pressure?: number;
+    }>, options?: {
+        stepDelayMs?: number;
+        pointerType?: 'mouse' | 'pen' | 'touch';
+        clickAtEnd?: boolean;
+    }, timeout?: number): Promise<{
+        eventCount: number;
+        pointCount: number;
+    }>;
+    /**
+     * Get the current camera state (position, rotation, fov, near, far, zoom, target).
+     * Auto-waits for the bridge to be ready.
+     */
+    getCameraState(timeout?: number): Promise<CameraState>;
     /**
      * Wait until the scene is ready — `window.__R3F_DOM__` is available and
      * the object count has stabilised across several consecutive checks.
+     * Logs bridge connection and scene readiness to the terminal.
      */
     waitForSceneReady(options?: WaitForSceneReadyOptions): Promise<void>;
     /**
@@ -164,42 +588,106 @@ declare class R3FFixture {
      * animation frames. Useful after triggering interactions or animations.
      */
     waitForIdle(options?: WaitForIdleOptions): Promise<void>;
+    /**
+     * Wait until one or more new objects appear in the scene that were not
+     * present when this call was made. Perfect for drawing apps where
+     * `drawPath()` creates new geometry asynchronously.
+     *
+     * @param options  Filter by type, nameContains, timeout, pollInterval
+     * @returns        Metadata of the newly added object(s)
+     */
+    waitForNewObject(options?: WaitForNewObjectOptions): Promise<WaitForNewObjectResult>;
+    /**
+     * Wait until an object (by testId or uuid) is no longer in the scene.
+     * Use for delete flows: trigger removal, then wait until the object is gone.
+     */
+    waitForObjectRemoved(idOrUuid: string, options?: WaitForObjectRemovedOptions): Promise<void>;
     /** Select a 3D object by testId or uuid (highlights in scene). */
     select(idOrUuid: string): Promise<void>;
     /** Clear the current selection. */
     clearSelection(): Promise<void>;
+    /**
+     * Fetch full bridge diagnostics (version, object counts, GPU info, etc.).
+     * Returns null if the bridge is not available.
+     */
+    getDiagnostics(): Promise<BridgeDiagnostics | null>;
+    /**
+     * Print a full diagnostics report to the terminal.
+     * Useful at the start of a test suite or when debugging failures.
+     */
+    logDiagnostics(): Promise<void>;
 }
 declare const test: _playwright_test.TestType<_playwright_test.PlaywrightTestArgs & _playwright_test.PlaywrightTestOptions & {
     r3f: R3FFixture;
 }, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions>;
+/**
+ * Create a custom test.extend with debug enabled for all tests:
+ *
+ * ```typescript
+ * import { createR3FTest } from '@react-three-dom/playwright';
+ * export const test = createR3FTest({ debug: true });
+ * ```
+ */
+declare function createR3FTest(options?: R3FFixtureOptions): _playwright_test.TestType<_playwright_test.PlaywrightTestArgs & _playwright_test.PlaywrightTestOptions & {
+    r3f: R3FFixture;
+}, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions>;
 
 /**
- * Extend Playwright's `expect` with 3D-native matchers.
+ * @module assertions
  *
- * Usage:
- * ```ts
- * import { test, expect } from '@react-three-dom/playwright';
+ * Custom Playwright `expect` matchers for 3D scene testing via react-three-dom.
  *
- * test('chair exists', async ({ page, r3f }) => {
- *   await r3f.waitForSceneReady();
- *   await expect(r3f).toExist('chair-primary');
- * });
- * ```
+ * Every matcher auto-retries until the assertion passes or the timeout
+ * expires, matching Playwright's built-in assertion behaviour.
+ *
+ * **Tier 1 — Metadata:** toExist, toBeVisible, toHavePosition,
+ * toHaveWorldPosition, toHaveRotation, toHaveScale, toHaveType, toHaveName,
+ * toHaveGeometryType, toHaveMaterialType, toHaveChildCount, toHaveParent,
+ * toHaveInstanceCount
+ *
+ * **Tier 2 — Inspection:** toBeInFrustum, toHaveBounds, toHaveColor,
+ * toHaveOpacity, toBeTransparent, toHaveVertexCount, toHaveTriangleCount,
+ * toHaveUserData, toHaveMapTexture
+ *
+ * **Scene-level:** toHaveObjectCount, toHaveObjectCountGreaterThan,
+ * toHaveCountByType, toHaveTotalTriangleCount,
+ * toHaveTotalTriangleCountLessThan
+ *
+ * **Camera:** toHaveCameraPosition, toHaveCameraFov, toHaveCameraNear,
+ * toHaveCameraFar, toHaveCameraZoom
+ *
+ * **Batch:** toAllExist, toAllBeVisible, toNoneExist
  */
-declare const expect: _playwright_test.Expect<{
-    toExist(this: _playwright_test.ExpectMatcherState, r3f: R3FMatcherReceiver, idOrUuid: string): Promise<{
+
+interface R3FMatcherReceiver {
+    page: Page;
+    canvasId?: string;
+    getObject(idOrUuid: string): Promise<ObjectMetadata | null>;
+    inspect(idOrUuid: string): Promise<ObjectInspection | null>;
+}
+/** Context provided by Playwright when the matcher is invoked via expect().extend() */
+interface ExpectMatcherContext {
+    isNot?: boolean;
+}
+interface MatcherOptions {
+    timeout?: number;
+    interval?: number;
+}
+type Vec3Opts = MatcherOptions & {
+    tolerance?: number;
+};
+declare const r3fMatchers: {
+    toExist(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, opts?: MatcherOptions): Promise<{
         pass: boolean;
         message: () => string;
         name: string;
         expected: string;
-        actual: ObjectMetadata | null;
+        actual: null;
     }>;
-    toBeVisible(this: _playwright_test.ExpectMatcherState, r3f: R3FMatcherReceiver, idOrUuid: string): Promise<{
-        pass: false;
+    toBeVisible(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
         message: () => string;
         name: string;
-        expected?: undefined;
-        actual?: undefined;
     } | {
         pass: boolean;
         message: () => string;
@@ -207,28 +695,43 @@ declare const expect: _playwright_test.Expect<{
         expected: boolean;
         actual: boolean;
     }>;
-    toBeInFrustum(this: _playwright_test.ExpectMatcherState, r3f: R3FMatcherReceiver, idOrUuid: string): Promise<{
-        pass: false;
+    toHavePosition(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expected: [number, number, number], tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
         message: () => string;
         name: string;
-        expected?: undefined;
-        actual?: undefined;
     } | {
         pass: boolean;
         message: () => string;
         name: string;
-        expected: string;
-        actual: {
-            min: [number, number, number];
-            max: [number, number, number];
-        };
+        expected: [number, number, number];
+        actual: [number, number, number];
+    }>;
+    toHaveWorldPosition(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expected: [number, number, number], tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: [number, number, number];
+        actual: [number, number, number];
+    }>;
+    toHaveRotation(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expected: [number, number, number], tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: [number, number, number];
+        actual: [number, number, number];
     }>;
-    toHavePosition(this: _playwright_test.ExpectMatcherState, r3f: R3FMatcherReceiver, idOrUuid: string, expected: [number, number, number], tolerance?: any): Promise<{
-        pass: false;
+    toHaveScale(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expected: [number, number, number], tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
         message: () => string;
         name: string;
-        expected?: undefined;
-        actual?: undefined;
     } | {
         pass: boolean;
         message: () => string;
@@ -236,15 +739,104 @@ declare const expect: _playwright_test.Expect<{
         expected: [number, number, number];
         actual: [number, number, number];
     }>;
-    toHaveBounds(this: _playwright_test.ExpectMatcherState, r3f: R3FMatcherReceiver, idOrUuid: string, expected: {
+    toHaveType(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedType: string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string;
+        actual: string;
+    }>;
+    toHaveName(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedName: string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string;
+        actual: string;
+    }>;
+    toHaveGeometryType(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedGeo: string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string;
+        actual: string | undefined;
+    }>;
+    toHaveMaterialType(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedMat: string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string;
+        actual: string | undefined;
+    }>;
+    toHaveChildCount(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedCount: number, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number;
+    }>;
+    toHaveParent(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedParent: string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string;
+        actual: string | null;
+    }>;
+    toHaveInstanceCount(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedCount: number, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number;
+    }>;
+    toBeInFrustum(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string;
+        actual: {
+            min: [number, number, number];
+            max: [number, number, number];
+        };
+    }>;
+    toHaveBounds(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expected: {
         min: [number, number, number];
         max: [number, number, number];
-    }, tolerance?: any): Promise<{
-        pass: false;
+    }, tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
         message: () => string;
         name: string;
-        expected?: undefined;
-        actual?: undefined;
     } | {
         pass: boolean;
         message: () => string;
@@ -258,12 +850,43 @@ declare const expect: _playwright_test.Expect<{
             max: [number, number, number];
         };
     }>;
-    toHaveInstanceCount(this: _playwright_test.ExpectMatcherState, r3f: R3FMatcherReceiver, idOrUuid: string, expectedCount: number): Promise<{
-        pass: false;
+    toHaveColor(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedColor: string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string;
+        actual: string | undefined;
+    }>;
+    toHaveOpacity(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedOpacity: number, tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number | undefined;
+    }>;
+    toBeTransparent(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: boolean;
+        actual: boolean | undefined;
+    }>;
+    toHaveVertexCount(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedCount: number, opts?: MatcherOptions): Promise<{
+        pass: boolean;
         message: () => string;
         name: string;
-        expected?: undefined;
-        actual?: undefined;
     } | {
         pass: boolean;
         message: () => string;
@@ -271,32 +894,349 @@ declare const expect: _playwright_test.Expect<{
         expected: number;
         actual: number;
     }>;
-}>;
-interface R3FMatcherReceiver {
-    getObject(idOrUuid: string): Promise<ObjectMetadata | null>;
-    inspect(idOrUuid: string): Promise<ObjectInspection | null>;
-}
+    toHaveTriangleCount(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedCount: number, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number;
+    }>;
+    toHaveUserData(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, key: string, expectedValue?: unknown, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: {};
+        actual: unknown;
+    }>;
+    toHaveMapTexture(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, id: string, expectedName?: string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+    } | {
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string;
+        actual: string | undefined;
+    }>;
+    /**
+     * Assert the total number of objects in the scene.
+     * Auto-retries until the count matches or timeout.
+     *
+     * @example expect(r3f).toHaveObjectCount(42);
+     * @example expect(r3f).toHaveObjectCount(42, { timeout: 10_000 });
+     */
+    toHaveObjectCount(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, expected: number, options?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number;
+    }>;
+    /**
+     * Assert the total number of objects is at least `min`.
+     * Useful for BIM scenes where the exact count may vary slightly.
+     *
+     * @example expect(r3f).toHaveObjectCountGreaterThan(10);
+     */
+    toHaveObjectCountGreaterThan(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, min: number, options?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string;
+        actual: number;
+    }>;
+    /**
+     * Assert the count of objects of a specific Three.js type.
+     * Auto-retries until the count matches or timeout.
+     *
+     * @example expect(r3f).toHaveCountByType('Mesh', 5);
+     * @example expect(r3f).toHaveCountByType('Line', 10, { timeout: 10_000 });
+     */
+    toHaveCountByType(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, type: string, expected: number, options?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number;
+    }>;
+    /**
+     * Assert the total triangle count across all meshes in the scene.
+     * Use as a performance budget guard — fail if the scene exceeds a threshold.
+     *
+     * @example expect(r3f).toHaveTotalTriangleCount(50000);
+     * @example expect(r3f).not.toHaveTotalTriangleCountGreaterThan(100000); // budget guard
+     */
+    toHaveTotalTriangleCount(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, expected: number, options?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number;
+    }>;
+    /**
+     * Assert the total triangle count is at most `max`.
+     * Perfect as a performance budget guard to prevent scene bloat.
+     *
+     * @example expect(r3f).toHaveTotalTriangleCountLessThan(100_000);
+     */
+    toHaveTotalTriangleCountLessThan(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, max: number, options?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string;
+        actual: number;
+    }>;
+    /**
+     * Assert the camera position is close to the expected [x, y, z].
+     *
+     * @example expect(r3f).toHaveCameraPosition([0, 5, 10], 0.1);
+     */
+    toHaveCameraPosition(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, expected: [number, number, number], tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: [number, number, number];
+        actual: [number, number, number];
+    }>;
+    /**
+     * Assert the camera field of view (PerspectiveCamera only).
+     *
+     * @example expect(r3f).toHaveCameraFov(75);
+     */
+    toHaveCameraFov(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, expected: number, tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number | undefined;
+    }>;
+    /**
+     * Assert the camera near clipping plane.
+     *
+     * @example expect(r3f).toHaveCameraNear(0.1);
+     */
+    toHaveCameraNear(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, expected: number, tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number;
+    }>;
+    /**
+     * Assert the camera far clipping plane.
+     *
+     * @example expect(r3f).toHaveCameraFar(1000);
+     */
+    toHaveCameraFar(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, expected: number, tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number;
+    }>;
+    /**
+     * Assert the camera zoom level.
+     *
+     * @example expect(r3f).toHaveCameraZoom(1);
+     */
+    toHaveCameraZoom(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, expected: number, tolOpts?: number | Vec3Opts): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: number;
+        actual: number;
+    }>;
+    /**
+     * Assert that ALL given objects exist in the scene.
+     * Accepts an array of testIds/uuids or a glob pattern (e.g. "wall-*").
+     *
+     * @example expect(r3f).toAllExist(['wall-1', 'wall-2', 'floor']);
+     * @example expect(r3f).toAllExist('wall-*');
+     */
+    toAllExist(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, idsOrPattern: string[] | string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string | string[];
+        actual: {
+            missing: string[];
+        };
+    }>;
+    /**
+     * Assert that ALL given objects are visible.
+     *
+     * @example expect(r3f).toAllBeVisible(['wall-1', 'wall-2', 'floor']);
+     * @example expect(r3f).toAllBeVisible('wall-*');
+     */
+    toAllBeVisible(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, idsOrPattern: string[] | string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string | string[];
+        actual: {
+            hidden: string[];
+        };
+    }>;
+    /**
+     * Assert that NONE of the given objects exist in the scene.
+     *
+     * @example expect(r3f).toNoneExist(['deleted-wall', 'old-floor']);
+     * @example expect(r3f).toNoneExist('temp-*');
+     */
+    toNoneExist(this: ExpectMatcherContext, r3f: R3FMatcherReceiver, idsOrPattern: string[] | string, opts?: MatcherOptions): Promise<{
+        pass: boolean;
+        message: () => string;
+        name: string;
+        expected: string | string[];
+        actual: {
+            found: string[];
+        };
+    }>;
+};
+
+/**
+ * @module interactions
+ *
+ * Playwright interaction helpers — thin wrappers around `page.evaluate` calls
+ * to the `window.__R3F_DOM__` bridge interaction methods.
+ *
+ * All object-targeted interactions auto-wait for:
+ *   1. The bridge to be ready (`_ready === true`)
+ *   2. The target object to exist (by testId or uuid)
+ *
+ * This mirrors Playwright's built-in auto-waiting on locators.
+ *
+ * Multi-canvas: pass `canvasId` to target a specific canvas instance.
+ * When undefined, uses the default `window.__R3F_DOM__`.
+ */
 
-/** Click a 3D object by its testId or uuid. */
-declare function click(page: Page, idOrUuid: string): Promise<void>;
-/** Double-click a 3D object by its testId or uuid. */
-declare function doubleClick(page: Page, idOrUuid: string): Promise<void>;
-/** Right-click / context-menu a 3D object by its testId or uuid. */
-declare function contextMenu(page: Page, idOrUuid: string): Promise<void>;
-/** Hover over a 3D object by its testId or uuid. */
-declare function hover(page: Page, idOrUuid: string): Promise<void>;
-/** Drag a 3D object by its testId or uuid with a given world-space delta. */
+/** Click a 3D object by its testId or uuid. Auto-waits for the object. */
+declare function click(page: Page, idOrUuid: string, timeout?: number, canvasId?: string): Promise<void>;
+/** Double-click a 3D object by its testId or uuid. Auto-waits for the object. */
+declare function doubleClick(page: Page, idOrUuid: string, timeout?: number, canvasId?: string): Promise<void>;
+/** Right-click / context-menu a 3D object. Auto-waits for the object. */
+declare function contextMenu(page: Page, idOrUuid: string, timeout?: number, canvasId?: string): Promise<void>;
+/** Hover over a 3D object. Auto-waits for the object. */
+declare function hover(page: Page, idOrUuid: string, timeout?: number, canvasId?: string): Promise<void>;
+/** Unhover / pointer-leave — resets hover state by moving pointer off-canvas. Auto-waits for bridge. */
+declare function unhover(page: Page, timeout?: number, canvasId?: string): Promise<void>;
+/** Drag a 3D object with a world-space delta. Auto-waits for the object. */
 declare function drag(page: Page, idOrUuid: string, delta: {
     x: number;
     y: number;
     z: number;
-}): Promise<void>;
-/** Dispatch a wheel/scroll event on a 3D object. */
+}, timeout?: number, canvasId?: string): Promise<void>;
+/** Dispatch a wheel/scroll event on a 3D object. Auto-waits for the object. */
 declare function wheel(page: Page, idOrUuid: string, options?: {
     deltaY?: number;
     deltaX?: number;
-}): Promise<void>;
-/** Click empty space to trigger onPointerMissed handlers. */
-declare function pointerMiss(page: Page): Promise<void>;
+}, timeout?: number, canvasId?: string): Promise<void>;
+/** Click empty space to trigger onPointerMissed handlers. Auto-waits for bridge. */
+declare function pointerMiss(page: Page, timeout?: number, canvasId?: string): Promise<void>;
+/** Draw a freeform path on the canvas. Auto-waits for bridge. */
+declare function drawPathOnCanvas(page: Page, points: Array<{
+    x: number;
+    y: number;
+    pressure?: number;
+}>, options?: {
+    stepDelayMs?: number;
+    pointerType?: 'mouse' | 'pen' | 'touch';
+    clickAtEnd?: boolean;
+}, timeout?: number, canvasId?: string): Promise<{
+    eventCount: number;
+    pointCount: number;
+}>;
+/** Get the current camera state (position, rotation, fov, near, far, zoom). Auto-waits for bridge. */
+declare function getCameraState(page: Page, timeout?: number, canvasId?: string): Promise<CameraState>;
+
+/**
+ * @module pathGenerators
+ *
+ * Pure geometry utilities that generate arrays of screen-space points for
+ * use with `r3f.drawPath()`. Provides line, quadratic bezier, rectangle,
+ * and circle/ellipse path generators.
+ *
+ * Duplicated from `@react-three-dom/core` to avoid a runtime dependency.
+ */
+/** A 2D screen-space point in CSS pixels, relative to the canvas top-left. */
+interface DrawPoint {
+    /** X coordinate in CSS pixels from canvas left edge. */
+    x: number;
+    /** Y coordinate in CSS pixels from canvas top edge. */
+    y: number;
+    /** Optional pressure (0–1). Default: 0.5 */
+    pressure?: number;
+}
+/**
+ * Generate points along a straight line.
+ *
+ * @param start     Start point
+ * @param end       End point
+ * @param steps     Intermediate points (excluding start/end). Default: 10
+ * @param pressure  Uniform pressure. Default: 0.5
+ */
+declare function linePath(start: {
+    x: number;
+    y: number;
+}, end: {
+    x: number;
+    y: number;
+}, steps?: number, pressure?: number): DrawPoint[];
+/**
+ * Generate points along a quadratic bezier curve.
+ *
+ * @param start     Start point
+ * @param control   Control point
+ * @param end       End point
+ * @param steps     Number of steps. Default: 20
+ * @param pressure  Uniform pressure. Default: 0.5
+ */
+declare function curvePath(start: {
+    x: number;
+    y: number;
+}, control: {
+    x: number;
+    y: number;
+}, end: {
+    x: number;
+    y: number;
+}, steps?: number, pressure?: number): DrawPoint[];
+/**
+ * Generate points forming a rectangle.
+ *
+ * @param topLeft      Top-left corner
+ * @param bottomRight  Bottom-right corner
+ * @param pointsPerSide  Points per side. Default: 5
+ * @param pressure     Uniform pressure. Default: 0.5
+ */
+declare function rectPath(topLeft: {
+    x: number;
+    y: number;
+}, bottomRight: {
+    x: number;
+    y: number;
+}, pointsPerSide?: number, pressure?: number): DrawPoint[];
+/**
+ * Generate points forming a circle/ellipse.
+ *
+ * @param center   Center point
+ * @param radiusX  Horizontal radius in CSS pixels
+ * @param radiusY  Vertical radius. Default: same as radiusX
+ * @param steps    Number of points. Default: 36
+ * @param pressure Uniform pressure. Default: 0.5
+ */
+declare function circlePath(center: {
+    x: number;
+    y: number;
+}, radiusX: number, radiusY?: number, steps?: number, pressure?: number): DrawPoint[];
 
-export { type ObjectInspection, type ObjectMetadata, R3FFixture, type SceneSnapshot, type SnapshotNode, type WaitForIdleOptions, type WaitForObjectOptions, type WaitForSceneReadyOptions, click, contextMenu, doubleClick, drag, expect, hover, pointerMiss, test, waitForIdle, waitForObject, waitForSceneReady, wheel };
+export { type BridgeDiagnostics, type CameraState, type DrawPoint, type InspectOptions, type ObjectInspection, type ObjectMetadata, R3FFixture, type R3FFixtureOptions, R3FReporter, type SceneDiff, type SceneDiffChange, type SceneSnapshot, type SnapshotNode, type WaitForIdleOptions, type WaitForNewObjectOptions, type WaitForNewObjectResult, type WaitForObjectOptions, type WaitForObjectRemovedOptions, type WaitForSceneReadyOptions, circlePath, click, contextMenu, createR3FTest, curvePath, diffSnapshots, doubleClick, drag, drawPathOnCanvas, getCameraState, hover, linePath, pointerMiss, r3fMatchers, rectPath, test, unhover, waitForIdle, waitForNewObject, waitForObject, waitForObjectRemoved, waitForSceneReady, wheel };