@sungen/driver-ui 3.2.35 → 3.3.0-alpha.10

package/dist/utils/url-path-regex.d.ts

@@ -0,0 +1,45 @@
+/**
+ * URL-path → RegExp-source conversion for page URL assertions (`toHaveURL`) and
+ * navigation waits (`waitForURL`).
+ *
+ * A selector's `value` may carry dynamic route placeholders (`:id`, `:receptionId`,
+ * …), e.g. `/cn22/view/so/ocr/results/:id`. A live URL populates those segments with
+ * real values (`…/results/rec-dummy-000017`), so a fully-escaped literal pattern would
+ * never match. Placeholder segments become a single-segment wildcard (`[^/]+`); every
+ * other segment is escaped so its regex metacharacters stay literal.
+ */
+/** Escape a literal string for safe use inside a RegExp source. */
+export declare function escapeRegex(text: string): string;
+/**
+ * Convert a URL path into a RegExp source string, turning dynamic route
+ * placeholders (`:name`) into `[^/]+` wildcards while escaping literal segments.
+ * `/` is emitted as the escaped `\/` so the result drops straight into `/…/`. A query or
+ * fragment in the input is dropped — see the comment in the body.
+ */
+export declare function pathToRegexSource(path: string): string;
+/** A page value split into the two patterns the runtime matches SEPARATELY. */
+export interface UrlPatternParts {
+    /** Pattern for `u.pathname`. Always present. */
+    pathRegex: string;
+    /** Pattern for `u.hostname` — set only when the page value named an absolute URL. */
+    hostRegex?: string;
+}
+/**
+ * Split a page value into the host and path patterns the runtime matches separately.
+ *
+ * `u.hostname` never appears in `u.pathname`, so one concatenated regex cannot carry both — it
+ * only ever "worked" while the match ran unanchored across the whole URL, which is the looseness
+ * that let a wait resolve on a transient URL (#677). A page value that names an absolute URL
+ * therefore yields two patterns; a relative one yields the path pattern alone, exactly as before.
+ *
+ * Every caller that builds a pathname pattern for a URL assertion or wait goes through here, so
+ * the host half cannot be honoured on one step form and silently dropped on another: before this,
+ * only `wait for [X] page` split the host, while both assertion forms matched the path against
+ * ANY host — `see [X] page` with `https://admin.example.com/jobs` passed on the public site.
+ *
+ * Dynamic `:id` segments still wildcard; the host stays a literal. A value that starts like an
+ * absolute URL but does not parse falls back to the path-only reading rather than throwing — the
+ * pattern is then wrong in a way the author can read, which beats losing the step.
+ */
+export declare function urlToPatternParts(path: string): UrlPatternParts;
+//# sourceMappingURL=url-path-regex.d.ts.map

package/dist/utils/url-path-regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-path-regex.d.ts","sourceRoot":"","sources":["../../src/utils/url-path-regex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,mEAAmE;AACnE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CActD;AAED,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC9B,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,qFAAqF;IACrF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAQ/D"}

