@sun-asterisk/sungen 3.2.24-beta.6 → 3.2.25

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

@@ -72,20 +72,38 @@ async function __ensureVisible(selector: string): Promise<WebdriverIO.Element> {
   }
   const safeBottom = Math.round(winH * 0.82); // above the floating bottom-nav band
   let lastY: number | null = null;
+  let lastEl: WebdriverIO.Element | null = null;
   for (let __i = 0; __i < 12; __i++) {
     let y: number | null = null;
+    let existsUndisplayed = false;
     try {
       const el = await $(selector);
       if (await el.isDisplayed()) {
         const r = await driver.getElementRect(el.elementId);
-        if (r.y + r.height <= safeBottom) return el; // rendered AND fully above the floating bottom nav → done
+        // Done when the element sits fully above the floating bottom-nav band — OR is simply too
+        // tall to ever fit there (a scroll container / full-screen list): demanding "fully above"
+        // from such an element makes the loop scroll a page that was already correct, dragging
+        // list-hosted siblings (e.g. the top bar as first list item) out of the viewport.
+        if (r.y + r.height <= safeBottom || r.height >= safeBottom) return el;
         y = r.y;
+        lastEl = el;
+      } else if (el.elementId) {
+        existsUndisplayed = true; // in the tree, just not visible right now
       }
     } catch { /* off-screen / not in tree yet → keep scrolling */ }
+    // Overlay grace (Android mirror of the iOS render grace above): the element is IN the tree but
+    // reports not-displayed — typically a launch popup/overlay covering it that auto-dismisses
+    // within seconds. Scrolling now would carry a list-hosted element (a Compose top bar is often
+    // the first list item) clean out of the viewport, where a down-only loop can never recover it —
+    // so wait the overlay out before the first scroll.
+    if (existsUndisplayed && __i < 4) { await driver.pause(1200); continue; }
     // No-progress break: the element is on screen but a prior scroll didn't move it — it's a FIXED
     // element (e.g. a bottom-nav tab, intentionally in the nav band) or we've hit the end of the
     // scrollable. Stop rather than burn the whole budget; the caller acts on it where it is.
-    if (y !== null && lastY !== null && Math.abs(y - lastY) < 2) return $(selector);
+    // Return the RESOLVED element, never a fresh $() stub: on an animation-churned tree (a looping
+    // banner is enough) a from-scratch re-find takes seconds and outlasts the caller's assertion
+    // budget — the element we just measured is the one the caller should act on.
+    if (y !== null && lastY !== null && Math.abs(y - lastY) < 2) return lastEl ?? $(selector);
     lastY = y;
     await driver.execute('mobile: scrollGesture', { left: 60, top: 420, width: 960, height: 1320, direction: 'down', percent: 0.5 });
     await driver.pause(300);
@@ -116,6 +134,74 @@ async function __assertVisible(selector: string): Promise<void> {
   }
   throw new Error(`Expect ${JSON.stringify(selector)} to be displayed — iOS geometry oracle: rect=${JSON.stringify(r)} is not on screen (0x0 = not rendered / scrolled out)`);
 }
