@testspectra/matchers 1.0.70 → 1.1.0-rc.0

package/dist/contract.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @packageDocumentation
+ * # PlatformDriverBridge Contract
+ *
+ * The unified abstract driver contract consumed by `@testspectra/matchers` element proxies,
+ * fluent matchers, and the `Spectra` automation object. Every platform-specific driver
+ * (`WebCdpDriverBridge`, `AndroidTcpDriverBridge`) implements this interface so that the
+ * DSL layer contains zero platform branching.
+ */
+import type { CDPNetworkEntry, MockInterceptHandle, MockRule, ScrollOptions, SpectraBrowserBridge, SwipeOptions } from './types.js';
+/**
+ * Runtime configuration injected by the Rust orchestrator via `globalThis.__TESTSPECTRA_CONFIG__`.
+ */
+export interface RuntimeWorkerConfig {
+    workerId?: number;
+    rootDir: string;
+    testFilePath?: string;
+    testFiles?: Array<{
+        id: string;
+        title: string;
+        filePath: string;
+        suite: string;
+    }>;
+    activePlatform: string;
+    configuredBaseUrl: string;
+    cdpWsUrl: string;
+    driverServerUrl: string;
+    manifest?: Record<string, any>;
+    /** Target app package (Android). Paired with androidSerial/adbPath for on-demand adb actions. */
+    appPackage?: string;
+    /** Target adb device serial for this worker (Android only). */
+    androidSerial?: string;
+    /** Resolved `adb` binary path (Android only), paired with androidSerial above. */
+    adbPath?: string;
+    /** Host port this worker's own MobileMockProxyServer should listen on (Android only) — derived
+     * per-device the same way androidSerial/the driver-server port already are, so each device in
+     * a multi-device run gets its own proxy instead of every worker racing for one shared port. */
+    mockProxyPort?: number;
+    implicitWaitMs?: number;
+    timeoutMs?: number;
+    stepDelayMs?: number;
+}
+/**
+ * Cross-cutting shared runtime state injected into the assembled worker script.
+ *
+ * The worker runtime is emitted as a single self-contained TypeScript module (concatenated
+ * by the Rust orchestrator). This object is created once in the harness prelude and mutated
+ * in place (`activeDriver` is bound after the platform bridge is instantiated), so fragments
+ * access it lazily at call-time through `globalThis.__TS_RUNTIME__`.
+ */
+export interface RuntimeContext {
+    config: RuntimeWorkerConfig;
+    activeDriver: PlatformDriverBridge | null;
+    mobileMockRules: MockRule[];
+    lastFocusedSelector: string | null;
+    currentTargetItem?: any;
+    emitEvent(tag: string, payload: string): void;
+    trackStep<T>(category: 'action' | 'assertion' | 'browser', payloadObj: Record<string, any>, fn: () => Promise<T>): Promise<T>;
+    pollCondition(fn: () => Promise<boolean> | boolean, timeoutMs?: number, intervalMs?: number): Promise<boolean>;
+    getImplicitWaitMs(): number;
+    getAssertionTimeoutMs(): number;
+    matchesUrlPattern(pattern: string, url: string): boolean;
+    createMockHandle(rule: MockRule): MockInterceptHandle;
+    parseMockRule(patternOrOptions?: any, maybeMethodOrHandler?: any, maybeFixture?: any, maybeOptions?: any): MockRule;
+    recordDuration?: (label: string, category: string, durationMs: number, extra?: Record<string, unknown>) => void;
+    withDuration?: <T>(label: string, category: string, fn: () => Promise<T>, extra?: Record<string, unknown>) => Promise<T>;
+    durationLogPath?: string | null;
+    createElementActions?: (selector: string, index: number | null) => Record<string, any>;
+    createElementState?: (selector: string, index: number | null) => Record<string, any>;
+    createElementAssertions?: (selector: string, index: number | null, state: Record<string, any>) => Record<string, any>;
+    createElementProxy?: (selector: string, index?: number | null) => any;
+    createCollectionProxy?: (selector: string) => any;
+    resolveTargetProxy?: (target: any) => any;
+    buildSpectra?: () => any;
+    cdpBridgeClass?: any;
+    androidBridgeClass?: any;
+    mobileMockProxyClass?: any;
+    mobileMockProxy?: any;
+    beforeHook?: (() => Promise<void> | void) | null;
+    afterHook?: (() => Promise<void> | void) | null;
+    beforeEachHook?: (() => Promise<void> | void) | null;
+    afterEachHook?: (() => Promise<void> | void) | null;
+    bootstrapEnvironment?: () => Promise<void>;
+    runSuite?: () => Promise<void>;
+}
+/**
+ * The unified platform driver contract. It extends the browser surface documented in
+ * `SpectraBrowserBridge` (navigation, script execution, network interception, browser-level
+ * assertions) with the element interaction and state-inspection methods needed by the DSL,
+ * so the `tools/matchers` layer never branches on `activePlatform`.
+ */
+export interface PlatformDriverBridge extends SpectraBrowserBridge {
+    /** Establishes connection to the underlying runtime endpoint (WebSocket / TCP Socket). */
+    connect(): Promise<void>;
+    /** Cleans up open connections, servers, and listeners. */
+    close(): Promise<void>;
+    /** Navigates to target URL (Web) or Activity / Deep Link (Android). */
+    navigate(targetUrl: string): Promise<void>;
+    click(selector: string, index?: number | null): Promise<void>;
+    doubleClick(selector: string, index?: number | null): Promise<void>;
+    rightClick(selector: string, index?: number | null): Promise<void>;
+    setValue(selector: string, value: unknown, index?: number | null): Promise<void>;
+    clearValue(selector: string, index?: number | null): Promise<void>;
+    select(selector: string, option: string, index?: number | null): Promise<void>;
+    hover(selector: string, index?: number | null): Promise<void>;
+    focus(selector: string, index?: number | null): Promise<void>;
+    dragDrop(sourceSelector: string, targetSelector: string, sourceIndex?: number | null): Promise<void>;
+    longPress(selector: string, duration: number, index?: number | null): Promise<void>;
+    scrollIntoView(selector: string, index?: number | null): Promise<void>;
+    getText(selector: string, index?: number | null): Promise<string>;
+    getValue(selector: string, index?: number | null): Promise<string>;
+    isDisplayed(selector: string, index?: number | null): Promise<boolean>;
+    isExisting(selector: string, index?: number | null): Promise<boolean>;
+    isEnabled(selector: string, index?: number | null): Promise<boolean>;
+    isSelected(selector: string, index?: number | null): Promise<boolean>;
+    isFocused(selector: string, index?: number | null): Promise<boolean>;
+    isClickable(selector: string, index?: number | null): Promise<boolean>;
+    hasClass(selector: string, className: string, index?: number | null): Promise<boolean>;
+    getAttribute(selector: string, name: string, index?: number | null): Promise<string | null>;
+    getCSSProperty(selector: string, name: string, index?: number | null): Promise<{
+        value: string;
+    }>;
+    count(selector: string): Promise<number>;
+    pressKey(key: string | number): Promise<void>;
+    scroll(options?: ScrollOptions): Promise<void>;
+    swipe(options: SwipeOptions): Promise<void>;
+    /**
+     * Grants an Android runtime permission on demand (e.g. right after confirming an in-app
+     * rationale dialog), via `adb shell pm grant` on the host. No-op on platforms without an
+     * OS-level runtime permission model (e.g. web).
+     */
+    grantPermission(name: string): Promise<void>;
+    /** Clears all active network interception rules. */
+    clearMocks(): void;
+    mockRules: MockRule[];
+    consoleErrors: string[];
+    recordedNetwork: CDPNetworkEntry[];
+}
+declare global {
+    var __TS_RUNTIME__: RuntimeContext;
+}

