moonwall 1.0.0-dev.0

package/dist/cli/internal/processHelpers.js

@@ -0,0 +1,56 @@
+import child_process from "node:child_process";
+import { promisify } from "node:util";
+import { createLogger } from "../../util/index.js";
+const logger = createLogger({ name: "actions:runner" });
+const debug = logger.debug.bind(logger);
+const execAsync = promisify(child_process.exec);
+/**
+ * Wraps a promise with a timeout. If the original promise does not resolve within the specified time, it rejects.
+ * @param promise The original promise to wrap.
+ * @param ms The timeout duration in milliseconds.
+ * @returns A promise that either resolves/rejects with the original promise or rejects with a timeout error.
+ */
+export const withTimeout = (promise, ms) => {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Operation timed out")), ms)),
+    ]);
+};
+// Execute process and return the output
+export async function runTask(cmd, { cwd, env } = {
+    cwd: process.cwd(),
+}, title) {
+    debug(`${title ? `Title: ${title}\n` : ""}Running task on directory ${cwd}: ${cmd}\n`);
+    try {
+        const result = await execAsync(cmd, { cwd, env });
+        return result.stdout;
+    }
+    catch (error) {
+        const status = error.status ? `[${error.status}]` : "[Unknown Status]";
+        const message = error.message ? `${error.message}` : "No Error Message";
+        debug(`Caught exception in command execution. Error[${status}] ${message}`);
+        throw error;
+    }
+}
+// Execute process return the emitter instantly, without wait
+export async function spawnTask(cmd, { cwd, env } = {
+    cwd: process.cwd(),
+}, title) {
+    debug(`${title ? `Title: ${title}\n` : ""}Running task on directory ${process.cwd()}: ${cmd}\n`);
+    try {
+        const process = child_process.spawn(cmd.split(" ")[0], cmd
+            .split(" ")
+            .slice(1)
+            .filter((a) => a.length > 0), {
+            cwd,
+            env,
+        });
+        return process;
+    }
+    catch (error) {
+        const status = error.status ? `[${error.status}]` : "[Unknown Status]";
+        const message = error.message ? `${error.message}` : "No Error Message";
+        debug(`Caught exception in command execution. Error[${status}] ${message}\n`);
+        throw error;
+    }
+}

package/dist/cli/internal/providerFactories.d.ts

@@ -0,0 +1,48 @@
+import type { MoonwallProvider, ProviderConfig, ProviderMap, ProviderType, ViemClient } from "../../api/types/index.js";
+import { ApiPromise } from "@polkadot/api";
+import { Wallet } from "ethers";
+import { type PolkadotClient } from "polkadot-api";
+import { Web3 } from "web3";
+export declare class ProviderFactory {
+    private providerConfig;
+    private url;
+    private privateKey;
+    constructor(providerConfig: ProviderConfig);
+    create(): MoonwallProvider;
+    private createPolkadotJs;
+    private createWeb3;
+    private createEthers;
+    private createViem;
+    private createPapi;
+    private createDefault;
+    static prepare(providerConfigs: ProviderConfig[]): MoonwallProvider[];
+    static prepareDefaultDev(): MoonwallProvider[];
+    static prepareDefaultZombie(): MoonwallProvider[];
+    static prepareNoEthDefaultZombie(): MoonwallProvider[];
+}
+interface GenericProvider<T extends ProviderType> {
+    name: string;
+    api: ProviderMap[T];
+    type: T;
+    greet: () => Promise<void> | Promise<{
+        rtVersion: number;
+        rtName: string;
+    }>;
+    disconnect: () => void | Promise<void>;
+}
+export declare class ProviderInterfaceFactory {
+    name: string;
+    type: ProviderType;
+    connect: () => Promise<ApiPromise> | Wallet | Web3 | Promise<ViemClient> | PolkadotClient | null;
+    constructor(name: string, type: ProviderType, connect: () => Promise<ApiPromise> | Wallet | Web3 | Promise<ViemClient> | PolkadotClient | null);
+    create(): Promise<GenericProvider<this["type"]>>;
+    private createPolkadotJs;
+    private createWeb3;
+    private createEthers;
+    private createViem;
+    private createPapi;
+    static populate(name: string, type: ProviderType, connect: () => Promise<ApiPromise> | Wallet | Web3 | Promise<ViemClient> | PolkadotClient | null): Promise<GenericProvider<ProviderType>>;
+}
+export declare const vitestAutoUrl: () => string;
+export {};
+//# sourceMappingURL=providerFactories.d.ts.map

