@sun-asterisk/sungen 3.2.24 → 3.2.25

package/dist/generators/test-generator/adapters/appium/templates/steps/actions/date-picker-unsupported.hbs

@@ -0,0 +1,4 @@
+{{!-- A date-picker on native mobile is a DIALOG (spinner/calendar), not a text field: the generic
+      fill would click the trigger and setValue into it, selecting nothing while reporting success.
+      Same treatment as the upload step — fail loud, and name both ways forward. --}}
+throw new Error("[sungen] {{escapeQuotes reason}}");

package/dist/generators/test-generator/adapters/appium/templates/steps/actions/lifecycle-missing-app-id.hbs

@@ -0,0 +1,5 @@
+{{!-- A lifecycle step (restart / reinstall) in a feature with no `Path:` app id. The lifecycle
+      templates resolve the app through a helper the test-file emits only when that id is present,
+      so without it the spec used to compile clean and die at runtime with a ReferenceError —
+      taking the whole spec down, not the step. Fail at the step, naming the missing line. --}}
+throw new Error("[sungen] {{escapeQuotes reason}}");

package/dist/generators/test-generator/adapters/appium/templates/steps/assertions/matches-format-assertion.hbs

@@ -0,0 +1,15 @@
+{{!-- Format assertion (mobile): same multi-source read as have-text/contain-text
+      (@text / @content-desc on Android, label/value on iOS), matched against the shape the spec
+      states. The error quotes the FORMAT and the actual string — the compiled regex is noise to
+      the person who wrote the requirement. --}}
+{
+  const __el = await {{> locator}};
+  await __el.waitForDisplayed();
+  const __sources = driver.isIOS
+    ? [await __el.getAttribute('label'), await __el.getAttribute('value')]
+    : [await __el.getText(), await __el.getAttribute('content-desc')];
+  const __actual = String(__sources.find(s => s && String(s).trim() !== '') ?? '').trim();
+  if (!{{{formatRegex}}}.test(__actual)) {
+    throw new Error(`[sungen] Expected [{{escapeQuotes selectorRef}}] to match the format "{{escapeQuotes format}}" but it reads "${__actual}"`);
+  }
+}

package/dist/generators/test-generator/adapters/appium/templates/steps/assertions/visible-filtered-assertion.hbs