package/dist/utils/url-path-regex.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * URL-path → RegExp-source conversion for page URL assertions (`toHaveURL`) and
+ * navigation waits (`waitForURL`).
+ *
+ * A selector's `value` may carry dynamic route placeholders (`:id`, `:receptionId`,
+ * …), e.g. `/cn22/view/so/ocr/results/:id`. A live URL populates those segments with
+ * real values (`…/results/rec-dummy-000017`), so a fully-escaped literal pattern would
+ * never match. Placeholder segments become a single-segment wildcard (`[^/]+`); every
+ * other segment is escaped so its regex metacharacters stay literal.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRegex = escapeRegex;
+exports.pathToRegexSource = pathToRegexSource;
+exports.urlToPatternParts = urlToPatternParts;
+const REGEX_SPECIALS = /[.*+?^${}()|[\]\\/]/g;
+/** Escape a literal string for safe use inside a RegExp source. */
+function escapeRegex(text) {
+    return text.replace(REGEX_SPECIALS, '\\$&');
+}
+/**
+ * Convert a URL path into a RegExp source string, turning dynamic route
+ * placeholders (`:name`) into `[^/]+` wildcards while escaping literal segments.
+ * `/` is emitted as the escaped `\/` so the result drops straight into `/…/`. A query or
+ * fragment in the input is dropped — see the comment in the body.
+ */
+function pathToRegexSource(path) {
+    // Every caller compiles this into a pattern tested against `u.pathname`, which never carries a
+    // query or a fragment. A page selector whose `value` includes one ('/search?tab=1' — off the
+    // documented "the value carries the PATH only" contract, but written in the field) would
+    // otherwise escape the `?` into the pattern and produce a match no real URL can satisfy: an
+    // assertion that can never pass, a wait that can only time out. Dropped here, once, rather than
+    // in each of the four resolvers that build a pathname pattern.
+    return path
+        .replace(/[?#].*$/, '')
+        .split('/')
+        .map((segment) => /^:[A-Za-z_][A-Za-z0-9_]*$/.test(segment) ? '[^/]+' : escapeRegex(segment))
+        .join('\\/');
+}
+/**
+ * Split a page value into the host and path patterns the runtime matches separately.
+ *
+ * `u.hostname` never appears in `u.pathname`, so one concatenated regex cannot carry both — it
+ * only ever "worked" while the match ran unanchored across the whole URL, which is the looseness
+ * that let a wait resolve on a transient URL (#677). A page value that names an absolute URL
+ * therefore yields two patterns; a relative one yields the path pattern alone, exactly as before.
+ *
+ * Every caller that builds a pathname pattern for a URL assertion or wait goes through here, so
+ * the host half cannot be honoured on one step form and silently dropped on another: before this,
+ * only `wait for [X] page` split the host, while both assertion forms matched the path against
+ * ANY host — `see [X] page` with `https://admin.example.com/jobs` passed on the public site.
+ *
+ * Dynamic `:id` segments still wildcard; the host stays a literal. A value that starts like an
+ * absolute URL but does not parse falls back to the path-only reading rather than throwing — the
+ * pattern is then wrong in a way the author can read, which beats losing the step.
+ */
+function urlToPatternParts(path) {
+    if (!/^https?:\/\//i.test(path))
+        return { pathRegex: pathToRegexSource(path) };
+    try {
+        const url = new URL(path);
+        return { hostRegex: escapeRegex(url.hostname), pathRegex: pathToRegexSource(url.pathname) };
+    }
+    catch {
+        return { pathRegex: pathToRegexSource(path) };
+    }
+}
+//# sourceMappingURL=url-path-regex.js.map

package/dist/utils/url-path-regex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-path-regex.js","sourceRoot":"","sources":["../../src/utils/url-path-regex.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;AAKH,kCAEC;AAQD,8CAcC;AA2BD,8CAQC;AA9DD,MAAM,cAAc,GAAG,sBAAsB,CAAC;AAE9C,mEAAmE;AACnE,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,IAAY;IAC5C,+FAA+F;IAC/F,6FAA6F;IAC7F,yFAAyF;IACzF,4FAA4F;IAC5F,gGAAgG;IAChG,+DAA+D;IAC/D,OAAO,IAAI;SACR,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;SACtB,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CACf,2BAA2B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,CAC3E;SACA,IAAI,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,iBAAiB,CAAC,IAAY;IAC5C,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC;IAC/E,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1B,OAAO,EAAE,SAAS,EAAE,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC9F,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,SAAS,EAAE,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC;IAChD,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-ui",
-  "version": "3.2.35",
+  "version": "3.3.0-alpha.10",
   "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",
@@ -8,16 +8,22 @@
     "capability": "ui"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json"
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "prepack": "npm run build"
   },
   "author": "eqe team (engineer & quality) — Sun Asterisk",
   "license": "MIT",
   "dependencies": {
-    "@sun-asterisk/sungen": "3.2.35"
+    "@sun-asterisk/sungen": "3.3.0-alpha.10"
   },
   "peerDependencies": {
     "@playwright/test": "^1.57.0"
   },
+  "devDependencies": {
+    "@playwright/test": "1.63.0",
+    "@types/node": "^20",
+    "typescript": "^5"
+  },
   "files": [
     "dist",
     "src"

package/src/index.ts

@@ -125,6 +125,11 @@ export function register(registry: CapabilityRegistry): void {
     gateProvider: uiGateProvider as (i: unknown) => unknown, // viewpoint coverage + depth
     sensors: [uiViewpointGateSensor],
     appProfilePresets: APP_PROFILE_PRESETS, // qa/app.yaml `extends: native|radix|antd`
+    // Trace target identity (SPI §4.5, DOS-14.5) — required on first use, so registering the UI
+    // capability never loads Playwright. A typed `require`, not `import()`: under the tsx-run CLI a
+    // dynamic import is real ESM and cannot resolve an extension-less TypeScript path.
+    traceIdentity: (input) =>
+      (require('./trace-identity/playwright-identity-resolver') as typeof import('./trace-identity/playwright-identity-resolver')).resolveTraceIdentities(input),
   });
 }
 

package/src/patterns/assertion-patterns.ts

@@ -1,10 +1,9 @@
 import { ParsedStep } from '@sun-asterisk/sungen';
 import { formatToRegexLiteral } from '@sun-asterisk/sungen';
-import { StepPattern, StepTemplateData, PatternContext, MappedStep, expandRecipe, unsupportedStepCode } from '@sun-asterisk/sungen';
+import { StepPattern, StepTemplateData, expandRecipe } from '@sun-asterisk/sungen';
 import { LIST_MEMBER_ROLES } from '@sun-asterisk/sungen';
 import { urlToPatternParts } from '../utils/url-path-regex';
 import { resolveColumnHeaderName } from '../utils/column-header';
-import { isDatePickerType } from './form-patterns';
 
 /**
  * Assertion patterns: visibility, text content, state, attributes
@@ -45,37 +44,6 @@ const IDENTITY_STRATEGIES = new Set([
   'accessibility-id', 'android-uiautomator', 'ios-predicate',
 ]);
 
-const EXPANDED_STATE_ALTERNATIVE =
-  'a native app exposes no expanded state - assert what the open panel shows instead (e.g. `see [X] section`)';
-
-/**
- * `see [X] … is expanded | is collapsed` — the assertion twin of the expand/collapse actions. Before
- * `expanded`/`collapsed` were state clauses the sentence fell to should-be-visible and the state
- * vanished: the step passed with the calendar closed (#911). Reads the SAME signal the action drives
- * (`expanded: { class | attribute }`, else aria-expanded), but strictly — the action's "assert only if
- * the attribute exists" leniency would make this assert nothing. A generator, not a resolver, because
- * `expanded: { state: none }` must refuse with a diagnostic rather than render a template.
- */
-function expandedStateAssertion(step: ParsedStep, context: PatternContext, state: 'expanded' | 'collapsed'): MappedStep {
-  const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-  // `state: none` is the author saying the widget shows no open/closed state, so there is nothing
-  // honest to assert — refuse rather than fall back to aria-expanded.
-  if (resolved.expanded?.state) {
-    const reason =
-      `step "${step.text}" asserts [${step.selectorRef}] is ${state}, but that entry declares `
-      + `expanded.state: ${resolved.expanded.state} (no observable state). Declare expanded.class or `
-      + `expanded.attribute on the entry, or assert what the open panel shows instead.`;
-    context.diagnostics?.add('SG-W017', reason, { feature: context.featureName, step: step.text });
-    return { code: unsupportedStepCode(reason), comment: `${step.selectorRef} has no ${state} state — see SG-W017` };
-  }
-  return {
-    code: context.templateEngine.renderStep('expanded-assertion', {
-      ...resolved, selectorRef: step.selectorRef, direction: state === 'expanded' ? 'expand' : 'collapse',
-    }),
-    comment: `Assert ${step.selectorRef} is ${state}`,
-  };
-}
-
 /**
  * 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
@@ -429,7 +397,6 @@ export const assertionPatterns: StepPattern[] = [
       ]);
       // 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.
-      // (A date-picker is handled alongside, as `isDatePicker` below, #907.)
       const AMBIGUOUS_VALUE_TYPES = new Set(['dropdown', 'select', 'combobox']);
 
       // Resolve data variable value
@@ -474,24 +441,11 @@ export const assertionPatterns: StepPattern[] = [
           (AMBIGUOUS_VALUE_TYPES.has(step.elementType) ||
             ['combobox', 'listbox'].includes(resolved.role)) &&
           resolved.variant !== 'native';
-        // A date-picker is just as ambiguous: its trigger is often a <button> opening a calendar
-        // popup, which has no `value` and shows the chosen date as text (#907).
-        const isDatePicker = isDatePickerType(step.elementType) && resolved.variant !== 'native';
 
-        // `assertValue` is the third recipe intent the app-profile spec defines alongside
-        // `fill`/`select` (spec §3.1). The lookup mirrors the fill step: a per-element `variant:`
-        // wins for ANY element type, then the profile's widget default for the type. It used to be
-        // consulted for dropdowns only, so a date-picker whose `fill` ran its recipe still asserted
-        // with toHaveValue() on the button (#907).
-        // Web only: the appium adapter ships no recipe-sequence and reads native values instead.
-        if (context.platform !== 'mobile') {
-          // A date-picker reads `widgets.datepicker` first — exactly as its fill does — even when it
-          // wears `role: combobox` (the shadcn/Radix trigger), which also makes it `ambiguous`.
-          const variantName =
-            resolved.variant ||
-            (isDatePicker ? context.appProfile?.widgetVariants?.['datepicker']
-              : ambiguous ? context.appProfile?.widgetVariants?.['select']
-              : undefined);
+        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']
@@ -515,7 +469,7 @@ export const assertionPatterns: StepPattern[] = [
         const code = context.templateEngine.renderStep('have-value-assertion', {
           ...resolved,
           dataValue,
-          probeNative: ambiguous || isDatePicker,
+          probeNative: ambiguous,
         });
         return {
           code,
@@ -541,27 +495,17 @@ export const assertionPatterns: StepPattern[] = [
         // CONTAINS, not exact: an entry for a label/value pair points legitimately either at
         // the value node ("JD-001") or at the row holding both ("Job No: JD-001"), and the web
         // regex it replaces was itself anchored only at the end. `exact: true` opts into the
-        // strict comparison. An EMPTY expected value is strict too: `toContainText('')` passes on
-        // any text at all, so "the field is blank" would assert nothing (#910). Judged on the base
-        // test-data value — the same compile-time read SG-W015 uses. An env overlay can change the
-        // value at run time; a base '' with a non-empty overlay then compares exactly.
+        // strict comparison.
         //
         // `resolved` is the SAME lookup, already performed above — this branch used to repeat it.
         if (IDENTITY_STRATEGIES.has(resolved.strategy)) {
-          // Empty on every value the ref takes (each @cases row, #950) → strict.
-          const values = context.dataResolver.peekValues
-            ? context.dataResolver.peekValues(step.dataRef, context.featureName)
-            : [context.dataResolver.peekBaseValue?.(step.dataRef, context.featureName)].filter((v): v is string => v !== undefined);
-          const strict = resolved.exact || (!!values?.length && values.every((v) => v === ''));
           const code = context.templateEngine.renderStep(
-            strict ? 'have-text-assertion' : 'contain-text-assertion',
-            // `strict` reads the BASE value at compile time; the runtime guard also covers an env
-            // overlay that sets '' over a non-empty base (#910).
-            { ...resolved, expectedText: dataValue, emptyMeansEmpty: true },
+            resolved.exact ? 'have-text-assertion' : 'contain-text-assertion',
+            { ...resolved, expectedText: dataValue },
           );
           return {
             code,
-            comment: `Assert ${step.selectorRef} label ${strict ? 'has' : 'contains'} value ${step.dataRef}`,
+            comment: `Assert ${step.selectorRef} label ${resolved.exact ? 'has' : 'contains'} value ${step.dataRef}`,
           };
         }
 
@@ -883,28 +827,6 @@ export const assertionPatterns: StepPattern[] = [
     },
     priority: 11,
   },
-  {
-    name: 'is-expanded',
-    states: ['expanded'],
-    platforms: ['web'],
-    platformAlternative: EXPANDED_STATE_ALTERNATIVE,
-    // A word match like the sibling state patterns (`is-disabled`), not `step.state`: that one is set
-    // only for a TRAILING clause, so `… is expanded  # calendar open` fell back to toBeVisible().
-    matcher: (step: ParsedStep) =>
-      /\b(see|sees)\s+\[/.test(step.text) && /\bis expanded\b/.test(step.text) && !step.dataRef && !!step.selectorRef,
-    generator: (step, context) => expandedStateAssertion(step, context, 'expanded'),
-    priority: 11,
-  },
-  {
-    name: 'is-collapsed',
-    states: ['collapsed'],
-    platforms: ['web'],
-    platformAlternative: EXPANDED_STATE_ALTERNATIVE,
-    matcher: (step: ParsedStep) =>
-      /\b(see|sees)\s+\[/.test(step.text) && /\bis collapsed\b/.test(step.text) && !step.dataRef && !!step.selectorRef,
-    generator: (step, context) => expandedStateAssertion(step, context, 'collapsed'),
-    priority: 11,
-  },
   {
     name: 'is-focused',
     states: ['focused'],

package/src/patterns/form-patterns.ts

@@ -1,25 +1,6 @@
 import { ParsedStep } from '@sun-asterisk/sungen';
 import { StepPattern, StepTemplateData, expandRecipe } from '@sun-asterisk/sungen';
 
-/** A date-picker / calendar element type — the steps that read `widgets.datepicker` agree on it. */
-export const isDatePickerType = (elementType: string | undefined): boolean =>
-  /date-?picker|calendar/.test(String(elementType || ''));
-
-/**
- * Whether an entry provably locates a `<button>`: a `button` role, or a CSS/locator selector whose
- * LAST compound starts with the `button` tag (`div.filters button[aria-haspopup="dialog"]`).
- * Attribute brackets are dropped first so a `[name="button"]` value cannot read as the tag. A
- * selector LIST (`input.date, button.trigger`) may match the input, so it is never called a button.
- */
-function isButtonTrigger(resolved: { strategy?: string; role?: string; value?: string }): boolean {
-  if (resolved.strategy === 'role') return resolved.role === 'button';
-  if (resolved.strategy !== 'css' && resolved.strategy !== 'locator') return false;
-  const selector = String(resolved.value ?? '').replace(/\[[^\]]*\]/g, '').trim();
-  if (selector.includes(',')) return false;
-  const compounds = selector.split(/[\s>+~]+/);
-  return /^button(?![\w-])/i.test(compounds[compounds.length - 1] ?? '');
-}
-
 /**
  * Form action patterns: fill, type, select, check, uncheck
  */