package/dist/cli/internal/providerFactories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providerFactories.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/providerFactories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,YAAY,EACZ,UAAU,EACX,iCAAiC;AAOlC,OAAO,EAAE,UAAU,EAAc,MAAM,eAAe,CAAC;AAEvD,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAIjE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAuE5B,qBAAa,eAAe;IAId,OAAO,CAAC,cAAc;IAHlC,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,UAAU,CAAS;gBAEP,cAAc,EAAE,cAAc;IAe3C,MAAM,IAAI,gBAAgB;IAiBjC,OAAO,CAAC,gBAAgB;IA8CxB,OAAO,CAAC,UAAU;IAiBlB,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,UAAU;IAgClB,OAAO,CAAC,UAAU;IAgBlB,OAAO,CAAC,aAAa;WAYP,OAAO,CAAC,eAAe,EAAE,cAAc,EAAE,GAAG,gBAAgB,EAAE;WAI9D,iBAAiB,IAAI,gBAAgB,EAAE;WAyBvC,oBAAoB,IAAI,gBAAgB,EAAE;WAsC1C,yBAAyB,IAAI,gBAAgB,EAAE;CAqB9D;AAED,UAAU,eAAe,CAAC,CAAC,SAAS,YAAY;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACpB,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5E,UAAU,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC;AAED,qBAAa,wBAAwB;IAE1B,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,YAAY;IAClB,OAAO,EAAE,MACZ,OAAO,CAAC,UAAU,CAAC,GACnB,MAAM,GACN,IAAI,GACJ,OAAO,CAAC,UAAU,CAAC,GACnB,cAAc,GACd,IAAI;gBARD,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,MACZ,OAAO,CAAC,UAAU,CAAC,GACnB,MAAM,GACN,IAAI,GACJ,OAAO,CAAC,UAAU,CAAC,GACnB,cAAc,GACd,IAAI;IAGG,MAAM,IAAI,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YAiB/C,gBAAgB;YAwBhB,UAAU;YAiBV,YAAY;YAyBZ,UAAU;YAcV,UAAU;WAiBJ,QAAQ,CAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,cAAc,GAAG,IAAI;CAgBnG;AAED,eAAO,MAAM,aAAa,cAMzB,CAAC"}

package/dist/cli/internal/providerFactories.js