@@ -1,9 +1,12 @@
 {{!-- Filtered visible (mobile): $$ over the base selector, per-OS text read matched against
       dataValue — no CSS filter() combinator exists on Appium, so the match is hand-rolled
       (covers both the locator- and role-strategy call sites, since both resolve through
-      appium-selector-expr). Assert at least one match is displayed. --}}
+      appium-selector-expr). Assert at least one match is displayed. Substring match by
+      default, matching the web hasText string contract: case-insensitive with collapsed
+      whitespace; `exact` opts into full case-sensitive equality (the anchored-regex twin). --}}
 {
   const __expected = String('{{escapeQuotes dataValue}}').trim();
+  const __norm = (s: string) => s.replace(/\s+/g, ' ').trim().toLowerCase();
   const __items = await $$({{> appium-selector-expr}});
   let __found = false;
   for (const __el of __items) {
@@ -11,7 +14,7 @@
       ? [await __el.getAttribute('label'), await __el.getAttribute('value')]
       : [await __el.getText(), await __el.getAttribute('content-desc')];
     const __actual = String(__sources.find(s => s && String(s).trim() !== '') ?? '').trim();
-    if (__actual === __expected && await __el.isDisplayed()) { __found = true; break; }
+    if ({{#if exact}}__actual === __expected{{else}}__norm(__actual).includes(__norm(__expected)){{/if}} && await __el.isDisplayed()) { __found = true; break; }
   }
   if (!__found) throw new Error(`[sungen] Expected a visible match with text "${__expected}"`);
 }

package/dist/generators/test-generator/adapters/appium/templates/test-file.hbs

@@ -366,31 +366,117 @@ describe('{{featureName}}', () => {
     }
     return __APP_PKG_DEFAULT__;
   }
-  beforeEach(async () => {
-    const __APP_PKG__ = __resolveAppId();
-    try { await driver.terminateApp(__APP_PKG__); } catch { /* app may not be running yet */ }
-    // Let the termination fully land before relaunching — activateApp racing a still-dying
-    // process can RESUME the old instance (prior scenario's scroll position and all) instead
-    // of cold-starting, which strands top-of-screen elements above the viewport.
-    await driver.pause(500);
-    await driver.activateApp(__APP_PKG__);
-    // Restore the NATIVE context — a prior scenario that entered a WebView (`switch to [X] frame`)
-    // without switching back would otherwise poison every following native find.
-    try { await driver.switchContext('NATIVE_APP'); } catch { /* single-context session */ }
-    // Restore portrait so a prior scenario's `rotate to landscape` can't leak into this one — the
-    // app relaunch above resets in-app state, but device orientation is OS-level and persists.
-    try { await driver.setOrientation('PORTRAIT'); } catch { /* orientation control not supported */ }
-    // Settle after a cold (re)launch: a Flutter app first renders a BLANK accessibility skeleton
-    // (nested FrameLayout/View, no content-desc) for several seconds before the real tree appears.
-    // So require rendered content — at least one non-empty content-desc/text — on two consecutive
-    // reads before proceeding. A generous timeout covers slow cold renders on a stressed emulator.
-    // Best-effort: a timeout never fails the scenario, it just falls through to the step's own
-    // auto-wait.
-    // "Settled" = rendered content present on TWO consecutive reads. Deliberately NOT full source
-    // equality: a UI with any looping animation (a rotating promo carousel is enough) never yields
-    // two identical snapshots, so an equality oracle starves and burns the whole timeout on every
-    // scenario. Two content-bearing reads still reject the blank first-frame skeleton (no
-    // content-desc/text at all) that a single read could false-positive on.
+  // ── Reset tier ────────────────────────────────────────────────────────────────────────────────
+  // How much state each scenario starts from (`@reset:` on the Feature; default `soft`):
+  //   none — nothing reset; state carries over BY DESIGN (a cart accumulating across scenarios)
+  //   soft — terminate + activate: in-memory state and the nav stack
+  //   data — soft + wipe the app's data layer (local DB, cache, prefs, keychain)
+  //   full — remove + reinstall: also permissions and install-time state
+  // Unlike web, no cheap "reload the URL" exists here, and a cold start is 5–30s — hence a ladder
+  // rather than one all-or-nothing switch.
+  const __DECLARED_TIER = '{{resetTier}}';
+  const __TIER_ORDER = ['none', 'soft', 'data', 'full'];
+  // SUNGEN_RESET_TIER RAISES the floor for a whole run — CI at `data`, local dev at `soft` — without
+  // regenerating a single spec (same runtime-resolution model as the test-data overlays). It never
+  // LOWERS a declared tier: a feature that asked for `full` needs it. Resolved once, so an
+  // unrecognized value warns once rather than per scenario — a silently ignored typo here would
+  // reintroduce exactly the false-confidence this tier system exists to remove.
+  const __RUN_TIER: string = (() => {
+    // Defensive only — the compiler validates the tag — but fall back to `soft`, NOT to index 0
+    // (`none`). A safety net that silently drops to "reset nothing" points the wrong way.
+    const declaredIdx = __TIER_ORDER.indexOf(__DECLARED_TIER);
+    const declared = declaredIdx < 0 ? __TIER_ORDER.indexOf('soft') : declaredIdx;
+    const raw = (process.env.SUNGEN_RESET_TIER || '').trim().toLowerCase();
+    if (!raw) return __TIER_ORDER[declared];
+    const floor = __TIER_ORDER.indexOf(raw);
+    if (floor < 0) {
+      console.warn(`  ! SUNGEN_RESET_TIER='${raw}' is not a tier (${__TIER_ORDER.join(', ')}) — ignored`);
+      return __TIER_ORDER[declared];
+    }
+    return __TIER_ORDER[Math.max(declared, floor)];
+  })();
+
+  // A scenario that FAILED left unknown state behind — a half-written local DB, an open modal — that a
+  // plain process relaunch does not undo. So the NEXT scenario resets one rung harder than it asked
+  // for: this is the "A fails mid-flow, B fails for A's reasons" case that no amount of relaunching
+  // fixes. One rung, one scenario, never sticky — otherwise a single flake would silently promote the
+  // whole run to `full` and put 30s on every remaining scenario.
+  // `none` is a FIXED POINT by design: it is an explicit state-carryover contract (a cart built up
+  // across scenarios), and escalating would silently break the very thing it was asked for. The chain
+  // is dead once one link fails anyway, so a relaunch would change only how the rest fail.
+  // Mirrors escalateResetTier() in the compiler; a test asserts the two ladders agree.
+  const __ESCALATE: Record<string, string> = { none: 'none', soft: 'data', data: 'full', full: 'full' };
+  // Holds the TITLE of the scenario that failed, not a boolean — because escalation must reach the next
+  // DIFFERENT scenario and must NOT reach a RETRY of the failed one.
+  //
+  // `mochaOpts.retries` re-runs a failed scenario, and the retry is also "the next run". Escalating it
+  // would make attempt 2 reset harder than attempt 1, which breaks the guarantee this config is built
+  // on: race victims recover on attempt 2 while REAL failures fail both attempts. A dirty-state failure
+  // is a real failure — if the retry silently got a wiped data layer it would pass, the reporter takes
+  // the last attempt, and a scenario that only works after a wipe would be delivered as a clean
+  // `Passed` under a feature file still reading its weaker declared tier. That false pass is worse than
+  // the flakiness escalation was added to fix, so the retry keeps attempt 1's tier and fails honestly.
+  //
+  // Comparing titles rather than reading mocha's retry counter keeps this independent of the runner's
+  // API, and it fails in the SAFE direction: if a title is unavailable both sides compare equal, so no
+  // escalation happens and the invariant above still holds. (Two scenarios sharing one title in a file
+  // lose the escalation between them — SG-W024 already reports that shape when tiers are involved.)
+  let __escalateAfter: string | null = null;
+
+  // Registered BEFORE any user @afterEach block so a throwing user hook cannot skip the bookkeeping.
+  afterEach(async function () {
+    __escalateAfter = this.currentTest?.state === 'failed' ? (this.currentTest?.title ?? '') : null;
+  });
+
+{{#if scenarioResetTiers}}
+  // Per-scenario `@reset:` overrides, keyed on the scenario's BASE name. Not on the rendered title:
+  // a @cases scenario builds its title at runtime (`name + ' — ' + row.__label`) and appium appends
+  // pass-through tags as a `[…]` suffix, so no compile-time key could match what mocha reports.
+  // __tierFor therefore strips those two suffixes back off — and MEMBERSHIP-TESTS at every step, so a
+  // name it cannot resolve returns 'none' (inherit the feature tier) instead of guessing a wrong one.
+  // Silently applying the wrong tier is the failure this whole feature exists to remove.
+  const __SCENARIO_TIERS: Record<string, string> = {
+{{#each scenarioResetTiers}}
+    '{{escapeQuotes name}}': '{{tier}}',
+{{/each}}
+  };
+  // Only a @cases scenario builds its it() title at RUNTIME (`name + ' \u2014 ' + row.__label`), so only
+  // these names may shed a trailing ` \u2014 <label>` during lookup. Stripping that from EVERY title let a
+  // scenario merely NAMED `<something> \u2014 <something>` resolve to a different scenario's tier.
+  const __CASES_NAMES = new Set<string>([{{#each scenarioResetTiers}}{{#if cases}}'{{escapeQuotes name}}', {{/if}}{{/each}}]);
+  function __tierFor(title: string): string {
+    if (Object.prototype.hasOwnProperty.call(__SCENARIO_TIERS, title)) return __SCENARIO_TIERS[title];
+    // `\[@` — must be a TAG group, not a trailing selector ref. Without the `@`, a scenario named
+    // `VP-001 tap [Save]` would reduce to `VP-001 tap` and could pick up a DIFFERENT scenario's tier.
+    const noTags = title.replace(/ \[@[^\]]*\]$/, '');
+    if (Object.prototype.hasOwnProperty.call(__SCENARIO_TIERS, noTags)) return __SCENARIO_TIERS[noTags];
+    // Shed row-label segments from the RIGHT, one at a time, accepting only a @cases name. Right-to-left
+    // and iterative so an em dash inside the scenario NAME or inside the row LABEL still resolves; every
+    // step is membership-tested against __CASES_NAMES, so this narrows toward a declared name and never
+    // guesses at one.
+    let base = noTags;
+    for (let i = base.lastIndexOf(' \u2014 '); i >= 0; i = base.lastIndexOf(' \u2014 ')) {
+      base = base.slice(0, i);
+      if (__CASES_NAMES.has(base)) return __SCENARIO_TIERS[base];
+    }
+    // Unresolvable ⟹ inherit the feature tier. Never a guess: a wrong tier applied silently is the
+    // failure this whole lookup exists to avoid.
+    return 'none';
+  }
+{{/if}}
+
+  // Settle after a cold (re)launch: a Flutter app first renders a BLANK accessibility skeleton
+  // (nested FrameLayout/View, no content-desc) for several seconds before the real tree appears.
+  // So require rendered content — at least one non-empty content-desc/text — on two consecutive
+  // reads before proceeding. A generous timeout covers slow cold renders on a stressed emulator.
+  // Best-effort: a timeout never fails the scenario, it just falls through to the step's own
+  // auto-wait.
+  // "Settled" = rendered content present on TWO consecutive reads. Deliberately NOT full source
+  // equality: a UI with any looping animation (a rotating promo carousel is enough) never yields
+  // two identical snapshots, so an equality oracle starves and burns the whole timeout on every
+  // scenario. Two content-bearing reads still reject the blank first-frame skeleton (no
+  // content-desc/text at all) that a single read could false-positive on.
+  async function __settleUi(timeout: number): Promise<void> {
     let __prevHadContent = false;
     await driver
       .waitUntil(
@@ -401,9 +487,82 @@ describe('{{featureName}}', () => {
           __prevHadContent = hasContent;
           return settled;
         },
-        { timeout: 30000, interval: 400, timeoutMsg: 'UI did not settle (no rendered content)' },
+        { timeout, interval: 400, timeoutMsg: 'UI did not settle (no rendered content)' },
       )
       .catch(() => { /* best-effort — fall through to per-step auto-wait */ });
+  }
+
+  // Wipe the app's data layer. `mobile: clearApp` is a UiAutomator2 (Android) command — it maps to
+  // `pm clear`, which drops the local DB, cache, SharedPreferences and keychain entries in one call
+  // for ~2–5s. XCUITest has NO equivalent, so iOS degrades to a reinstall: slower, but the only way
+  // to reach the same layers. That needs a build to install from, hence the named throw.
+  async function __clearAppData(pkg: string): Promise<void> {
+    if (driver.isIOS) {
+      await __reinstallApp(pkg);
+      return;
+    }
+    await driver.execute('mobile: clearApp', { appId: pkg });
+  }
+
+  async function __reinstallApp(pkg: string): Promise<void> {
+    const caps = (driver.requestedCapabilities || {}) as Record<string, string>;
+    const appPath = caps['appium:app'] || caps['app'];
+    if (!appPath) {
+      throw new Error(
+        `reset tier needs the app's build file to reinstall — set APP_APK (Android) / IOS_APP (iOS) so the appium:app capability is present, or drop to @reset:soft.`,
+      );
+    }
+    try { await driver.removeApp(pkg); } catch { /* not installed */ }
+    await driver.installApp(appPath);
+  }
+
+  // One reset, at the given tier. `none` still restores the NATIVE context and portrait: both leak at
+  // OS/session level rather than app level, so skipping them alongside the relaunch would make `none`
+  // outright buggy instead of merely stateful. It skips the settle wait, though — nothing relaunched,
+  // so there is no blank first frame to wait through, and burning up to 30s per scenario would defeat
+  // the whole point of asking for `none`.
+  async function __resetApp(tier: string): Promise<void> {
+    const __APP_PKG__ = __resolveAppId();
+    if (tier !== 'none') {
+      if (tier === 'full') {
+        try { await driver.terminateApp(__APP_PKG__); } catch { /* app may not be running yet */ }
+        await __reinstallApp(__APP_PKG__);
+      } else {
+        try { await driver.terminateApp(__APP_PKG__); } catch { /* app may not be running yet */ }
+        if (tier === 'data') await __clearAppData(__APP_PKG__);
+      }
+      // Let the termination fully land before relaunching — activateApp racing a still-dying
+      // process can RESUME the old instance (prior scenario's scroll position and all) instead
+      // of cold-starting, which strands top-of-screen elements above the viewport.
+      await driver.pause(500);
+      await driver.activateApp(__APP_PKG__);
+    }
+    // Restore the NATIVE context — a prior scenario that entered a WebView (`switch to [X] frame`)
+    // without switching back would otherwise poison every following native find.
+    try { await driver.switchContext('NATIVE_APP'); } catch { /* single-context session */ }
+    // Restore portrait so a prior scenario's `rotate to landscape` can't leak into this one — the
+    // app relaunch above resets in-app state, but device orientation is OS-level and persists.
+    try { await driver.setOrientation('PORTRAIT'); } catch { /* orientation control not supported */ }
+    // A fresh install paints its first frame slower than a plain relaunch — same oracle, more rope.
+    if (tier !== 'none') await __settleUi(tier === 'full' || tier === 'data' ? 45000 : 30000);
+  }
+  beforeEach(async function () {
+{{#if scenarioResetTiers}}
+    // A scenario tier RAISES the feature tier, never lowers it: a @reset:full feature must not be
+    // weakened by one scenario asking for less. Use a separate feature when you genuinely need that.
+    const __scenarioTier = __tierFor(this.currentTest?.title ?? '');
+    const __base = __TIER_ORDER.indexOf(__scenarioTier) > __TIER_ORDER.indexOf(__RUN_TIER) ? __scenarioTier : __RUN_TIER;
+{{else}}
+    const __base = __RUN_TIER;
+{{/if}}
+    // Same title ⟹ this is a retry of the scenario that just failed: keep its declared tier so a real
+    // failure fails both attempts (see __escalateAfter above).
+    const __escalate = __escalateAfter !== null && __escalateAfter !== (this.currentTest?.title ?? '');
+    const __tier = __escalate ? __ESCALATE[__base] : __base;
+    if (__tier !== __base) {
+      console.log(`  \u2191 reset escalated ${__base} \u2192 ${__tier} (previous scenario failed: "${__escalateAfter}")`);
+    }
+    await __resetApp(__tier);
 {{#if backgroundSteps}}
     // Background runs here (inside beforeEach) — the app resets to its launch screen every scenario,
     // so Background setup (nav, dismiss launch promos…) must re-run after each relaunch, not once.

package/dist/generators/test-generator/adapters/playwright/playwright-adapter.d.ts

@@ -1,4 +1,4 @@
-import { TestGeneratorAdapter, TestFileData, ScenarioData } from '../adapter-interface';
+import { TestGeneratorAdapter, TestFileData, ScenarioData, RenderImportsOptions } from '../adapter-interface';
 /**
  * PlaywrightAdapter
  * Generates Playwright TypeScript test code using Handlebars templates
@@ -11,16 +11,7 @@ export declare class PlaywrightAdapter implements TestGeneratorAdapter {
     constructor();
     renderTestFile(data: TestFileData): string;
     renderScenario(data: ScenarioData): string;
-    renderImports(options?: {
-        runtimeData?: boolean;
-        basePath?: string;
-        isParallel?: boolean;
-        needsCleanupImport?: boolean;
-        needsDb?: boolean;
-        needsApi?: boolean;
-        needsMock?: boolean;
-        urlAssertImports?: string;
-    }): string;
+    renderImports(options?: RenderImportsOptions): string;
     renderBeforeEach(data: {
         steps: Array<{
             comment?: string;

package/dist/generators/test-generator/adapters/playwright/playwright-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playwright-adapter.d.ts","sourceRoot":"","sources":["../../../../../src/generators/test-generator/adapters/playwright/playwright-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGxF;;;GAGG;AACH,qBAAa,iBAAkB,YAAW,oBAAoB;IAC5D,QAAQ,CAAC,aAAa,gBAAgB;IACtC,QAAQ,CAAC,aAAa,cAAc;IACpC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,OAAO,CAAC,cAAc,CAAiB;;IAQvC,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM;IAI1C,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM;IAI1C,aAAa,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,kBAAkB,CAAC,EAAE,OAAO,CAAE;QAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM;IAIzN,gBAAgB,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,GAAG,MAAM;IAIpF,eAAe,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,GAAG,MAAM;IAInF,eAAe,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,GAAG,MAAM;IAInF,cAAc,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,GAAG,MAAM;IAIlF,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,MAAM;CAGpD"}
+{"version":3,"file":"playwright-adapter.d.ts","sourceRoot":"","sources":["../../../../../src/generators/test-generator/adapters/playwright/playwright-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG9G;;;GAGG;AACH,qBAAa,iBAAkB,YAAW,oBAAoB;IAC5D,QAAQ,CAAC,aAAa,gBAAgB;IACtC,QAAQ,CAAC,aAAa,cAAc;IACpC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,OAAO,CAAC,cAAc,CAAiB;;IAQvC,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM;IAI1C,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM;IAI1C,aAAa,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,MAAM;IAIrD,gBAAgB,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,GAAG,MAAM;IAIpF,eAAe,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,GAAG,MAAM;IAInF,eAAe,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,GAAG,MAAM;IAInF,cAAc,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,GAAG,MAAM;IAIlF,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,MAAM;CAGpD"}

package/dist/generators/test-generator/adapters/playwright/playwright-adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"playwright-adapter.js","sourceRoot":"","sources":["../../../../../src/generators/test-generator/adapters/playwright/playwright-adapter.ts"],"names":[],"mappings":";;;;;;AAAA,gDAAwB;AAExB,2DAAuD;AAEvD;;;GAGG;AACH,MAAa,iBAAiB;IAM5B;QALS,kBAAa,GAAG,YAAY,CAAC;QAC7B,kBAAa,GAAG,UAAU,CAAC;QAKlC,2CAA2C;QAC3C,IAAI,CAAC,YAAY,GAAG,cAAI,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QACtD,IAAI,CAAC,cAAc,GAAG,IAAI,gCAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC9D,CAAC;IAED,cAAc,CAAC,IAAkB;QAC/B,OAAO,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,cAAc,CAAC,IAAkB;QAC/B,OAAO,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,aAAa,CAAC,OAAkM;QAC9M,OAAO,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IACpD,CAAC;IAED,gBAAgB,CAAC,IAA0D;QACzE,OAAO,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACpD,CAAC;IAED,eAAe,CAAC,IAA0D;QACxE,OAAO,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;IAED,eAAe,CAAC,IAA0D;QACxE,OAAO,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;IAED,cAAc,CAAC,IAA0D;QACvE,OAAO,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,UAAU,CAAC,YAAoB,EAAE,IAAS;QACxC,OAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;IAC5D,CAAC;CACF;AA3CD,8CA2CC"}
+{"version":3,"file":"playwright-adapter.js","sourceRoot":"","sources":["../../../../../src/generators/test-generator/adapters/playwright/playwright-adapter.ts"],"names":[],"mappings":";;;;;;AAAA,gDAAwB;AAExB,2DAAuD;AAEvD;;;GAGG;AACH,MAAa,iBAAiB;IAM5B;QALS,kBAAa,GAAG,YAAY,CAAC;QAC7B,kBAAa,GAAG,UAAU,CAAC;QAKlC,2CAA2C;QAC3C,IAAI,CAAC,YAAY,GAAG,cAAI,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QACtD,IAAI,CAAC,cAAc,GAAG,IAAI,gCAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC9D,CAAC;IAED,cAAc,CAAC,IAAkB;QAC/B,OAAO,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,cAAc,CAAC,IAAkB;QAC/B,OAAO,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,aAAa,CAAC,OAA8B;QAC1C,OAAO,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IACpD,CAAC;IAED,gBAAgB,CAAC,IAA0D;QACzE,OAAO,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACpD,CAAC;IAED,eAAe,CAAC,IAA0D;QACxE,OAAO,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;IAED,eAAe,CAAC,IAA0D;QACxE,OAAO,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;IAED,cAAc,CAAC,IAA0D;QACvE,OAAO,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,UAAU,CAAC,YAAoB,EAAE,IAAS;QACxC,OAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;IAC5D,CAAC;CACF;AA3CD,8CA2CC"}

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

@@ -15,6 +15,9 @@ import { mock } from '{{basePath}}/mock';
 {{#if urlAssertImports}}
 import { {{urlAssertImports}} } from '{{basePath}}/url-assert';
 {{/if}}
+{{#if regexEscapeImport}}
+import { escapeRegExp } from '{{basePath}}/regex-escape';
+{{/if}}
 
 // This file is auto-generated from Gherkin feature files
 // DO NOT EDIT MANUALLY - changes will be overwritten

package/dist/generators/test-generator/adapters/playwright/templates/steps/actions/select-action.hbs

@@ -1 +1,17 @@
-await {{> locator}}.selectOption('{{selectValue}}');
+{{#if probeNative}}
+{{!-- The selector resolved to an ARIA role that a native <select> and a custom trigger share
+      (`combobox`/`listbox`). .selectOption() only works on a real <select>; on a Radix/shadcn or
+      MUI trigger it throws "Element is not a <select> element". Probe the tag, then take the
+      native path or the open-then-pick path. Pin `variant: native` (or bind a `select` recipe in
+      qa/app.yaml) to compile one branch only. --}}
+{ const el = {{> locator}};
+if ((await el.evaluate((n) => n.tagName.toLowerCase())) === 'select') {
+await el.selectOption('{{selectValue}}');
+} else {
+await el.click();
+await page.getByText('{{selectValue}}', { exact: true }).first().click();
+}
+}
+{{~else~}}
+await {{> locator}}.selectOption('{{selectValue}}');
+{{~/if}}

package/dist/generators/test-generator/adapters/playwright/templates/steps/assertions/attribute-assertion.hbs

@@ -1,3 +1,8 @@
-{{#if pattern}}await expect({{> locator}}).toHaveAttribute('{{attribute}}', /{{dataValue}}/);
+{{!-- `pattern` opts the value into REGEX semantics: the value IS the pattern, so it must
+      NOT be regex-escaped. A string container (not a /…/ literal) keeps it that way in
+      runtime-data mode — the transformer escapes values landing in regex LITERALS but
+      leaves a whole-marker string as a bare accessor call. escapeQuotes doubles
+      backslashes, so `\d` in a static pattern reaches RegExp intact. --}}
+{{#if pattern}}await expect({{> locator}}).toHaveAttribute('{{attribute}}', new RegExp('{{escapeQuotes dataValue}}'));
 {{else}}await expect({{> locator}}).toHaveAttribute('{{attribute}}', '{{dataValue}}');
 {{/if}}

package/dist/generators/test-generator/adapters/playwright/templates/steps/assertions/have-value-assertion.hbs

@@ -1 +1,18 @@
-await expect({{> locator}}).toHaveValue('{{escapeQuotes dataValue}}');
+{{#if probeNative}}
+{{!-- Ambiguous value target (dropdown/select/combobox): ARIA role `combobox` is worn both by a
+      native <select> and by a `<button role="combobox">` trigger (Radix/shadcn, MUI, Headless UI).
+      toHaveValue() reads the DOM `value` property — a button has none, so it throws "Not an input
+      element". Probe the tag and assert whatever the element actually exposes. Same runtime-probe
+      idiom as selected-assertion.hbs. Pin a real native control with `variant: native`, or bind an
+      `assertValue` recipe, to skip the probe entirely. --}}
+{ const el = {{> locator}};
+const tag = await el.evaluate((n) => n.tagName.toLowerCase());
+if (tag === 'input' || tag === 'select' || tag === 'textarea') {
+await expect(el).toHaveValue('{{escapeQuotes dataValue}}');
+} else {
+await expect(el).toHaveText('{{escapeQuotes dataValue}}');
+}
+}
+{{~else~}}
+await expect({{> locator}}).toHaveValue('{{escapeQuotes dataValue}}');
+{{~/if}}

package/dist/generators/test-generator/adapters/playwright/templates/steps/assertions/hidden-with-filter-assertion.hbs

@@ -1 +1,5 @@
-await expect({{> locator-base}}.filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{> locator-nth}}).toBeHidden();
+{{!-- Same filter contract as the visible/contains siblings (has-text-value): substring by
+      default, `exact: true` in the selector YAML anchors. Divergent defaults let the pair
+      `see [X] with {{v}}` (substring, matches) + `… is hidden` (anchored, 0 elements)
+      BOTH pass on one element — a vacuous-pass contradiction. --}}
+await expect({{> locator-base}}.filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact}} }){{> locator-nth}}).toBeHidden();

package/dist/generators/test-generator/adapters/playwright/templates/steps/assertions/matches-format-assertion.hbs

@@ -0,0 +1,5 @@
+{{!-- Format assertion: the label must match the SHAPE the spec states, not a fixed value.
+      toHaveText accepts a RegExp and retries under the standard expect timeout, so a label that
+      renders late still passes. The message names the FORMAT (not the compiled regex) because the
+      failure is read by whoever wrote the requirement. --}}
+await expect({{> locator}}, 'Expected [{{escapeQuotes selectorRef}}] to match the format "{{escapeQuotes format}}"').toHaveText({{{formatRegex}}});

package/dist/generators/test-generator/adapters/playwright/templates/steps/assertions/state-with-filter-assertion.hbs

@@ -1,5 +1,7 @@
+{{!-- Filter contract shared with the visible/hidden/contains siblings (has-text-value):
+      substring by default, `exact: true` in the selector YAML anchors. --}}
 {{#if selectedProbe}}
-{ const el = {{> locator-base}}.filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{> locator-nth}};
+{ const el = {{> locator-base}}.filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact}} }){{> locator-nth}};
 if ((await el.getAttribute('aria-selected')) !== null) {
 await expect(el).toHaveAttribute('aria-selected', 'true');
 } else {
@@ -7,5 +9,5 @@ await expect(el).toBeChecked();
 }
 }
 {{else}}
-await expect({{> locator-base}}.filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{> locator-nth}}).{{{stateAssertion}}};
+await expect({{> locator-base}}.filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact}} }){{> locator-nth}}).{{{stateAssertion}}};
 {{/if}}

package/dist/generators/test-generator/adapters/playwright/templates/steps/navigation/wait-for-element-with-text.hbs

@@ -1 +1,4 @@
-await {{> locator-base}}.filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{> locator-nth}}.waitFor({ state: '{{state}}' });
+{{!-- Filter contract shared with the see-assertion siblings (has-text-value): substring by
+      default, `exact: true` in the selector YAML anchors — `wait for [X] with {{v}}` and
+      `see [X] … with {{v}}` must match the same element for the same input. --}}
+await {{> locator-base}}.filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact}} }){{> locator-nth}}.waitFor({ state: '{{state}}' });

package/dist/generators/test-generator/adapters/playwright/templates/steps/partials/recipe-expect-text.hbs

@@ -1 +1 @@
-await expect({{{targetExpr}}}).toContainText({{{valueExpr}}});
+await expect({{{targetExpr}}}).{{#if exact}}toHaveText{{else}}toContainText{{/if}}({{{valueExpr}}});

package/dist/generators/test-generator/code-generator.d.ts

@@ -33,6 +33,12 @@ export declare class CodeGenerator {
      * Generate test file from parsed feature
      */
     generateTest(feature: ParsedFeature, outputDir: string): Promise<GeneratedTest>;
+    /**
+     * Report SG-E022 when the emitted spec is not parseable. Reported, never thrown: the
+     * caller still writes the file, so the user keeps the artifact to inspect (and `--strict`
+     * turns it into a non-zero exit like every other diagnostic).
+     */
+    private assertParseable;
     /**
      * Count total steps in feature (excluding background).
      * For @extend scenarios, counts base steps + own steps (merged total).

package/dist/generators/test-generator/code-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../../src/generators/test-generator/code-generator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAA8B,MAAM,mBAAmB,CAAC;AAI9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAqOrD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,UAAU,CAAC,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAM;IAErB,OAAO,CAAC,eAAe,CAAc;IAErC,OAAO,CAAC,aAAa,CAAqC;IAE1D,OAAO,CAAC,WAAW,CAA8B;gBAErC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAO;IAiBtK,oFAAoF;IACpF,cAAc,IAAI,oBAAoB;IAItC;;OAEG;IACG,YAAY,CAChB,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC;IA0EzB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAclB;;OAEG;IACH,SAAS,CAAC,aAAa,EAAE,aAAa,GAAG,IAAI;IAS7C;;OAEG;IACH;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IA0C3B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAoB/B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAY3B,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;YASzB,gBAAgB;YA0ThB,uBAAuB;YAYvB,kBAAkB;YAoBlB,YAAY;IAqB1B;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB;YASlB,gBAAgB;IAoJ9B;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAS7B;;OAEG;IACH;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,kBAAkB;IAyBpB,gBAAgB,CACpB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC,aAAa,EAAE,CAAC;CA+D5B"}
+{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../../src/generators/test-generator/code-generator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAA8B,MAAM,mBAAmB,CAAC;AAI9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAuOrD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,UAAU,CAAC,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAM;IAErB,OAAO,CAAC,eAAe,CAAc;IAErC,OAAO,CAAC,aAAa,CAAqC;IAE1D,OAAO,CAAC,WAAW,CAA8B;gBAErC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAO;IAiBtK,oFAAoF;IACpF,cAAc,IAAI,oBAAoB;IAItC;;OAEG;IACG,YAAY,CAChB,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC;IA4FzB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAavB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAclB;;OAEG;IACH,SAAS,CAAC,aAAa,EAAE,aAAa,GAAG,IAAI;IAS7C;;OAEG;IACH;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IA0C3B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAoB/B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAY3B,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;YASzB,gBAAgB;YAmWhB,uBAAuB;YAYvB,kBAAkB;YAoBlB,YAAY;IAqB1B;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB;YASlB,gBAAgB;IAoJ9B;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAS7B;;OAEG;IACH;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,kBAAkB;IAyBpB,gBAAgB,CACpB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC,aAAa,EAAE,CAAC;CA+D5B"}

package/dist/generators/test-generator/code-generator.js

@@ -10,10 +10,12 @@ const step_mapper_1 = require("./step-mapper");
 const adapters_1 = require("./adapters");
 const runtime_data_transformer_1 = require("./utils/runtime-data-transformer");
 const diagnostics_1 = require("./diagnostics");
+const reset_tier_1 = require("./reset-tier");
 const registry_1 = require("../../capabilities/registry");
 const discover_1 = require("../../capabilities/discover");
 const capability_1 = require("../../harness/capability");
 const scenario_merger_1 = require("../../exporters/scenario-merger");
+const spec_syntax_check_1 = require("./utils/spec-syntax-check");
 /**
  * Filter base scenario steps for @extend: only keep Given→When steps.
  * Skips Then and any And/But that follow Then (since And/But inherit
@@ -82,7 +84,7 @@ function extractCleanupFlags(tags) {
 const FUNCTIONAL_TAG_PREFIXES = [
     '@parallel', '@serial', '@cleanup:', '@auth:', '@manual', '@no-auth',
     '@steps:', '@extend:', '@screenshot:', '@beforeAll', '@afterEach', '@afterAll',
-    '@flow', '@cases:', '@deferred:', '@owned-by:', '@platform:',
+    '@flow', '@cases:', '@deferred:', '@owned-by:', '@platform:', '@reset:',
 ];
 function extractPassThroughTags(scenarioTags, featureTags) {
     const allTags = [...featureTags, ...scenarioTags];
@@ -298,7 +300,15 @@ class CodeGenerator {
                 this.syncGeneratedHelper(outputDir, h.file, h.template);
         }
         // Generate test code (async now to support AI mapping)
-        const testCode = await this.generateTestCode(feature);
+        let testCode = await this.generateTestCode(feature);
+        // Runtime data: replace __SUNGEN_TD$…$__ markers with testData.get() calls.
+        // Runs BEFORE the imports are rendered so they can reflect what the transformed
+        // body actually references (a marker inside a regex literal becomes an
+        // escapeRegExp(...) call that needs its helper imported). Imports carry no
+        // markers, so transforming only the body loses nothing.
+        if (this.options.runtimeData) {
+            testCode = (0, runtime_data_transformer_1.transformToRuntimeData)(testCode);
+        }
         // `url-assert` is imported from what the body actually emitted, not from an active capability:
         // page assertions belong to the DEFAULT ui capability, so a capability flag would import the
         // helper into every UI spec — including the many that touch no URL at all. Hence the body is
@@ -307,14 +317,23 @@ class CodeGenerator {
         const urlAssertImports = ['urlMatches', 'joinPath'].filter((n) => testCode.includes(`${n}(`)).join(', ');
         if (urlAssertImports)
             this.syncGeneratedHelper(outputDir, 'url-assert.ts', 'specs-url-assert.ts');
-        const imports = this.adapter.renderImports({ runtimeData: this.options.runtimeData, basePath, needsCleanupImport, needsDb, needsApi, needsMock, urlAssertImports });
+        // Same body-first rule for the runtime regex-escape helper: only a spec whose
+        // transformed body wraps a value in escapeRegExp() imports (and syncs) it.
+        const regexEscapeImport = /\bescapeRegExp\(/.test(testCode);
+        if (regexEscapeImport)
+            this.syncGeneratedHelper(outputDir, 'regex-escape.ts', 'specs-regex-escape.ts');
+        const imports = this.adapter.renderImports({ runtimeData: this.options.runtimeData, basePath, needsCleanupImport, needsDb, needsApi, needsMock, urlAssertImports, regexEscapeImport });
         // Combine and collapse any runs of 3+ newlines down to 2 (one blank line max)
         const raw = `${imports}\n\n${testCode}`;
         let code = raw.replace(/\n{3,}/g, '\n\n');
-        // Runtime data: replace __SUNGEN_TD$…$__ markers with testData.get() calls
-        if (this.options.runtimeData) {
-            code = (0, runtime_data_transformer_1.transformToRuntimeData)(code);
-        }
+        // SG-E022 — compiler self-check. Every template and post-processor above assembles
+        // TEXT, so a delimiter bug in any of them yields a file Playwright cannot parse at all:
+        // one SyntaxError, zero scenarios run. That is exactly how the runtime-data quote-pairing
+        // defect reached a user — `sungen generate` reported success and the breakage only
+        // surfaced at `npx playwright test`, a step further from the cause. Parsing what we are
+        // about to write makes the compiler name its own bad output, at the moment it makes it.
+        // (The runtime-data transform itself ran on the body above, before the imports.)
+        this.assertParseable(code, feature.name, filePath);
         return {
             featureName: feature.name,
             filePath,
@@ -323,6 +342,20 @@ class CodeGenerator {
             stepCount: this.countSteps(feature),
         };
     }
+    /**
+     * Report SG-E022 when the emitted spec is not parseable. Reported, never thrown: the
+     * caller still writes the file, so the user keeps the artifact to inspect (and `--strict`
+     * turns it into a non-zero exit like every other diagnostic).
+     */
+    assertParseable(code, featureName, filePath) {
+        const detail = (0, spec_syntax_check_1.findSyntaxError)(code);
+        if (!detail)
+            return;
+        this.diagnostics.add('SG-E022', `generated spec "${filePath}" is not parseable TypeScript (${detail}) — Playwright will `
+            + 'fail the whole file with one SyntaxError and run NONE of its scenarios. This is a sungen '
+            + 'compiler bug, not a problem with the .feature: please report it with the step this file '
+            + 'was generated from.', { feature: featureName });
+    }
     /**
      * Count total steps in feature (excluding background).
      * For @extend scenarios, counts base steps + own steps (merged total).
@@ -696,6 +729,44 @@ class CodeGenerator {
         // package (activity stripped, it isn't needed for terminateApp/activateApp); iosBundleId is the part
         // after `|` when present. Without these the test-file template's `{{#if appPackage}}` stays false and
         // the beforeEach (terminate+activate) reset is never emitted → nav scenarios cascade-fail.
+        // Mobile: how much state each scenario starts from — `@reset:none|soft|data|full`, default 'soft'
+        // (the terminate+activate relaunch this adapter always did, so an untagged feature is unchanged).
+        // Appium-only: web features get a clean slate from navigation and carry no tier.
+        const resetTier = this.adapter.frameworkName === 'appium'
+            ? ((0, reset_tier_1.parseResetTier)(feature.tags || []) ?? reset_tier_1.DEFAULT_RESET_TIER)
+            : undefined;
+        // Per-scenario `@reset:` overrides. Keyed on the scenario's BASE name — NOT the rendered it()
+        // title, because a @cases scenario concatenates its title at runtime from the row label, so no
+        // compile-time key could match it. The generated spec normalizes a title back to a base name and
+        // membership-tests each step, so a miss just inherits the feature tier rather than guessing wrong.
+        // `cases` marks a scenario whose it() title is BUILT AT RUNTIME (`name + ' — ' + row.__label`).
+        // Only those titles may have a row suffix stripped when looking a tier up; applying that strip to
+        // every scenario let a name that merely LOOKED like `<base> — <suffix>` resolve to a different
+        // scenario's tier.
+        const scenarioResetTiers = this.adapter.frameworkName === 'appium'
+            ? (feature.scenarios || []).reduce((acc, sc) => {
+                const tier = (0, reset_tier_1.parseResetTier)(sc.tags || []);
+                if (tier)
+                    acc.push({ name: sc.name, tier, cases: (sc.tags || []).some(t => t.startsWith('@cases:')) });
+                return acc;
+            }, [])
+            : undefined;
+        // SG-W024 — the runtime lookup is keyed on the scenario NAME, so two scenarios sharing a name
+        // cannot be told apart. Counted over EVERY scenario, not just the tagged ones: an UNTAGGED
+        // scenario sharing a name with a tagged one silently inherits that tier (weakening a
+        // `@reset:none` chain, or paying a reinstall it never asked for), and scanning only the tagged
+        // subset missed exactly that case.
+        if (scenarioResetTiers && scenarioResetTiers.length) {
+            const tiered = new Set(scenarioResetTiers.map(t => t.name));
+            const counts = new Map();
+            for (const sc of feature.scenarios || [])
+                counts.set(sc.name, (counts.get(sc.name) || 0) + 1);
+            for (const [name, n] of counts) {
+                if (n < 2 || !tiered.has(name))
+                    continue;
+                this.diagnostics.add('SG-W024', `${n} scenarios in this feature are named "${name}" and at least one carries a @reset: tag — the generated lookup is keyed on the scenario NAME, so every one of them resolves to the SAME tier, including any that declared none. Rename them so each is unique.`, { feature: feature.name, step: name });
+            }
+        }
         let appPackage;
         let iosBundleId;
         if (this.adapter.frameworkName === 'appium' && feature.path) {
@@ -731,6 +802,8 @@ class CodeGenerator {
             singleAuthRole,
             appPackage,
             iosBundleId,
+            resetTier,
+            scenarioResetTiers: scenarioResetTiers && scenarioResetTiers.length ? scenarioResetTiers : undefined,
         });
     }
     async generateBackgroundSteps(background) {