@sungen/driver-ui 3.2.24 → 3.2.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-ui",
-  "version": "3.2.24",
+  "version": "3.2.25",
   "description": "Sungen UI capability (Playwright) — step patterns, viewpoint gate, and phase hooks. Plugs into @sun-asterisk/sungen via the capability SPI.",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -13,7 +13,7 @@
   "author": "eqe team (engineer & quality) — Sun Asterisk",
   "license": "MIT",
   "dependencies": {
-    "@sun-asterisk/sungen": "3.2.24"
+    "@sun-asterisk/sungen": "3.2.25"
   },
   "peerDependencies": {
     "@playwright/test": "^1.57.0"

package/src/app-profile-presets.ts

@@ -20,6 +20,11 @@ export const APP_PROFILE_PRESETS: Record<string, unknown> = {
           { click: '$trigger' },
           { clickText: { role: 'option', text: '$value', exact: true } },
         ],
+        // The trigger is a <button role="combobox"> — it has no DOM `value`, so the selected
+        // option is read from its text (Radix renders it into <SelectValue> inside the button).
+        assertValue: [
+          { expectText: { locator: '$trigger', value: '$value', exact: true } },
+        ],
       },
       // Ant Design Select: closed panels stay in the DOM hidden — scope every lookup
       // to the VISIBLE dropdown panel. `waitFor: attached` first because a select that
@@ -33,6 +38,11 @@ export const APP_PROFILE_PRESETS: Record<string, unknown> = {
           { waitFor: '.ant-select-dropdown:not(.ant-select-dropdown-hidden)' },
           { clickText: { within: '.ant-select-dropdown:not(.ant-select-dropdown-hidden)', text: '$value' } },
         ],
+        // AntD keeps the chosen label in `.ant-select-selection-item` inside the trigger, not in
+        // a form value — assert the trigger's text, never toHaveValue().
+        assertValue: [
+          { expectText: { locator: '$trigger', value: '$value', exact: true } },
+        ],
       },
       // Ant Design DatePicker (typed input + panel): after typing, the panel keeps
       // blocking pointer events; a single blur dismisses it (Escape/force-click are

package/src/patterns/assertion-patterns.ts

@@ -1,5 +1,6 @@
 import { ParsedStep } from '@sun-asterisk/sungen';
-import { StepPattern, StepTemplateData } from '@sun-asterisk/sungen';
+import { formatToRegexLiteral } from '@sun-asterisk/sungen';
+import { StepPattern, StepTemplateData, expandRecipe } from '@sun-asterisk/sungen';
 import { LIST_MEMBER_ROLES } from '@sun-asterisk/sungen';
 import { pathToRegexSource } from '../utils/url-path-regex';
 
@@ -23,6 +24,22 @@ function qualifiedState(text: string): { assertion: string; label: string; probe
   return null;
 }
 