package/dist/contract.js

@@ -0,0 +1,10 @@
+/**
+ * @packageDocumentation
+ * # PlatformDriverBridge Contract
+ *
+ * The unified abstract driver contract consumed by `@testspectra/matchers` element proxies,
+ * fluent matchers, and the `Spectra` automation object. Every platform-specific driver
+ * (`WebCdpDriverBridge`, `AndroidTcpDriverBridge`) implements this interface so that the
+ * DSL layer contains zero platform branching.
+ */
+export {};

package/dist/index.d.ts

@@ -2,25 +2,8 @@
  * @packageDocumentation
  * # @testspectra/matchers
  *
- * Cross-platform action commands, fluent runners, and callable assertion matchers for TestSpectra.
- *
- * ## Features:
- * - **`Spectra`**: Unified automation API (`Spectra.get()`, `Spectra.getAll()`, `Spectra.click()`, `Spectra.type()`, etc.)
- * - **`SingleElementRunner`**: Fluent interaction & assertion runner for single element targets
- * - **`MultiElementRunner`**: Fluent assertion & traversal runner for multi-element collections
- * - **Callable Matchers**: Ambient prototypes for WebdriverIO Element & Browser (`.shouldBeVisible()`, `.shouldHaveText()`, etc.)
- *
- * @example
- * ```ts
- * import { Spectra } from "@testspectra/matchers";
- *
- * await Spectra.get("#login-btn").click().should("not.be.visible");
- * await Spectra.getAll(".list-item").should("have.length.greaterThan", 0);
- * ```
+ * Canonical TypeScript contracts, action/assertion types, and ambient type definitions for TestSpectra.
  */
