@testspectra/cli 1.2.12 → 1.2.14

package/dist/commands/init.d.ts

@@ -1,5 +1,7 @@
 export interface InitCommandOptions {
     force?: boolean;
-    template?: 'default' | 'nx' | 'react-component';
+    template?: 'default' | 'nx' | 'react-component' | 'react-native-component';
+    /** `false` (from `--no-demo`) scaffolds the default template without demo plugin, demo content or WebdriverIO. */
+    demo?: boolean;
 }
 export declare function initCommand(options?: InitCommandOptions): Promise<void>;

package/dist/commands/init.js

@@ -7,6 +7,39 @@ import { ConfigLoader } from '../config/loader.js';
 import { TypeGenerator } from '../types/generator.js';
 import { TsConfigGenerator } from '../generator/tsconfig-generator.js';
 import { generateArchitectureDoc } from '../generator/architecture-doc-generator.js';
+/** Top-level template entries that only exist to demonstrate the framework against the demo app. */
+const DEMO_TEMPLATE_ENTRIES = ['specs', 'page-objects', 'fixtures', 'support'];
+/** Empty directories a `--no-demo` scaffold keeps, each with a `.gitkeep`. */
+const DEMO_FREE_DIRECTORIES = ['specs', 'page-objects', 'fixtures', 'support/steps', 'support/actions'];
+const DEMO_CONFIG_REPLACEMENTS = {
+    '    environmentVariables: { DEMO_API_MODE: "sandbox" },': '    environmentVariables: {},',
+    '    // Demo plugin: registers Spectra.findComponent() / Spectra.findButton() commands.\n    plugins: ["@testspectra/plugin-demo"],\n': '',
+};
+function isDemoOnlyDependency(name) {
+    return name === '@testspectra/plugin-demo' || name === 'webdriverio' || name.startsWith('@wdio/');
+}
+function scaffoldEmptyDirectories(root) {
+    for (const rel of DEMO_FREE_DIRECTORIES) {
+        const dir = path.join(root, rel);
+        fs.mkdirSync(dir, { recursive: true });
+        const keep = path.join(dir, '.gitkeep');
+        if (!fs.existsSync(keep))
+            fs.writeFileSync(keep, '', 'utf-8');
+    }
+}
+/** Nearest ancestor of `cwd` (excluding `cwd`) that holds a pnpm-workspace.yaml, if any. */
+function findAncestorPnpmWorkspace(cwd) {
+    let dir = path.dirname(cwd);
+    for (;;) {
+        const candidate = path.join(dir, 'pnpm-workspace.yaml');
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
 function parsePnpmWorkspaceGlobs(content) {
     const lines = content.split('\n');
     const globs = [];
@@ -225,6 +258,11 @@ export async function initCommand(options = {}) {
                     value: 'react-component',
                     hint: 'Real-browser React component testing with Vite & Testing Library',
                 },
+                {
+                    label: 'React Native Component Testing',
+                    value: 'react-native-component',
+                    hint: 'Real-device/emulator React Native component testing with Hermes',
+                },
             ],
         });
         if (p.isCancel(templateChoice)) {
@@ -234,6 +272,9 @@ export async function initCommand(options = {}) {
         selectedTemplate = templateChoice;
     }
     const templateName = selectedTemplate || (isMonorepo ? 'nx' : 'default');
+    if (options.demo === false && templateName !== 'default') {
+        p.log.warn(chalk.yellow('--no-demo only applies to the default template; ignoring it for this template.'));
+    }
     // 1. Resolve template directory
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
@@ -267,8 +308,9 @@ export async function initCommand(options = {}) {
     catch { }
     const projectName = path.basename(cwd);
     const cliDepVersion = cliVersion.startsWith('^') ? cliVersion : `^${cliVersion}`;
-    // Helper: Copy directory contents recursively
-    function copyRecursive(src, dest, replacements = {}) {
+    // Helper: Copy directory contents recursively. `demoFree` drops the demo-only template entries and
+    // their dependencies/config (see --no-demo).
+    function copyRecursive(src, dest, replacements = {}, demoFree = false) {
         const base = path.basename(src);
         if (base === 'node_modules' || base === 'dist' || base === '.testspectra' || base === '.git') {
             return;
@@ -280,7 +322,9 @@ export async function initCommand(options = {}) {
             }
             const entries = fs.readdirSync(src);
             for (const entry of entries) {
-                copyRecursive(path.join(src, entry), path.join(dest, entry), replacements);
+                if (demoFree && src === templateDir && DEMO_TEMPLATE_ENTRIES.includes(entry))
+                    continue;
+                copyRecursive(path.join(src, entry), path.join(dest, entry), replacements, demoFree);
             }
         }
         else {
@@ -291,12 +335,23 @@ export async function initCommand(options = {}) {
             for (const [k, v] of Object.entries(replacements)) {
                 content = content.replaceAll(k, v);
             }
+            if (demoFree && dest === path.join(cwd, 'spectra.config.ts')) {
+                for (const [k, v] of Object.entries(DEMO_CONFIG_REPLACEMENTS)) {
+                    content = content.replaceAll(k, v);
+                }
+            }
             if (dest.endsWith('package.json')) {
                 try {
                     const pkg = JSON.parse(content);
                     if (!pkg.name || pkg.name.startsWith('@testspectra/template-') || pkg.name === 'spectra-monorepo') {
                         pkg.name = projectName;
                     }
+                    if (demoFree && pkg.devDependencies) {
+                        for (const key of Object.keys(pkg.devDependencies)) {
+                            if (isDemoOnlyDependency(key))
+                                delete pkg.devDependencies[key];
+                        }
+                    }
                     if (pkg.devDependencies) {
                         for (const key of Object.keys(pkg.devDependencies)) {
                             if (key.startsWith('@testspectra/') ||
@@ -606,9 +661,16 @@ export async function initCommand(options = {}) {
     // --- STANDALONE / DEFAULT PROJECT FLOW ---
     const s = p.spinner();
     s.start('Scaffolding standalone TestSpectra project...');
-    copyRecursive(templateDir, cwd);
+    const demoFree = options.demo === false && templateName === 'default';
+    copyRecursive(templateDir, cwd, {}, demoFree);
+    if (demoFree)
+        scaffoldEmptyDirectories(cwd);
     const standaloneWsPath = path.join(cwd, 'pnpm-workspace.yaml');
-    if (!fs.existsSync(standaloneWsPath) || options.force) {
+    const ancestorWsPath = findAncestorPnpmWorkspace(cwd);
+    if (ancestorWsPath) {
+        p.log.info(chalk.gray(`Using the pnpm workspace at ${path.relative(cwd, ancestorWsPath) || ancestorWsPath}; no nested pnpm-workspace.yaml written.`));
+    }
+    else if (!fs.existsSync(standaloneWsPath) || options.force) {
         const pnpmWsContent = `allowBuilds:\n  chromedriver: true\n  edgedriver: true\n  geckodriver: true\n`;
         fs.writeFileSync(standaloneWsPath, pnpmWsContent, 'utf-8');
     }

package/dist/commands/test.d.ts

@@ -8,6 +8,10 @@ export interface TestCommandOptions {
     failed?: boolean | string;
     output?: string;
     concurrency?: string | number;
+    platform?: string;
+    target?: string;
+    port?: string | number;
+    deviceId?: string;
 }
 /**
  * Guarantees the `.testspectra` solution-tsconfig scaffolding exists before the component

package/dist/commands/test.js

@@ -7,6 +7,7 @@ import { resolvePluginSpecifiers } from '../plugins/resolver.js';
 import { renderSummaryView } from '../reporter/summary-view.js';
 import { Reporter } from '../runner/reporter.js';
 import { RustCoreBridge } from '../runner/bridge.js';
+import { HarnessGenerator } from '../generator/harness-generator.js';
 import { TypeGenerator } from '../generator/type-generator.js';
 import { runSystemChecks } from './doctor.js';
 /**
@@ -70,10 +71,112 @@ export function collectFailedTestTitles(reportPath) {
  * runners rather than one extended pipeline.
  */
 export async function testCommand(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
+    const cwd = path.resolve(process.cwd(), options.cwd ?? '.');
     // User-facing phase log. Deliberately describes TestSpectra's own stages only — never the
     // bundled runtime/toolchain underneath — so the CLI surface stays implementation-agnostic.
     const logPhase = (message) => p.log.step(chalk.dim(message));
+    const rawPlatform = options.platform ?? options.target ?? 'web';
+    const platform = String(rawPlatform).toLowerCase();
+    const isMobile = platform === 'android' || platform === 'mobile';
+    if (isMobile) {
+        logPhase('Preparing mobile component test workspace…');
+        ensureTestSpectraScaffolding(cwd);
+        HarnessGenerator.ensureMobileHarness(cwd);
+        let rnPkg;
+        try {
+            rnPkg = await import('@testspectra/react-native');
+        }
+        catch {
+            p.log.error(chalk.red('✖ @testspectra/react-native is not installed in this workspace.'));
+            p.log.info(chalk.dim('Mobile component testing requires the @testspectra/react-native package.'));
+            p.log.info(chalk.dim('  👉 Install it:  pnpm add -D @testspectra/react-native'));
+            process.exit(1);
+            return;
+        }
+        const isLibraryProject = !fs.existsSync(path.join(cwd, 'android')) && !fs.existsSync(path.join(cwd, 'ios'));
+        const reporter = new Reporter();
+        const runStartedAt = Date.now();
+        const outputFile = options.output ? path.resolve(cwd, options.output) : undefined;
+        let ok = false;
+        let testResult;
+        if (isLibraryProject) {
+            logPhase('Executing mobile component library tests…');
+            testResult = await rnPkg.runMobileComponentTests({
+                testRoot: cwd,
+                spec: options.spec,
+                reporter,
+                mode: 'library',
+            });
+            ok = testResult.status === 'passed';
+            if (!ok) {
+                for (const res of testResult.results) {
+                    if (!res.passed && res.error) {
+                        p.log.error(chalk.red(`✖ [${res.specPath}] ${res.error}`));
+                    }
+                }
+            }
+        }
+        else {
+            logPhase('Checking ADB device connection…');
+            const adbCheck = await rnPkg.checkAdbDevices();
+            if (!adbCheck.connected || adbCheck.devices.length === 0) {
+                p.log.error(chalk.red('✖ No connected Android devices or emulators found.'));
+                p.log.info(chalk.dim('Ensure an Android emulator is running or a device is connected with USB debugging.'));
+                p.log.info(chalk.dim('  👉 Run:  adb devices'));
+                process.exit(1);
+                return;
+            }
+            p.log.info(chalk.dim(`Connected Android device(s): ${adbCheck.devices.join(', ')}`));
+            logPhase('Starting mobile bundle server (esbuild React Native)…');
+            const bundleServer = await rnPkg.startMobileBundleServer({
+                testRoot: cwd,
+                port: options.port !== undefined ? parseInt(String(options.port), 10) : undefined,
+            });
+            try {
+                logPhase('Executing mobile component tests on device…');
+                testResult = await rnPkg.runMobileComponentTests({
+                    testRoot: cwd,
+                    spec: options.spec,
+                    reporter,
+                    bundleUrl: bundleServer.url,
+                    deviceId: options.deviceId,
+                });
+                ok = testResult.status === 'passed';
+                if (!ok) {
+                    for (const res of testResult.results) {
+                        if (!res.passed && res.error) {
+                            p.log.error(chalk.red(`✖ [${res.specPath}] ${res.error}`));
+                        }
+                    }
+                }
+            }
+            finally {
+                await bundleServer.stop();
+            }
+        }
+        const durationMs = Date.now() - runStartedAt;
+        const passedCount = testResult?.passedCount ?? 0;
+        const failedCount = ok ? 0 : Math.max(testResult?.failedCount ?? 0, 1);
+        const totalSuites = testResult?.suitesRun ?? passedCount + failedCount;
+        const totalTests = passedCount + failedCount;
+        const result = reporter.generateResult(ok ? 'passed' : 'failed', `${(durationMs / 1000).toFixed(1)}s`);
+        if (outputFile) {
+            try {
+                fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+                fs.writeFileSync(outputFile, JSON.stringify(result, null, 2), 'utf8');
+            }
+            catch { }
+        }
+        renderSummaryView({
+            totalSuites,
+            totalTests,
+            passedCount,
+            failedCount,
+            durationMs,
+            reportLocation: outputFile ? path.relative(cwd, outputFile) : '(use -o/--output to save a report)',
+        });
+        process.exit(ok ? 0 : 1);
+    }
     logPhase('Preparing component test workspace…');
     ensureTestSpectraScaffolding(cwd);
     let reactPkg;

package/dist/config/schema.d.ts

@@ -1,3 +1,22 @@
+/**
+ * Request a dev server must answer correctly before the run proceeds. Guards against an unrelated
+ * server that happens to occupy the port (e.g. one reused via `reuseExistingServer`).
+ */
+export interface DevServerHealthCheck {
+    /**
+     * Path requested on the dev server `url` (e.g. "/__mock/scenarios").
+     */
+    path: string;
+    /**
+     * Expected HTTP status code of the response.
+     * @default 200
+     */
+    status?: number;
+    /**
+     * Text the response body must contain. When omitted, the body is not inspected.
+     */
+    bodyIncludes?: string;
+}
 /**
  * Configuration for an individual local development server lifecycle.
  */
@@ -36,6 +55,11 @@ export interface DevServerConfig {
      * Custom environment variables passed to the spawned development server process.
      */
     env?: Record<string, string>;
+    /**
+     * Request verified after the server is ready (reused or started). The run fails if the response
+     * does not match. Omit to skip the check.
+     */
+    healthCheck?: DevServerHealthCheck;
 }
 /**
  * Configuration options for failure-only video recording.

package/dist/generator/harness-generator.d.ts

@@ -0,0 +1,13 @@
+/**
+ * HarnessGenerator — manages auto-generated component testing harness apps.
+ *
+ * Automatically provisions the standalone mobile component harness container
+ * (<SpectraHarnessRoot />) inside `.testspectra/harness/` for both React Native
+ * component libraries and full mobile application workspaces.
+ */
+export declare class HarnessGenerator {
+    /**
+     * Ensures the mobile component harness entry files exist in `.testspectra/harness/`.
+     */
+    static ensureMobileHarness(cwd: string): void;
+}

package/dist/generator/harness-generator.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * HarnessGenerator — manages auto-generated component testing harness apps.
+ *
+ * Automatically provisions the standalone mobile component harness container
+ * (<SpectraHarnessRoot />) inside `.testspectra/harness/` for both React Native
+ * component libraries and full mobile application workspaces.
+ */
+export class HarnessGenerator {
+    /**
+     * Ensures the mobile component harness entry files exist in `.testspectra/harness/`.
+     */
+    static ensureMobileHarness(cwd) {
+        const harnessDir = path.join(cwd, '.testspectra', 'harness');
+        if (!fs.existsSync(harnessDir)) {
+            fs.mkdirSync(harnessDir, { recursive: true });
+        }
+        const appFile = path.join(harnessDir, 'App.tsx');
+        if (!fs.existsSync(appFile)) {
+            const appContent = `/**
+ * Auto-generated by TestSpectra.
+ * Standalone Mobile Component Testing Harness Container.
+ * DO NOT EDIT MANUALLY.
+ */
+import React from 'react';
+import { AppRegistry } from 'react-native';
+import { SpectraHarnessRoot } from '@testspectra/react-native';
+
+export function SpectraHarnessApp(): React.JSX.Element {
+  return <SpectraHarnessRoot />;
+}
+
+AppRegistry.registerComponent('SpectraHarness', () => SpectraHarnessApp);
+export default SpectraHarnessApp;
+`;
+            fs.writeFileSync(appFile, appContent, 'utf8');
+        }
+        const indexFile = path.join(harnessDir, 'index.js');
+        if (!fs.existsSync(indexFile)) {
+            const indexContent = `/**
+ * Auto-generated by TestSpectra.
+ * Standalone Mobile Component Testing Harness Entrypoint.
+ * DO NOT EDIT MANUALLY.
+ */
+import './App.js';
+`;
+            fs.writeFileSync(indexFile, indexContent, 'utf8');
+        }
+    }
+}

package/dist/generator/index.d.ts

@@ -1,3 +1,4 @@
 export * from './type-generator.js';
 export * from './tsconfig-generator.js';
 export * from './architecture-doc-generator.js';
+export * from './harness-generator.js';

package/dist/generator/index.js

@@ -1,3 +1,4 @@
 export * from './type-generator.js';
 export * from './tsconfig-generator.js';
 export * from './architecture-doc-generator.js';
+export * from './harness-generator.js';

package/dist/generator/page-object-declarations.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Page object discovery and ambient declarations. Mirrors `core/orchestrator`'s discovery and
+ * `core/worker-runtime`'s `publishPageObject`, so declared types and injected values share one tree:
+ * a folder holding a platform file is a page object; any other folder is a namespace; every page object
+ * is `Page.<namespace>.<name>`, and a flat one (directly under `page-objects/`) is also a global `<name>`.
+ */
+export interface PageObjectEntry {
+    /** Folders between `page-objects/` and the page object's own folder. Empty for a flat page object. */
+    namespace: string[];
+    name: string;
+    /** Absolute path of the platform file that makes this entry a page object. */
+    file: string;
+    /** Absolute path of the page object's folder, or of the loose file for a flat `<Name>.<stem>.ts` entry. */
+    source: string;
+}
+/** The platform file that makes `folder` a page object: `<stem>.ts`, `<stem>.page.ts`, `<stem>.po.ts`, `<stem>.js`, and `index.ts` for the common stem. */
+export declare function findFolderPageObjectFile(folder: string, hierarchy: string[]): string | null;
+/**
+ * Collects the page objects under one `page-objects/` root at any depth. Loose `<Name>.ts` /
+ * `<Name>.<stem>.ts` files directly under the root remain flat page objects.
+ */
+export declare function collectPageObjectEntries(poDir: string, hierarchy: string[]): PageObjectEntry[];
+/**
+ * Renders the page-object declarations for one platform file: a `declare const <Name>` for each flat page
+ * object, and one `declare const Page` holding the whole tree. Returns `''` when there are no entries.
+ */
+export declare function renderPageObjectDeclarations(entries: PageObjectEntry[], outputTypesDir: string, cwd: string): string;

package/dist/generator/page-object-declarations.js

@@ -0,0 +1,142 @@
+import fs from 'fs';
+import path from 'path';
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/** The platform file that makes `folder` a page object: `<stem>.ts`, `<stem>.page.ts`, `<stem>.po.ts`, `<stem>.js`, and `index.ts` for the common stem. */
+export function findFolderPageObjectFile(folder, hierarchy) {
+    for (const stem of hierarchy) {
+        const candidates = [`${stem}.ts`, `${stem}.page.ts`, `${stem}.po.ts`, `${stem}.js`];
+        if (stem === 'common')
+            candidates.push('index.ts');
+        for (const name of candidates) {
+            const cand = path.join(folder, name);
+            if (fs.existsSync(cand) && fs.statSync(cand).isFile())
+                return cand;
+        }
+    }
+    return null;
+}
+/**
+ * Collects the page objects under one `page-objects/` root at any depth. Loose `<Name>.ts` /
+ * `<Name>.<stem>.ts` files directly under the root remain flat page objects.
+ */
+export function collectPageObjectEntries(poDir, hierarchy) {
+    const entries = [];
+    if (!fs.existsSync(poDir))
+        return entries;
+    const walk = (dir, namespace, isRoot) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const file = findFolderPageObjectFile(fullPath, hierarchy);
+                if (file) {
+                    entries.push({ namespace, name: entry.name, file, source: fullPath });
+                }
+                else {
+                    walk(fullPath, [...namespace, entry.name], false);
+                }
+            }
+            else if (isRoot && entry.isFile() && entry.name.endsWith('.ts')) {
+                const parts = entry.name.split('.');
+                if (parts.length === 2 || (parts.length > 2 && hierarchy.includes(parts[1]))) {
+                    entries.push({ namespace: [], name: parts[0], file: fullPath, source: fullPath });
+                }
+            }
+        }
+    };
+    walk(poDir, [], true);
+    return entries;
+}
+/** Import type of a page object file, the same expression the generator has always emitted. */
+function importedType(file, outputTypesDir) {
+    let rel = path.relative(outputTypesDir, file).replace(/\\/g, '/').replace(/\.ts$/, '.js');
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    return `(typeof import('${rel}') extends { default: infer T } ? T : typeof import('${rel}'))`;
+}
+function dottedPath(namespace, name) {
+    return ['Page', ...namespace, name].join('.');
+}
+/**
+ * The folder of the first `depth` namespace segments of `entry`. The entry's source is its own folder, one level
+ * below the deepest namespace, so the depth-`d` folder is `namespace.length - d + 1` levels up.
+ */
+function namespaceFolder(entry, depth) {
+    let folder = entry.source;
+    for (let up = entry.namespace.length - depth + 1; up > 0; up--)
+        folder = path.dirname(folder);
+    return folder;
+}
+function shown(p, cwd) {
+    return path.relative(cwd, p).replace(/\\/g, '/');
+}
+/**
+ * Builds the `Page` tree and throws when two entries claim the same path: two page objects at one
+ * namespace level, or a namespace and a page object with the same name. The message names both paths.
+ */
+function buildPageTree(entries, cwd) {
+    const root = { children: new Map() };
+    for (const entry of entries) {
+        if (entry.namespace.length === 0 && entry.name === 'Page') {
+            throw new Error(`Page object name conflict: "${shown(entry.source, cwd)}" is named "Page", the reserved root of every page object`);
+        }
+        let node = root;
+        entry.namespace.forEach((segment, index) => {
+            const child = node.children.get(segment);
+            if (!child) {
+                const created = { children: new Map(), folder: namespaceFolder(entry, index + 1) };
+                node.children.set(segment, created);
+                node = created;
+                return;
+            }
+            if (child.leaf) {
+                throw new Error(`Page object conflict: "${dottedPath(entry.namespace.slice(0, index), segment)}" is both a page object (${shown(child.leaf.source, cwd)}) and a namespace (${shown(namespaceFolder(entry, index + 1), cwd)})`);
+            }
+            node = child;
+        });
+        const existing = node.children.get(entry.name);
+        if (existing?.leaf) {
+            throw new Error(`Duplicate page object "${dottedPath(entry.namespace, entry.name)}": ${shown(existing.leaf.source, cwd)} and ${shown(entry.source, cwd)}`);
+        }
+        if (existing) {
+            throw new Error(`Page object conflict: "${dottedPath(entry.namespace, entry.name)}" is both a page object (${shown(entry.source, cwd)}) and a namespace (${shown(existing.folder ?? '', cwd)})`);
+        }
+        node.children.set(entry.name, { children: new Map(), leaf: entry });
+    }
+    return root;
+}
+function propertyName(name) {
+    return IDENTIFIER.test(name) ? name : JSON.stringify(name);
+}
+function renderObjectType(node, indent, outputTypesDir) {
+    const lines = ['{'];
+    for (const [name, child] of node.children) {
+        const key = propertyName(name);
+        if (child.leaf) {
+            lines.push(`${indent}  ${key}: ${importedType(child.leaf.file, outputTypesDir)};`);
+        }
+        else {
+            lines.push(`${indent}  ${key}: ${renderObjectType(child, `${indent}  `, outputTypesDir)};`);
+        }
+    }
+    lines.push(`${indent}}`);
+    return lines.join('\n');
+}
+/**
+ * Renders the page-object declarations for one platform file: a `declare const <Name>` for each flat page
+ * object, and one `declare const Page` holding the whole tree. Returns `''` when there are no entries.
+ */
+export function renderPageObjectDeclarations(entries, outputTypesDir, cwd) {
+    if (entries.length === 0)
+        return '';
+    const root = buildPageTree(entries, cwd);
+    let content = '';
+    for (const [name, child] of root.children) {
+        if (child.leaf) {
+            content += `declare const ${name}: ${importedType(child.leaf.file, outputTypesDir)};\n`;
+        }
+    }
+    content += `declare const Page: ${renderObjectType(root, '', outputTypesDir)};\n`;
+    return content;
+}

package/dist/generator/type-generator.d.ts

@@ -22,10 +22,15 @@ export interface EntityScope {
  */
 export declare function discoverEntityScopes(cwd: string): EntityScope[];
 /**
- * Detects a component-testing project (`@testspectra/react`'s Vitest browser-mode runner), via
- * the same signal `cli/src/commands/test.ts` uses to gate `spectra test` itself. Used to augment
- * the generated `Spectra` ambient type with `.mount()`, which only exists in that runtime.
+ * Detects component-testing capabilities (Web via `@testspectra/react` or Mobile via `@testspectra/react-native`).
+ * Used to augment the generated `Spectra` ambient type with `.mount()`.
  */
+export interface ComponentTestingInfo {
+    isComponent: boolean;
+    isWebComponent: boolean;
+    isMobileComponent: boolean;
+}
+export declare function detectComponentTesting(cwd: string): ComponentTestingInfo;
 export declare function isComponentTestingProject(cwd: string): boolean;
 export declare class TypeGenerator {
     /**