@qate/cli 1.0.0

package/dist/PlaywrightGenerator.js

@@ -0,0 +1,1342 @@
+"use strict";
+/**
+ * Playwright Code Generator
+ * Converts Qate test definitions to runnable Playwright test files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePlaywrightTests = generatePlaywrightTests;
+exports.generateSummary = generateSummary;
+/**
+ * Extract placeholder patterns ({{name}}) from a string
+ */
+function extractPlaceholdersFromString(str) {
+    if (!str)
+        return [];
+    const matches = str.match(/\{\{([^}]+)\}\}/g);
+    if (!matches)
+        return [];
+    return matches.map(m => m.replace(/\{\{|\}\}/g, ''));
+}
+/**
+ * Extract all unique placeholders from test steps
+ */
+function extractPlaceholders(test) {
+    const placeholders = new Set();
+    for (const step of test.steps || []) {
+        const input = step.toolInput || {};
+        // Check common input fields that may contain placeholders
+        const fieldsToCheck = ['value', 'text', 'url', 'expected', 'selector'];
+        for (const field of fieldsToCheck) {
+            if (typeof input[field] === 'string') {
+                for (const p of extractPlaceholdersFromString(input[field])) {
+                    placeholders.add(p);
+                }
+            }
+        }
+        // Also check nested objects (like verification)
+        if (step.verification && typeof step.verification === 'object') {
+            for (const key in step.verification) {
+                if (typeof step.verification[key] === 'string') {
+                    for (const p of extractPlaceholdersFromString(step.verification[key])) {
+                        placeholders.add(p);
+                    }
+                }
+            }
+        }
+    }
+    return Array.from(placeholders);
+}
+/**
+ * Check if a string contains placeholder patterns
+ */
+function containsPlaceholder(str) {
+    if (!str)
+        return false;
+    return /\{\{[^}]+\}\}/.test(str);
+}
+/**
+ * Wrap a value with resolve() if it contains placeholders, otherwise return quoted string
+ */
+function wrapValue(value, usePlaceholderResolve) {
+    if (!value)
+        return "''";
+    if (usePlaceholderResolve && containsPlaceholder(value)) {
+        return `resolve('${escapeString(value)}')`;
+    }
+    return `'${escapeString(value)}'`;
+}
+// Actions that trigger network/DOM changes and need settling
+const SETTLING_ACTIONS = new Set([
+    'goTo', 'go_to', 'click', 'fill', 'type',
+    'selectOption', 'select_option', 'check', 'uncheck',
+    'doubleClick', 'double_click', 'rightClick', 'right_click',
+    'dragAndDrop', 'drag_and_drop', 'drag', 'evaluate', 'hover'
+]);
+/**
+ * Get the pure Playwright action code (without timing wrapper)
+ */
+function getActionCode(toolName, input, indent, usePlaceholderResolve) {
+    switch (toolName) {
+        case 'goTo':
+        case 'go_to':
+            return `${indent}await page.goto(${wrapValue(input.url, usePlaceholderResolve)});`;
+        case 'click':
+            return `${indent}await page.click('${escapeString(input.selector)}');`;
+        case 'fill':
+            return `${indent}await page.fill('${escapeString(input.selector)}', ${wrapValue(input.value, usePlaceholderResolve)});`;
+        case 'type':
+            const typeOpts = input.delay ? `, { delay: ${input.delay} }` : '';
+            return `${indent}await page.locator('${escapeString(input.selector)}').type(${wrapValue(input.text, usePlaceholderResolve)}${typeOpts});`;
+        case 'selectOption':
+        case 'select_option':
+            const values = Array.isArray(input.values) ? input.values : [input.values];
+            return `${indent}await page.selectOption('${escapeString(input.selector)}', ${JSON.stringify(values)});`;
+        case 'check':
+            return `${indent}await page.check('${escapeString(input.selector)}');`;
+        case 'uncheck':
+            return `${indent}await page.uncheck('${escapeString(input.selector)}');`;
+        case 'hover':
+            return `${indent}await page.hover('${escapeString(input.selector)}');`;
+        case 'doubleClick':
+        case 'double_click':
+            return `${indent}await page.dblclick('${escapeString(input.selector)}');`;
+        case 'rightClick':
+        case 'right_click':
+            return `${indent}await page.click('${escapeString(input.selector)}', { button: 'right' });`;
+        case 'dragAndDrop':
+        case 'drag_and_drop':
+        case 'drag':
+            return `${indent}await page.locator('${escapeString(input.sourceSelector)}').dragTo(page.locator('${escapeString(input.targetSelector)}'));`;
+        case 'evaluate':
+            return `${indent}await page.evaluate(() => { ${input.script} });`;
+        default:
+            return '';
+    }
+}
+/**
+ * Wrap action with timing capture and error tracking for step result reporting
+ * Used for settling actions (click, fill, goTo, etc.) that need networkidle wait
+ */
+function wrapWithTiming(actionCode, stepId, stepIndex, indent, description) {
+    const varPrefix = `step_${stepIndex}`;
+    const escapedDescription = escapeString(description);
+    return `${indent}// Step ${stepIndex + 1}: ${stepId}
+${indent}qateStartStepNetworkCapture();
+${indent}const ${varPrefix}_activityStart = Date.now();
+${indent}let ${varPrefix}_error: string | undefined;
+${indent}try {
+${actionCode.split('\n').map(line => indent + '  ' + line.trim()).join('\n')}
+${indent}} catch (e) {
+${indent}  ${varPrefix}_error = e instanceof Error ? e.message : String(e);
+${indent}  const ${varPrefix}_activityEnd = Date.now();
+${indent}  qateRecordStepTiming('${stepId}', ${stepIndex}, '${escapedDescription}', 'failed', ${varPrefix}_activityStart, ${varPrefix}_activityEnd, ${varPrefix}_activityEnd, ${varPrefix}_error);
+${indent}  throw e;
+${indent}}
+${indent}const ${varPrefix}_activityEnd = Date.now();
+${indent}await page.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => {});
+${indent}const ${varPrefix}_settledEnd = Date.now();
+${indent}qateRecordStepTiming('${stepId}', ${stepIndex}, '${escapedDescription}', 'passed', ${varPrefix}_activityStart, ${varPrefix}_activityEnd, ${varPrefix}_settledEnd);`;
+}
+/**
+ * Wrap action with step tracking (no networkidle wait)
+ * Used for non-settling actions like focus, press, scroll, assertions, etc.
+ */
+function wrapWithStepTracking(actionCode, stepId, stepIndex, indent, description) {
+    const varPrefix = `step_${stepIndex}`;
+    const escapedDescription = escapeString(description);
+    return `${indent}// Step ${stepIndex + 1}: ${stepId}
+${indent}qateStartStepNetworkCapture();
+${indent}const ${varPrefix}_activityStart = Date.now();
+${indent}try {
+${actionCode.split('\n').map(line => indent + '  ' + line.trim()).join('\n')}
+${indent}  const ${varPrefix}_activityEnd = Date.now();
+${indent}  qateRecordStepTiming('${stepId}', ${stepIndex}, '${escapedDescription}', 'passed', ${varPrefix}_activityStart, ${varPrefix}_activityEnd, ${varPrefix}_activityEnd);
+${indent}} catch (e) {
+${indent}  const ${varPrefix}_error = e instanceof Error ? e.message : String(e);
+${indent}  const ${varPrefix}_activityEnd = Date.now();
+${indent}  qateRecordStepTiming('${stepId}', ${stepIndex}, '${escapedDescription}', 'failed', ${varPrefix}_activityStart, ${varPrefix}_activityEnd, ${varPrefix}_activityEnd, ${varPrefix}_error);
+${indent}  throw e;
+${indent}}`;
+}
+/**
+ * Convert a test step to Playwright code
+ */
+function stepToPlaywright(step, indent = '    ', usePlaceholderResolve = false, stepIndex = 0) {
+    const toolName = step.toolName?.replace('ui_automation--', '') || '';
+    const input = step.toolInput || {};
+    const stepId = step.id || `step_${stepIndex}`;
+    const description = step.description || `${toolName} ${input.selector || input.url || ''}`.trim();
+    // For actions that trigger network changes, wrap with timing capture
+    if (SETTLING_ACTIONS.has(toolName)) {
+        const actionCode = getActionCode(toolName, input, indent, usePlaceholderResolve);
+        if (actionCode) {
+            return wrapWithTiming(actionCode, stepId, stepIndex, indent, description);
+        }
+    }
+    // Handle non-settling actions (assertions, waits, navigation info, etc.)
+    // Generate the raw action code first, then wrap with step tracking
+    let actionCode = null;
+    switch (toolName) {
+        case 'focus':
+            actionCode = `await page.focus('${escapeString(input.selector)}');`;
+            break;
+        case 'press':
+        case 'pressKey':
+        case 'press_key':
+            if (input.selector) {
+                actionCode = `await page.click('${escapeString(input.selector)}');\n    await page.keyboard.press('${escapeString(input.key)}');`;
+            }
+            else {
+                actionCode = `await page.keyboard.press('${escapeString(input.key)}');`;
+            }
+            break;
+        case 'scroll':
+            const direction = input.direction || 'down';
+            const multiplier = input.multiplier || 0.7;
+            actionCode = `await page.evaluate(({ dir, mult }) => {
+      const scrollAmount = window.innerHeight * mult;
+      window.scrollBy(0, dir === 'down' ? scrollAmount : -scrollAmount);
+    }, { dir: '${direction}', mult: ${multiplier} });`;
+            break;
+        case 'waitForSelector':
+        case 'wait_for_selector':
+        case 'waitForElement':
+        case 'wait_for_element':
+            const state = input.state || 'visible';
+            actionCode = `await page.waitForSelector('${escapeString(input.selector)}', { state: '${state}' });`;
+            break;
+        case 'assert':
+            actionCode = generateAssertionCode(input, usePlaceholderResolve);
+            break;
+        case 'screenshot':
+            actionCode = `await page.screenshot({ fullPage: ${input.fullPage || false} });`;
+            break;
+        case 'goBack':
+        case 'go_back':
+            actionCode = `await page.goBack();`;
+            break;
+        case 'goForward':
+        case 'go_forward':
+            actionCode = `await page.goForward();`;
+            break;
+        case 'reload':
+            actionCode = `await page.reload();`;
+            break;
+        case 'getTitle':
+        case 'get_title':
+            actionCode = `const title = await page.title();`;
+            break;
+        case 'getCurrentUrl':
+        case 'get_current_url':
+            actionCode = `const url = page.url();`;
+            break;
+        case 'getInnerHTML':
+        case 'get_inner_html':
+            actionCode = `const html = await page.locator('${escapeString(input.selector)}').innerHTML();`;
+            break;
+        case 'getInputValue':
+        case 'get_input_value':
+            actionCode = `const value = await page.locator('${escapeString(input.selector)}').inputValue();`;
+            break;
+        case 'setViewportSize':
+        case 'set_viewport_size':
+            actionCode = `await page.setViewportSize({ width: ${input.width}, height: ${input.height} });`;
+            break;
+        default:
+            // For unknown tools, add a comment (no step tracking)
+            return `${indent}// TODO: Unsupported tool '${toolName}' - ${JSON.stringify(input)}`;
+    }
+    // Wrap the action with step tracking
+    if (actionCode) {
+        return wrapWithStepTracking(`${indent}${actionCode}`, stepId, stepIndex, indent, description);
+    }
+    return `${indent}// No action generated for '${toolName}'`;
+}
+/**
+ * Generate Playwright assertion code (raw, without indent prefix)
+ */
+function generateAssertionCode(input, usePlaceholderResolve = false) {
+    const { selector, assertion, expected, attribute, timeout } = input;
+    const timeoutOpt = timeout ? `{ timeout: ${timeout} }` : '';
+    switch (assertion) {
+        case 'toBeVisible':
+            return `await expect(page.locator('${escapeString(selector)}')).toBeVisible(${timeoutOpt});`;
+        case 'toBeHidden':
+            return `await expect(page.locator('${escapeString(selector)}')).toBeHidden();`;
+        case 'toBeEnabled':
+            return `await expect(page.locator('${escapeString(selector)}')).toBeEnabled();`;
+        case 'toBeDisabled':
+            return `await expect(page.locator('${escapeString(selector)}')).toBeDisabled();`;
+        case 'toHaveText':
+            return `await expect(page.locator('${escapeString(selector)}')).toHaveText(${wrapValue(expected, usePlaceholderResolve)});`;
+        case 'toContainText':
+            return `await expect(page.locator('${escapeString(selector)}')).toContainText(${wrapValue(expected, usePlaceholderResolve)});`;
+        case 'toHaveValue':
+            return `await expect(page.locator('${escapeString(selector)}')).toHaveValue(${wrapValue(expected, usePlaceholderResolve)});`;
+        case 'toHaveAttribute':
+            return `await expect(page.locator('${escapeString(selector)}')).toHaveAttribute('${escapeString(attribute)}', ${wrapValue(expected, usePlaceholderResolve)});`;
+        case 'toHaveCount':
+            return `await expect(page.locator('${escapeString(selector)}')).toHaveCount(${expected});`;
+        case 'toBeChecked':
+            return `await expect(page.locator('${escapeString(selector)}')).toBeChecked();`;
+        case 'toBeUnchecked':
+            return `await expect(page.locator('${escapeString(selector)}')).not.toBeChecked();`;
+        case 'toBeEditable':
+            return `await expect(page.locator('${escapeString(selector)}')).toBeEditable();`;
+        case 'toBeFocused':
+            return `await expect(page.locator('${escapeString(selector)}')).toBeFocused();`;
+        case 'toHaveURL':
+            return `await expect(page).toHaveURL(${typeof expected === 'string' ? wrapValue(expected, usePlaceholderResolve) : expected});`;
+        case 'toHaveTitle':
+            return `await expect(page).toHaveTitle(${typeof expected === 'string' ? wrapValue(expected, usePlaceholderResolve) : expected});`;
+        default:
+            return `// TODO: Unsupported assertion '${assertion}'`;
+    }
+}
+/**
+ * Escape string for use in generated code
+ */
+function escapeString(str) {
+    if (!str)
+        return '';
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/'/g, "\\'")
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r');
+}
+/**
+ * Convert test name to valid filename
+ */
+function toFilename(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 50);
+}
+/**
+ * Generate a single test file
+ */
+function generateTestFile(test, baseUrl) {
+    const placeholders = extractPlaceholders(test);
+    const hasPlaceholders = placeholders.length > 0;
+    // Filter and sort steps, then map with index for timing capture
+    const filteredSteps = (test.steps || [])
+        .filter(s => s.type === 'tool_use')
+        .sort((a, b) => (a.order || 0) - (b.order || 0));
+    const steps = filteredSteps
+        .map((step, index) => stepToPlaywright(step, '    ', hasPlaceholders, index))
+        .join('\n\n');
+    const description = test.description ? `\n * ${test.description}` : '';
+    const tags = test.tags?.length ? `\n * Tags: ${test.tags.join(', ')}` : '';
+    const priority = test.priority ? `\n * Priority: ${test.priority}` : '';
+    // Generate import statements
+    const imports = [`import { test, expect } from '@playwright/test';`];
+    imports.push(`import { qateRecordStepTiming, qateGetAndClearStepTimings, qateSetupNetworkCapture } from '../qate-runtime';`);
+    if (hasPlaceholders) {
+        imports.push(`import { qateResolve, replacePlaceholders } from '../qate-runtime';`);
+    }
+    // Generate test context and resolver setup for placeholder tests
+    let contextSetup = '';
+    if (hasPlaceholders) {
+        const testContext = {
+            testId: test.id?.toString() || '',
+            testName: test.name,
+            datasetId: test.datasetId || null,
+            authRoleId: test.authRoleId || null,
+            placeholders: placeholders,
+        };
+        contextSetup = `
+    // Resolve placeholders at runtime
+    const testContext = ${JSON.stringify(testContext, null, 6).replace(/\n/g, '\n    ')};
+    const resolved = await qateResolve(testContext);
+    const resolve = (v: string) => replacePlaceholders(v, resolved);
+`;
+    }
+    return `/**
+ * Test: ${test.name}${description}${tags}${priority}
+ *
+ * Generated by Qate CLI
+ * Do not edit manually - regenerate using: qate generate
+ */
+
+${imports.join('\n')}
+
+test.describe('${escapeString(test.name)}', () => {
+  test('${escapeString(test.name)}', async ({ page }, testInfo) => {
+    // Set up network capture (only captures when QATE_EXECUTION_ID is set)
+    qateSetupNetworkCapture(page);
+${contextSetup}
+    try {
+${steps.split('\n').map(line => '  ' + line).join('\n')}
+    } finally {
+      // Always attach step timings for reporter (even on failure)
+      const stepTimings = qateGetAndClearStepTimings();
+      if (stepTimings.length > 0) {
+        await testInfo.attach('qate-step-timings', {
+          body: JSON.stringify(stepTimings),
+          contentType: 'application/json',
+        });
+      }
+    }
+  });
+});
+`;
+}
+/**
+ * Convert user-friendly OS name to BrowserStack format
+ */
+function toBrowserStackOS(os) {
+    const osLower = os.toLowerCase();
+    if (osLower === 'macos' || osLower === 'mac' || osLower === 'osx') {
+        return 'OS X';
+    }
+    if (osLower === 'windows' || osLower === 'win') {
+        return 'Windows';
+    }
+    return 'Windows'; // default
+}
+/**
+ * Convert user-friendly browser name to BrowserStack format
+ */
+function toBrowserStackBrowser(browser) {
+    const browserLower = browser.toLowerCase();
+    if (browserLower === 'safari' || browserLower === 'webkit') {
+        return 'playwright-webkit';
+    }
+    if (browserLower === 'firefox' || browserLower === 'ff') {
+        return 'playwright-firefox';
+    }
+    if (browserLower === 'edge') {
+        return 'edge';
+    }
+    return 'chrome'; // default
+}
+/**
+ * Convert user-friendly browser name to LambdaTest format
+ */
+function toLambdaTestBrowser(browser) {
+    const browserLower = browser.toLowerCase();
+    if (browserLower === 'safari' || browserLower === 'webkit') {
+        return 'pw-webkit';
+    }
+    if (browserLower === 'firefox' || browserLower === 'ff') {
+        return 'pw-firefox';
+    }
+    if (browserLower === 'edge') {
+        return 'MicrosoftEdge';
+    }
+    return 'Chrome'; // default
+}
+/**
+ * Convert user-friendly OS to LambdaTest platform format
+ */
+function toLambdaTestPlatform(os, osVersion) {
+    const osLower = os.toLowerCase();
+    if (osLower === 'macos' || osLower === 'mac' || osLower === 'osx') {
+        return `MacOS ${osVersion || 'Sonoma'}`;
+    }
+    if (osLower === 'windows' || osLower === 'win') {
+        return `Windows ${osVersion || '11'}`;
+    }
+    return `Windows ${osVersion || '11'}`; // default
+}
+/**
+ * Generate playwright.config.ts
+ */
+function generateConfig(options, appUrl) {
+    const { provider = 'local', browsers = ['chromium'], browser = 'chrome', browserVersion = 'latest', os = 'windows', osVersion = '11', orchestration = 'websocket' } = options;
+    let projects = '';
+    let connectOptions = '';
+    // Determine effective orchestration mode
+    // Sauce Labs only supports CLI orchestration
+    const effectiveOrchestration = provider === 'saucelabs' ? 'cli' : orchestration;
+    if (provider === 'browserstack' && effectiveOrchestration === 'websocket') {
+        const bsBrowser = toBrowserStackBrowser(browser);
+        const bsOS = toBrowserStackOS(os);
+        connectOptions = `
+  // BrowserStack configuration (WebSocket/CDP approach)
+  // Docs: https://www.browserstack.com/docs/automate/playwright
+  use: {
+    connectOptions: {
+      wsEndpoint: \`wss://cdp.browserstack.com/playwright?caps=\${encodeURIComponent(JSON.stringify({
+        'browser': '${bsBrowser}',
+        'browser_version': '${browserVersion}',
+        'os': '${bsOS}',
+        'os_version': '${osVersion}',
+        'project': 'Qate Tests',
+        'build': process.env.BUILD_NUMBER || 'local',
+        'name': 'Playwright Test',
+        'browserstack.username': process.env.BROWSERSTACK_USERNAME,
+        'browserstack.accessKey': process.env.BROWSERSTACK_ACCESS_KEY,
+        'browserstack.debug': true,
+        'browserstack.console': 'verbose',
+        'browserstack.networkLogs': true,
+      }))}\`,
+    },
+  },`;
+    }
+    else if (provider === 'browserstack' && effectiveOrchestration === 'cli') {
+        // BrowserStack CLI orchestration - no connectOptions needed
+        connectOptions = `
+  // BrowserStack configuration (CLI orchestration)
+  // Run with: npx browserstack-node-sdk playwright test
+  // Docs: https://www.browserstack.com/docs/automate/playwright/getting-started/nodejs`;
+    }
+    else if (provider === 'saucelabs') {
+        // Sauce Labs only supports CLI orchestration
+        connectOptions = `
+  // Sauce Labs configuration (CLI orchestration only)
+  // IMPORTANT: Sauce Labs requires the saucectl CLI to run tests
+  // Install: npm install -g saucectl
+  // Run: saucectl run
+  // Docs: https://docs.saucelabs.com/web-apps/automated-testing/playwright/`;
+    }
+    else if (provider === 'lambdatest' && effectiveOrchestration === 'websocket') {
+        const ltBrowser = toLambdaTestBrowser(browser);
+        const ltPlatform = toLambdaTestPlatform(os, osVersion);
+        connectOptions = `
+  // LambdaTest configuration (WebSocket/CDP approach)
+  // Docs: https://www.lambdatest.com/support/docs/playwright-testing/
+  use: {
+    connectOptions: {
+      wsEndpoint: \`wss://cdp.lambdatest.com/playwright?capabilities=\${encodeURIComponent(JSON.stringify({
+        'browserName': '${ltBrowser}',
+        'browserVersion': '${browserVersion}',
+        'LT:Options': {
+          'platform': '${ltPlatform}',
+          'build': process.env.BUILD_NUMBER || 'Qate Tests',
+          'name': 'Qate Playwright Test',
+          'user': process.env.LT_USERNAME,
+          'accessKey': process.env.LT_ACCESS_KEY,
+          'network': true,
+          'video': true,
+          'console': true,
+        }
+      }))}\`,
+    },
+  },`;
+    }
+    else if (provider === 'lambdatest' && effectiveOrchestration === 'cli') {
+        // LambdaTest CLI orchestration - no connectOptions needed
+        connectOptions = `
+  // LambdaTest HyperExecute configuration (CLI orchestration)
+  // Run with: ./hyperexecute --config hyperexecute.yaml
+  // Docs: https://www.lambdatest.com/support/docs/hyperexecute-guided-walkthrough/`;
+    }
+    else {
+        // Local provider
+        const browserProjects = browsers.map(browser => `
+    {
+      name: '${browser}',
+      use: { ...devices['Desktop Chrome'] },
+    }`).join(',');
+        projects = `
+  projects: [${browserProjects}
+  ],`;
+    }
+    return `/**
+ * Playwright Configuration
+ * Generated by Qate CLI
+ *
+ * Provider: ${provider}
+ */
+
+import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: [
+    ['html'],
+    ['json', { outputFile: 'test-results.json' }],
+    ['./qate-reporter.ts'],
+  ],
+
+  use: {
+    baseURL: '${appUrl}',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+  },
+${connectOptions}${projects}
+  // Global timeout
+  timeout: 30000,
+  expect: {
+    timeout: 5000,
+  },
+});
+`;
+}
+/**
+ * Generate package.json
+ */
+function generatePackageJson(name, provider = 'local') {
+    const safeName = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    const scripts = {
+        test: 'playwright test',
+        'test:headed': 'playwright test --headed',
+        'test:debug': 'playwright test --debug',
+        report: 'playwright show-report',
+    };
+    const devDependencies = {
+        '@playwright/test': '^1.40.0',
+    };
+    // Add saucectl for Sauce Labs
+    if (provider === 'saucelabs') {
+        scripts.test = 'saucectl run';
+        scripts['test:local'] = 'playwright test';
+    }
+    return JSON.stringify({
+        name: `${safeName}-e2e-tests`,
+        version: '1.0.0',
+        description: `E2E tests generated by Qate CLI`,
+        scripts,
+        devDependencies,
+    }, null, 2);
+}
+/**
+ * Generate Qate reporter for sending results back to Qate
+ */
+function generateQateReporter(testMapping, options) {
+    const testMappingJson = JSON.stringify(testMapping, null, 2);
+    const executionId = options.executionId || '';
+    const apiUrl = options.apiUrl || 'https://api.qate.ai';
+    const provider = options.provider || 'local';
+    return `/**
+ * Qate Reporter
+ * Reports test results back to Qate for tracking and analytics
+ *
+ * Generated by Qate CLI
+ */
+
+import type {
+  Reporter,
+  FullConfig,
+  Suite,
+  TestCase,
+  TestResult,
+  FullResult,
+} from '@playwright/test/reporter';
+import type { StepTiming } from './qate-runtime';
+
+// Qate configuration (hardcoded at generation time)
+const EXECUTION_ID = '${executionId}';
+const API_URL = '${apiUrl}';
+const PROVIDER = '${provider}';
+
+// Test ID mapping from Qate
+const TEST_MAPPING: { [filename: string]: { testId: string; testName: string } } = ${testMappingJson};
+
+interface StepNetworkRequest {
+  url: string;
+  method: string;
+  status?: number;
+  contentType?: string;
+  duration?: number;
+  failure?: string;
+}
+
+interface StepResult {
+  stepId?: string;
+  stepIndex: number;
+  description: string;
+  status: 'passed' | 'failed' | 'error' | 'skipped';
+  duration: number;
+  error?: string;
+  performanceData?: {
+    activityStart: string;
+    activityEnd: string;
+    activityDuration: number;
+    activityDurationFormatted: string;
+    settledEnd?: string;
+    settledDuration?: number;
+    settledDurationFormatted?: string;
+  };
+  networkRequests?: StepNetworkRequest[];
+}
+
+interface TestResultData {
+  testId: string;
+  testName: string;
+  status: 'passed' | 'failed' | 'error';
+  duration: number;
+  startedAt: string;
+  steps: StepResult[];
+  error?: string;
+  metadata?: Record<string, unknown>;
+}
+
+class QateReporter implements Reporter {
+  private results: TestResultData[] = [];
+  private startTime: Date = new Date();
+  private config: FullConfig | null = null;
+
+  onBegin(config: FullConfig, suite: Suite) {
+    this.config = config;
+    this.startTime = new Date();
+    console.log('\\n[Qate] Starting test execution...');
+    console.log('[Qate] Execution ID:', EXECUTION_ID || 'not set');
+  }
+
+  onTestEnd(test: TestCase, result: TestResult) {
+    // Find test mapping by filename
+    const filePath = test.location.file;
+    const filename = filePath.split('/').pop()?.split('\\\\').pop() || '';
+    const mapping = TEST_MAPPING[filename];
+
+    if (!mapping) {
+      console.warn('[Qate] No mapping found for test file:', filename);
+      return;
+    }
+
+    // Get step timings from test attachments (cross-process communication from worker)
+    let collectedStepTimings: StepTiming[] = [];
+    const stepTimingsAttachment = result.attachments.find(a => a.name === 'qate-step-timings');
+    if (stepTimingsAttachment?.body) {
+      try {
+        collectedStepTimings = JSON.parse(stepTimingsAttachment.body.toString());
+      } catch (e) {
+        console.warn('[Qate] Failed to parse step timings attachment');
+      }
+    }
+
+    // Helper to format duration
+    const formatDuration = (ms: number): string => {
+      if (ms < 1000) return \`\${Math.round(ms)}ms\`;
+      if (ms < 60000) return \`\${(ms / 1000).toFixed(2)}s\`;
+      const minutes = Math.floor(ms / 60000);
+      const seconds = ((ms % 60000) / 1000).toFixed(1);
+      return \`\${minutes}m \${seconds}s\`;
+    };
+
+    // Build steps from stepTimings (collected via qateRecordStepTiming calls in generated test code)
+    // This is more reliable than result.steps which only contains steps defined via test.step()
+    const steps: StepResult[] = collectedStepTimings
+      .sort((a, b) => a.stepIndex - b.stepIndex)
+      .map((timing) => {
+        const stepResult: StepResult = {
+          stepId: timing.stepId,
+          stepIndex: timing.stepIndex,
+          description: timing.description,
+          status: timing.status,
+          duration: timing.settledDuration,
+          error: timing.error,
+        };
+
+        // Add performance data
+        stepResult.performanceData = {
+          activityStart: new Date(timing.activityStart).toISOString(),
+          activityEnd: new Date(timing.activityEnd).toISOString(),
+          activityDuration: timing.activityDuration,
+          activityDurationFormatted: formatDuration(timing.activityDuration),
+          settledEnd: new Date(timing.settledEnd).toISOString(),
+          settledDuration: timing.settledDuration,
+          settledDurationFormatted: formatDuration(timing.settledDuration),
+        };
+
+        // Add network requests if captured
+        if (timing.networkRequests && timing.networkRequests.length > 0) {
+          stepResult.networkRequests = timing.networkRequests;
+        }
+
+        return stepResult;
+      });
+
+    // Log step count for debugging
+    console.log(\`[Qate] Collected \${steps.length} step results from attachment\`);
+
+    const testResult: TestResultData = {
+      testId: mapping.testId,
+      testName: mapping.testName,
+      status: result.status === 'passed' ? 'passed' : result.status === 'timedOut' ? 'error' : 'failed',
+      duration: result.duration,
+      startedAt: result.startTime.toISOString(),
+      steps,
+      error: result.error?.message,
+      metadata: {
+        retries: result.retry,
+        workerIndex: result.workerIndex,
+        attachments: result.attachments.map(a => ({ name: a.name, contentType: a.contentType })),
+      },
+    };
+
+    this.results.push(testResult);
+
+    const statusIcon = testResult.status === 'passed' ? '✓' : '✗';
+    console.log(\`[Qate] \${statusIcon} \${mapping.testName} (\${testResult.duration}ms)\`);
+  }
+
+  async onEnd(result: FullResult) {
+    const apiKey = process.env.QATE_API_KEY;
+
+    if (!EXECUTION_ID) {
+      console.log('\\n[Qate] No execution ID configured - skipping result reporting');
+      return;
+    }
+
+    if (!apiKey) {
+      console.log('\\n[Qate] QATE_API_KEY not set - skipping result reporting');
+      return;
+    }
+
+    console.log('\\n[Qate] Reporting results to Qate...');
+
+    const payload = {
+      executionId: EXECUTION_ID,
+      status: result.status,
+      results: this.results,
+      summary: {
+        total: this.results.length,
+        passed: this.results.filter(r => r.status === 'passed').length,
+        failed: this.results.filter(r => r.status === 'failed').length,
+        error: this.results.filter(r => r.status === 'error').length,
+        status: result.status,
+      },
+      startedAt: this.startTime.toISOString(),
+      completedAt: new Date().toISOString(),
+      provider: PROVIDER,
+      environment: {
+        browser: this.config?.projects?.[0]?.name || 'unknown',
+        os: process.platform,
+      },
+    };
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 30000); // 30s timeout
+
+      const response = await fetch(\`\${API_URL}/ci/report\`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': apiKey,
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (response.ok) {
+        const data = await response.json();
+        console.log('[Qate] Results reported successfully');
+        console.log(\`[Qate] Summary: \${data.summary?.passed || 0} passed, \${data.summary?.failed || 0} failed\`);
+        console.log(\`[Qate] View results at: https://app.qate.ai/executions/\${EXECUTION_ID}\`);
+      } else {
+        const error = await response.text();
+        console.error('[Qate] Failed to report results:', response.status, error);
+      }
+    } catch (error: any) {
+      if (error.name === 'AbortError') {
+        console.error('[Qate] Request timed out after 30 seconds');
+      } else {
+        console.error('[Qate] Error reporting results:', error.message || error);
+      }
+    }
+
+    // Small delay to ensure HTTP connection is properly closed before Playwright cleanup
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+}
+
+export default QateReporter;
+`;
+}
+/**
+ * Generate qate-runtime.ts helper for placeholder resolution
+ */
+function generateQateRuntime(apiUrl, executionId) {
+    const trackingEnabled = executionId ? 'true' : 'false';
+    return `/**
+ * Qate Runtime Helper
+ * Resolves placeholders at runtime by calling the Qate API
+ *
+ * Generated by Qate CLI
+ */
+
+export interface QateTestContext {
+  testId: string;
+  testName: string;
+  datasetId?: string | null;
+  authRoleId?: string | null;
+  placeholders: string[];
+}
+
+interface PlaceholderResolutionResult {
+  success: boolean;
+  values: Record<string, string>;
+  metadata: {
+    totpTimeRemaining?: number | null;
+  };
+}
+
+// Cache for non-TOTP values (cleared per test)
+let placeholderCache: Record<string, string> = {};
+
+/**
+ * Resolve placeholders by calling the Qate API
+ * Note: TOTP values are always fetched fresh (not cached)
+ */
+export async function qateResolve(context: QateTestContext): Promise<Record<string, string>> {
+  const apiKey = process.env.QATE_API_KEY;
+  const apiUrl = '${apiUrl}';
+
+  if (!apiKey) {
+    console.warn('[Qate Runtime] QATE_API_KEY not set - placeholders will not be resolved');
+    return {};
+  }
+
+  if (context.placeholders.length === 0) {
+    return {};
+  }
+
+  // Clear cache for new test
+  placeholderCache = {};
+
+  try {
+    const response = await fetch(\`\${apiUrl}/ci/resolve-placeholders\`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': apiKey,
+      },
+      body: JSON.stringify({
+        testId: context.testId,
+        datasetId: context.datasetId,
+        authRoleId: context.authRoleId,
+        placeholders: context.placeholders,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      console.error('[Qate Runtime] Failed to resolve placeholders:', response.status, error);
+      return {};
+    }
+
+    const data: PlaceholderResolutionResult = await response.json();
+
+    if (!data.success) {
+      console.warn('[Qate Runtime] Placeholder resolution returned unsuccessful');
+      return {};
+    }
+
+    // Cache non-TOTP values
+    for (const [key, value] of Object.entries(data.values)) {
+      if (key !== 'mfa_code') {
+        placeholderCache[key] = value;
+      }
+    }
+
+    // Log TOTP time remaining if present
+    if (data.metadata?.totpTimeRemaining != null) {
+      console.log(\`[Qate Runtime] TOTP time remaining: \${data.metadata.totpTimeRemaining}s\`);
+    }
+
+    return data.values;
+  } catch (error) {
+    console.error('[Qate Runtime] Error resolving placeholders:', error);
+    return {};
+  }
+}
+
+/**
+ * Replace placeholder patterns in a string with resolved values
+ */
+export function replacePlaceholders(text: string, values: Record<string, string>): string {
+  return text.replace(/\{\{([^}]+)\}\}/g, (match, name) => {
+    if (name in values) {
+      return values[name];
+    }
+    console.warn(\`[Qate Runtime] Unresolved placeholder: \${name}\`);
+    return match; // Return original if not resolved
+  });
+}
+
+// Step timing storage - collected by QateReporter after test completes
+export interface StepTiming {
+  stepId: string;
+  stepIndex: number;
+  description: string;
+  status: 'passed' | 'failed';
+  error?: string;
+  activityStart: number;
+  activityEnd: number;
+  settledEnd: number;
+  activityDuration: number;
+  settledDuration: number;
+  networkRequests?: NetworkRequest[];
+}
+
+// Global storage for step timings (cleared per test)
+export const stepTimings: StepTiming[] = [];
+
+// Network activity capture (only when tracking is enabled)
+export interface NetworkRequest {
+  url: string;
+  method: string;
+  status?: number;
+  contentType?: string;
+  duration?: number;
+  failure?: string;
+}
+
+// Per-step network capture state
+let currentStepNetworkRequests: NetworkRequest[] = [];
+let pendingRequests = new Map<string, { url: string; method: string; requestTime: number }>();
+let networkCaptureEnabled = false;
+const MAX_NETWORK_REQUESTS_PER_STEP = 20;
+
+/**
+ * Set up network capture on a Playwright page
+ * Only captures when QATE_EXECUTION_ID is set (tracking enabled)
+ */
+export function qateSetupNetworkCapture(page: any): void {
+  // Skip if tracking is disabled
+  if (!${trackingEnabled}) {
+    return;
+  }
+  networkCaptureEnabled = true;
+
+  page.on('request', (request: any) => {
+    if (!networkCaptureEnabled) return;
+    if (currentStepNetworkRequests.length >= MAX_NETWORK_REQUESTS_PER_STEP) return;
+
+    const url = request.url();
+    // Skip data URLs, chrome-extension, and static assets
+    if (url.startsWith('data:') || url.startsWith('chrome-extension:') ||
+        url.match(/\\.(png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot|ico|css)$/i)) {
+      return;
+    }
+
+    pendingRequests.set(url, {
+      url: url.length > 500 ? url.substring(0, 500) + '...' : url,
+      method: request.method(),
+      requestTime: Date.now(),
+    });
+  });
+
+  page.on('response', (response: any) => {
+    if (!networkCaptureEnabled) return;
+    const url = response.url();
+    const pending = pendingRequests.get(url);
+    if (pending && currentStepNetworkRequests.length < MAX_NETWORK_REQUESTS_PER_STEP) {
+      currentStepNetworkRequests.push({
+        url: pending.url,
+        method: pending.method,
+        status: response.status(),
+        contentType: response.headers()['content-type']?.split(';')[0],
+        duration: Date.now() - pending.requestTime,
+      });
+      pendingRequests.delete(url);
+    }
+  });
+
+  page.on('requestfailed', (request: any) => {
+    if (!networkCaptureEnabled) return;
+    const url = request.url();
+    const pending = pendingRequests.get(url);
+    if (pending && currentStepNetworkRequests.length < MAX_NETWORK_REQUESTS_PER_STEP) {
+      currentStepNetworkRequests.push({
+        url: pending.url,
+        method: pending.method,
+        failure: request.failure()?.errorText || 'Request failed',
+        duration: Date.now() - pending.requestTime,
+      });
+      pendingRequests.delete(url);
+    }
+  });
+}
+
+/**
+ * Start capturing network for a new step (clears previous step's data)
+ */
+export function qateStartStepNetworkCapture(): void {
+  currentStepNetworkRequests = [];
+  pendingRequests.clear();
+}
+
+/**
+ * Get network requests captured during the current step
+ */
+export function qateGetStepNetworkRequests(): NetworkRequest[] {
+  return [...currentStepNetworkRequests];
+}
+
+/**
+ * Record step timing data for performance measurement
+ * Called by generated test code after each action
+ */
+export function qateRecordStepTiming(
+  stepId: string,
+  stepIndex: number,
+  description: string,
+  status: 'passed' | 'failed',
+  activityStart: number,
+  activityEnd: number,
+  settledEnd: number,
+  error?: string
+): void {
+  const activityDuration = activityEnd - activityStart;
+  const settledDuration = settledEnd - activityStart;
+
+  // Capture network requests for this step (if tracking enabled)
+  const networkReqs = qateGetStepNetworkRequests();
+
+  stepTimings.push({
+    stepId,
+    stepIndex,
+    description,
+    status,
+    error,
+    activityStart,
+    activityEnd,
+    settledEnd,
+    activityDuration,
+    settledDuration,
+    networkRequests: networkReqs.length > 0 ? networkReqs : undefined,
+  });
+}
+
+/**
+ * Get and clear step timings (called by reporter)
+ */
+export function qateGetAndClearStepTimings(): StepTiming[] {
+  const timings = [...stepTimings];
+  stepTimings.length = 0;
+  return timings;
+}
+`;
+}
+/**
+ * Convert user-friendly browser name to Sauce Labs format
+ */
+function toSauceLabsBrowser(browser) {
+    const browserLower = browser.toLowerCase();
+    if (browserLower === 'safari' || browserLower === 'webkit') {
+        return 'webkit';
+    }
+    if (browserLower === 'firefox' || browserLower === 'ff') {
+        return 'firefox';
+    }
+    if (browserLower === 'edge') {
+        return 'chromium'; // Sauce Labs uses chromium for Edge
+    }
+    return 'chromium'; // default
+}
+/**
+ * Convert user-friendly OS to Sauce Labs platform format
+ */
+function toSauceLabsPlatform(os, osVersion) {
+    const osLower = os.toLowerCase();
+    if (osLower === 'macos' || osLower === 'mac' || osLower === 'osx') {
+        return `macOS ${osVersion || '13'}`;
+    }
+    if (osLower === 'windows' || osLower === 'win') {
+        return `Windows ${osVersion || '11'}`;
+    }
+    return `Windows ${osVersion || '11'}`; // default
+}
+/**
+ * Generate Sauce Labs saucectl config.yml
+ */
+function generateSauceConfig(appUrl, options) {
+    const { browser = 'chrome', os = 'windows', osVersion = '11' } = options;
+    const slBrowser = toSauceLabsBrowser(browser);
+    const slPlatform = toSauceLabsPlatform(os, osVersion);
+    const browserDisplayName = browser.charAt(0).toUpperCase() + browser.slice(1).toLowerCase();
+    return `# Sauce Labs Configuration
+# Docs: https://docs.saucelabs.com/web-apps/automated-testing/playwright/yaml/
+apiVersion: v1alpha
+kind: playwright
+defaults:
+  timeout: 30m
+sauce:
+  region: us-west-1
+  concurrency: 5
+  metadata:
+    tags:
+      - qate
+      - e2e
+    build: "\${BUILD_NUMBER:-local}"
+playwright:
+  version: package.json
+rootDir: ./
+suites:
+  - name: "Qate E2E Tests - ${browserDisplayName}"
+    platformName: "${slPlatform}"
+    testMatch: ["tests/*.spec.ts"]
+    params:
+      browserName: "${slBrowser}"
+      baseURL: "${appUrl}"
+artifacts:
+  download:
+    when: always
+    match:
+      - "playwright-report/*"
+      - "test-results/*"
+    directory: ./artifacts
+`;
+}
+/**
+ * Generate BrowserStack browserstack.yml config
+ */
+function generateBrowserStackConfig(options) {
+    const { browser = 'chrome', browserVersion = 'latest', os = 'windows', osVersion = '11' } = options;
+    const bsBrowser = toBrowserStackBrowser(browser);
+    const bsOS = toBrowserStackOS(os);
+    return `# BrowserStack Configuration
+# Docs: https://www.browserstack.com/docs/automate/playwright/getting-started/nodejs
+#
+# Run with: npx browserstack-node-sdk playwright test
+
+userName: \${BROWSERSTACK_USERNAME}
+accessKey: \${BROWSERSTACK_ACCESS_KEY}
+
+platforms:
+  - os: ${bsOS}
+    osVersion: "${osVersion}"
+    browserName: ${bsBrowser}
+    browserVersion: ${browserVersion}
+
+parallelsPerPlatform: 5
+
+browserstackLocal: false
+
+projectName: "Qate Tests"
+buildName: "\${BUILD_NUMBER:-local}"
+buildIdentifier: "#\${BUILD_NUMBER:-1}"
+
+debug: true
+networkLogs: true
+consoleLogs: verbose
+`;
+}
+/**
+ * Generate LambdaTest HyperExecute YAML config
+ */
+function generateHyperExecuteConfig(options) {
+    const { browser = 'chrome', os = 'windows', osVersion = '11' } = options;
+    const ltBrowser = toLambdaTestBrowser(browser);
+    const runson = os.toLowerCase() === 'macos' || os.toLowerCase() === 'mac' ? 'mac' : 'linux';
+    return `# LambdaTest HyperExecute Configuration
+# Docs: https://www.lambdatest.com/support/docs/hyperexecute-guided-walkthrough/
+#
+# Run with: ./hyperexecute --config hyperexecute.yaml
+# Download CLI: https://www.lambdatest.com/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/
+
+version: "0.1"
+globalTimeout: 90
+testSuiteTimeout: 90
+testSuiteStep: 90
+
+runson: ${runson}
+
+autosplit: true
+retryOnFailure: false
+maxRetries: 1
+concurrency: 5
+
+env:
+  PLAYWRIGHT_BROWSERS_PATH: 0
+
+pre:
+  - npm install
+  - npx playwright install ${ltBrowser === 'Chrome' ? 'chromium' : ltBrowser === 'pw-firefox' ? 'firefox' : 'webkit'}
+
+testDiscovery:
+  type: raw
+  mode: dynamic
+  command: grep -rn "test\\|it(" tests/*.spec.ts | cut -d':' -f1 | uniq
+
+testRunnerCommand: npx playwright test $test --reporter=html
+
+jobLabel:
+  - qate
+  - playwright
+  - ${browser}
+
+framework:
+  name: playwright
+  args:
+    browserName: ${ltBrowser}
+    platform: "${os === 'macos' || os === 'mac' ? 'MacOS' : 'Windows'} ${osVersion}"
+`;
+}
+/**
+ * Main generator function
+ */
+function generatePlaywrightTests(exportData, options) {
+    const appUrl = exportData.application?.url || 'http://localhost:3000';
+    const appName = exportData.application?.name || 'app';
+    const tests = exportData.tests || [];
+    const provider = options.provider || 'local';
+    const result = {
+        'playwright.config.ts': generateConfig(options, appUrl),
+        'package.json': generatePackageJson(appName, provider),
+        tests: {},
+    };
+    // Build test mapping for Qate reporter (filename -> testId/testName)
+    const testMapping = {};
+    // Check if any tests have placeholders
+    let anyTestHasPlaceholders = false;
+    // Generate test files
+    for (const test of tests) {
+        const filename = `${toFilename(test.name)}.spec.ts`;
+        result.tests[filename] = generateTestFile(test, appUrl);
+        // Add to test mapping for reporter
+        testMapping[filename] = {
+            testId: test.id?.toString() || '',
+            testName: test.name,
+        };
+        // Check for placeholders in this test
+        if (extractPlaceholders(test).length > 0) {
+            anyTestHasPlaceholders = true;
+        }
+    }
+    // Generate qate-runtime.ts - always needed for step timing functions used by reporter
+    const apiUrl = options.apiUrl || 'https://api.qate.ai';
+    result['qate-runtime.ts'] = generateQateRuntime(apiUrl, options.executionId);
+    // Determine effective orchestration mode
+    const orchestration = options.orchestration || 'websocket';
+    const effectiveOrchestration = provider === 'saucelabs' ? 'cli' : orchestration;
+    // Add provider-specific config files for CLI orchestration
+    if (provider === 'saucelabs') {
+        result['.sauce/config.yml'] = generateSauceConfig(appUrl, options);
+    }
+    else if (provider === 'browserstack' && effectiveOrchestration === 'cli') {
+        result['browserstack.yml'] = generateBrowserStackConfig(options);
+    }
+    else if (provider === 'lambdatest' && effectiveOrchestration === 'cli') {
+        result['hyperexecute.yaml'] = generateHyperExecuteConfig(options);
+    }
+    // Generate Qate reporter for result reporting
+    result['qate-reporter.ts'] = generateQateReporter(testMapping, {
+        executionId: options.executionId,
+        apiUrl,
+        provider: options.provider,
+    });
+    return result;
+}
+/**
+ * Generate a summary of what will be created
+ */
+function generateSummary(exportData) {
+    const testCount = exportData.tests?.length || 0;
+    const stepCount = exportData.tests?.reduce((sum, t) => sum + (t.steps?.length || 0), 0) || 0;
+    const appName = exportData.application?.name || 'Unknown';
+    const appUrl = exportData.application?.url || 'Not specified';
+    const type = exportData.type === 'testsequence' ? 'Test Sequence' : 'Test Set';
+    const name = exportData.testSequence?.name || exportData.testSet?.name || 'Unknown';
+    return `
+Generating Playwright tests from ${type}: "${name}"
+Application: ${appName} (${appUrl})
+Tests: ${testCount}
+Total Steps: ${stepCount}
+`;
+}
+//# sourceMappingURL=PlaywrightGenerator.js.map