-export * from "./types.js";
-export * from "./matchers.js";
-export * from "./runner/single.js";
-export * from "./runner/collection.js";
-export * from "./spectra.js";
-export * from "./proto.js";
+export * from './types.js';
+export * from './contract.js';
+export * from './proto.js';

package/dist/index.js

@@ -2,25 +2,8 @@
  * @packageDocumentation
  * # @testspectra/matchers
  *
- * Cross-platform action commands, fluent runners, and callable assertion matchers for TestSpectra.
- *
- * ## Features:
- * - **`Spectra`**: Unified automation API (`Spectra.get()`, `Spectra.getAll()`, `Spectra.click()`, `Spectra.type()`, etc.)
- * - **`SingleElementRunner`**: Fluent interaction & assertion runner for single element targets
- * - **`MultiElementRunner`**: Fluent assertion & traversal runner for multi-element collections
- * - **Callable Matchers**: Ambient prototypes for WebdriverIO Element & Browser (`.shouldBeVisible()`, `.shouldHaveText()`, etc.)
- *
- * @example
- * ```ts
- * import { Spectra } from "@testspectra/matchers";
- *
- * await Spectra.get("#login-btn").click().should("not.be.visible");
- * await Spectra.getAll(".list-item").should("have.length.greaterThan", 0);
- * ```
+ * Canonical TypeScript contracts, action/assertion types, and ambient type definitions for TestSpectra.
  */
-export * from "./types.js";
-export * from "./matchers.js";
-export * from "./runner/single.js";
-export * from "./runner/collection.js";
-export * from "./spectra.js";
-export * from "./proto.js";
+export * from './types.js';
+export * from './contract.js';
+export * from './proto.js';

package/dist/intercept/cdp-handler.d.ts

@@ -0,0 +1,22 @@
+import { MockHandle } from './mock-handle.js';
+import { InterceptedRequest, InterceptRule } from './types.js';
+export declare class CdpHandler {
+    private static cdpEnabled;
+    private static cdpPromise;
+    /**
+     * Ensures Chrome DevTools Protocol Fetch domain is enabled and listening.
+     * Awaits confirmation from CDP Fetch.enable before resolving.
+     */
+    static enableFetchDomain(): Promise<void>;
+    /**
+     * Atomically registers rule and awaits CDP Fetch.enable before returning the handle.
+     */
+    static registerRule(rule: InterceptRule): Promise<MockHandle>;
+    /**
+     * Dispatches an intercepted request through the MockRegistry, records metrics, and returns fulfillment.
+     */
+    static dispatchIncomingRequest(req: InterceptedRequest): Promise<{
+        aborted?: string;
+        response?: any;
+    }>;
+}

package/dist/intercept/cdp-handler.js