+
+// Checkbox / toggle / radio state oracle. There is NO single authoritative source for it on
+// mobile, and the standard one lies in a way that cannot be detected from the read itself:
+// UiAutomator2 puts `checked` on EVERY Android node and defaults it to "false" when the widget
+// publishes no checked semantics. So a custom-rendered control — a Flutter widget without
+// `Semantics(checked: …)`, an RN `Pressable` without `accessibilityState={ checked: … }` — is not
+// ABSENT from the tree, it reports a confident false while sitting visibly ON, and a strict
+// `toHaveAttribute('checked','true')` fails with no way to see why.
+// Hence: probe every signal both runtimes expose, and let the DIRECTION of the assertion decide
+// how to combine them (__assertCheckedState below).
+//   Android: `checked`, `selected`, isSelected()   iOS: `value` ("1"/"0"), `selected`, isSelected()
+// Descendants are probed too, bounded: on a composite row (label + control merged into one a11y
+// node) the state routinely sits on an inner node while the queried outer node reports the default.
+// A child xpath must start with `.//` — a leading `//` is ABSOLUTE in Appium even when chained.
+async function __probeCheckedSignals(el: WebdriverIO.Element): Promise<{ source: string; value: boolean }[]> {
+  const out: { source: string; value: boolean }[] = [];
+  const read = async (node: WebdriverIO.Element, prefix: string): Promise<void> => {
+    for (const attr of driver.isIOS ? ['value', 'selected'] : ['checked', 'selected']) {
+      let raw: string | null = null;
+      try { raw = await node.getAttribute(attr); } catch { continue; } // attribute unsupported on this node
+      const v = String(raw ?? '').trim().toLowerCase();
+      if (v === 'true' || v === '1') out.push({ source: `${prefix}${attr}="${raw}"`, value: true });
+      else if (v === 'false' || v === '0') out.push({ source: `${prefix}${attr}="${raw}"`, value: false });
+      // anything else (empty, a real iOS `value` string like "Off") carries no parseable state → skip
+    }
+    try { out.push({ source: `${prefix}isSelected()`, value: await node.isSelected() }); } catch { /* not supported here */ }
+  };
+  await read(el, '');
+  // Only descend when the node itself yielded nothing positive — otherwise we already have the
+  // answer and a subtree walk would turn one assertion into dozens of round-trips for nothing.
+  if (!out.some(s => s.value)) {
+    let kids: WebdriverIO.Element[] = [];
+    try { kids = await el.$$('.//*'); } catch { /* no child query on this node */ }
+    for (const k of kids.slice(0, 8)) await read(k, 'descendant.');
+  }
+  return out;
+}
+
+// Assert checked/unchecked from the probed signals. The two directions are deliberately NOT
+// symmetric, because the evidence isn't:
+//   checked   → ANY credible positive signal passes. One runtime exposing the state is enough;
+//               demanding the standard attribute is what breaks custom-rendered controls.
+//   unchecked → NO signal anywhere may be positive. Strictly stronger than reading one attribute,
+//               so a visibly-ON custom toggle can't slip through as a false PASS.
+// Polls like WDIO's own matchers do — a tap-then-assert reads the tree mid-animation.
+// KNOWN LIMIT, stated rather than hidden: on Android a UiAutomator2-defaulted `checked="false"` is
+// indistinguishable from a genuine false — that information is not in the tree. So `unchecked`
+// passes on "no positive signal anywhere", which is the strongest available evidence, not proof.
+async function __assertCheckedState(el: WebdriverIO.Element, expected: boolean, label: string): Promise<void> {
+  // Fail loud with the REAL cause when the element never resolved (mirrors check-action, #430).
+  if (!el.elementId) throw new Error((el as any).error?.message || `Element not found: ${el.selector}`);
+  let signals: { source: string; value: boolean }[] = [];
+  for (let __i = 0; __i < 10; __i++) {
+    signals = await __probeCheckedSignals(el);
+    if (signals.some(s => s.value) === expected) return;
+    await driver.pause(500);
+  }
+  const want = expected ? 'checked' : 'unchecked';
+  if (signals.length === 0) {
+    throw new Error(
+      `Expect ${label} to be ${want} — the control publishes NO checked/selected state, on itself or any child. ` +
+      `A custom-rendered control has to publish it for any tool to read it: Flutter → wrap it in Semantics(checked: …); ` +
+      `React Native → accessibilityState={ checked: … }. Until then assert a visible consequence instead ` +
+      `(a label/text change), or tag the scenario @manual.`,
+    );
+  }
+  throw new Error(`Expect ${label} to be ${want} — read [${signals.map(s => `${s.source} → ${s.value}`).join(', ')}]`);
+}
 {{#if singleAuthRole}}
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -133,7 +219,9 @@ function __authSelector(s: { type: string; value: string }): string {
     case 'accessibility-id': case 'testid': case 'label': case 'placeholder': case 'text': return '~' + s.value;
     case 'android-uiautomator': return 'android=' + s.value;
     case 'ios-predicate': return '-ios predicate string:' + s.value;
-    case 'id': return 'id=' + s.value;
+    // Appium's id strategy prepends `<appPackage>:id/` to colon-less values, which breaks bare
+    // Compose testTagsAsResourceId ids — match those exactly via UiSelector on Android instead.
+    case 'id': return (!driver.isIOS && !s.value.includes(':')) ? 'android=new UiSelector().resourceId("' + s.value + '")' : 'id=' + s.value;
     case 'xpath': case 'locator': default: return s.value;
   }
 }
@@ -205,10 +293,29 @@ async function __ensureAuth(role: string): Promise<void> {
   }
 
   // ── Mode B: legacy authedMarker (present on the landing screen ⟺ logged in) ──
-  const markerPresent = async (): Promise<boolean> => present(cfg.authedMarker, 6000);
-  if (await markerPresent()) return; // idempotent — already authenticated (session kept by noReset)
+  // markerTimeoutMs: contract override for slow-booting apps — a cold start that needs 10-15s+ to
+  // render the landing screen false-negatives the 6s default into "logged out" and then blocks the
+  // spec when the login form never appears.
+  const __budget = cfg.markerTimeoutMs || 6000;
+  // When the contract also names a loggedOutMarker (an element unique to the login screen), the
+  // state is decided by WHICHEVER marker renders first (alternating short probes): a slow-booting
+  // landing screen costs only its real boot time instead of gambling on one fixed timeout, and a
+  // genuine logged-out state is detected without waiting out the full authed budget first.
+  if (cfg.loggedOutMarker) {
+    let loggedOut = false;
+    const __t0 = Date.now();
+    while (Date.now() - __t0 < __budget) {
+      if (await present(cfg.authedMarker, 3000)) return; // logged in — nothing to do
+      if (await present(cfg.loggedOutMarker, 3000)) { loggedOut = true; break; }
+    }
+    if (!loggedOut) {
+      throw new Error(`@auth:${role} could not decide the login state within ${__budget}ms — neither authedMarker nor loggedOutMarker rendered. Check the markers in ${rel}.`);
+    }
+  } else if (await present(cfg.authedMarker, __budget)) {
+    return; // idempotent — already authenticated (session kept by noReset)
+  }
   await runSteps(cfg.loginSteps);
-  if (!(await markerPresent())) {
+  if (!(await present(cfg.authedMarker, __budget))) {
     throw new Error(`@auth:${role} login failed — verify credentials / loginSteps / authedMarker in ${rel}.`);
   }
 }
@@ -259,37 +366,203 @@ 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 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.
-    // That skeleton is static, so a "two equal reads" check alone false-positives on it and we'd
-    // proceed before any element exists (→ every find fails). So require the tree to (a) contain
-    // rendered content — at least one non-empty content-desc/text — AND (b) be stable across two
-    // reads. 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.
-    let __prevSrc = '';
+  // ── 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(
         async () => {
           const src = await driver.getPageSource();
           const hasContent = /content-desc="[^"]+"|\btext="[^"]+"/.test(src);
-          const stable = hasContent && src === __prevSrc;
-          __prevSrc = src;
-          return stable;
+          const settled = hasContent && __prevHadContent;
+          __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"}