+/** Locator-strategy element-type tokens that name a LIST MEMBER (many-matching by design —
+ *  custom widgets with no role, e.g. a 96-slot time picker). Text assertions on these must
+ *  filter the multi-locator by the value first: a bare toHaveText/toContainText on the raw
+ *  locator strict-mode-fails. The role-strategy counterpart is LIST_MEMBER_ROLES. */
+const LOCATOR_LIST_MEMBER_TYPES = new Set(['item', 'listitem', 'option', 'cell']);
+
+/**
+ * INVARIANT — a pattern whose generated code accounts for a trailing state clause (`… is hidden`)
+ * MUST declare it in `states`. Undeclared, the clause reaches SG-E021 and the step compiles to a
+ * `throw`; over-declared, the clause is silently dropped and the assertion reads as something it is
+ * not. Determine the truth from the TEMPLATE the resolver names, never from the matcher.
+ *
+ * Deliberately NOT declared, because each really does drop the clause today: `page-assertion`
+ * (a page has no state — this was the original defect), `wait-for-page`, `table-row-exists`,
+ * `table-column-exists`, `see-with-variable`, `alert-text-assertion`, `all-contain-element`.
+ */
 export const assertionPatterns: StepPattern[] = [
   // Browser alert text assertion: "see [Are you sure?] alert"
   {
@@ -145,6 +162,7 @@ export const assertionPatterns: StepPattern[] = [
   // Pattern: Then User see [panel] dialog with {{kudo.title}} hidden -> toBeHidden()
   {
     name: 'see-with-variable-hidden',
+    states: ['hidden'],
     matcher: (step: ParsedStep) =>
       (step.text.includes('should see') || step.text.match(/\b(see|sees)\s+\[/)) &&
       !!step.selectorRef &&
@@ -217,6 +235,7 @@ export const assertionPatterns: StepPattern[] = [
   // Pattern: Then User see [submit] button with {{label}} disabled -> toBeDisabled()
   {
     name: 'see-with-variable-disabled',
+    states: ['disabled'],
     matcher: (step: ParsedStep) =>
       (step.text.includes('should see') || step.text.match(/\b(see|sees)\s+\[/)) &&
       !!step.selectorRef &&
@@ -287,6 +306,9 @@ export const assertionPatterns: StepPattern[] = [
   // `is disabled` / `is hidden` keep their existing dedicated twins — not matched here.
   {
     name: 'see-with-variable-state',
+    // Exactly the labels `qualifiedState()` above resolves — `hidden`/`disabled` are excluded
+    // there and owned by the -hidden/-disabled twins.
+    states: ['checked', 'empty', 'enabled', 'focused', 'selected', 'unchecked'],
     matcher: (step: ParsedStep) =>
       (step.text.includes('should see') || !!step.text.match(/\b(see|sees)\s+\[/)) &&
       !!step.selectorRef &&
@@ -351,6 +373,9 @@ export const assertionPatterns: StepPattern[] = [
         'field', 'textarea', 'search', 'dropdown', 'slider', 'date-picker',
         'input', 'textbox', 'editor', 'select', 'combobox',
       ]);
+      // Subset of INPUT_TYPES whose DOM implementation cannot be inferred from the token:
+      // a component library may render any of these as a non-input trigger element.
+      const AMBIGUOUS_VALUE_TYPES = new Set(['dropdown', 'select', 'combobox']);
 
       // Resolve data variable value
       let dataValue: string;
@@ -387,10 +412,46 @@ export const assertionPatterns: StepPattern[] = [
       }
 
       // --- Input types: toHaveValue ---
+      // `dropdown`/`select`/`combobox` are AMBIGUOUS: 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, which a button has not got
+      // — hence the runtime "Not an input element". Resolution follows the app-profile layering
+      // (sungen_app_profile_spec.md §3): per-element `variant:` / app-profile recipe wins, and
+      // the built-in default probes the tag at runtime instead of assuming a native input.
       if (step.elementType && INPUT_TYPES.has(step.elementType)) {
+        const ambiguous =
+          (AMBIGUOUS_VALUE_TYPES.has(step.elementType) ||
+            ['combobox', 'listbox'].includes(resolved.role)) &&
+          resolved.variant !== 'native';
+
+        if (ambiguous) {
+          // `assertValue` is the third recipe intent the app-profile spec defines alongside
+          // `fill`/`select` (spec §3.1). Same lookup shape as the select-dropdown fork.
+          const variantName = resolved.variant || context.appProfile?.widgetVariants?.['select'];
+          const recipeSteps =
+            variantName && variantName !== 'native'
+              ? context.appProfile?.recipes?.[variantName]?.['assertValue']
+              : undefined;
+          if (recipeSteps) {
+            try {
+              const steps = expandRecipe(recipeSteps as unknown[], {
+                triggerCode: context.renderLocator(resolved),
+                value: dataValue,
+              });
+              return {
+                code: context.templateEngine.renderStep('recipe-sequence', { steps }),
+                comment: `Assert ${step.selectorRef} has value ${step.dataRef} (${variantName} recipe)`,
+              };
+            } catch {
+              // malformed recipe -> fall through to the runtime probe below
+            }
+          }
+        }
+
         const code = context.templateEngine.renderStep('have-value-assertion', {
           ...resolved,
           dataValue,
+          probeNative: ambiguous,
         });
         return {
           code,
@@ -453,17 +514,18 @@ export const assertionPatterns: StepPattern[] = [
 
       // --- Everything else: toHaveText (exact full match) ---
       // Locator-strategy LIST MEMBERS first: `see [X] item|option|cell with {{v}}` on a
-      // CSS-locator list (custom widgets with no role — e.g. a 96-slot time picker) means
-      // "a member whose text is v exists". A bare toHaveText on the multi-matching locator
-      // strict-mode-fails, so filter by the EXACT value then assert visible — the locator
-      // counterpart of the role-based branch below. Unique-element types (text/message/…)
+      // CSS-locator list means "a member whose text is v exists". A bare toHaveText on the
+      // multi-matching locator strict-mode-fails, so filter by the value then assert
+      // visible — the locator counterpart of the role-based branch below. The filter
+      // matches by SUBSTRING (Playwright's standard hasText) unless the selector YAML
+      // declares `exact: true` — the same contract as the role branch; a hardcoded exact
+      // here rejected members whose rendered text wraps the value (icons, counts, i18n
+      // suffixes) with no way to opt out. Unique-element types (text/message/…)
       // keep toHaveText: that is a VALUE assertion and must not be weakened to existence.
-      const LOCATOR_LIST_MEMBER_TYPES = new Set(['item', 'listitem', 'option', 'cell']);
       if (resolved.strategy === 'locator' && step.elementType && LOCATOR_LIST_MEMBER_TYPES.has(step.elementType)) {
         const code = context.templateEngine.renderStep('visible-filtered-assertion', {
           ...resolved,
           dataValue,
-          exact: true,
         });
         return {
           code,
@@ -534,6 +596,9 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'should-be-visible',
+    // `is visible` is redundant (bare `see [X] type` already asserts it) but harmless — the review
+    // checklist flags the redundancy; the compiler must not turn it into a hard failure.
+    states: ['visible'],
     matcher: (step: ParsedStep) =>
       (step.text.includes('should be visible') ||
        step.text.includes('should be displayed') ||
@@ -552,6 +617,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'is-hidden',
+    states: ['hidden'],
     // "see [target] is hidden" — no variable version; with-variable handled by see-with-variable-hidden
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis hidden\b/.test(step.text) &&
@@ -568,6 +634,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'should-be-enabled',
+    states: ['enabled'],
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis enabled\b/.test(step.text) && !!step.selectorRef,
     resolver: (step, context): StepTemplateData => {
@@ -582,6 +649,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'should-be-disabled',
+    states: ['disabled'],
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis disabled\b/.test(step.text) && !!step.selectorRef,
     resolver: (step, context): StepTemplateData => {
@@ -594,6 +662,29 @@ export const assertionPatterns: StepPattern[] = [
     },
     priority: 11,
   },
+  {
+    // `matches "<format>"` — assert the SHAPE of a label, not its value. A spec states a label's
+    // contract as "Format: yyyy/mm/dd ~ yyyy/mm/dd" or "Format: 残りX個"; neither existing text
+    // assertion can carry that (an exact value pins data that changes daily, `contains` passes on
+    // anything). Requires the quoted form so it cannot claim the API-side `matches schema [Ref]`.
+    // Priority above should-have-text / should-contain-text (both 12): those match on the words
+    // "has text" / "contains", which a format step does not use, but the generic visibility
+    // catch-all would otherwise take an unrecognised `see [X] label matches …`.
+    name: 'matches-format',
+    matcher: (step: ParsedStep) =>
+      /\bmatches\s+"/i.test(step.text) && !!step.selectorRef && !!step.value,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'matches-format-assertion',
+        // `format` rides along so a failure message can name the shape the author asked for —
+        // a bare regex in the error is the hardest kind of red for a QA to read.
+        data: { ...resolved, selectorRef: step.selectorRef, formatRegex: formatToRegexLiteral(step.value!), format: step.value },
+        comment: `Assert ${step.selectorRef} matches the format "${step.value}"`,
+      };
+    },
+    priority: 16,
+  },
   {
     name: 'should-contain-text',
     matcher: (step: ParsedStep) =>
@@ -601,10 +692,31 @@ export const assertionPatterns: StepPattern[] = [
     resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const expectedText = step.value || context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      const comment = `Assert ${step.selectorRef} contains "${step.value || step.dataRef}"`;
+      // LIST MEMBERS (locator item/option/cell types, role listitem/option/cell): the
+      // locator matches many elements by design, so a bare toContainText strict-mode-fails.
+      // `contains` on a list means "a member containing v exists" — filter by the substring
+      // then assert visible, the same routing the with-{{v}} existence branches use.
+      // Always substring here (never the YAML `exact`): the step itself says "contains".
+      // Unique elements keep toContainText below — a VALUE assertion is not weakened.
+      // A role entry pinned to ONE element (explicit `name:` or `nth:`) counts as unique:
+      // filter-then-visible would turn its value check into a visibility gate (a collapsed
+      // but present member would flip from pass to fail with a worse failure message).
+      const isListMember =
+        (resolved.strategy === 'locator' && step.elementType && LOCATOR_LIST_MEMBER_TYPES.has(step.elementType)) ||
+        (resolved.strategy === 'role' && !!resolved.role && LIST_MEMBER_ROLES.has(resolved.role) &&
+          !(resolved.name && resolved.name.trim()) && resolved.nth == null);
+      if (isListMember) {
+        return {
+          templateName: 'visible-filtered-assertion',
+          data: { ...resolved, exact: false, dataValue: expectedText },
+          comment,
+        };
+      }
       return {
         templateName: 'contain-text-assertion',
         data: { ...resolved, expectedText },
-        comment: `Assert ${step.selectorRef} contains "${step.value || step.dataRef}"`,
+        comment,
       };
     },
     priority: 12,
@@ -626,6 +738,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'is-empty',
+    states: ['empty'],
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis empty\b/.test(step.text) && !!step.selectorRef,
     resolver: (step, context): StepTemplateData => {
@@ -640,6 +753,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'is-checked',
+    states: ['checked'],
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis checked\b/.test(step.text) && !!step.selectorRef,
     resolver: (step, context): StepTemplateData => {
@@ -654,6 +768,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'is-unchecked',
+    states: ['unchecked'],
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis unchecked\b/.test(step.text) && !!step.selectorRef,
     resolver: (step, context): StepTemplateData => {
@@ -668,6 +783,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'is-focused',
+    states: ['focused'],
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis focused\b/.test(step.text) && !!step.selectorRef,
     resolver: (step, context): StepTemplateData => {
@@ -771,6 +887,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'is-loading',
+    states: ['loading'],
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis loading\b/.test(step.text) && !!step.selectorRef,
     resolver: (step, context): StepTemplateData => {
@@ -785,6 +902,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'is-selected',
+    states: ['selected'],
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis selected\b/.test(step.text) && !!step.selectorRef,
     resolver: (step, context): StepTemplateData => {
@@ -799,6 +917,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'is-sorted-ascending',
+    states: ['sorted ascending'],
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bsorted ascending\b/.test(step.text) && !!step.selectorRef,
     resolver: (step, context): StepTemplateData => {
@@ -813,6 +932,7 @@ export const assertionPatterns: StepPattern[] = [
   },
   {
     name: 'is-sorted-descending',
+    states: ['sorted descending'],
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bsorted descending\b/.test(step.text) && !!step.selectorRef,
     resolver: (step, context): StepTemplateData => {

package/src/patterns/form-patterns.ts

@@ -74,6 +74,29 @@ export const formPatterns: StepPattern[] = [
         }
       }
 
+      // A date-picker on MOBILE with no recipe configured: refuse rather than type into it.
+      // The generic fill is `click → clearValue → setValue`, which is right for a text field and
+      // wrong for a native picker — Android opens a spinner/calendar DIALOG, so setValue lands on
+      // the trigger, selects nothing, and reports success. The step then reads as "the date was
+      // chosen" while nothing was. The recipe hook above is the supported answer (an app profile
+      // declaring `widgets.datepicker`); without one there is no honest compilation, so this
+      // follows the upload-step precedent and fails loud with the two ways forward.
+      if (isDatePicker && context.platform === 'mobile') {
+        return {
+          templateName: 'date-picker-unsupported',
+          data: {
+            reason:
+              // No double quotes in this text: it is rendered INTO a double-quoted JS string literal,
+              // where a stray quote would break the generated file rather than the step.
+              `date-picker step for [${step.selectorRef}] cannot be compiled on the appium adapter: `
+              + `a native picker is a dialog, so the generic fill would type into the trigger and select `
+              + `nothing while reporting success. Declare the picker choreography in qa/app.yaml `
+              + `(widgets.datepicker, a recipe with a fill intent), or tag this scenario @manual.`,
+          },
+          comment: `date-picker not compilable on mobile without a recipe — see qa/app.yaml widgets.datepicker`,
+        };
+      }
+
       // Use pressSequentially template for contenteditable/rich-text editors (auto-detected by live-scan)
       // or when Gherkin explicitly uses 'editor' element type
       const isEditor = resolved.inputMethod === 'pressSequentially' || step.elementType === 'editor';
@@ -180,7 +203,16 @@ export const formPatterns: StepPattern[] = [
 
         if (isNativeSelect) {
           templateName = 'select-action';
-          data = { ...resolved, selectorRef: step.selectorRef, selectValue: value };
+          // Role alone cannot prove a native <select>: `combobox` is also the role of a
+          // `<button role="combobox">` trigger (Radix/shadcn, MUI, Headless UI), where
+          // .selectOption() throws "Element is not a <select> element". Probe the tag at
+          // runtime unless the entry pins `variant: native`. A recipe (above) still wins.
+          data = {
+            ...resolved,
+            selectorRef: step.selectorRef,
+            selectValue: value,
+            probeNative: resolved.variant !== 'native',
+          };
         } else {
           templateName = 'click-select-action';
           data = { ...resolved, selectorRef: step.selectorRef, selectValue: value };

package/src/patterns/interaction-patterns.ts

@@ -384,6 +384,9 @@ export const interactionPatterns: StepPattern[] = [
   },
   {
     name: 'wait-for-role-with-text',
+    // Shares `extractWaitState()` with wait-for-element — same four, same reason for the
+    // omissions.
+    states: ['hidden', 'disabled', 'enabled', 'visible'],
     matcher: (step: ParsedStep) =>
       (step.text.includes('wait for') || step.text.includes('waits for')) &&
       !step.selectorRef &&
@@ -515,6 +518,9 @@ export const interactionPatterns: StepPattern[] = [
   },
   {
     name: 'wait-for-element',
+    // Exactly what `extractWaitState()` resolves. Every other clause falls back to 'visible', i.e.
+    // is silently dropped — so it is deliberately NOT declared and now reports SG-E021.
+    states: ['hidden', 'disabled', 'enabled', 'visible'],
     matcher: (step: ParsedStep) =>
       (step.text.includes('wait for') || step.text.includes('waits for')) && !!step.selectorRef,
     resolver: (step, context) => {

package/src/patterns/navigation-patterns.ts

@@ -3,6 +3,29 @@ import { StepPattern } from '@sun-asterisk/sungen';
 import { inferPath, resolvePathVariables, getPathCode } from '@sun-asterisk/sungen';
 import { pathToRegexSource } from '../utils/url-path-regex';
 
+/**
+ * `is on` names a NAVIGATION only for a page — or for an untyped / data-bound reference, the
+ * legacy `is on {{route}}` form kept working here. `is on [X] <any other type>` means "the user
+ * is AT X", a state inside the current page, and must not reach this pattern: its Given/When
+ * branch emits page.goto(<the SCREEN's path>, ignoring [X]), which on a multi-step flow is a
+ * full reload that wipes the state the earlier steps built, and its Then branch asserts that
+ * same path, which on a single-URL SPA can never fail. Both were silent. The step-mapper now
+ * refuses those shapes outright; this guard keeps the pattern from claiming them meanwhile.
+ */
+const isOnNavigation = (step: ParsedStep): boolean => {
+  const verb = /\bis\s+on\b/i.exec(step.text);
+  if (!verb) return false;
+  // `see [Notification Toggle] is on` — the reference precedes the words, so they are a STATE
+  // being asserted, not the navigation verb. Claiming it here compiled a toggle assertion into
+  // a URL assertion that, on the screen's own path, could never fail.
+  const bracket = step.text.indexOf('[');
+  if (bracket !== -1 && bracket < verb.index) return false;
+  if (!/\bis\s+on\s+\[/i.test(step.text)) return true; // no typed reference — legacy route form
+  // `screen` is the mobile analog of `page` (the appium adapter renders it as the app-launch
+  // no-op); keep it navigating so a dual-target feature compiles the same on both.
+  return !step.elementType || step.elementType === 'page' || step.elementType === 'screen';
+};
+
 /**
  * Navigation patterns: goto, navigate, open page
  */
@@ -115,7 +138,7 @@ export const navigationPatterns: StepPattern[] = [
   {
     name: 'navigate-to-route',
     matcher: (step: ParsedStep) =>
-      (step.text.includes('navigate to') || step.text.includes('navigates to') || step.text.includes('is on')) &&
+      (step.text.includes('navigate to') || step.text.includes('navigates to') || isOnNavigation(step)) &&
       !!(step.selectorRef || step.dataRef),
     resolver: (step, context) => {
       const route = step.selectorRef || step.dataRef;

package/src/patterns/setup-patterns.ts

@@ -49,6 +49,9 @@ export const setupPatterns: StepPattern[] = [
   },
   {
     name: 'clear-database',
+    // `Given database is empty` ESTABLISHES the state rather than asserting it — the clause is the
+    // directive, not a dropped assertion.
+    states: ['empty'],
     matcher: (step: ParsedStep) =>
       step.text.includes('database is empty') ||
       step.text.includes('database is cleared') ||

package/src/patterns/table-patterns.ts

@@ -95,6 +95,7 @@ export const tablePatterns: StepPattern[] = [
   // "User see [Table] table is empty"
   {
     name: 'table-is-empty',
+    states: ['empty'],
     matcher: (step) => {
       return /\btable\s+is\s+empty\b/i.test(step.text);
     },
@@ -207,6 +208,7 @@ export const tablePatterns: StepPattern[] = [
   // "User see [Ref] row in [Table] table with {{value}} is hidden"
   {
     name: 'table-row-hidden',
+    states: ['hidden'],
     matcher: (step) => {
       return step.elementType === 'row' &&
              /\bin\b.*\btable\b/i.test(step.text) &&