@@ -0,0 +1,123 @@
+import { MockRegistry } from './mock-registry.js';
+export class CdpHandler {
+    static cdpEnabled = false;
+    static cdpPromise = null;
+    /**
+     * Ensures Chrome DevTools Protocol Fetch domain is enabled and listening.
+     * Awaits confirmation from CDP Fetch.enable before resolving.
+     */
+    static async enableFetchDomain() {
+        if (this.cdpEnabled)
+            return;
+        if (this.cdpPromise)
+            return this.cdpPromise;
+        this.cdpPromise = (async () => {
+            // Check if running inside real WebdriverIO browser with CDP
+            const b = globalThis.browser;
+            if (b && typeof b.getPuppeteer === 'function') {
+                try {
+                    const puppeteer = await b.getPuppeteer();
+                    const pages = await puppeteer.pages();
+                    const page = pages[0];
+                    if (page) {
+                        const client = await page.target().createCDPSession();
+                        await client.send('Fetch.enable', {
+                            patterns: [{ urlPattern: '*' }],
+                        });
+                        client.on('Fetch.requestPaused', async (event) => {
+                            const req = {
+                                id: event.requestId,
+                                url: event.request.url,
+                                method: event.request.method,
+                                headers: event.request.headers,
+                                body: event.request.postData,
+                                timestamp: Date.now(),
+                            };
+                            const fulfill = await CdpHandler.dispatchIncomingRequest(req);
+                            if (fulfill.aborted) {
+                                await client.send('Fetch.failRequest', {
+                                    requestId: event.requestId,
+                                    errorReason: fulfill.aborted,
+                                });
+                            }
+                            else if (fulfill.response) {
+                                const bodyStr = typeof fulfill.response.body === 'object'
+                                    ? JSON.stringify(fulfill.response.body)
+                                    : String(fulfill.response.body || '');
+                                const base64Body = Buffer.from(bodyStr).toString('base64');
+                                const responseHeaders = Object.entries(fulfill.response.headers || {}).map(([name, value]) => ({
+                                    name,
+                                    value,
+                                }));
+                                await client.send('Fetch.fulfillRequest', {
+                                    requestId: event.requestId,
+                                    responseCode: fulfill.response.status || 200,
+                                    responseHeaders,
+                                    body: base64Body,
+                                });
+                            }
+                            else {
+                                await client.send('Fetch.continueRequest', {
+                                    requestId: event.requestId,
+                                });
+                            }
+                        });
+                    }
+                }
+                catch {
+                    // Graceful fallback in non-CDP environments (e.g. mobile Appium or test runners)
+                }
+            }
+            this.cdpEnabled = true;
+        })();
+        return this.cdpPromise;
+    }
+    /**
+     * Atomically registers rule and awaits CDP Fetch.enable before returning the handle.
+     */
+    static async registerRule(rule) {
+        await this.enableFetchDomain();
+        const registry = MockRegistry.getInstance();
+        return registry.register(rule);
+    }
+    /**
+     * Dispatches an intercepted request through the MockRegistry, records metrics, and returns fulfillment.
+     */
+    static async dispatchIncomingRequest(req) {
+        const startTime = Date.now();
+        const registry = MockRegistry.getInstance();
+        const handle = registry.findMatchingHandle(req.method, req.url);
+        let result = {};
+        if (handle) {
+            const fulfill = await handle.matchAndFulfill(req);
+            result = fulfill;
+        }
+        // Record network traffic
+        const duration = Date.now() - startTime;
+        const status = result.aborted ? 0 : result.response?.status || 200;
+        const statusText = result.aborted ? result.aborted : status === 200 ? 'OK' : 'Mocked';
+        const recorded = {
+            id: req.id,
+            url: req.url,
+            method: req.method,
+            status,
+            statusText,
+            resourceType: 'fetch',
+            requestHeaders: req.headers,
+            responseHeaders: result.response?.headers,
+            requestBody: req.body,
+            responseBody: result.response?.body,
+            timing: {
+                dns: 1.0,
+                tcp: 1.5,
+                ssl: 2.0,
+                ttfb: duration,
+                download: 0.5,
+                total: duration + 5.0,
+            },
+            transferSize: result.response?.body ? JSON.stringify(result.response.body).length : 0,
+        };
+        registry.recordResource(recorded);
+        return result;
+    }
+}

package/dist/intercept/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './mock-handle.js';
+export * from './mock-registry.js';
+export * from './cdp-handler.js';

package/dist/intercept/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './mock-handle.js';
+export * from './mock-registry.js';
+export * from './cdp-handler.js';

package/dist/intercept/mock-handle.d.ts

