@sun-asterisk/sungen 3.2.28 → 3.2.30

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

@@ -1,6 +1,14 @@
 {{#if platform}}
 // sungen:platform={{platform}}
 {{/if}}
+{{#if screenshotOnFailure}}
+// @screenshot:on-failure — used to be web-only and silently dropped on mobile.
+// wdio.conf.ts's afterTest hook already captures screenshot + page source + device log for EVERY
+// mobile failure, so the tag is not what turns evidence on. What it declares is that this feature's
+// evidence is ESSENTIAL: it survives SUNGEN_MOBILE_EVIDENCE=off, which otherwise suppresses capture
+// for the run. Set at module load, so it covers every scenario in this spec.
+(globalThis as Record<string, unknown>).__sungenForceEvidence = true;
+{{/if}}
 {{#if runtimeData}}
 
 const testData = TestDataLoader.load('{{screenName}}', '{{featureFileName}}');
@@ -202,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';
@@ -332,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>` —
@@ -358,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`):
@@ -575,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

@@ -1,2 +1,7 @@
-{ const tableRow = {{> locator}}.getByRole('row').nth({{{rowIndexExpr}}});
-await {{{actionLocator}}}.{{action}}(); }
+{{!-- Row universe: `rows:` on the table entry (what EVERY row matches — a <div> list has no
+     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}}});
+{{!-- `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

@@ -1,2 +1,7 @@
-{ const tableRow = {{> locator}}.getByRole('row').filter({ hasText: '{{escapeQuotes filterValue}}' });
-await {{{actionLocator}}}.{{action}}(); }
+{{!-- Row universe: `rows:` on the table entry (what EVERY row matches — a <div> list has no
+     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}}' });
+{{!-- `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}});

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

@@ -1,3 +1,14 @@
-await expect({{> locator}}.getByRole('columnheader', { name: '{{columnName}}', includeHidden: true })).toBeVisible();
+{{!-- Rooted at `page`, like the two lines below it. This line used to render `{{> locator}}` from
+      step data that carries no strategy/value at all, so it emitted `page.locator('')` — an empty
+      CSS selector, which Playwright refuses to parse. The step could not run.
+
+      Block-scoped: the column-index const is named after the [Reference], so two steps naming the
+      same column — or two non-ASCII references, which sanitize down to the same identifier — would
+      redeclare it in one scenario and the spec would not compile. The braces make each step's
+      binding its own.
+
+      Not dialog/frame scoped: this step form carries no selector entry, so there is nothing for
+      `pageRoot` to read. A column assertion inside a modal needs the row-scoped form. --~}}{ await expect(page.getByRole('columnheader', { name: '{{columnName}}', includeHidden: true })).toBeVisible();
 const {{columnIndexVar}} = (await page.getByRole('columnheader', { includeHidden: true }).filter({ visible: true }).allTextContents()).findIndex(h => h.includes('{{columnName}}'));
-await expect(page.getByRole('row', { includeHidden: true }).filter({ visible: true }).nth({{rowNth}}).getByRole('cell', { includeHidden: true }).filter({ visible: true }).nth({{columnIndexVar}})).toHaveText('{{dataValue}}');
+expect({{columnIndexVar}}, 'Column "{{escapeQuotes columnName}}" is not among the visible headers').toBeGreaterThanOrEqual(0);
+await expect(page.getByRole('row', { includeHidden: true }).filter({ visible: true }).nth({{rowNth}}).getByRole('cell', { includeHidden: true }).filter({ visible: true }).nth({{columnIndexVar}})).toHaveText('{{dataValue}}'); }

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

@@ -1 +1 @@
-await expect({{> locator}}).toContainText('{{expectedText}}');
+await expect({{> locator}}).toContainText('{{escapeQuotes expectedText}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/disabled-with-role-variable-assertion.hbs

@@ -1,5 +1,5 @@
 {{#if name}}
-await expect(page.getByRole('{{role}}', { name: '{{escapeQuotes name}}'{{#if exact}}, exact: true{{/if}} }).filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{#if (gte nth 0)}}.nth({{nth}}){{/if}}).toBeDisabled();
+await expect(page.getByRole('{{role}}', { name: '{{escapeQuotes name}}'{{#if exact}}, exact: true{{/if}} }).filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{> locator-nth}}).toBeDisabled();
 {{else}}
-await expect(page.getByRole('{{role}}'{{#if exact}}, { exact: true }{{/if}}).filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{#if (gte nth 0)}}.nth({{nth}}){{/if}}).toBeDisabled();
+await expect(page.getByRole('{{role}}'{{#if exact}}, { exact: true }{{/if}}).filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{> locator-nth}}).toBeDisabled();
 {{/if}}

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/disabled-with-variable-assertion.hbs

@@ -1 +1 @@
-await expect(page.getByText('{{escapeQuotes selectorRef}}').filter({ hasText: {{#if (eq selectorValue "")}}/.*{{escapeRegex dataValue}}$/{{else}}'{{escapeQuotes dataValue}}'{{/if}} }){{#if (gte nth 0)}}.nth({{nth}}){{/if}}).toBeDisabled();
+await expect(page.getByText('{{escapeQuotes selectorRef}}').filter({ hasText: {{#if (eq selectorValue "")}}/.*{{escapeRegex dataValue}}$/{{else}}'{{escapeQuotes dataValue}}'{{/if}} }){{> locator-nth}}).toBeDisabled();

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

@@ -1 +1 @@
-await expect({{> locator}}).toHaveText('{{expectedText}}');
+await expect({{> locator}}).toHaveText('{{escapeQuotes expectedText}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/hidden-with-role-variable-assertion.hbs

@@ -1,5 +1,5 @@
 {{#if name}}
-await expect(page.getByRole('{{role}}', { name: '{{escapeQuotes name}}'{{#if exact}}, exact: true{{/if}} }).filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{#if (gte nth 0)}}.nth({{nth}}){{/if}}).toBeHidden();
+await expect(page.getByRole('{{role}}', { name: '{{escapeQuotes name}}'{{#if exact}}, exact: true{{/if}} }).filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{> locator-nth}}).toBeHidden();
 {{else}}
-await expect(page.getByRole('{{role}}'{{#if exact}}, { exact: true }{{/if}}).filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{#if (gte nth 0)}}.nth({{nth}}){{/if}}).toBeHidden();
+await expect(page.getByRole('{{role}}'{{#if exact}}, { exact: true }{{/if}}).filter({ hasText: /^{{escapeRegex dataValue}}$/ }){{> locator-nth}}).toBeHidden();
 {{/if}}

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

@@ -1 +1 @@
-await expect(page.getByText('{{escapeQuotes selectorRef}}').filter({ hasText: {{#if (eq selectorValue "")}}/.*{{escapeRegex dataValue}}$/{{else}}'{{escapeQuotes dataValue}}'{{/if}} }){{#if (gte nth 0)}}.nth({{nth}}){{/if}}).toBeHidden();
+await expect(page.getByText('{{escapeQuotes selectorRef}}').filter({ hasText: {{#if (eq selectorValue "")}}/.*{{escapeRegex dataValue}}$/{{else}}'{{escapeQuotes dataValue}}'{{/if}} }){{> locator-nth}}).toBeHidden();

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

@@ -1 +1,2 @@
-await expect({{> locator}}).toBeChecked({ checked: false });
+{{!-- Inverse of checked-assertion.hbs — see there (#675). --}}
+await expectCheckedState({{> locator}}, false, '{{escapeQuotes selectorRef}}'{{> checked-opts cls=checkedClass attr=checkedAttribute}});

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

@@ -1,7 +1,16 @@
-{{#if (or (eq role 'checkbox') (eq role 'radio') (eq role 'switch'))}}
+{{#if (or checkedClass checkedAttribute)}}
+{{!-- A DECLARED signal (issue #730) short-circuits the whole ARIA probe below: the author
+     reached for `selected:`/`checked:` precisely because this component publishes no aria-selected,
+     no aria-current and no checked state — a Tailwind card/tab picker. Probing for them first would
+     just spend the budget confirming they are absent. --}}
+await expectCheckedState({{> locator}}, true, '{{escapeQuotes selectorRef}}'{{> checked-opts cls=checkedClass attr=checkedAttribute}});
+{{else if (or (eq role 'checkbox') (eq role 'radio') (eq role 'switch'))}}
 {{!-- Form control: "selected" is the checked state, never aria-selected. A native checkbox/radio
      exposes no aria-selected attribute — its state lives in the `checked` property. --}}
-await expect({{> locator}}).toBeChecked();
+{{!-- "selected" on a form control IS the checked state — routed through expectCheckedState so an
+     aria-pressed toggle does not throw "Not a checkbox or radio button" (#675), and so the selector
+     that declares role: switch while the element publishes aria-pressed still reads correctly. --}}
+await expectCheckedState({{> locator}}, true, '{{escapeQuotes selectorRef}}');
 {{else}}
 {{!-- Other/unknown role (tab, option, or a text/testid/css selector): probe at runtime. An ARIA
      single-select widget exposes aria-selected → assert it; anything without it falls back to the
@@ -9,8 +18,17 @@ await expect({{> locator}}).toBeChecked();
 { const el = {{> locator}};
 if ((await el.getAttribute('aria-selected')) !== null) {
 await expect(el).toHaveAttribute('aria-selected', 'true');
+} else if ((await el.getAttribute('aria-current')) !== null) {
+{{!-- aria-current marks the CURRENT item of a navigation set (WAI-ARIA 1.1): a Next.js tab strip
+     of plain <a> links carries aria-current="page" and has neither aria-selected nor a checked
+     state, so toBeChecked() threw "Not a checkbox or radio button" on a correct step. Any value
+     but "false" ("page", "step", "true", …) means current. Probed AFTER aria-selected: a real
+     role=tab owns the stronger signal. --}}
+await expect(el).toHaveAttribute('aria-current', /^(?!false$)./);
 } else {
-await expect(el).toBeChecked();
+{{!-- Last resort, same as the -with-filter twin: neither aria-selected nor aria-current, so read the
+     checked/pressed state through the #675-safe path rather than toBeChecked(). --}}
+await expectCheckedState(el, true, '{{escapeQuotes selectorRef}}');
 }
 }
 {{/if}}

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

@@ -1,13 +1,31 @@
 {{!-- Filter contract shared with the visible/hidden/contains siblings (has-text-value):
       substring by default, `exact: true` in the selector YAML anchors. --}}
 {{#if selectedProbe}}
+{{#if (or checkedClass checkedAttribute)}}
+{{!-- Declared class signal (issue #730) — short-circuits the ARIA probe, exactly as the unfiltered
+     twin selected-assertion.hbs does. Without this branch the filtered form stayed broken while the
+     unfiltered one worked, which is the inconsistency #730's second field report ran into. --}}
+await expectCheckedState({{> locator-base}}.filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact}} }){{> locator-nth}}, true, '{{escapeQuotes selectorRef}}'{{> checked-opts cls=checkedClass attr=checkedAttribute}});
+{{else}}
 { 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 if ((await el.getAttribute('aria-current')) !== null) {
+{{!-- aria-current marks the CURRENT item of a navigation set (WAI-ARIA 1.1): a Next.js tab strip
+     of plain <a> links carries aria-current="page" and has neither aria-selected nor a checked
+     state, so toBeChecked() threw "Not a checkbox or radio button" on a correct step. Any value
+     but "false" ("page", "step", "true", …) means current. Probed AFTER aria-selected: a real
+     role=tab owns the stronger signal. --}}
+await expect(el).toHaveAttribute('aria-current', /^(?!false$)./);
 } else {
-await expect(el).toBeChecked();
+{{!-- Last resort: the element publishes neither aria-selected nor aria-current. toBeChecked() used
+     to sit here and threw "Not a checkbox or radio button" on an aria-pressed toggle (#675). --}}
+await expectCheckedState(el, true, '{{escapeQuotes selectorRef}}');
 }
 }
+{{/if}}
+{{else}}{{#if isCheckedAssertion}}
+await expectCheckedState({{> locator-base}}.filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact}} }){{> locator-nth}}, {{checkedWant}}, '{{escapeQuotes selectorRef}}'{{> checked-opts cls=checkedClass attr=checkedAttribute}});
 {{else}}
 await expect({{> locator-base}}.filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact}} }){{> locator-nth}}).{{{stateAssertion}}};
-{{/if}}
+{{/if}}{{/if}}

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/table-empty.hbs

@@ -1 +1,4 @@
-await expect({{> locator}}.locator('tbody').getByRole('row', { includeHidden: true }).filter({ visible: true })).toHaveCount(0);
+{{!-- Row universe: `rows:` on the table entry (what EVERY row matches — a <div> list has no
+     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. --}}
+await expect({{> locator}}{{#if rows}}.locator('{{escapeQuotes rows}}'){{else}}.locator('tbody').getByRole('row', { includeHidden: true }){{/if}}.filter({ visible: true })).toHaveCount(0);