@@ -69,7 +50,7 @@ export const formPatterns: StepPattern[] = [
       // Widget recipe hook: per-element `variant:` wins; else, for a date-picker element,
       // the profile's `widgets.datepicker` (custom datepickers — readonly inputs that need
       // open-panel choreography). Resolves to a recipe with a `fill` intent.
-      const isDatePicker = isDatePickerType(step.elementType);
+      const isDatePicker = /date-?picker|calendar/.test(String(step.elementType || ''));
       const fillVariant = resolved.variant || (isDatePicker ? context.appProfile?.widgetVariants?.['datepicker'] : undefined);
       const fillRecipe = fillVariant ? context.appProfile?.recipes?.[fillVariant]?.['fill'] : undefined;
       if (fillRecipe) {
@@ -111,25 +92,6 @@ export const formPatterns: StepPattern[] = [
         };
       }
 
-      // A web date-picker whose trigger is a BUTTON, with no recipe: `.fill()` throws "Element is
-      // not an <input>" on it, and there is no value to type — the date is chosen in the calendar
-      // the button opens. Refuse at compile time and name the recipe to declare (#907). Only the
-      // shapes that are provably a button are refused; any other locator may still be a native
-      // `<input type="date">`, where the generic fill is right.
-      if (isDatePicker && isButtonTrigger(resolved)) {
-        const reason =
-          `step "${step.text}" fills [${step.selectorRef}] date-picker, but that entry locates a button `
-          + `(a calendar trigger) and no recipe drives it — fill() cannot type into a button. Declare a `
-          + `recipe with a fill intent in qa/app.yaml and point the entry at it with variant: <recipe> `
-          + `(or set widgets.datepicker), or tag this scenario @manual.`;
-        context.diagnostics?.add('SG-W017', reason, { feature: context.featureName, step: step.text });
-        return {
-          templateName: 'date-picker-unsupported',
-          data: { reason },
-          comment: `date-picker trigger is a button with no fill recipe — see SG-W017`,
-        };
-      }
-
       // Rich-text editors fill with pressSequentially, not .fill(). Two ways in: the selector
       // entry (`contenteditable: true`, which the resolver translates into `inputMethod`, #712 —
       // or `inputMethod` written out), and the Gherkin `editor` element type, which is a property
@@ -142,16 +104,9 @@ export const formPatterns: StepPattern[] = [
       const isEditor = resolved.inputMethod === 'pressSequentially' || step.elementType === 'editor';
       const templateName = isEditor ? 'fill-editor-action' : 'fill-action';
 
-      // `.fill()` only works on an input / textarea / select / contenteditable. A date-picker whose
-      // trigger is a <button> opening a calendar popup (Radix Popover + React Day Picker), or an
-      // entry that is plainly a button or link, fails with Playwright's "Element is not an <input>"
-      // — which says nothing about the fix. Guard those at runtime with the way forward: a recipe
-      // with a `fill` intent (#907). A locator's tag is unknown at compile time, hence a probe.
-      const guardFillable = !isEditor && (isDatePicker || ['button', 'link'].includes(String(resolved.role || '')));
-
       return {
         templateName,
-        data: { ...resolved, selectorRef: step.selectorRef, fillValue: value, ...(guardFillable ? { guardFillable: true } : {}) },
+        data: { ...resolved, selectorRef: step.selectorRef, fillValue: value },
         comment: isEditor
           ? `Fill rich text editor ${step.selectorRef} with ${step.dataRef || step.value}`
           : `Fill ${step.selectorRef} with ${step.dataRef || step.value}`,

package/src/patterns/table-patterns.ts

@@ -234,21 +234,9 @@ export const tablePatterns: StepPattern[] = [
              !/\bis\s+hidden\b/i.test(step.text);
     },
     resolver: (step, context) => {
-      // Decide by the literal value(s) (runtime mode returns an opaque marker from resolveData). In
-      // @cases a dataset column has one value per row: it is a count only when EVERY row is a
-      // number (#950). Mixed rows compile to text — and say so, since some rows read as counts.
-      const values = context.dataResolver.peekValues
-        ? context.dataResolver.peekValues(step.dataRef!, context.featureName)
-        : [context.dataResolver.peekBaseValue?.(step.dataRef!, context.featureName)].filter((v): v is string => v !== undefined);
-      const isCount = (v: string) => /^\d+$/.test(v.trim());
-      if (!values?.length || !values.every(isCount)) {
-        if (values?.some(isCount)) {
-          context.diagnostics?.add('SG-W015',
-            `\`see [${step.selectorRef}] row with {{${step.dataRef}}}\` mixes numbers and text across the @cases rows, so it compiles to a TEXT assertion, not a row count. Split the counting rows into their own @cases scenario.`,
-            { feature: context.featureName, step: step.text });
-        }
-        return null as any; // not numeric → fall through to text semantics
-      }
+      // Decide by the BASE literal (runtime mode returns an opaque marker from resolveData).
+      const base = context.dataResolver.peekBaseValue?.(step.dataRef!, context.featureName);
+      if (base === undefined || !/^\d+$/.test(String(base).trim())) return null as any; // not numeric → fall through to text semantics
       const resolved = context.selectorResolver.resolveSelector(
         step.selectorRef!, context.featureName, 'row', step.nth
       );

package/src/trace-identity/aria-snapshot-head.ts

@@ -0,0 +1,33 @@
+/**
+ * The head line of a Playwright `locator.ariaSnapshot()` → role, accessible name, heading level.
+ *
+ * Owned here on purpose (G5): the spike loaded Playwright's private aria-YAML parser by absolute
+ * path, which breaks on any internal move. We only ever need the FIRST node of a single element's
+ * snapshot, whose grammar is small and documented in Playwright's aria snapshot docs:
+ *
+ *   - button "Login"
+ *   - heading "My Account" [level=1]
+ *   - textbox "Email": test@playground.dev      (a value after the colon)
+ *   - link "Products":                           (children on the next lines)
+ *   - text: Hi, Jane                             (a bare text node — no role)
+ *
+ * More than one top-level node (a fragment) has no single identity.
+ */
+export interface AriaHead { role: string; name: string; level?: number; note?: string }
+
+const LINE = /^- ([a-zA-Z]+)(?: "((?:[^"\\]|\\.)*)")?((?: \[[^\]]*\])*)(?::.*)?$/;
+
+function unescape(raw: string): string {
+  try { return JSON.parse(`"${raw}"`) as string; } catch { return raw.replace(/\\"/g, '"'); }
+}
+
+export function parseAriaHead(yaml: string): AriaHead {
+  const top = yaml.split(/\r?\n/).filter((l) => l.startsWith('- '));
+  if (top.length !== 1) return { role: 'generic', name: '', note: `fragment of ${top.length}` };
+  const m = LINE.exec(top[0].trimEnd());
+  if (!m) return { role: 'generic', name: '', note: `unparsed: ${top[0].slice(0, 60)}` };
+  const role = m[1];
+  if (role === 'text') return { role: 'text', name: '', note: 'text node' };
+  const level = /\[level=(\d)\]/.exec(m[3] ?? '')?.[1];
+  return { role, name: m[2] === undefined ? '' : unescape(m[2]), ...(level ? { level: Number(level) } : {}) };
+}

package/src/trace-identity/playwright-identity-resolver.ts

@@ -0,0 +1,123 @@
+/**
+ * `traceIdentity` for the UI capability (SPI §4.5, DOS-14.5): who a recorded action was aimed at,
+ * from Playwright's OWN accessibility engine on the replayed snapshot — the phase 07 method that
+ * agreed with the test's locator on 98/98 oracle-bearing actions over two real sites.
+ *
+ *   replay     the inert HTML core rendered, in a context with JavaScript disabled, offline,
+ *              service workers blocked, every request routed to abort AND Chromium's network
+ *              blocklist set to `*` (non-http schemes too) — nothing leaves the machine
+ *   identity   role + name from `ariaSnapshot()` of the element Playwright marked, re-resolved with
+ *              `getByRole(role, { name, exact })`: it must land on exactly that element
+ *   G3         if role+name matches several elements, look for a named scope (row, landmark,
+ *              dialog, card…) inside which it is unique; none → `low` (ambiguous)
+ *   low        any reason at all: core's caps (missing CSS, broken refs), no semantic role, empty
+ *              name, getByRole missing the target, ambiguity, a failed snapshot
+ * A missing browser is an ERROR, never a silent `low` for everything.
+ */
+import { chromium, type Browser, type Locator, type Page } from '@playwright/test';
+import type { CapabilityDescriptor } from '@sun-asterisk/sungen';
+import { parseAriaHead } from './aria-snapshot-head';
+
+type Resolver = NonNullable<CapabilityDescriptor['traceIdentity']>;
+type Input = Parameters<Resolver>[0];
+type Output = Awaited<ReturnType<Resolver>>;
+type Result = Output['results'][number];
+
+const NAMELESS = new Set(['generic', 'none', 'presentation', 'text', 'fragment', 'paragraph']);
+const SCOPE_ROLES = ['row', 'listitem', 'article', 'dialog', 'alertdialog', 'form', 'group', 'tabpanel', 'region', 'navigation', 'complementary', 'search', 'banner', 'contentinfo', 'main', 'menu', 'list', 'table', 'grid'];
+
+export const RESOLVER_ID = 'driver-ui/playwright-aria@1';
+
+/** At most this many snapshots per call — a bound on work, not a sampling. */
+export const MAX_REQUESTS = 2000;
+
+async function launch(): Promise<Browser> {
+  try { return await chromium.launch({ headless: true }); } catch (e) {
+    throw new Error(`trace identity needs Chromium for Playwright — run \`npx playwright install chromium\` (${(e as Error).message.split('\n')[0]})`);
+  }
+}
+
+/** A fresh page in a fresh isolated context: JS off, offline, SW blocked, every request aborted, CDP blocklist `*`. */
+async function isolatedPage(browser: Browser, counter: { blocked: number }): Promise<Page> {
+  const context = await browser.newContext({ javaScriptEnabled: false, offline: true, serviceWorkers: 'block' });
+  await context.route('**/*', (route) => route.abort('blockedbyclient'));
+  const page = await context.newPage();
+  page.on('request', () => { counter.blocked++; });
+  const cdp = await context.newCDPSession(page);
+  await cdp.send('Network.enable');
+  await cdp.send('Network.setBlockedURLs', { urls: ['*'] });
+  return page;
+}
+
+const byRole = (root: Page | Locator, role: string, name: string, level?: number): Locator =>
+  root.getByRole(role as Parameters<Page['getByRole']>[0], { ...(name ? { name, exact: true } : {}), ...(level ? { level } : {}) });
+
+/** A named container in which role+name is unique and lands on the target (G3). */
+async function scopeFor(page: Page, target: Locator, role: string, name: string, level?: number): Promise<Result['scope'] | undefined> {
+  for (const scopeRole of SCOPE_ROLES) {
+    const holders = byRole(page, scopeRole, '').filter({ has: target });
+    const n = await holders.count();
+    if (!n) continue;
+    const head = parseAriaHead((await holders.nth(n - 1).ariaSnapshot({ timeout: 3_000 }).catch(() => '')).split('\n')[0]);
+    if (!head.name) continue;
+    const scoped = byRole(byRole(page, scopeRole, head.name), role, name, level);
+    if ((await scoped.count()) === 1 && (await scoped.and(target).count()) === 1) return { role: scopeRole, name: head.name };
+  }
+  return undefined;
+}
+
+const lowResult = (key: string, reasons: string[]): Result => ({ key, role: 'generic', name: '', identityConfidence: 'low', reasons });
+
+async function identify(page: Page, req: Input['requests'][number]): Promise<Result> {
+  const low = (reasons: string[]): Result => lowResult(req.key, reasons);
+  await page.setViewportSize({ width: Math.max(1, req.viewport.width), height: Math.max(1, req.viewport.height) });
+  await page.setContent(req.html, { waitUntil: 'domcontentloaded', timeout: 10_000 });
+  const target = page.locator(req.targetSelector);
+  const marked = await target.count();
+  if (marked !== 1) return low([...req.capReasons, `marked-elements=${marked}`]);
+  let aria: string;
+  try { aria = await target.ariaSnapshot({ timeout: 3_000 }); } catch (e) { return low([...req.capReasons, `ariaSnapshot-failed: ${(e as Error).message.split('\n')[0]}`]); }
+  const head = parseAriaHead(aria);
+  const id = { role: head.role, name: head.name, ...(head.level ? { level: head.level } : {}) };
+  const reasons = [...req.capReasons];
+  if (NAMELESS.has(head.role)) reasons.push(`no-semantic-role(${head.role})`);
+  if (!head.name) reasons.push('empty-name');
+  let scope: Result['scope'];
+  if (!NAMELESS.has(head.role)) {
+    const all = byRole(page, head.role, head.name, head.level);
+    const count = await all.count();
+    if ((await all.and(target).count()) !== 1) reasons.push('getByRole-misses-target');
+    else if (count > 1) {
+      scope = head.name ? await scopeFor(page, target, head.role, head.name, head.level) : undefined;
+      if (!scope) reasons.push(`ambiguous(${count})`);
+    }
+  }
+  return reasons.length ? { key: req.key, ...id, identityConfidence: 'low', reasons } : { key: req.key, ...id, ...(scope ? { scope } : {}), identityConfidence: 'high', reasons: [] };
+}
+
+export async function resolveTraceIdentities(input: Input): Promise<Output> {
+  const requests = Array.isArray(input?.requests) ? input.requests : [];
+  if (requests.length > MAX_REQUESTS) throw new Error(`trace identity: ${requests.length} snapshots in one call (max ${MAX_REQUESTS})`);
+  const browser = await launch();
+  try {
+    const counter = { blocked: 0 };
+    let page = await isolatedPage(browser, counter);
+    const results: Result[] = [];
+    for (const req of requests) {
+      try {
+        results.push(await identify(page, req));
+      } catch (e) {
+        // One bad snapshot is a `low` answer for that snapshot, never a crash of the whole check.
+        const why = (e as Error).message.split('\n')[0].slice(0, 200);
+        results.push(lowResult(req.key, [`replay-failed: ${why}`]));
+        if (page.isClosed() || /closed/i.test(why)) {
+          await page.context().close().catch(() => undefined);
+          page = await isolatedPage(browser, counter);
+        }
+      }
+    }
+    return { resolver: RESOLVER_ID, browser: `chromium ${browser.version()}`, results, blockedRequests: counter.blocked };
+  } finally {
+    await browser.close();
+  }
+}