@@ -0,0 +1,49 @@
+import { InterceptedRequest, InterceptRule, MockResponse, NetworkAbortReason } from './types.js';
+export interface FulfillResult {
+    aborted?: NetworkAbortReason;
+    response?: MockResponse;
+}
+export declare class MockHandle {
+    readonly rule: InterceptRule;
+    private onceQueue;
+    private defaultResponse;
+    private abortReason;
+    private interceptedCalls;
+    private waitingCallers;
+    constructor(rule: InterceptRule);
+    /**
+     * Updates the default mock response for all subsequent matching requests.
+     */
+    respondWith(response: MockResponse): this;
+    /**
+     * Queues a one-time mock response for the next matching request (FIFO queue for polling/retries).
+     */
+    respondOnce(response: MockResponse): this;
+    /**
+     * Simulates a network failure or connection abort.
+     */
+    abort(errorCode?: NetworkAbortReason): this;
+    /**
+     * Total matching requests intercepted so far.
+     */
+    get callCount(): number;
+    /**
+     * Historical array of intercepted requests.
+     */
+    get calls(): InterceptedRequest[];
+    /**
+     * Awaits until a matching request arrives or times out.
+     */
+    waitForCall(options?: {
+        timeout?: number;
+        count?: number;
+    }): Promise<InterceptedRequest>;
+    /**
+     * Internal fulfillment method called when a request matches this rule.
+     */
+    matchAndFulfill(req: InterceptedRequest): Promise<FulfillResult>;
+    /**
+     * Resets local state and queued responses.
+     */
+    clear(): void;
+}

package/dist/intercept/mock-handle.js

@@ -0,0 +1,124 @@
+export class MockHandle {
+    rule;
+    onceQueue = [];
+    defaultResponse = null;
+    abortReason = null;
+    interceptedCalls = [];
+    waitingCallers = [];
+    constructor(rule) {
+        this.rule = rule;
+        if (rule.response) {
+            this.defaultResponse = rule.response;
+        }
+    }
+    /**
+     * Updates the default mock response for all subsequent matching requests.
+     */
+    respondWith(response) {
+        this.defaultResponse = response;
+        this.abortReason = null;
+        return this;
+    }
+    /**
+     * Queues a one-time mock response for the next matching request (FIFO queue for polling/retries).
+     */
+    respondOnce(response) {
+        this.onceQueue.push(response);
+        return this;
+    }
+    /**
+     * Simulates a network failure or connection abort.
+     */
+    abort(errorCode = 'Aborted') {
+        this.abortReason = errorCode;
+        return this;
+    }
+    /**
+     * Total matching requests intercepted so far.
+     */
+    get callCount() {
+        return this.interceptedCalls.length;
+    }
+    /**
+     * Historical array of intercepted requests.
+     */
+    get calls() {
+        return [...this.interceptedCalls];
+    }
+    /**
+     * Awaits until a matching request arrives or times out.
+     */
+    async waitForCall(options = {}) {
+        const timeout = options.timeout ?? 5000;
+        const targetCount = options.count ?? 1;
+        if (this.interceptedCalls.length >= targetCount) {
+            return this.interceptedCalls[targetCount - 1];
+        }
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                const idx = this.waitingCallers.findIndex((w) => w.timer === timer);
+                if (idx !== -1)
+                    this.waitingCallers.splice(idx, 1);
+                reject(new Error(`waitForCall timed out after ${timeout}ms. Expected ${targetCount} call(s), but received ${this.interceptedCalls.length}.`));
+            }, timeout);
+            this.waitingCallers.push({
+                targetCount,
+                resolve,
+                reject,
+                timer,
+            });
+        });
+    }
+    /**
+     * Internal fulfillment method called when a request matches this rule.
+     */
+    async matchAndFulfill(req) {
+        this.interceptedCalls.push(req);
+        // Notify any waiting callers whose count requirement is met
+        for (let i = this.waitingCallers.length - 1; i >= 0; i--) {
+            const waiter = this.waitingCallers[i];
+            if (this.interceptedCalls.length >= waiter.targetCount) {
+                clearTimeout(waiter.timer);
+                waiter.resolve(req);
+                this.waitingCallers.splice(i, 1);
+            }
+        }
+        if (this.abortReason) {
+            return { aborted: this.abortReason };
+        }
+        // 1. Shift from FIFO onceQueue if available
+        if (this.onceQueue.length > 0) {
+            const nextOnce = this.onceQueue.shift();
+            return { response: nextOnce };
+        }
+        // 2. Fall back to default response
+        if (typeof this.defaultResponse === 'function') {
+            const res = await this.defaultResponse(req);
+            return { response: res };
+        }
+        if (this.defaultResponse) {
+            return { response: this.defaultResponse };
+        }
+        // Default 200 OK
+        return {
+            response: {
+                status: 200,
+                headers: { 'content-type': 'application/json' },
+                body: {},
+            },
+        };
+    }
+    /**
+     * Resets local state and queued responses.
+     */
+    clear() {
+        this.onceQueue = [];
+        this.interceptedCalls = [];
+        this.abortReason = null;
+        for (const waiter of this.waitingCallers) {
+            clearTimeout(waiter.timer);
+            waiter.reject(new Error('Mock rule cleared while waiting for call'));
+        }
+        this.waitingCallers = [];
+    }
+}