@@ -0,0 +1,442 @@
+import { ALITH_PRIVATE_KEY, createLogger, deriveViemChain, normalizeUrlToHttps, } from "../../util/index.js";
+import { ApiPromise, WsProvider } from "@polkadot/api";
+import { Wallet, ethers } from "ethers";
+import { createClient } from "polkadot-api";
+import { getWsProvider } from "polkadot-api/ws-provider";
+import { createWalletClient, http, publicActions } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { Web3 } from "web3";
+import { WebSocketProvider } from "web3-providers-ws";
+import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat";
+import * as fs from "node:fs";
+import * as path from "node:path";
+const logger = createLogger({ name: "providers" });
+const debug = logger.debug.bind(logger);
+/**
+ * Get the metadata cache directory.
+ * Uses MOONWALL_CACHE_DIR if set (from startup caching), otherwise defaults to tmp/metadata-cache.
+ */
+const getMetadataCacheDir = () => {
+    return process.env.MOONWALL_CACHE_DIR || path.join(process.cwd(), "tmp", "metadata-cache");
+};
+/**
+ * Load cached metadata if available, returns { genesisHash: metadataHex } or undefined
+ */
+const loadCachedMetadata = () => {
+    const cacheDir = getMetadataCacheDir();
+    const metadataPath = path.join(cacheDir, "metadata-cache.json");
+    try {
+        const data = fs.readFileSync(metadataPath, "utf-8");
+        const cached = JSON.parse(data);
+        debug(`Loaded cached metadata for genesis: ${Object.keys(cached).join(", ")}`);
+        return cached;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Save metadata to cache for future connections
+ */
+const saveCachedMetadata = (genesisHash, metadataHex) => {
+    const cacheDir = getMetadataCacheDir();
+    // Ensure cache directory exists
+    try {
+        fs.mkdirSync(cacheDir, { recursive: true });
+    }
+    catch {
+        // Directory might already exist or creation failed, try to continue
+    }
+    const metadataPath = path.join(cacheDir, "metadata-cache.json");
+    const lockPath = `${metadataPath}.lock`;
+    try {
+        // Simple lock to prevent concurrent writes
+        try {
+            fs.openSync(lockPath, fs.constants.O_CREAT | fs.constants.O_EXCL);
+        }
+        catch {
+            // Another process is writing, skip
+            return;
+        }
+        const data = JSON.stringify({ [genesisHash]: metadataHex });
+        fs.writeFileSync(metadataPath, data, "utf-8");
+        debug(`Saved metadata cache for genesis: ${genesisHash}`);
+    }
+    catch (e) {
+        debug(`Failed to save metadata cache: ${e}`);
+    }
+    finally {
+        try {
+            fs.unlinkSync(lockPath);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+};
+export class ProviderFactory {
+    providerConfig;
+    url;
+    privateKey;
+    constructor(providerConfig) {
+        this.providerConfig = providerConfig;
+        const endpoint = providerConfig.endpoints[0];
+        // Support "AUTO" endpoint that uses dynamic MOONWALL_RPC_PORT
+        if (endpoint === "AUTO" || endpoint.includes("ENV_VAR")) {
+            this.url =
+                endpoint === "AUTO"
+                    ? vitestAutoUrl()
+                    : process.env.WSS_URL || "error_missing_WSS_URL_env_var";
+        }
+        else {
+            this.url = endpoint;
+        }
+        debug(`Constructor - providerConfig.endpoints[0]: ${endpoint}, this.url: ${this.url}`);
+        this.privateKey = process.env.MOON_PRIV_KEY || ALITH_PRIVATE_KEY;
+    }
+    create() {
+        switch (this.providerConfig.type) {
+            case "polkadotJs":
+                return this.createPolkadotJs();
+            case "web3":
+                return this.createWeb3();
+            case "ethers":
+                return this.createEthers();
+            case "viem":
+                return this.createViem();
+            case "papi":
+                return this.createPapi();
+            default:
+                return this.createDefault();
+        }
+    }
+    createPolkadotJs() {
+        debug(`🟢  PolkadotJs provider ${this.providerConfig.name} details prepared to connect to ${this.url}`);
+        // Check if metadata caching is enabled (default: true)
+        const cacheEnabled = this.providerConfig.cacheMetadata !== false;
+        return {
+            name: this.providerConfig.name,
+            type: this.providerConfig.type,
+            connect: async () => {
+                const cachedMetadata = cacheEnabled ? loadCachedMetadata() : undefined;
+                const startTime = Date.now();
+                const options = {
+                    provider: new WsProvider(this.url),
+                    initWasm: false,
+                    noInitWarn: true,
+                    isPedantic: false,
+                    rpc: this.providerConfig.rpc ? this.providerConfig.rpc : undefined,
+                    typesBundle: this.providerConfig.additionalTypes
+                        ? this.providerConfig.additionalTypes
+                        : undefined,
+                    metadata: cachedMetadata,
+                };
+                const api = await ApiPromise.create(options);
+                await api.isReady;
+                // Cache metadata for future connections if caching is enabled and not already cached
+                if (cacheEnabled && !cachedMetadata) {
+                    const genesisHash = api.genesisHash.toHex();
+                    const metadataHex = api.runtimeMetadata.toHex();
+                    saveCachedMetadata(genesisHash, metadataHex);
+                    debug(`PolkadotJs connected in ${Date.now() - startTime}ms (metadata fetched & cached)`);
+                }
+                else if (cachedMetadata) {
+                    debug(`PolkadotJs connected in ${Date.now() - startTime}ms (using cached metadata)`);
+                }
+                else {
+                    debug(`PolkadotJs connected in ${Date.now() - startTime}ms (caching disabled)`);
+                }
+                return api;
+            },
+            ws: (timeout) => new WsProvider(this.url, 1000, {}, timeout),
+        };
+    }
+    createWeb3() {
+        debug(`🟢  Web3 provider ${this.providerConfig.name} details prepared`);
+        return {
+            name: this.providerConfig.name,
+            type: this.providerConfig.type,
+            connect: () => {
+                const provider = new WebSocketProvider(this.url, {}, { delay: 50, autoReconnect: false, maxAttempts: 10 });
+                return new Web3(provider);
+            },
+        };
+    }
+    createEthers() {
+        debug(`🟢  Ethers provider ${this.providerConfig.name} details prepared`);
+        return {
+            name: this.providerConfig.name,
+            type: this.providerConfig.type,
+            connect: () => {
+                const provider = this.url.startsWith("ws")
+                    ? new ethers.WebSocketProvider(this.url)
+                    : new ethers.JsonRpcProvider(this.url);
+                return new Wallet(this.privateKey, provider);
+            },
+        };
+    }
+    createViem() {
+        debug(`🟢  Viem omni provider ${this.providerConfig.name} details prepared`);
+        return {
+            name: this.providerConfig.name,
+            type: this.providerConfig.type,
+            connect: async () => {
+                try {
+                    debug(`Original URL (this.url): ${this.url}`);
+                    const httpUrl = normalizeUrlToHttps(this.url);
+                    debug(`Converted HTTP URL: ${httpUrl} for provider ${this.providerConfig.name}`);
+                    debug(`🔌 Attempting to derive chain for viem provider ${this.providerConfig.name} from ${httpUrl}`);
+                    const chain = await deriveViemChain(httpUrl);
+                    const client = createWalletClient({
+                        chain,
+                        account: privateKeyToAccount(this.privateKey),
+                        transport: http(httpUrl),
+                    }).extend(publicActions);
+                    return client;
+                }
+                catch (error) {
+                    console.error(`❌ Failed to create viem provider ${this.providerConfig.name} at ${this.url}: ${error.message}`);
+                    throw new Error(`Viem provider initialization failed for ${this.providerConfig.name} at ${this.url}: ${error.message}`);
+                }
+            },
+        };
+    }
+    createPapi() {
+        debug(`🟢  Papi provider ${this.providerConfig.name} details prepared`);
+        return {
+            name: this.providerConfig.name,
+            type: this.providerConfig.type,
+            connect: () => {
+                // Dev nodes in moonwall often sit idle between manual block builds, which means
+                // the default 40s websocket heartbeat in polkadot-api can trigger false
+                // disconnects. Relax the heartbeat so the connection remains up while the
+                // test orchestrator drives block production.
+                const provider = withPolkadotSdkCompat(getWsProvider(this.url, {}));
+                return createClient(provider);
+            },
+        };
+    }
+    createDefault() {
+        debug(`🟢  Default provider ${this.providerConfig.name} details prepared`);
+        return {
+            name: this.providerConfig.name,
+            type: this.providerConfig.type,
+            connect: () => {
+                console.log(`🚧  provider ${this.providerConfig.name} not yet implemented`);
+                return null;
+            },
+        };
+    }
+    static prepare(providerConfigs) {
+        return providerConfigs.map((providerConfig) => new ProviderFactory(providerConfig).create());
+    }
+    static prepareDefaultDev() {
+        return ProviderFactory.prepare([
+            {
+                name: "dev",
+                type: "polkadotJs",
+                endpoints: [vitestAutoUrl()],
+            },
+            {
+                name: "w3",
+                type: "web3",
+                endpoints: [vitestAutoUrl()],
+            },
+            {
+                name: "eth",
+                type: "ethers",
+                endpoints: [vitestAutoUrl()],
+            },
+            {
+                name: "public",
+                type: "viem",
+                endpoints: [vitestAutoUrl()],
+            },
+        ]);
+    }
+    static prepareDefaultZombie() {
+        const MOON_PARA_WSS = process.env.MOON_PARA_WSS || "error";
+        const MOON_RELAY_WSS = process.env.MOON_RELAY_WSS || "error";
+        const providers = [
+            {
+                name: "w3",
+                type: "web3",
+                endpoints: [MOON_PARA_WSS],
+            },
+            {
+                name: "eth",
+                type: "ethers",
+                endpoints: [MOON_PARA_WSS],
+            },
+            {
+                name: "viem",
+                type: "viem",
+                endpoints: [MOON_PARA_WSS],
+            },
+            {
+                name: "relaychain",
+                type: "polkadotJs",
+                endpoints: [MOON_RELAY_WSS],
+            },
+        ];
+        if (MOON_PARA_WSS !== "error") {
+            providers.push({
+                name: "parachain",
+                type: "polkadotJs",
+                endpoints: [MOON_PARA_WSS],
+            });
+        }
+        return ProviderFactory.prepare(providers);
+    }
+    static prepareNoEthDefaultZombie() {
+        const MOON_PARA_WSS = process.env.MOON_PARA_WSS || "error";
+        const MOON_RELAY_WSS = process.env.MOON_RELAY_WSS || "error";
+        const providers = [
+            {
+                name: "relaychain",
+                type: "polkadotJs",
+                endpoints: [MOON_RELAY_WSS],
+            },
+        ];
+        if (MOON_PARA_WSS !== "error") {
+            providers.push({
+                name: "parachain",
+                type: "polkadotJs",
+                endpoints: [MOON_PARA_WSS],
+            });
+        }
+        return ProviderFactory.prepare(providers);
+    }
+}
+export class ProviderInterfaceFactory {
+    name;
+    type;
+    connect;
+    constructor(name, type, connect) {
+        this.name = name;
+        this.type = type;
+        this.connect = connect;
+    }
+    async create() {
+        switch (this.type) {
+            case "polkadotJs":
+                return this.createPolkadotJs();
+            case "web3":
+                return this.createWeb3();
+            case "ethers":
+                return this.createEthers();
+            case "viem":
+                return this.createViem();
+            case "papi":
+                return this.createPapi();
+            default:
+                throw new Error("UNKNOWN TYPE");
+        }
+    }
+    async createPolkadotJs() {
+        debug(`🔌 Connecting PolkadotJs provider: ${this.name}`);
+        const api = (await this.connect());
+        debug(`✅ PolkadotJs provider ${this.name} connected`);
+        1;
+        return {
+            name: this.name,
+            api,
+            type: "polkadotJs",
+            greet: async () => {
+                debug(`👋  Provider ${this.name} is connected to chain` +
+                    ` ${api.consts.system.version.specName.toString()} ` +
+                    `RT${api.consts.system.version.specVersion.toNumber()}`);
+                return {
+                    rtVersion: api.consts.system.version.specVersion.toNumber(),
+                    rtName: api.consts.system.version.specName.toString(),
+                };
+            },
+            disconnect: async () => api.disconnect(),
+        };
+    }
+    async createWeb3() {
+        const api = (await this.connect());
+        return {
+            name: this.name,
+            api,
+            type: "web3",
+            greet: async () => console.log(`👋 Provider ${this.name} is connected to chain ${await api.eth.getChainId()}`),
+            disconnect: async () => {
+                if (!api.eth.net.currentProvider) {
+                    throw new Error("No connected web3 provider to disconnect from");
+                }
+                api.eth.net.currentProvider.disconnect();
+            },
+        };
+    }
+    async createEthers() {
+        const api = (await this.connect());
+        return {
+            name: this.name,
+            api,
+            type: "ethers",
+            greet: async () => {
+                if (!api.provider) {
+                    throw new Error("No connected ethers provider to greet with");
+                }
+                debug(`👋  Provider ${this.name} is connected to chain ${(await api.provider.getNetwork()).chainId}`);
+            },
+            disconnect: () => {
+                if (!api.provider) {
+                    throw new Error("No connected ethers provider to disconnect from");
+                }
+                api.provider.destroy();
+            },
+        };
+    }
+    async createViem() {
+        const api = (await this.connect());
+        return {
+            name: this.name,
+            api,
+            type: "viem",
+            greet: async () => console.log(`👋 Provider ${this.name} is connected to chain ${await api.getChainId()}`),
+            disconnect: async () => {
+                // Not needed until we switch to websockets
+            },
+        };
+    }
+    async createPapi() {
+        const api = (await this.connect());
+        return {
+            name: this.name,
+            api,
+            type: "papi",
+            greet: async () => {
+                const unsafeApi = await api.getUnsafeApi();
+                const { spec_version, spec_name } = await unsafeApi.constants.System.Version();
+                return { rtVersion: spec_version, rtName: spec_name };
+            },
+            async disconnect() {
+                api.destroy();
+            },
+        };
+    }
+    static async populate(name, type, connect) {
+        debug(`🔄 Populating provider: ${name} of type: ${type}`);
+        try {
+            const providerInterface = await new ProviderInterfaceFactory(name, type, connect).create();
+            debug(`✅ Successfully populated provider: ${name}`);
+            return providerInterface;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(`❌ Failed to populate provider: ${name} - ${error.message}`);
+            }
+            else {
+                console.error(`❌ Failed to populate provider: ${name} - Unknown error`);
+            }
+            throw error;
+        }
+    }
+}
+export const vitestAutoUrl = () => {
+    const url = `ws://127.0.0.1:${process.env.MOONWALL_RPC_PORT}`;
+    debug(`vitestAutoUrl - MOONWALL_RPC_PORT=${process.env.MOONWALL_RPC_PORT}, Generated URL: ${url}`);
+    return url;
+};

package/dist/cli/internal/testIdParser.d.ts

@@ -0,0 +1,34 @@
+export interface TestIds {
+    suiteId: string | undefined;
+    testIds: string[];
+}
+/**
+ * Extracts suite and test IDs from a Moonwall test file using AST parsing.
+ * This is more robust than regex as it handles comments, multiline formatting, etc.
+ */
+export declare function extractTestIds(fileContent: string): TestIds;
+/**
+ * Replaces the suite ID in a Moonwall test file.
+ * Returns the modified file content, or undefined if no describeSuite was found.
+ */
+export declare function replaceSuiteId(fileContent: string, newId: string): string | undefined;
+/**
+ * Checks if a file contains a describeSuite call (is a Moonwall test file).
+ */
+export declare function hasSuiteDefinition(fileContent: string): boolean;
+export interface MatchedTestFile {
+    filePath: string;
+    suiteId: string;
+    testIds: string[];
+}
+/**
+ * Finds all test files matching the pattern using ast-grep's parallel file search.
+ * Uses Rust threads for efficient parsing and searching.
+ *
+ * @param testDirs - Directories to search for test files
+ * @param includeGlobs - Glob patterns for files to include (e.g., ["*test*.ts", "*spec*.ts"])
+ * @param idPattern - Regex pattern to match against suite/test IDs
+ * @returns Promise resolving to array of matching file paths
+ */
+export declare function findTestFilesMatchingPattern(testDirs: string[], includeGlobs: string[], idPattern: RegExp): Promise<string[]>;
+//# sourceMappingURL=testIdParser.d.ts.map

package/dist/cli/internal/testIdParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testIdParser.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/testIdParser.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAoCD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CA8B3D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA6BrF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI/D;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,EAAE,CAAC,CAmEnB"}