@sun-asterisk/sungen 3.2.29 → 3.2.30

package/src/generators/test-generator/adapters/appium/templates/after-all.hbs

@@ -1,8 +1,26 @@
   after(async () => {
+{{#if collect}}
+    // Hook checks are collected: every failed step is recorded and the hook fails ONCE with the full list
+    const __hookFailures: string[] = [];
+{{/if}}
 {{#each steps}}
 {{#if comment}}
     // {{comment}}
 {{/if}}
+{{#if wrap}}
+    try {
+{{code}}
+    } catch (e) {
+      __hookFailures.push({{label}} + ': ' + String((e as Error).message).split('\n')[0]);
+{{#if stopOnFailure}}
+      if (__hookFailures.length) throw new Error('[sungen] hook preconditions not met:\n' + __hookFailures.join('\n'));
+{{/if}}
+    }
+{{else}}
 {{code}}
+{{/if}}
 {{/each}}
+{{#if collect}}
+    if (__hookFailures.length) throw new Error('[sungen] hook preconditions not met:\n' + __hookFailures.join('\n'));
+{{/if}}
   });

package/src/generators/test-generator/adapters/appium/templates/after-each.hbs

@@ -1,8 +1,26 @@
   afterEach(async () => {
+{{#if collect}}
+    // Hook checks are collected: every failed step is recorded and the hook fails ONCE with the full list
+    const __hookFailures: string[] = [];
+{{/if}}
 {{#each steps}}
 {{#if comment}}
     // {{comment}}
 {{/if}}
+{{#if wrap}}
+    try {
+{{code}}
+    } catch (e) {
+      __hookFailures.push({{label}} + ': ' + String((e as Error).message).split('\n')[0]);
+{{#if stopOnFailure}}
+      if (__hookFailures.length) throw new Error('[sungen] hook preconditions not met:\n' + __hookFailures.join('\n'));
+{{/if}}
+    }
+{{else}}
 {{code}}
+{{/if}}
 {{/each}}
+{{#if collect}}
+    if (__hookFailures.length) throw new Error('[sungen] hook preconditions not met:\n' + __hookFailures.join('\n'));
+{{/if}}
   });

package/src/generators/test-generator/adapters/appium/templates/before-all.hbs

@@ -1,8 +1,26 @@
   before(async () => {
+{{#if collect}}
+    // Hook checks are collected: every failed step is recorded and the hook fails ONCE with the full list
+    const __hookFailures: string[] = [];
+{{/if}}
 {{#each steps}}
 {{#if comment}}
     // {{comment}}
 {{/if}}
+{{#if wrap}}
+    try {
+{{code}}
+    } catch (e) {
+      __hookFailures.push({{label}} + ': ' + String((e as Error).message).split('\n')[0]);
+{{#if stopOnFailure}}
+      if (__hookFailures.length) throw new Error('[sungen] hook preconditions not met:\n' + __hookFailures.join('\n'));
+{{/if}}
+    }
+{{else}}
 {{code}}
+{{/if}}
 {{/each}}
+{{#if collect}}
+    if (__hookFailures.length) throw new Error('[sungen] hook preconditions not met:\n' + __hookFailures.join('\n'));
+{{/if}}
   });

package/src/generators/test-generator/adapters/appium/templates/steps/actions/click-at-position-action.hbs

@@ -0,0 +1 @@
+throw new Error('[sungen] "click … at position/offset" is web-only — tap the control the position targets directly ("User tap [X] button"), or tag the scenario @manual');

package/src/generators/test-generator/adapters/appium/templates/steps/actions/click-element-with-text.hbs

@@ -1,2 +1,2 @@
 {{!-- Tap an element by its visible text / content-desc (dynamic text match). --}}
-{{#if nth}}await $$('//*[contains(@content-desc,"{{escapeQuotes dataValue}}") or contains(@text,"{{escapeQuotes dataValue}}")]')[{{nth}}].click();{{else}}await $('//*[contains(@content-desc,"{{escapeQuotes dataValue}}") or contains(@text,"{{escapeQuotes dataValue}}")]').click();{{/if}}
+{{#if (gte nth -1)}}await (await $$('//*[contains(@content-desc,"{{escapeQuotes dataValue}}") or contains(@text,"{{escapeQuotes dataValue}}")]')).at({{nth}}).click();{{else}}await $('//*[contains(@content-desc,"{{escapeQuotes dataValue}}") or contains(@text,"{{escapeQuotes dataValue}}")]').click();{{/if}}

package/src/generators/test-generator/adapters/appium/templates/steps/actions/double-click-action.hbs

@@ -1,6 +1,13 @@
 {{!-- Double-tap. Use the platform gesture (element.doubleClick is web-oriented). --}}
 {
   const __el = await {{> locator}};
+  // Fail loud with the REAL cause when the element never resolved. `driver.execute` does NOT do
+  // WDIO's implicit existence wait (every other action template gets that for free by going
+  // through .click()/.setValue()/expect), and the locator partial returns $(selector) even for a
+  // never-found element by design. So an undefined elementId reaches Appium, which falls through
+  // to its coordinates branch and reports "Double click offset coordinates must be provided if
+  // element is not set" — a message about offsets for what is really a not-found element (#668).
+  if (!__el.elementId) throw new Error((__el as any).error?.message || `Element not found: ${__el.selector}`);
   if (driver.isIOS) await driver.execute('mobile: doubleTap', { elementId: __el.elementId });
   else await driver.execute('mobile: doubleClickGesture', { elementId: __el.elementId });
 }

package/src/generators/test-generator/adapters/appium/templates/steps/actions/frame-enter-action.hbs

@@ -1,6 +1,3 @@
-{{!-- Hybrid app: switch into the webview context (mobile equivalent of entering an iframe). --}}
-{
-  const __ctxs = await driver.getContexts();
-  const __web = __ctxs.find(c => /WEBVIEW|CHROMIUM/i.test(typeof c === 'string' ? c : c.id));
-  if (__web) await driver.switchContext(typeof __web === 'string' ? __web : __web.id);
-}
+{{!-- Hybrid app: switch into the webview context (mobile equivalent of entering an iframe).
+      Polls for the context and throws when it never appears — see __enterWebContext (#705). --}}
+await __enterWebContext('{{escapeQuotes frameRef}}');

package/src/generators/test-generator/adapters/appium/templates/steps/actions/table-paginate-action.hbs

@@ -0,0 +1,3 @@
+{{!-- An HTML paginator is a web control: a native list pages by scrolling, not by a next/prev
+      button pair, so there is nothing honest to emit here. --}}
+throw new Error("[sungen] 'go to next/prev page in table' drives an HTML paginator and is not supported on the appium adapter. Scroll the list instead, tap the pager control as a plain tap step, or tag this scenario @manual.");

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

@@ -8,7 +8,7 @@
 await expect({{> locator}}).toBeDisplayed();
 {{~else if scope~}}
 await expect({{> locator}}).toBeDisplayed();
-{{~else if nth~}}
+{{~else if (gte nth -1)~}}
 await expect({{> locator}}).toBeDisplayed();
 {{~else~}}
 await __assertVisible({{> appium-selector-expr}});

package/src/generators/test-generator/adapters/appium/templates/steps/gestures/long-press-action.hbs

@@ -1,4 +1,8 @@
 await (async () => { const e = await {{> locator}};
+  // Fail loud on a missing target — `driver.execute` skips WDIO's implicit existence wait, so an
+  // undefined elementId surfaces as an opaque coordinates/offset error instead of the not-found
+  // that actually happened (#668).
+  if (!e.elementId) throw new Error((e as any).error?.message || `Element not found: ${e.selector}`);
   // XCUITest `mobile: touchAndHold` takes SECONDS; UiAutomator2 `mobile: longClickGesture` takes ms.
   if (driver.isIOS) { await driver.execute('mobile: touchAndHold', { elementId: e.elementId, duration: {{durationMs}} / 1000 }); }
   else { await driver.execute('mobile: longClickGesture', { elementId: e.elementId, duration: {{durationMs}} }); }

package/src/generators/test-generator/adapters/appium/templates/steps/gestures/pinch-zoom-action.hbs

@@ -1,4 +1,8 @@
 await (async () => { const e = await {{> locator}};
+  // Fail loud on a missing target — `driver.execute` skips WDIO's implicit existence wait, so an
+  // undefined elementId surfaces as an opaque coordinates/offset error instead of the not-found
+  // that actually happened (#668).
+  if (!e.elementId) throw new Error((e as any).error?.message || `Element not found: ${e.selector}`);
   // XCUITest `mobile: pinch`: scale >1 zooms in, <1 zooms out (velocity sign must match).
   if (driver.isIOS) { await driver.execute('mobile: pinch', { elementId: e.elementId, scale: {{#if zoomOut}}0.5{{else}}2{{/if}}, velocity: {{#if zoomOut}}-1{{else}}1{{/if}} }); }
   else { await driver.execute('mobile: {{#if zoomOut}}pinchCloseGesture{{else}}pinchOpenGesture{{/if}}', { elementId: e.elementId, percent: 0.75 }); }

package/src/generators/test-generator/adapters/appium/templates/steps/partials/locator.hbs

@@ -9,7 +9,15 @@
       scroll-into-view, so a below-fold / nav-occluded element is scrolled into the safe band before any
       find/tap/assert (Appium has no auto-scroll). Parent/scope/nth chains keep the plain `$()` — those
       resolve within a container / by index where a blind scroll doesn't apply.
+      `nth` is an INDEX, gated numerically (`gte nth -1`), not on truthiness (#720): `{{#if nth}}` read
+      `nth: 0` — the index every doc page uses as its example — as "no index declared" and sent it down
+      the __ensureVisible branch, while the web adapter indexed it, so the two adapters disagreed on the
+      one value authors actually write. It renders `(await $$(expr)).at(n)`: `$$` is a
+      ChainablePromiseArray in WDIO v9, so the old `$$(expr)[n]` indexed a promise and was `undefined`
+      for EVERY n (the awaited form is what the mobile helpers elsewhere in the emitted spec already
+      use), and `.at()` carries `-1` = last match with no second branch. The resolver has already
+      normalised anything outside `>= -1` to undefined and reported it as SG-W018.
       `plain=true` (passed by is-hidden-assertion) also forces the bare `$()`: an element asserted HIDDEN
       is expected to be absent, so scroll-hunting for it is both pointless and harmful — the 12x down-scroll
       would drag the screen to the bottom and strand later same-scenario steps that sit above. --}}
-{{~#if parentLocator~}}{{parentLocator}}.{{#if nth}}$$({{> appium-selector-expr}})[{{nth}}]{{else}}$({{> appium-selector-expr}}){{/if}}{{~else~}}{{#if scope}}$('~{{escapeQuotes scope}}').{{#if nth}}$$({{> appium-selector-expr}})[{{nth}}]{{else}}$({{> appium-selector-expr}}){{/if}}{{else}}{{#if nth}}$$({{> appium-selector-expr}})[{{nth}}]{{else}}{{#if plain}}$({{> appium-selector-expr}}){{else}}(await __ensureVisible({{> appium-selector-expr}})){{/if}}{{/if}}{{/if}}{{~/if~}}
+{{~#if parentLocator~}}{{#if (gte nth -1)}}(await {{parentLocator}}.$$({{> appium-selector-expr}})).at({{nth}}){{else}}{{parentLocator}}.$({{> appium-selector-expr}}){{/if}}{{~else~}}{{#if scope}}{{#if (gte nth -1)}}(await $('~{{escapeQuotes scope}}').$$({{> appium-selector-expr}})).at({{nth}}){{else}}$('~{{escapeQuotes scope}}').$({{> appium-selector-expr}}){{/if}}{{else}}{{#if (gte nth -1)}}(await $$({{> appium-selector-expr}})).at({{nth}}){{else}}{{#if plain}}$({{> appium-selector-expr}}){{else}}(await __ensureVisible({{> appium-selector-expr}})){{/if}}{{/if}}{{/if}}{{~/if~}}

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

@@ -210,6 +210,36 @@ async function __assertCheckedState(el: WebdriverIO.Element, expected: boolean,
   }
   throw new Error(`Expect ${label} to be ${want} — read [${signals.map(s => `${s.source} → ${s.value}`).join(', ')}]`);
 }
+
+// Entering a "frame" on a native driver means switching into the WebView CONTEXT — there is no
+// iframe to locate. That context does not exist until the WebView runtime has created it, and the
+// tap that kicks off the navigation returns long before that, so a ONE-SHOT getContexts() reads a
+// list that holds only NATIVE_APP. Skipping the switch on that reading is the worst possible
+// answer: every later step then searches the native tree, where a hybrid WebView is a SINGLE
+// opaque leaf with no children — the target can never appear there, so no downstream wait can
+// recover it and the run dies with a misleading "element still not displayed" (#705). Poll for the
+// context instead, and throw when it never arrives: a step that reads "switch to X frame" must
+// never quietly not switch.
+async function __enterWebContext(label: string): Promise<void> {
+  const budget = Number((driver as any)?.options?.waitforTimeout) || 30000;
+  const deadline = Date.now() + budget;
+  let seen: any[] = [];
+  for (;;) {
+    seen = await driver.getContexts();
+    const web = seen.find(c => /WEBVIEW|CHROMIUM/i.test(typeof c === 'string' ? c : c.id));
+    if (web) { await driver.switchContext(typeof web === 'string' ? web : web.id); return; }
+    if (Date.now() >= deadline) break;
+    await driver.pause(500);
+  }
+  throw new Error(
+    `[sungen] "switch to ${label} frame" — no WEBVIEW/CHROMIUM context appeared within ${budget}ms ` +
+    `(contexts seen: ${JSON.stringify(seen)}). The driver is still in NATIVE_APP, where a hybrid WebView ` +
+    `is one opaque node with no children, so every later step would fail as "element not displayed" ` +
+    `while the real cause is this switch. If the transition is genuinely slower than ${budget}ms, raise ` +
+    `waitforTimeout in wdio.conf.ts; if the screen has no WebView, drop the frame step and assert the ` +
+    `native markers instead.`,
+  );
+}
 {{#if singleAuthRole}}
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -340,23 +370,25 @@ describe('{{featureName}}', () => {
   // @auth:{{singleAuthRole}} — authenticate ONCE before any scenario; the session persists across
   // the per-scenario relaunch below (noReset:true). Throws (blocks the spec) if login can't be done.
   before(async () => {
-{{#if appPackage}}
     // Relaunch to a known launch screen first — the session may attach to the app in any state.
     // Platform-aware id (NOT the Android literal): on iOS a @platform:mobile feature's app is the
     // dual-id bundle id — a literal appPackage here would throw and block the whole spec.
-    // (__resolveAppId is a hoisted function declaration in this describe scope.)
+    // (__resolveAppId is a hoisted function declaration in this describe scope. It is no longer
+    // gated on a `Path:`-derived package (#669): it resolves the session capability too, and throws
+    // a named error when nothing supplies an id at all.)
     const __AUTH_APP__ = __resolveAppId();
     try { await driver.terminateApp(__AUTH_APP__); } catch { /* not running */ }
     await driver.activateApp(__AUTH_APP__);
-{{/if}}
     await __ensureAuth('{{singleAuthRole}}');
   });
 
 {{/if}}
-{{#if appPackage}}
   // Multi-app: this feature's app (from the `Path:` line). Reset to its launch screen before each
   // scenario so one `wdio run` can host screens from different apps — each spec launches its own.
   // The `Path:` holds the ANDROID package (or, for an @platform:ios feature, the iOS bundle id).
+  // EMPTY when the feature declared no usable `Path:` (#669) — the session capability then supplies
+  // the id (see __resolveAppId). Emitted unconditionally so that a feature without a `Path:` still
+  // gets per-scenario reset + Background instead of silently dropping to a once-per-file before().
   const __APP_PKG_DEFAULT__ = '{{appPackage}}';
 {{#if iosBundleId}}
   // Per-feature iOS bundle id from the dual-id `Path: <androidPkg>/<activity> | <iosBundleId>` —
@@ -366,13 +398,26 @@ describe('{{featureName}}', () => {
 {{/if}}
   // Platform-aware app id: an @platform:mobile spec runs on BOTH OSes. On iOS prefer the feature's own
   // bundle id (dual-id Path), then the session cap (IOS_BUNDLE_ID in wdio.conf), then the Path value;
-  // on Android (or any non-iOS session) use the Path package unchanged.
+  // on Android (or any non-iOS session) prefer the Path package, then the session cap.
+  // The session-capability fallback (#669) is what lets a feature with no app-package `Path:` keep a
+  // real per-scenario reset: wdio.conf sets `appium:appPackage` for the run, so the id the compiler
+  // could not read off the feature file is almost always present here. Throwing when NOTHING supplies
+  // it is deliberate — the alternative was the silent once-per-file before() this issue is about,
+  // where scenarios leak tab/scroll/login state into each other and the suite lies about why it
+  // failed. SG-W029 already named this at compile time, so this throw is never the first warning.
   function __resolveAppId(): string {
-    if (typeof driver !== 'undefined' && driver.isIOS) {
-      const caps = (driver.requestedCapabilities || {}) as Record<string, string>;
-      return {{#if iosBundleId}}__IOS_BUNDLE__ || {{/if}}caps['appium:bundleId'] || caps['bundleId'] || __APP_PKG_DEFAULT__;
+    const caps = (typeof driver !== 'undefined' ? (driver.requestedCapabilities || {}) : {}) as Record<string, string>;
+    const resolved = (typeof driver !== 'undefined' && driver.isIOS)
+      ? ({{#if iosBundleId}}__IOS_BUNDLE__ || {{/if}}caps['appium:bundleId'] || caps['bundleId'] || __APP_PKG_DEFAULT__ || caps['appium:appPackage'] || caps['appPackage'])
+      : (__APP_PKG_DEFAULT__ || caps['appium:appPackage'] || caps['appPackage'] || caps['appium:bundleId'] || caps['bundleId']);
+    if (!resolved) {
+      throw new Error(
+        `[sungen] cannot resolve this app's id, so no per-scenario reset is possible (SG-W029). ` +
+        `Add an app-package \`Path:\` to the feature — \`Path: com.example.app/.MainActivity\` — ` +
+        `or set APP_PACKAGE (Android) / IOS_BUNDLE_ID (iOS) so wdio.conf puts it on the session.`,
+      );
     }
-    return __APP_PKG_DEFAULT__;
+    return resolved;
   }
   // ── Reset tier ────────────────────────────────────────────────────────────────────────────────
   // How much state each scenario starts from (`@reset:` on the Feature; default `soft`):
@@ -583,20 +628,6 @@ describe('{{featureName}}', () => {
 {{/if}}
   });
 
-{{/if}}
-{{#unless appPackage}}
-{{#if backgroundSteps}}
-  before(async () => {
-{{#each backgroundSteps}}
-{{#if comment}}
-    // {{comment}}
-{{/if}}
-{{code}}
-{{/each}}
-  });
-
-{{/if}}
-{{/unless}}
 {{#if beforeAll}}
 {{beforeAll}}
 

package/src/generators/test-generator/adapters/index.ts

@@ -1,4 +1,4 @@
-export { TestGeneratorAdapter, TestFileData, ScenarioData, StepTemplateData, LocatorExpression } from './adapter-interface';
+export { TestGeneratorAdapter, TestFileData, ScenarioData, StepTemplateData, LocatorExpression, HookStep, HookRenderData } from './adapter-interface';
 export { AdapterRegistry, adapterRegistry, DriverNotInstalledError } from './adapter-registry';
 export { PlaywrightAdapter } from './playwright/playwright-adapter';
 export { AppiumAdapter } from './appium/appium-adapter';

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

@@ -1,5 +1,5 @@
 import path from 'path';
-import { TestGeneratorAdapter, TestFileData, ScenarioData, RenderImportsOptions } from '../adapter-interface';
+import { TestGeneratorAdapter, TestFileData, ScenarioData, RenderImportsOptions, HookRenderData } from '../adapter-interface';
 import { TemplateEngine } from '../../template-engine';
 
 /**
@@ -34,15 +34,15 @@ export class PlaywrightAdapter implements TestGeneratorAdapter {
     return this.templateEngine.renderBeforeEach(data);
   }
 
-  renderBeforeAll(data: { steps: Array<{ comment?: string; code: string }> }): string {
+  renderBeforeAll(data: HookRenderData): string {
     return this.templateEngine.renderBeforeAll(data);
   }
 
-  renderAfterEach(data: { steps: Array<{ comment?: string; code: string }> }): string {
+  renderAfterEach(data: HookRenderData): string {
     return this.templateEngine.renderAfterEach(data);
   }
 
-  renderAfterAll(data: { steps: Array<{ comment?: string; code: string }> }): string {
+  renderAfterAll(data: HookRenderData): string {
     return this.templateEngine.renderAfterAll(data);
   }
 

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

@@ -1,8 +1,26 @@
-  test.afterAll(async ({ request }) => {
+  test.afterAll(async () => {
+{{#if collect}}
+    // Hook checks are collected: every failed step is recorded and the hook fails ONCE with the full list
+    const __hookFailures: string[] = [];
+{{/if}}
 {{#each steps}}
 {{#if comment}}
     // {{comment}}
 {{/if}}
+{{#if wrap}}
+    try {
+{{code}}
+    } catch (e) {
+      __hookFailures.push({{label}} + ': ' + String((e as Error).message).split('\n')[0]);
+{{#if stopOnFailure}}
+      expect(__hookFailures, 'Hook preconditions not met').toEqual([]);
+{{/if}}
+    }
+{{else}}
 {{code}}
+{{/if}}
 {{/each}}
+{{#if collect}}
+    expect(__hookFailures, 'Hook preconditions not met').toEqual([]);
+{{/if}}
   });

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

@@ -1,8 +1,26 @@
   test.afterEach(async ({ page }) => {
+{{#if collect}}
+    // Hook checks are collected: every failed step is recorded and the hook fails ONCE with the full list
+    const __hookFailures: string[] = [];
+{{/if}}
 {{#each steps}}
 {{#if comment}}
     // {{comment}}
 {{/if}}
+{{#if wrap}}
+    try {
+{{code}}
+    } catch (e) {
+      __hookFailures.push({{label}} + ': ' + String((e as Error).message).split('\n')[0]);
+{{#if stopOnFailure}}
+      expect(__hookFailures, 'Hook preconditions not met').toEqual([]);
+{{/if}}
+    }
+{{else}}
 {{code}}
+{{/if}}
 {{/each}}
+{{#if collect}}
+    expect(__hookFailures, 'Hook preconditions not met').toEqual([]);
+{{/if}}
   });

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

@@ -1,8 +1,26 @@
-  test.beforeAll(async ({ request }) => {
+  test.beforeAll(async () => {
+{{#if collect}}
+    // Hook checks are collected: every failed step is recorded and the hook fails ONCE with the full list
+    const __hookFailures: string[] = [];
+{{/if}}
 {{#each steps}}
 {{#if comment}}
     // {{comment}}
 {{/if}}
+{{#if wrap}}
+    try {
+{{code}}
+    } catch (e) {
+      __hookFailures.push({{label}} + ': ' + String((e as Error).message).split('\n')[0]);
+{{#if stopOnFailure}}
+      expect(__hookFailures, 'Hook preconditions not met').toEqual([]);
+{{/if}}
+    }
+{{else}}
 {{code}}
+{{/if}}
 {{/each}}
+{{#if collect}}
+    expect(__hookFailures, 'Hook preconditions not met').toEqual([]);
+{{/if}}
   });

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

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

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

@@ -1 +1,6 @@
-await {{> locator}}.check();
+{{!-- Playwright's .check() accepts ONLY native checkbox/radio and role=checkbox|radio|switch —
+      a `<button aria-pressed>` toggle threw "Not a checkbox or radio button" (#675). The branch
+      cannot be decided here: a testid/CSS selector carries no role, so the element is inspected at
+      run time by setCheckedState (specs/checked-state.ts), which also keeps the step IDEMPOTENT —
+      the reason `check` exists rather than `click`. --}}
+await setCheckedState({{> locator}}, true, '{{escapeQuotes selectorRef}}'{{> checked-opts cls=checkedClass attr=checkedAttribute}});

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/click-at-position-action.hbs

@@ -0,0 +1,23 @@
+{{#if clickPosition}}
+{{!-- Positioned click: coordinates are relative to the element's PADDING box (clientWidth/Height),
+      the same box `click({ position })` measures from — boundingBox() would be the border box and
+      drift by the border width. Read once, checked, then clicked, so an offset past the real size
+      fails naming that size instead of landing on a neighbour. --}}
+{ const el = {{> locator}};
+const __label = {{{label}}};
+await el.waitFor({ state: 'visible' }); // the box is read once — not before the element has laid out
+{{!-- padding box = bounding rect minus borders: clientWidth/Height would read 0 on an inline element (a link). --}}
+const box = await el.evaluate((n) => {
+  const r = n.getBoundingClientRect(); const cs = getComputedStyle(n); const b = (p: string) => parseFloat(cs.getPropertyValue(p)) || 0;
+  return { w: r.width - b('border-left-width') - b('border-right-width'), h: r.height - b('border-top-width') - b('border-bottom-width') };
+});
+if (box.w <= 0 || box.h <= 0) throw new Error('[sungen] ' + __label + ': element has no layout box (hidden, detached or zero-sized)');
+const x = {{#if (eq clickPosition.xUnit '%')}}box.w * {{clickPosition.xRatio}}{{else}}{{clickPosition.x}}{{/if}};
+const y = {{#if (eq clickPosition.yUnit '%')}}box.h * {{clickPosition.yRatio}}{{else}}{{clickPosition.y}}{{/if}};
+if (x >= box.w || y >= box.h) throw new Error('[sungen] ' + __label + ': click position (' + Math.round(x) + ', ' + Math.round(y) + ') lies outside the element box ' + Math.round(box.w) + 'x' + Math.round(box.h));
+await el.click({ position: { x, y } });
+}
+{{else}}
+{{!-- Unreachable through the compiler (SG-E026 replaces the step) — kept so a stray render fails loud. --}}
+throw new Error('[sungen] click position could not be parsed');
+{{/if}}

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

@@ -5,20 +5,20 @@ await el.click();
 {{else if expanded.class}}
 {{!-- State signalled by a class on a descendant (e.g. an accordion chevron icon). --}}
 {{#if (eq direction 'expand')}}
-if (!(await el.locator('.{{expanded.class}}').count())) { await el.click(); }
-await expect(el.locator('.{{expanded.class}}')).toBeVisible();
+if (!(await el.locator('.{{escapeQuotes expanded.class}}').count())) { await el.click(); }
+await expect(el.locator('.{{escapeQuotes expanded.class}}')).toBeVisible();
 {{else}}
-if (await el.locator('.{{expanded.class}}').count()) { await el.click(); }
-await expect(el.locator('.{{expanded.class}}')).toHaveCount(0);
+if (await el.locator('.{{escapeQuotes expanded.class}}').count()) { await el.click(); }
+await expect(el.locator('.{{escapeQuotes expanded.class}}')).toHaveCount(0);
 {{/if}}
 {{else if expanded.attribute}}
 {{!-- Explicit boolean attribute ('true'/'false'), custom or aria-expanded. --}}
 {{#if (eq direction 'expand')}}
-if (await el.getAttribute('{{expanded.attribute}}') !== 'true') { await el.click(); }
-await expect(el).toHaveAttribute('{{expanded.attribute}}', 'true');
+if (await el.getAttribute('{{escapeQuotes expanded.attribute}}') !== 'true') { await el.click(); }
+await expect(el).toHaveAttribute('{{escapeQuotes expanded.attribute}}', 'true');
 {{else}}
-if (await el.getAttribute('{{expanded.attribute}}') !== 'false') { await el.click(); }
-await expect(el).toHaveAttribute('{{expanded.attribute}}', 'false');
+if (await el.getAttribute('{{escapeQuotes expanded.attribute}}') !== 'false') { await el.click(); }
+await expect(el).toHaveAttribute('{{escapeQuotes expanded.attribute}}', 'false');
 {{/if}}
 {{else}}
 {{!-- Default (zero-config): drive by aria-expanded, but assert it ONLY when the element exposes it. --}}

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

@@ -1,3 +1,8 @@
-const editorLocator = {{> locator}};
+{{!-- Block-scoped, like the appium counterpart: `const editorLocator` at statement level made a
+      SECOND editor fill in the same scenario a duplicate declaration, and Playwright fails the
+      WHOLE file with one SyntaxError — every scenario in it never runs. Unreachable while
+      `contenteditable:` was dead and nothing set `inputMethod` (#712); a form with two rich-text
+      fields hits it immediately once the field works. SG-E022 is the gate that caught it. --}}
+{ const editorLocator = {{> locator}};
 await editorLocator.click();
-await editorLocator.pressSequentially('{{escapeQuotes fillValue}}');
+await editorLocator.pressSequentially('{{escapeQuotes fillValue}}'); }

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/table-action-in-row-nth.hbs

@@ -2,4 +2,6 @@
      role=row, so the ARIA chain below is 0 elements and this assertion would be vacuous, issue #688)
      wins; otherwise the historical ARIA chain, byte-identical. --}}
 { const tableRow = {{> locator}}{{#if rows}}.locator('{{escapeQuotes rows}}'){{else}}.getByRole('row'){{/if}}.nth({{{rowIndexExpr}}});
-await {{{actionLocator}}}.{{action}}(); }
+{{!-- `check`/`uncheck` must not emit a bare .check() here either (#675) — the row control is just
+     as likely to be an aria-pressed toggle as a standalone one. `click` stays a plain click. --}}
+{{#if (eq action 'click')}}await {{{actionLocator}}}.click();{{else}}await setCheckedState({{{actionLocator}}}, {{#if (eq action 'check')}}true{{else}}false{{/if}}, '{{escapeQuotes elementName}}'{{> checked-opts cls=actionCheckedClass attr=actionCheckedAttribute}});{{/if}} }

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/table-action-in-row.hbs

@@ -2,4 +2,6 @@
      role=row, so the ARIA chain below is 0 elements and this assertion would be vacuous, issue #688)
      wins; otherwise the historical ARIA chain, byte-identical. --}}
 { const tableRow = {{> locator}}{{#if rows}}.locator('{{escapeQuotes rows}}'){{else}}.getByRole('row'){{/if}}.filter({ hasText: '{{escapeQuotes filterValue}}' });
-await {{{actionLocator}}}.{{action}}(); }
+{{!-- `check`/`uncheck` must not emit a bare .check() here either (#675) — the row control is just
+     as likely to be an aria-pressed toggle as a standalone one. `click` stays a plain click. --}}
+{{#if (eq action 'click')}}await {{{actionLocator}}}.click();{{else}}await setCheckedState({{{actionLocator}}}, {{#if (eq action 'check')}}true{{else}}false{{/if}}, '{{escapeQuotes elementName}}'{{> checked-opts cls=actionCheckedClass attr=actionCheckedAttribute}});{{/if}} }

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/table-paginate-action.hbs

@@ -0,0 +1,5 @@
+{{!-- The paginator is located from `page`, NOT from inside the table locator: antd/MUI/Radix all
+      render the control as a SIBLING of the <table>, so scoping it to the table would resolve 0
+      elements (issue #712). No implicit wait — the round-trip belongs to
+      `User wait for [X] table to refresh`. A disabled control fails loud: click waits for enabled. --}}
+await page.locator('{{escapeQuotes paginationSelector}}').click();

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

@@ -1 +1,3 @@
-await {{> locator}}.uncheck();
+{{!-- Inverse of check-action.hbs — see there and specs/checked-state.ts for why the control is
+      inspected at run time rather than driven by a bare .uncheck() (#675). --}}
+await setCheckedState({{> locator}}, false, '{{escapeQuotes selectorRef}}'{{> checked-opts cls=checkedClass attr=checkedAttribute}});

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/unknown-element-action.hbs

@@ -1 +1 @@
-await page.getByText('{{escapeQuotes selectorValue}}').filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact legacyTail=(eq selectorValue "")}} }){{#if (gte nth 0)}}.nth({{nth}}){{/if}}.{{action}}();
+await page.getByText('{{escapeQuotes selectorValue}}').filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact legacyTail=(eq selectorValue "")}} }){{> locator-nth}}.{{action}}();

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/wait-for-page.hbs

@@ -1 +1,18 @@
-await page.waitForURL(/{{pathRegex}}/);
+{{!-- `wait for [T] page` is a WAIT, not an oracle — but a bare `page.waitForURL(/…/)` resolves on
+      the FIRST URL sample that matches, which for a client-side router is the URL it pushed before
+      the route guard had answered. Every step after the wait then ran against a page mid-redirect,
+      so their failures pointed at the wrong thing (#677). The unanchored regex also matched a
+      neighbour: `/vi/search` resolved on `/vi/search-results`.
+
+      `waitForPage` is the third caller of the settle-and-hold core in specs/url-assert.ts, after
+      the `see [T] page` / `is on [T] page` pair #662 routed there (partials/url-assertion.hbs):
+      arrive, let the page settle, HOLD the URL, and fail naming where the user actually ended up.
+
+      Where it deliberately DIFFERS from the Then-side `expectPage`: the query is not constrained.
+      A bare page ASSERTION means a bare page; a wait for a results page legitimately lands on
+      `?q=…`, and reddening there would assert something the step never said. The helper's docstring
+      carries the full argument.
+
+      `hostname` rides separately and only for an absolute page value: it is read off `u.hostname`,
+      which never appears in `u.pathname`, so one concatenated regex cannot carry both. --}}
+await waitForPage(page, { pathname: /^{{pathRegex}}\/?$/{{#if hostRegex}}, hostname: /^{{hostRegex}}$/{{/if}} });

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/all-contain-assertion.hbs

@@ -1,7 +1,35 @@
-{
-    const __items_{{stepCounter}} = await {{> locator}}.allInnerTexts();
-    expect(__items_{{stepCounter}}.length, 'Expected at least one [{{selectorRef}}]').toBeGreaterThan(0);
+{{!-- All-contain: the assertion has to SURVIVE whatever async action precedes it.
+
+      `locator.allInnerTexts()` is a one-shot DOM read — no auto-wait, no retry — and wrapping its
+      RESULT in expect() adds no waiting either, because by then it is a plain array of strings.
+      Playwright's auto-waiting only applies when the LOCATOR is handed to expect(). Placed after a
+      search click or a filter change, the old shape asserted against the PRE-action DOM and failed
+      deterministically, naming real-looking values that read as a product defect rather than as a
+      generator bug (#672). A `toBeGreaterThan(0)` guard does not help: the stale list is non-empty,
+      so the length check passes and the CONTENT check is what races.
+
+      Playwright has no locator-level "every match contains X" — `filter({ hasNotText })` matches
+      case-insensitively on normalized whitespace, which is not the `toContain` semantics this step
+      promises — so the wait is expressed with expect.poll, which retries for `expect.timeout` from
+      playwright.config.ts. Two details carry the fix:
+
+      - The loop asserts on the snapshot the poll SETTLED on. Re-reading the locator afterwards
+        reopens the very race being closed — a late render pass between the poll settling and the
+        re-read swapped the rows out again, which is how the reporter's first patch passed in
+        isolation and failed in the full suite.
+      - The poll's own rejection is swallowed: on its own it can only report
+        `toBe(true) received false`. The per-item expect() below names expected vs received, which
+        is the message a QA has to act on. --~}}{
+    const __expected_{{stepCounter}} = '{{escapeQuotes expectedText}}';
+    let __items_{{stepCounter}}: string[] = [];
+    try {
+      await expect.poll(async () => {
+        __items_{{stepCounter}} = await {{> locator}}.allInnerTexts();
+        return __items_{{stepCounter}}.length > 0 && __items_{{stepCounter}}.every((__s) => __s.includes(__expected_{{stepCounter}}));
+      }).toBe(true);
+    } catch { /* the assertions below report expected-vs-received on the settled snapshot */ }
+    expect(__items_{{stepCounter}}.length, 'Expected at least one [{{escapeQuotes selectorRef}}]').toBeGreaterThan(0);
     for (const __t_{{stepCounter}} of __items_{{stepCounter}}) {
-      expect(__t_{{stepCounter}}).toContain('{{expectedText}}');
+      expect(__t_{{stepCounter}}).toContain(__expected_{{stepCounter}});
     }
   }

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/all-contain-element.hbs

@@ -1,7 +1,10 @@
-{
+{{!-- The count() below is a one-shot read, same class as #672: after a search or filter click the
+      container list may not have rendered yet, and a bare `toBeGreaterThan(0)` on a stale 0 fails
+      instantly with no retry. `not.toHaveCount(0)` IS locator-based, so it auto-waits for the list
+      to appear; count() then reads a list that is already known to exist. --~}}{
     const {{containerVar}} = {{> locator}};
+    await expect({{containerVar}}, 'Expected at least one [{{escapeQuotes selectorRef}}]').not.toHaveCount(0);
     const __n_{{stepCounter}} = await {{containerVar}}.count();
-    expect(__n_{{stepCounter}}, 'Expected at least one [{{escapeQuotes selectorRef}}]').toBeGreaterThan(0);
     for (let {{containerIndexVar}} = 0; {{containerIndexVar}} < __n_{{stepCounter}}; {{containerIndexVar}}++) {
       await expect({{#with child}}{{> locator parentLocator=(add (add (add ../containerVar ".nth(") ../containerIndexVar) ")")}}{{/with}}, 'Every [{{escapeQuotes selectorRef}}] must contain [{{escapeQuotes childRef}}]').toBeVisible();
     }

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

@@ -1 +1,5 @@
-await expect({{> locator}}).toBeChecked();
+{{!-- `expect(locator).toBeChecked()` throws the same "Not a checkbox or radio button" (#675) on a
+      `<button aria-pressed>` as the action side did, so driving a toggle worked while ASSERTING it
+      did not. expectCheckedState reads state the same way setCheckedState drives it — an action and
+      the assertion after it can never disagree about what the control reports. --}}
+await expectCheckedState({{> locator}}, true, '{{escapeQuotes selectorRef}}'{{> checked-opts cls=checkedClass attr=checkedAttribute}});