package/dist/intercept/mock-registry.d.ts

@@ -0,0 +1,18 @@
+import { MockHandle } from './mock-handle.js';
+import { InterceptRule, RecordedNetworkResource } from './types.js';
+export declare function globToRegExp(glob: string): RegExp;
+export declare function matchesUrl(pattern: string | RegExp, url: string): boolean;
+export declare function matchesMethod(ruleMethod?: string, reqMethod?: string): boolean;
+export declare class MockRegistry {
+    private static instance;
+    private handles;
+    private recordedResources;
+    static getInstance(): MockRegistry;
+    register(rule: InterceptRule): MockHandle;
+    findMatchingHandle(method: string, url: string): MockHandle | undefined;
+    clear(): void;
+    recordResource(resource: RecordedNetworkResource): void;
+    getRecordedResources(): RecordedNetworkResource[];
+    clearRecordedResources(): void;
+    exportNetworkResources(filePath: string): void;
+}

package/dist/intercept/mock-registry.js

@@ -0,0 +1,97 @@
+import fs from 'fs';
+import path from 'path';
+import { MockHandle } from './mock-handle.js';
+export function globToRegExp(glob) {
+    let regexStr = '';
+    let i = 0;
+    while (i < glob.length) {
+        const c = glob[i];
+        if (c === '*' && glob[i + 1] === '*') {
+            regexStr += '.*';
+            i += 2;
+        }
+        else if (c === '*') {
+            regexStr += '[^/]*';
+            i += 1;
+        }
+        else if (['.', '?', '+', '^', '$', '[', ']', '(', ')', '{', '}', '|', '\\'].includes(c)) {
+            regexStr += `\\${c}`;
+            i += 1;
+        }
+        else {
+            regexStr += c;
+            i += 1;
+        }
+    }
+    // If glob does not start with protocol and does not start with wildcard, allow leading domain
+    if (!glob.startsWith('http://') && !glob.startsWith('https://') && !glob.startsWith('*')) {
+        return new RegExp(`(?:https?://[^/]+)?${regexStr}(?:\\?.*)?$`);
+    }
+    return new RegExp(`^${regexStr}(?:\\?.*)?$`);
+}
+export function matchesUrl(pattern, url) {
+    if (pattern instanceof RegExp) {
+        return pattern.test(url);
+    }
+    if (pattern === url) {
+        return true;
+    }
+    try {
+        const parsed = new URL(url, 'http://localhost');
+        if (pattern === parsed.pathname || pattern === `${parsed.pathname}${parsed.search}`) {
+            return true;
+        }
+    }
+    catch { }
+    const reg = globToRegExp(pattern);
+    return reg.test(url);
+}
+export function matchesMethod(ruleMethod, reqMethod = 'GET') {
+    if (!ruleMethod || ruleMethod.toUpperCase() === 'ALL') {
+        return true;
+    }
+    return ruleMethod.toUpperCase() === reqMethod.toUpperCase();
+}
+export class MockRegistry {
+    static instance;
+    handles = [];
+    recordedResources = [];
+    static getInstance() {
+        if (!MockRegistry.instance) {
+            MockRegistry.instance = new MockRegistry();
+        }
+        return MockRegistry.instance;
+    }
+    register(rule) {
+        const handle = new MockHandle(rule);
+        this.handles.unshift(handle);
+        return handle;
+    }
+    findMatchingHandle(method, url) {
+        return this.handles.find((h) => {
+            return matchesMethod(h.rule.method, method) && matchesUrl(h.rule.url, url);
+        });
+    }
+    clear() {
+        for (const h of this.handles) {
+            h.clear();
+        }
+        this.handles = [];
+    }
+    recordResource(resource) {
+        this.recordedResources.push(resource);
+    }
+    getRecordedResources() {
+        return [...this.recordedResources];
+    }
+    clearRecordedResources() {
+        this.recordedResources = [];
+    }
+    exportNetworkResources(filePath) {
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, JSON.stringify(this.recordedResources, null, 2), 'utf-8');
+    }
+}