@sun-asterisk/sungen 2.5.2 → 2.6.1

package/src/generators/test-generator/adapters/adapter-interface.ts

@@ -21,6 +21,9 @@ export interface TestFileData {
   runtimeData?: boolean; // --runtime-data flag: testData.get() instead of hardcoded values
   screenName?: string; // Screen name for TestDataLoader.load()
   featureFileName?: string; // Feature file name for TestDataLoader.load()
+  isParallel?: boolean; // @parallel tag: fresh page per test (opt-out from serial default)
+  cleanup?: { overlay?: boolean; forms?: boolean; scroll?: boolean; storage?: boolean };
+  backgroundSteps?: Array<{ comment?: string; code: string }>; // Raw background steps for serial beforeAll
   scenarios: string[];
   authGroups?: AuthGroup[]; // Grouped by auth role for nested describes
   singleAuthRole?: string;  // Auth role when all scenarios share the same role
@@ -30,6 +33,8 @@ export interface ScenarioData {
   scenarioName: string;
   steps: Array<{ comment?: string; code: string }>;
   authRole?: string; // Auth role for storage state
+  isParallel?: boolean; // @parallel: use fresh page from fixture
+  tags?: string; // Pass-through tags for Playwright { tag: [...] }, e.g. "'@smoke', '@critical'"
 }
 
 export interface StepTemplateData {
@@ -57,7 +62,7 @@ export interface TestGeneratorAdapter {
   // Template rendering methods
   renderTestFile(data: TestFileData): string;
   renderScenario(data: ScenarioData): string;
-  renderImports(options?: { runtimeData?: boolean }): string;
+  renderImports(options?: { runtimeData?: boolean; basePath?: string; isParallel?: boolean; needsCleanupImport?: boolean }): string;
   renderBeforeEach(data: { steps: Array<{ comment?: string; code: string }> }): string;
   renderBeforeAll(data: { steps: Array<{ comment?: string; code: string }> }): string;
   renderAfterEach(data: { steps: Array<{ comment?: string; code: string }> }): string;

package/src/generators/test-generator/adapters/playwright/playwright-adapter.ts

@@ -26,7 +26,7 @@ export class PlaywrightAdapter implements TestGeneratorAdapter {
     return this.templateEngine.renderScenario(data);
   }
 
-  renderImports(options?: { runtimeData?: boolean }): string {
+  renderImports(options?: { runtimeData?: boolean; basePath?: string; isParallel?: boolean; needsCleanupImport?: boolean }): string {
     return this.templateEngine.renderImports(options);
   }
 

package/src/generators/test-generator/adapters/playwright/templates/imports.hbs

@@ -1,6 +1,7 @@
-import { test, expect } from '../base';
+import { test, expect{{#if needsCleanupImport}}, cleanupPage{{/if}} } from '{{basePath}}/base';
+import { type Page, type BrowserContext } from '@playwright/test';
 {{#if runtimeData}}
-import { TestDataLoader } from '../test-data';
+import { TestDataLoader } from '{{basePath}}/test-data';
 {{/if}}
 
 // This file is auto-generated from Gherkin feature files

package/src/generators/test-generator/adapters/playwright/templates/scenario.hbs

@@ -1,8 +1,27 @@
+{{#if isParallel}}
+{{#if tags}}
+  test('{{scenarioName}}', { tag: [{{{tags}}}] }, async ({ page }) => {
+{{else}}
   test('{{scenarioName}}', async ({ page }) => {
+{{/if}}
+{{#each steps}}
+{{#if comment}}
+    // {{comment}}
+{{/if}}
+{{code}}
+{{/each}}
+  });
+{{else}}
+{{#if tags}}
+  test('{{scenarioName}}', { tag: [{{{tags}}}] }, async () => {
+{{else}}
+  test('{{scenarioName}}', async () => {
+{{/if}}
 {{#each steps}}
 {{#if comment}}
     // {{comment}}
 {{/if}}
 {{code}}
 {{/each}}
-  });
+  });
+{{/if}}

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/alert-accept-action.hbs

@@ -1 +1 @@
-page.once('dialog', dialog => dialog.accept());
+page.on('dialog', dialog => dialog.accept());

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/alert-dismiss-action.hbs

@@ -1 +1 @@
-page.once('dialog', dialog => dialog.dismiss());
+page.on('dialog', dialog => dialog.dismiss());

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/alert-fill-action.hbs

@@ -1 +1 @@
-page.once('dialog', dialog => dialog.accept('{{escapeQuotes fillValue}}'));
+page.on('dialog', dialog => dialog.accept('{{escapeQuotes fillValue}}'));

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/alert-text-assertion.hbs

@@ -1,8 +1,8 @@
 const dialogPromise{{stepCounter}} = new Promise<string>(resolve => {
-  page.once('dialog', dialog => {
+  page.on('dialog', dialog => {
     resolve(dialog.message());
     dialog.accept();
   });
 });
 // Trigger the dialog action, then:
-// expect(await dialogPromise{{stepCounter}}).toContain('{{escapeQuotes dataValue}}');
+// expect(await dialogPromise{{stepCounter}}).toContain('{{escapeQuotes dataValue}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/column-cell-assertion.hbs

@@ -1,2 +1,3 @@
+await expect({{> locator}}.getByRole('columnheader', { name: '{{columnName}}' })).toBeVisible();
 const {{columnIndexVar}} = (await page.getByRole('columnheader').allTextContents()).findIndex(h => h.includes('{{columnName}}'));
 await expect(page.getByRole('row').nth({{rowNth}}).getByRole('cell').nth({{columnIndexVar}})).toHaveText('{{dataValue}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/navigation/navigation.hbs

@@ -1 +1,2 @@
-await page.goto('{{#if baseURL}}{{baseURL}}{{/if}}{{path}}', { waitUntil: 'load' });
+await page.goto('{{#if baseURL}}{{baseURL}}{{/if}}{{path}}', { waitUntil: 'load' });
+await page.waitForLoadState('domcontentloaded');

package/src/generators/test-generator/adapters/playwright/templates/steps/navigation/route-assertion.hbs

@@ -1,2 +1 @@
-await page.waitForURL('**{{path}}', { timeout: 5000 });
-expect(page.url()).toContain('{{path}}');
+await expect(page).toHaveURL(/{{escapeRegex path}}/);

package/src/generators/test-generator/adapters/playwright/templates/steps/navigation/wait-timeout.hbs

@@ -1 +1 @@
-await page.waitForTimeout({{duration}});
+await page.waitForLoadState('networkidle');

package/src/generators/test-generator/adapters/playwright/templates/test-file.hbs

@@ -11,14 +11,11 @@ const testData = TestDataLoader.load('{{screenName}}', '{{featureFileName}}');
  */
 {{/if}}
 
+{{#if isParallel}}
 test.describe('{{featureName}}', () => {
 {{#if singleAuthRole}}
   test.use({ storageState: 'specs/.auth/{{singleAuthRole}}.json' });
 
-{{/if}}
-{{#if cleanupConfig}}
-  test.use({ autoCleanup: { {{cleanupConfig}} } });
-
 {{/if}}
 {{#if screenshotOnFailure}}
   test.use({ screenshotOnFailure: true });
@@ -66,3 +63,86 @@ test.describe('{{featureName}}', () => {
 {{/each}}
 {{/if}}
 });
+{{else}}
+test.describe.serial('{{featureName}}', () => {
+  let page: Page;
+  let context: BrowserContext;
+
+{{#if singleAuthRole}}
+  test.beforeAll(async ({ browser }) => {
+    context = await browser.newContext({ storageState: 'specs/.auth/{{singleAuthRole}}.json' });
+    page = await context.newPage();
+{{#each backgroundSteps}}
+{{#if comment}}
+    // {{comment}}
+{{/if}}
+{{code}}
+{{/each}}
+  });
+{{else}}
+  test.beforeAll(async ({ browser }) => {
+    context = await browser.newContext();
+    page = await context.newPage();
+{{#each backgroundSteps}}
+{{#if comment}}
+    // {{comment}}
+{{/if}}
+{{code}}
+{{/each}}
+  });
+{{/if}}
+
+  test.afterAll(async () => {
+    await page.close();
+    await context.close();
+  });
+
+{{#if cleanup}}
+  test.afterEach(async () => {
+    await cleanupPage(page, { {{cleanupConfig}} });
+  });
+
+{{/if}}
+{{#if screenshotOnFailure}}
+  test.use({ screenshotOnFailure: true });
+
+{{/if}}
+{{#if beforeAll}}
+{{beforeAll}}
+
+{{/if}}
+{{#if afterEach}}
+{{afterEach}}
+
+{{/if}}
+{{#if afterAll}}
+{{afterAll}}
+
+{{/if}}
+{{#if authGroups}}
+{{#each authGroups}}
+{{#if authRole}}
+  test.describe('{{authRole}}', () => {
+    test.use({ storageState: 'specs/.auth/{{authRole}}.json' });
+
+{{#each scenarios}}
+{{indent this 2}}
+
+{{/each}}
+  });
+
+{{else}}
+{{#each scenarios}}
+{{this}}
+
+{{/each}}
+{{/if}}
+{{/each}}
+{{else}}
+{{#each scenarios}}
+{{this}}
+
+{{/each}}
+{{/if}}
+});
+{{/if}}

package/src/generators/test-generator/code-generator.ts

@@ -48,6 +48,44 @@ function extractCleanupConfig(tags: string[]): string | undefined {
   return entries.map(key => `${key}: true`).join(', ');
 }
 
+/**
+ * Extract @cleanup:* tags into structured flags for serial mode afterEach
+ */
+function extractCleanupFlags(tags: string[]): { overlay?: boolean; forms?: boolean; scroll?: boolean; storage?: boolean } | undefined {
+  const validKeys = ['overlay', 'forms', 'scroll', 'storage'] as const;
+  const flags: Record<string, boolean> = {};
+  let found = false;
+  for (const tag of tags) {
+    if (!tag.startsWith('@cleanup:')) continue;
+    const key = tag.replace('@cleanup:', '');
+    if (validKeys.includes(key as any)) {
+      flags[key] = true;
+      found = true;
+    }
+  }
+  return found ? flags : undefined;
+}
+
+/**
+ * Extract pass-through tags (non-functional) for Playwright { tag: [...] }.
+ * Any tag not recognized by sungen as functional → pass through.
+ */
+const FUNCTIONAL_TAG_PREFIXES = [
+  '@parallel', '@cleanup:', '@auth:', '@manual', '@no-auth',
+  '@steps:', '@extend:', '@screenshot:', '@beforeAll', '@afterEach', '@afterAll',
+  '@flow',
+];
+
+function extractPassThroughTags(scenarioTags: string[], featureTags: string[]): string | undefined {
+  const allTags = [...featureTags, ...scenarioTags];
+  const passThrough = allTags.filter(tag =>
+    !FUNCTIONAL_TAG_PREFIXES.some(prefix => tag.startsWith(prefix))
+  );
+  const unique = [...new Set(passThrough)];
+  if (unique.length === 0) return undefined;
+  return unique.map(t => `'${t}'`).join(', ');
+}
+
 /**
  * Check for @screenshot:on-failure tag
  */
@@ -134,7 +172,7 @@ export class CodeGenerator {
   // Steps registry built per feature during generateTestCode(); used by countSteps()
   private stepsRegistry = new Map<string, ParsedScenario>();
 
-  constructor(options: { useAI?: boolean; verbose?: boolean; framework?: string; baseURL?: string; screenName?: string; runtimeData?: boolean } = {}) {
+  constructor(options: { useAI?: boolean; verbose?: boolean; framework?: string; baseURL?: string; screenName?: string; runtimeData?: boolean; flowMode?: boolean } = {}) {
     this.options = options;
     this.screenName = options.screenName;
     this.stepMapper = new StepMapper(options);
@@ -165,25 +203,37 @@ export class CodeGenerator {
       fileName = this.featureNameToFileName(feature.name);
     }
     
-    // Extract screen name from source file path if available
+    // Extract screen/flow name from source file path for output subdirectory
     // qa/screens/{screenName}/features/{featureName}.feature -> screenName
-    let screenSubdir = '';
+    // qa/flows/{flowName}/features/{featureName}.feature -> flows/flowName
+    let outputSubdir = '';
     if (feature.sourceFile) {
       const sourceDir = path.dirname(feature.sourceFile);
       const parts = sourceDir.split(path.sep);
+      const flowsIndex = parts.indexOf('flows');
       const screensIndex = parts.indexOf('screens');
-      if (screensIndex >= 0 && screensIndex < parts.length - 2) {
-        screenSubdir = parts[screensIndex + 1]; // screen name after 'screens'
+      if (flowsIndex >= 0 && flowsIndex < parts.length - 2) {
+        outputSubdir = path.join('flows', parts[flowsIndex + 1]);
+      } else if (screensIndex >= 0 && screensIndex < parts.length - 2) {
+        outputSubdir = parts[screensIndex + 1];
       }
     }
-    
-    // Build output path with screen subdirectory
-    const filePath = screenSubdir 
-      ? path.join(outputDir, screenSubdir, fileName)
+
+    // Build output path with subdirectory
+    const filePath = outputSubdir
+      ? path.join(outputDir, outputSubdir, fileName)
       : path.join(outputDir, fileName);
 
-    // Generate imports using adapter
-    const imports = this.adapter.renderImports({ runtimeData: this.options.runtimeData });
+    // Compute relative path from output file back to specs/generated/
+    const depth = outputSubdir ? outputSubdir.split(path.sep).length : 0;
+    const basePath = depth > 0 ? Array(depth).fill('..').join('/') : '..';
+
+    // Serial + @cleanup tags → need cleanupPage import from base
+    const isParallelFeature = (feature.tags || []).includes('@parallel');
+    const hasCleanupTags = (feature.tags || []).some(t => t.startsWith('@cleanup:'));
+    const needsCleanupImport = !isParallelFeature && hasCleanupTags;
+
+    const imports = this.adapter.renderImports({ runtimeData: this.options.runtimeData, basePath, needsCleanupImport });
 
     // Generate test code (async now to support AI mapping)
     const testCode = await this.generateTestCode(feature);
@@ -278,19 +328,29 @@ export class CodeGenerator {
       featureName = this.featureNameToFileName(feature.name).replace('.spec.ts', '');
     }
     
-    // Derive screen name from source file path when not explicitly set
+    // Derive screen/flow name from source file path when not explicitly set
     // qa/screens/{screenName}/features/{featureName}.feature -> screenName
+    // qa/flows/{flowName}/features/{featureName}.feature -> flowName
     let effectiveScreenName = this.screenName;
+    let isFlowFeature = !!this.options.flowMode;
     if (!this.screenName && feature.sourceFile) {
       const sourceDir = path.dirname(feature.sourceFile);
       const parts = sourceDir.split(path.sep);
+      const flowsIndex = parts.indexOf('flows');
       const screensIndex = parts.indexOf('screens');
-      if (screensIndex >= 0 && screensIndex < parts.length - 2) {
+      if (flowsIndex >= 0 && flowsIndex < parts.length - 2) {
+        effectiveScreenName = parts[flowsIndex + 1];
+        isFlowFeature = true;
+      } else if (screensIndex >= 0 && screensIndex < parts.length - 2) {
         effectiveScreenName = parts[screensIndex + 1];
-        this.stepMapper.setScreenContext(effectiveScreenName);
+        isFlowFeature = false;
       }
+      this.stepMapper.setScreenContext(effectiveScreenName);
     }
 
+    // Reset flow mode per feature to prevent state leak in --all mode
+    this.stepMapper.setFlowMode(isFlowFeature);
+
     // Set feature context for data resolution and navigation
     this.stepMapper.setFeatureContext(featureName, feature.path);
     
@@ -322,10 +382,18 @@ export class CodeGenerator {
       }
     }
 
+    // Detect @parallel opt-out (default is serial)
+    const isParallel = (feature.tags || []).includes('@parallel');
+
     // Generate background if exists
     let background: string | undefined;
+    let backgroundSteps: Array<{ comment?: string; code: string }> | undefined;
     if (feature.background) {
-      background = await this.generateBeforeEach(feature.background);
+      if (isParallel) {
+        background = await this.generateBeforeEach(feature.background);
+      } else {
+        backgroundSteps = await this.generateBackgroundSteps(feature.background);
+      }
     }
 
     // Generate hook blocks
@@ -369,7 +437,8 @@ export class CodeGenerator {
       const code = await this.generateScenario(
         scenario,
         !!feature.background,
-        feature.tags || []
+        feature.tags || [],
+        isParallel
       );
       renderedScenarios.push({ code, authRole });
     }
@@ -396,6 +465,14 @@ export class CodeGenerator {
     // - Single group: flat structure (test.use at describe level if auth)
     // - Multiple groups: nested describes per auth role
     const needsGrouping = authGroups.length > 1;
+
+    if (needsGrouping && !isParallel) {
+      throw new Error(
+        `Feature "${feature.name}" has multiple auth groups but no @parallel tag.\n` +
+        `Serial mode uses a shared browser context — it cannot mix different auth roles.\n` +
+        `Fix: add @parallel tag to the feature.`
+      );
+    }
     const scenarios = renderedScenarios.map(s => s.code);
 
     // For single group, extract the auth role to put test.use at describe level
@@ -405,6 +482,7 @@ export class CodeGenerator {
 
     // Extract @cleanup:* tags for autoCleanup fixture config
     const cleanupConfig = extractCleanupConfig(feature.tags || []);
+    const cleanup = extractCleanupFlags(feature.tags || []);
     const screenshotOnFailure = hasScreenshotOnFailure(feature.tags || []);
 
     // Use adapter to render the complete test file structure
@@ -419,14 +497,29 @@ export class CodeGenerator {
       cleanupConfig,
       screenshotOnFailure,
       runtimeData: this.options.runtimeData,
-      screenName: effectiveScreenName,
+      screenName: isFlowFeature ? `flows/${effectiveScreenName}` : effectiveScreenName,
       featureFileName: featureName,
+      isParallel,
+      cleanup,
+      backgroundSteps,
       scenarios: needsGrouping ? [] : scenarios,
       authGroups: needsGrouping ? authGroups : undefined,
       singleAuthRole,
     });
   }
 
+  private async generateBackgroundSteps(background: ParsedScenario): Promise<Array<{ comment?: string; code: string }>> {
+    const steps: Array<{ comment?: string; code: string }> = [];
+    for (const step of background.steps) {
+      const mapped = await Promise.resolve(this.stepMapper.mapStep(step));
+      steps.push({
+        comment: mapped.comment,
+        code: this.indentCode(mapped.code, 4),
+      });
+    }
+    return steps;
+  }
+
   private async generateBeforeEach(background: ParsedScenario): Promise<string> {
     // Map all steps
     const steps: Array<{ comment?: string; code: string }> = [];
@@ -466,9 +559,10 @@ export class CodeGenerator {
   }
 
   private async generateScenario(
-    scenario: ParsedScenario, 
+    scenario: ParsedScenario,
     hasBackground: boolean,
-    featureTags: string[] = []
+    featureTags: string[] = [],
+    isParallel: boolean = false
   ): Promise<string> {
     // Resolve base steps and tags for @extend scenarios
     let stepsToMap = scenario.steps;
@@ -527,11 +621,16 @@ export class CodeGenerator {
       }
     }
 
+    // Extract pass-through tags (feature + scenario, excluding functional tags)
+    const tags = extractPassThroughTags(scenario.tags, featureTags);
+
     // Use adapter to render scenario
     return this.adapter.renderScenario({
       scenarioName: scenario.name,
       steps,
-      authRole
+      authRole,
+      isParallel,
+      tags,
     });
   }
 

package/src/generators/test-generator/patterns/interaction-patterns.ts

@@ -296,12 +296,34 @@ export const interactionPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       (step.text.includes('wait for') || step.text.includes('waits for')) && step.elementType === 'page',
     resolver: (step, context) => {
-      const path = step.featurePath || '/';
-      const pathRegex = path.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+      let path = step.featurePath || '/';
+
+      if (step.selectorRef) {
+        try {
+          const resolved = context.selectorResolver.resolveSelector(
+            step.selectorRef, context.featureName, step.elementType, step.nth
+          );
+          path = resolved.value || path;
+        } catch (error) {
+          // fallback to featurePath
+        }
+      }
+
+      const isAbsoluteUrl = /^https?:\/\//.test(path);
+      let pathRegex: string;
+      if (isAbsoluteUrl) {
+        const url = new URL(path);
+        const hostEscaped = url.hostname.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+        const pathEscaped = url.pathname !== '/' ? url.pathname.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&') : '';
+        pathRegex = hostEscaped + pathEscaped;
+      } else {
+        pathRegex = path.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+      }
+
       return {
         templateName: 'wait-for-page',
         data: { pathRegex },
-        comment: `Wait for page`,
+        comment: step.selectorRef ? `Wait for ${step.selectorRef} page` : `Wait for page`,
       };
     },
     priority: 9,

package/src/generators/test-generator/patterns/navigation-patterns.ts

@@ -26,10 +26,11 @@ export const navigationPatterns: StepPattern[] = [
       }
 
       const finalPath = resolvePathVariables(path, context.scenarioSteps || []);
+      const isAbsoluteUrl = /^https?:\/\//.test(finalPath);
 
       return {
         templateName: 'navigation',
-        data: { baseURL: context.baseURL, path: finalPath },
+        data: { baseURL: isAbsoluteUrl ? undefined : context.baseURL, path: finalPath },
         comment: step.selectorRef ? `Open ${step.selectorRef} page` : `Navigate to page`,
       };
     },
@@ -52,10 +53,12 @@ export const navigationPatterns: StepPattern[] = [
       });
       const resolvedPath = resolvePathVariables(inferredPath, context.scenarioSteps || []);
       const pathCode = getPathCode(resolvedPath);
+      const cleanPath = pathCode.replace(/^['`]|['`]$/g, '');
+      const isAbsoluteUrl = /^https?:\/\//.test(cleanPath);
 
       return {
         templateName: 'navigation',
-        data: { baseURL: context.baseURL, path: pathCode.replace(/^['`]|['`]$/g, '') },
+        data: { baseURL: isAbsoluteUrl ? undefined : context.baseURL, path: cleanPath },
         comment: `Open ${pageName}`,
       };
     },
@@ -75,10 +78,12 @@ export const navigationPatterns: StepPattern[] = [
       });
       const resolvedPath = resolvePathVariables(inferredPath, context.scenarioSteps || []);
       const pathCode = getPathCode(resolvedPath);
+      const cleanPath = pathCode.replace(/^['`]|['`]$/g, '');
+      const isAbsoluteUrl = /^https?:\/\//.test(cleanPath);
 
       return {
         templateName: 'navigation',
-        data: { baseURL: context.baseURL, path: pathCode.replace(/^['`]|['`]$/g, '') },
+        data: { baseURL: isAbsoluteUrl ? undefined : context.baseURL, path: cleanPath },
         comment: `Navigate to ${route}`,
       };
     },

package/src/generators/test-generator/step-mapper.ts

@@ -71,6 +71,14 @@ export class StepMapper {
     this.dataResolver.setScreenContext(screenName);
   }
 
+  /**
+   * Enable flow mode — colon in selector refs is a namespace separator, not cross-screen
+   */
+  setFlowMode(enabled: boolean): void {
+    this.selectorResolver.setFlowMode(enabled);
+    this.dataResolver.setFlowMode(enabled);
+  }
+
   /**
    * Set scenario context for path variable resolution
    */

package/src/generators/test-generator/template-engine.ts

@@ -229,8 +229,8 @@ export class TemplateEngine {
     this.baseContext = {};
   }
 
-  renderImports(options?: { runtimeData?: boolean }): string {
-    return this.render('imports', { runtimeData: options?.runtimeData });
+  renderImports(options?: { runtimeData?: boolean; basePath?: string; isParallel?: boolean; needsCleanupImport?: boolean }): string {
+    return this.render('imports', { runtimeData: options?.runtimeData, basePath: options?.basePath || '..', isParallel: options?.isParallel, needsCleanupImport: options?.needsCleanupImport });
   }
 
   renderTestFile(data: {
@@ -246,6 +246,9 @@ export class TemplateEngine {
     runtimeData?: boolean;
     screenName?: string;
     featureFileName?: string;
+    isParallel?: boolean;
+    cleanup?: { overlay?: boolean; forms?: boolean; scroll?: boolean; storage?: boolean };
+    backgroundSteps?: Array<{ comment?: string; code: string }>;
     scenarios: string[];
     authGroups?: Array<{ authRole?: string; scenarios: string[] }>;
     singleAuthRole?: string;