@sun-asterisk/sungen 3.2.29 → 3.2.30

package/dist/generators/test-generator/utils/selector-nth-validation.d.ts

@@ -0,0 +1,59 @@
+/**
+ * SG-W018 — an `nth:` value outside the contract (issue #720).
+ *
+ * `nth:` was the one SelectorEntry field whose VALUE nothing validated. The key is recognised
+ * (it is in CONSUMED_ENTRY_FIELDS, so SG-W004 stays quiet) and the entry's `type:` is valid (so
+ * SG-E027 stays quiet) — every check we own stopped at the key. What landed in the value went
+ * straight to two adapters that disagreed about what a valid `nth` even is:
+ *
+ *   nth: -1     web → the filter vanished (`.getByRole('combobox')`, byte-identical to deleting
+ *                     the line), mobile → `$$('~x')[-1]`, which is `undefined` in JavaScript
+ *   nth: 'last' web → dropped, mobile → `$$('~x')[last]` — a bare identifier, valid syntax and a
+ *                     ReferenceError at run time, so even the SG-E022 parse self-check passed it
+ *   nth: 1.5    emitted verbatim into `.nth(1.5)` / `[1.5]`
+ *
+ * Zero diagnostics in every case. `SelectorEntry.nth` is typed `number?`, but YAML is parsed, not
+ * type-checked — the declared type buys nothing at the boundary. Same family as #712 (an
+ * unrecognised KEY) and #711 (an unrecognised VALUE for `type:`), one level deeper again.
+ *
+ * THE CONTRACT: an integer `>= -1`. `0..N` is the zero-based index; `-1` means the last match
+ * (Playwright's `.last()` IS `.nth(-1)`, and the appium side now renders `.at(-1)`). Anything
+ * else is ignored by the resolver — normalised to `undefined` before it can reach a template —
+ * and reported here, so "ignored" is something the author is told rather than something they
+ * discover from a strict-mode violation.
+ *
+ * A WARNING, not an error, on SG-W004's reasoning: the value is inert once dropped, the selector
+ * still resolves (it just does not filter by position), and `--strict` already turns the channel
+ * non-zero for CI.
+ */
+import type { DiagnosticsCollector } from '../diagnostics';
+/** True for the values `nth:` accepts: an integer index `>= 0`, or `-1` for the last match. */
+export declare function isValidNth(v: unknown): v is number;
+/**
+ * The one normalisation every resolve path runs `nth` through: a valid index, or `undefined`.
+ *
+ * Returning `undefined` rather than the raw value is what makes the SG-W018 message true — and
+ * it is the half that keeps broken JavaScript out of the emitted spec even on paths this check
+ * does not walk (the legacy selector format), because a template only ever sees a real index.
+ */
+export declare function normalizeNth(v: unknown): number | undefined;
+export interface InvalidNth {
+    /** Dotted path to the offending entry, e.g. `danh muc` or `greeting.android`. */
+    path: string;
+    /** The `nth:` value exactly as written, for quoting back at the author. */
+    nth: unknown;
+}
+/** Every entry in `file` whose `nth:` is present but outside the contract. */
+export declare function collectInvalidNth(file: Record<string, unknown>): InvalidNth[];
+/**
+ * SG-W018 — report every entry whose `nth:` the compiler cannot use.
+ *
+ * Runs once per selector FILE (the resolver's load is cached), so an entry named by twenty steps
+ * is reported once — the same load point and the same reason as SG-W004 and SG-E027. Silent when
+ * no diagnostics channel is attached: `generate` must not depend on diagnostics being wired.
+ */
+export declare function reportInvalidNth(file: Record<string, unknown>, opts: {
+    feature?: string;
+    diagnostics?: DiagnosticsCollector;
+}): void;
+//# sourceMappingURL=selector-nth-validation.d.ts.map

package/dist/generators/test-generator/utils/selector-nth-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selector-nth-validation.d.ts","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/selector-nth-validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAG3D,+FAA+F;AAC/F,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE3D;AAED,MAAM,WAAW,UAAU;IACzB,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,GAAG,EAAE,OAAO,CAAC;CACd;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,EAAE,CAa7E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,oBAAoB,CAAA;CAAE,GAC7D,IAAI,CAiBN"}

package/dist/generators/test-generator/utils/selector-nth-validation.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * SG-W018 — an `nth:` value outside the contract (issue #720).
+ *
+ * `nth:` was the one SelectorEntry field whose VALUE nothing validated. The key is recognised
+ * (it is in CONSUMED_ENTRY_FIELDS, so SG-W004 stays quiet) and the entry's `type:` is valid (so
+ * SG-E027 stays quiet) — every check we own stopped at the key. What landed in the value went
+ * straight to two adapters that disagreed about what a valid `nth` even is:
+ *
+ *   nth: -1     web → the filter vanished (`.getByRole('combobox')`, byte-identical to deleting
+ *                     the line), mobile → `$$('~x')[-1]`, which is `undefined` in JavaScript
+ *   nth: 'last' web → dropped, mobile → `$$('~x')[last]` — a bare identifier, valid syntax and a
+ *                     ReferenceError at run time, so even the SG-E022 parse self-check passed it
+ *   nth: 1.5    emitted verbatim into `.nth(1.5)` / `[1.5]`
+ *
+ * Zero diagnostics in every case. `SelectorEntry.nth` is typed `number?`, but YAML is parsed, not
+ * type-checked — the declared type buys nothing at the boundary. Same family as #712 (an
+ * unrecognised KEY) and #711 (an unrecognised VALUE for `type:`), one level deeper again.
+ *
+ * THE CONTRACT: an integer `>= -1`. `0..N` is the zero-based index; `-1` means the last match
+ * (Playwright's `.last()` IS `.nth(-1)`, and the appium side now renders `.at(-1)`). Anything
+ * else is ignored by the resolver — normalised to `undefined` before it can reach a template —
+ * and reported here, so "ignored" is something the author is told rather than something they
+ * discover from a strict-mode violation.
+ *
+ * A WARNING, not an error, on SG-W004's reasoning: the value is inert once dropped, the selector
+ * still resolves (it just does not filter by position), and `--strict` already turns the channel
+ * non-zero for CI.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidNth = isValidNth;
+exports.normalizeNth = normalizeNth;
+exports.collectInvalidNth = collectInvalidNth;
+exports.reportInvalidNth = reportInvalidNth;
+const selector_entry_walk_1 = require("./selector-entry-walk");
+/** True for the values `nth:` accepts: an integer index `>= 0`, or `-1` for the last match. */
+function isValidNth(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= -1;
+}
+/**
+ * The one normalisation every resolve path runs `nth` through: a valid index, or `undefined`.
+ *
+ * Returning `undefined` rather than the raw value is what makes the SG-W018 message true — and
+ * it is the half that keeps broken JavaScript out of the emitted spec even on paths this check
+ * does not walk (the legacy selector format), because a template only ever sees a real index.
+ */
+function normalizeNth(v) {
+    return isValidNth(v) ? v : undefined;
+}
+/** Every entry in `file` whose `nth:` is present but outside the contract. */
+function collectInvalidNth(file) {
+    const out = [];
+    (0, selector_entry_walk_1.walkSelectorEntries)(file, {
+        entry(entry, path) {
+            // An ABSENT `nth:` is the common case and means "no positional filter". An explicit
+            // `nth: null` is read the same way — the resolver has always treated null as unset, and
+            // reporting it would fire on a legitimate "no index here" written out loud.
+            if (entry.nth === undefined || entry.nth === null)
+                return;
+            if (isValidNth(entry.nth))
+                return;
+            out.push({ path, nth: entry.nth });
+        },
+    });
+    return out;
+}
+/**
+ * SG-W018 — report every entry whose `nth:` the compiler cannot use.
+ *
+ * Runs once per selector FILE (the resolver's load is cached), so an entry named by twenty steps
+ * is reported once — the same load point and the same reason as SG-W004 and SG-E027. Silent when
+ * no diagnostics channel is attached: `generate` must not depend on diagnostics being wired.
+ */
+function reportInvalidNth(file, opts) {
+    const sink = opts.diagnostics;
+    if (!sink)
+        return;
+    for (const { path, nth } of collectInvalidNth(file)) {
+        // Quoted for a string so `nth: 'last'` reads back as the string it is; `String()` for a number
+        // so -2, 1.5 and .nan survive as written (JSON.stringify renders NaN as `null`, which would
+        // quote a value the author never typed).
+        const written = typeof nth === 'string' ? `"${nth}"`
+            : typeof nth === 'number' ? String(nth)
+                : JSON.stringify(nth) ?? String(nth);
+        sink.add('SG-W018', `selectors.yaml entry "${path}" declares nth: ${written}, which is not a valid index — `
+            + `it is IGNORED, so the selector does not filter by position and a step naming it resolves `
+            + `to every match (strict mode then fails at run time naming the DOM, never this line). `
+            + `Use an integer >= 0 for a zero-based index, or -1 for the last match.`, { feature: opts.feature });
+    }
+}
+//# sourceMappingURL=selector-nth-validation.js.map

package/dist/generators/test-generator/utils/selector-nth-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selector-nth-validation.js","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/selector-nth-validation.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;;AAMH,gCAEC;AASD,oCAEC;AAUD,8CAaC;AASD,4CAoBC;AApED,+DAA4D;AAE5D,+FAA+F;AAC/F,SAAgB,UAAU,CAAC,CAAU;IACnC,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;AACjE,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,YAAY,CAAC,CAAU;IACrC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACvC,CAAC;AASD,8EAA8E;AAC9E,SAAgB,iBAAiB,CAAC,IAA6B;IAC7D,MAAM,GAAG,GAAiB,EAAE,CAAC;IAC7B,IAAA,yCAAmB,EAAC,IAAI,EAAE;QACxB,KAAK,CAAC,KAAK,EAAE,IAAI;YACf,oFAAoF;YACpF,wFAAwF;YACxF,4EAA4E;YAC5E,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,KAAK,IAAI;gBAAE,OAAO;YAC1D,IAAI,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC;gBAAE,OAAO;YAClC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;QACrC,CAAC;KACF,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,gBAAgB,CAC9B,IAA6B,EAC7B,IAA8D;IAE9D,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC;IAC9B,IAAI,CAAC,IAAI;QAAE,OAAO;IAClB,KAAK,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC;QACpD,+FAA+F;QAC/F,4FAA4F;QAC5F,yCAAyC;QACzC,MAAM,OAAO,GAAG,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG;YAClD,CAAC,CAAC,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;gBACvC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,CAAC,GAAG,CAAC,SAAS,EAChB,yBAAyB,IAAI,mBAAmB,OAAO,iCAAiC;cACtF,2FAA2F;cAC3F,uFAAuF;cACvF,uEAAuE,EACzE,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IAC/B,CAAC;AACH,CAAC"}

package/dist/generators/test-generator/utils/selector-resolver.d.ts

@@ -56,6 +56,8 @@ export interface ResolvedSelector {
         attribute?: string;
         state?: 'none';
     };
+    checkedClass?: string;
+    checkedAttribute?: string;
     anchor?: ResolvedSelector;
 }
 /**
@@ -94,7 +96,7 @@ export declare class SelectorResolver {
      * Web is unaffected — there the role IS the locator (see LIST_MEMBER_ROLES).
      */
     private isUnusableMobileRole;
-    /** Attach the compile-diagnostics collector (SG-W003) */
+    /** Attach the compile-diagnostics collector (SG-W003, SG-W016, SG-W030) */
     setDiagnostics(collector: DiagnosticsCollector): void;
     /** Override the name-from-content role list from the app profile (qa/app.yaml feedback.toast) */
     setContentNamedRoles(roles: string[]): void;
@@ -180,9 +182,36 @@ export declare class SelectorResolver {
      * "No variables"   → "No variables" (unchanged)
      */
     private static resolveTemplateVars;
+    /** Encode `{{var}}` references inside a table's `columns: { <col>: { header } }` map. */
+    private static resolveColumnHeaders;
+    /**
+     * Normalise `checked:` / `selected:` into the one signal consumers read (issue #730). The two
+     * spellings are an authoring convenience for the same thing — `checked:` on a toggle, `selected:`
+     * on a card/tab picker — so they collapse here rather than at every call site. Each spelling can
+     * publish the state as a class token or as a boolean attribute; one entry declares one of them.
+     *
+     * Validated at CODEGEN because every failure mode here is silent at run time: the class token
+     * lands inside `[class~="..."]`, where a quote breaks the selector and whitespace can never match
+     * (the `~=` operator matches ONE whitespace-separated token, so 'a b' matches nothing at all and
+     * the step would just time out claiming the control never changed state); an attribute name has
+     * the same exposure inside `[name="true"]`. Refused rather than warned-and-dropped, unlike
+     * `expanded:`: dropping this signal leaves the step with nothing to read, so it would fail again
+     * with the original "no on/off state" error and hide the real cause.
+     */
+    private resolveCheckedSignal;
     /**
      * Resolve from new structured entry format
      */
+    /**
+     * An `expanded:` signal's `class` / `attribute` value is pasted into the generated spec — into a
+     * string literal, a regex, a `classList.contains()` argument. selectors.yaml is often generated
+     * from the page under test, so a value carrying a quote, a `${`, whitespace or any other character
+     * a class or attribute name cannot legitimately contain is refused (diagnostic + the field is
+     * dropped) rather than compiled into code. Dropping it leaves a working step — codegen falls back
+     * to driving/asserting `aria-expanded` — which is why this warns where the checked/selected signal,
+     * whose fallback is the failure it exists to fix, refuses outright.
+     */
+    private validatedStateSignal;
     private resolveFromEntry;
     /**
      * Resolve selector by priority chain (legacy)

package/dist/generators/test-generator/utils/selector-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selector-resolver.d.ts","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/selector-resolver.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"selector-resolver.d.ts","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/selector-resolver.ts"],"names":[],"mappings":"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"}

package/dist/generators/test-generator/utils/selector-resolver.js

@@ -40,6 +40,9 @@ const path = __importStar(require("path"));
 const yaml_io_1 = require("../../../utils/yaml-io");
 const data_resolver_1 = require("./data-resolver");
 const app_profile_1 = require("../app-profile");
+const selector_entry_fields_1 = require("./selector-entry-fields");
+const selector_type_validation_1 = require("./selector-type-validation");
+const selector_nth_validation_1 = require("./selector-nth-validation");
 /**
  * Roles whose accessible name comes from their own CONTENT, not from a label — so a name the
  * compiler invented from the `[Reference]` text can never match a real element.
@@ -93,7 +96,7 @@ class SelectorResolver {
     isUnusableMobileRole(r) {
         return this.platform === 'mobile' && !!r && r.strategy === 'role' && !r.name;
     }
-    /** Attach the compile-diagnostics collector (SG-W003) */
+    /** Attach the compile-diagnostics collector (SG-W003, SG-W016, SG-W030) */
     setDiagnostics(collector) {
         this.diagnostics = collector;
     }
@@ -448,9 +451,112 @@ class SelectorResolver {
             return data_resolver_1.DataResolver.encodeMarker(varName.trim());
         });
     }
+    /** Encode `{{var}}` references inside a table's `columns: { <col>: { header } }` map. */
+    static resolveColumnHeaders(columns) {
+        const out = {};
+        for (const [key, col] of Object.entries(columns)) {
+            out[key] = col && typeof col.header === 'string'
+                ? { ...col, header: SelectorResolver.resolveTemplateVars(col.header) }
+                : col;
+        }
+        return out;
+    }
+    /**
+     * Normalise `checked:` / `selected:` into the one signal consumers read (issue #730). The two
+     * spellings are an authoring convenience for the same thing — `checked:` on a toggle, `selected:`
+     * on a card/tab picker — so they collapse here rather than at every call site. Each spelling can
+     * publish the state as a class token or as a boolean attribute; one entry declares one of them.
+     *
+     * Validated at CODEGEN because every failure mode here is silent at run time: the class token
+     * lands inside `[class~="..."]`, where a quote breaks the selector and whitespace can never match
+     * (the `~=` operator matches ONE whitespace-separated token, so 'a b' matches nothing at all and
+     * the step would just time out claiming the control never changed state); an attribute name has
+     * the same exposure inside `[name="true"]`. Refused rather than warned-and-dropped, unlike
+     * `expanded:`: dropping this signal leaves the step with nothing to read, so it would fail again
+     * with the original "no on/off state" error and hide the real cause.
+     */
+    resolveCheckedSignal(entry, label) {
+        const signal = {};
+        // Recorded BEFORE it is thrown, every time. A pattern that resolves its selector inside a
+        // `catch {}` — several do, to fall back when a `[Ref]` simply is not in the file — would
+        // otherwise swallow the refusal whole and emit a step against an unresolved locator, with
+        // nothing anywhere naming the entry. The throw is what stops the file; the diagnostic is what
+        // survives a caller that decided not to be stopped, and what `--strict` counts.
+        const refuse = (message) => {
+            this.diagnostics?.add('SG-E031', message, { feature: this.featureName });
+            throw new Error(message);
+        };
+        for (const key of ['class', 'attribute']) {
+            const fromChecked = entry.checked?.[key]?.trim();
+            const fromSelected = entry.selected?.[key]?.trim();
+            if (fromChecked && fromSelected && fromChecked !== fromSelected) {
+                refuse(`Selector "[${label}]" declares both \`checked.${key}\` ("${fromChecked}") and ` +
+                    `\`selected.${key}\` ("${fromSelected}") with different values. They are two spellings of ONE ` +
+                    `signal — how the control marks its ON state — so only one can be right. Keep \`checked:\` for ` +
+                    `a toggle/checkbox or \`selected:\` for a card/tab picker, and delete the other.`);
+            }
+            const value = fromChecked || fromSelected;
+            if (!value)
+                continue;
+            if (/\s/.test(value)) {
+                refuse(`Selector "[${label}]" declares checked/selected ${key} "${value}", which contains whitespace. ` +
+                    `This must be ONE ${key === 'class' ? 'class token, not a class list' : 'attribute name'}: the ` +
+                    `generated matcher tests a single token, so a multi-token value can never match and the step ` +
+                    `would time out rather than fail clearly. Pick the one ${key} that marks the ON state ` +
+                    `(e.g. '${key === 'class' ? 'border-link' : 'data-checked'}', not ` +
+                    `'${key === 'class' ? 'card border-link' : 'data-checked aria-checked'}').`);
+            }
+            if (value.includes('"') || value.includes('\\')) {
+                refuse(`Selector "[${label}]" declares checked/selected ${key} "${value}", which contains a quote or ` +
+                    `backslash. The value is embedded in a [${key === 'class' ? 'class~="..."' : 'name="true"'}] CSS ` +
+                    `selector, which those characters would break. A ${key} carrying them is almost certainly a typo.`);
+            }
+            signal[key] = value;
+        }
+        if (signal.class && signal.attribute) {
+            refuse(`Selector "[${label}]" declares both a checked/selected \`class\` ("${signal.class}") and ` +
+                `\`attribute\` ("${signal.attribute}"). One control publishes its ON state one way — declaring ` +
+                `two lets an action drive one signal while the assertion after it reads the other. Keep the one ` +
+                `the component actually swaps.`);
+        }
+        return signal.class || signal.attribute ? signal : undefined;
+    }
     /**
      * Resolve from new structured entry format
      */
+    /**
+     * An `expanded:` signal's `class` / `attribute` value is pasted into the generated spec — into a
+     * string literal, a regex, a `classList.contains()` argument. selectors.yaml is often generated
+     * from the page under test, so a value carrying a quote, a `${`, whitespace or any other character
+     * a class or attribute name cannot legitimately contain is refused (diagnostic + the field is
+     * dropped) rather than compiled into code. Dropping it leaves a working step — codegen falls back
+     * to driving/asserting `aria-expanded` — which is why this warns where the checked/selected signal,
+     * whose fallback is the failure it exists to fix, refuses outright.
+     */
+    validatedStateSignal(signal, field, label) {
+        // Letters, digits and the punctuation real class/attribute names use — including Tailwind
+        // arbitrary values (`bg-[#eff6ff]`, `!mt-0`, `@md:flex`, `w-[calc(100%-2rem)]`). Excluded on
+        // purpose: whitespace, quotes, backticks, backslash, `$`/`{`/`}` — the characters that could
+        // close a literal or open an interpolation in the generated code.
+        const SAFE = /^[A-Za-z0-9_\-:./[\]%#!@(),&+=*~|?]+$/;
+        const out = {};
+        for (const key of ['class', 'attribute']) {
+            const value = signal[key];
+            if (value === undefined || value === null)
+                continue;
+            const text = String(value);
+            if (SAFE.test(text)) {
+                out[key] = text;
+                continue;
+            }
+            const warnKey = `w030:${label}:${field}.${key}`;
+            if (!this.warnedContentNamed.has(warnKey)) { // once per entry+field, not once per step that uses it
+                this.warnedContentNamed.add(warnKey);
+                this.diagnostics?.add('SG-W030', `selector "${label}": ${field}.${key} ${JSON.stringify(text)} is not accepted as a ${key} name (no whitespace, quotes, backslash, \`$\`, \`{\` or \`}\`) — the value is ignored and the step compiles to its default form`, { feature: this.featureName });
+            }
+        }
+        return out.class || out.attribute ? out : undefined;
+    }
     resolveFromEntry(entry, originalLabel) {
         // Default values
         const locator = entry.locator || '';
@@ -472,9 +578,22 @@ class SelectorResolver {
             : (entry.name ?? '');
         const value = SelectorResolver.resolveTemplateVars(rawValue);
         const name = SelectorResolver.resolveTemplateVars(rawName);
-        const nth = entry.nth !== undefined && entry.nth !== null ? entry.nth : undefined;
+        // `nth:` is the one field whose VALUE nothing used to check (#720): anything non-null was
+        // handed to the adapters, which disagreed about it — web dropped `-1` silently, mobile emitted
+        // `$$(...)[-1]`. Normalised to a real index (integer >= -1) or `undefined` HERE, so no template
+        // ever renders a value it cannot express; the out-of-contract write is reported as SG-W018 at
+        // the file load point below.
+        const nth = (0, selector_nth_validation_1.normalizeNth)(entry.nth);
         const exact = entry.exact === true || entry.match === 'exact';
-        const inputMethod = entry.inputMethod;
+        // `contenteditable: true` is the MANUAL override for a rich-text editor (#712). It was a
+        // documented, plumbed field that nothing read: the rich-text decision lives in driver-ui's
+        // fill pattern, which gates on `inputMethod` to pick `fill-editor-action`, so an author who
+        // followed the selector reference and wrote `contenteditable: true` got a plain `.fill()` and
+        // no diagnostic. Forcing the input method HERE rather than adding a second condition in the
+        // pattern keeps ONE rich-text signal on ResolvedSelector, so every consumer — current and
+        // future — reads the intent off a single field. An explicit `inputMethod` is more specific and
+        // still wins, so the two may be mixed without surprise.
+        const inputMethod = entry.inputMethod ?? (entry.contenteditable ? 'pressSequentially' : undefined);
         // v2 fields
         const v2Fields = {};
         if (entry.scope)
@@ -489,8 +608,11 @@ class SelectorResolver {
             v2Fields.frame = entry.frame;
         if (entry.contenteditable)
             v2Fields.contenteditable = true;
+        // A column's `header` is DOM text like any other selector field, so a `{{var}}` in it is a
+        // runtime reference — the same i18n escape hatch `name:`/`value:` have. Encoded here rather
+        // than at the read site so every consumer of the map gets it (issue #674).
         if (entry.columns)
-            v2Fields.columns = entry.columns;
+            v2Fields.columns = SelectorResolver.resolveColumnHeaders(entry.columns);
         if (entry.pagination)
             v2Fields.pagination = entry.pagination;
         if (typeof entry.rows === 'string' && entry.rows.trim())
@@ -499,8 +621,16 @@ class SelectorResolver {
             v2Fields.attribute = entry.attribute;
         if (entry.pattern)
             v2Fields.pattern = entry.pattern;
-        if (entry.expanded)
-            v2Fields.expanded = entry.expanded;
+        if (entry.expanded) {
+            const expanded = this.validatedStateSignal(entry.expanded, 'expanded', originalLabel);
+            if (expanded || entry.expanded.state)
+                v2Fields.expanded = { ...expanded, ...(entry.expanded.state ? { state: entry.expanded.state } : {}) };
+        }
+        const checked = this.resolveCheckedSignal(entry, originalLabel);
+        if (checked?.class)
+            v2Fields.checkedClass = checked.class;
+        if (checked?.attribute)
+            v2Fields.checkedAttribute = checked.attribute;
         // The anchor is a selector in its own right; it must not inherit the PAGE's label as its
         // accessible name, so it resolves against its own name (or nothing).
         if (entry.anchor)
@@ -535,7 +665,26 @@ class SelectorResolver {
         // If type is 'locator', use locator field (or value as fallback) as the CSS locator directly.
         // `exact` travels along: a locator LIST filtered by a test-data value (hasText) matches by
         // substring by default, and `exact: true` in the YAML opts into the anchored full-text match.
-        if (type === 'locator') {
+        //
+        // `upload` rides the SAME branch rather than getting a case of its own. A file input is
+        // addressed by CSS in practice (`input[type=file]`, an id, a testid wrapper), and the selector
+        // reference has always documented `upload` as `page.locator(value).setInputFiles()` — so the
+        // two spellings must resolve identically or teams migrating off the workaround get a silent
+        // behaviour change. It had no case at all before, so it fell through to `default:` and
+        // compiled to `getByPlaceholder('<the CSS string>')` — a locator hunting an input whose
+        // placeholder ATTRIBUTE is the literal text `input[type=file]`, which no page has. It failed
+        // at run time with no diagnostic, and the only way out was to work out for oneself that
+        // `type: locator` had to be used instead, which no page of the reference says (issue #690).
+        //
+        // Handled HERE, above the generic `locator:`-field branch below, because that branch returns
+        // strategy 'css' and drops `exact` — putting `upload` in the switch left the two spellings
+        // diverging for any entry that sets `locator:`. `withExtras` still stamps the declared
+        // `selectorType`, so a consumer that needs to tell an upload from a plain locator still can.
+        //
+        // `exact` is inert for the upload action itself (`setInputFiles` takes no text filter), but it
+        // is NOT dead: the same key reused by a filtered step (`… with {{v}}`) reaches has-text-value,
+        // which reads `exact` regardless of strategy.
+        if (type === 'locator' || type === 'upload') {
             const locatorValue = locator && locator.trim() ? locator : value;
             return withExtras({
                 strategy: 'locator',
@@ -647,7 +796,14 @@ class SelectorResolver {
                     exact,
                 });
             default:
-                // Fallback to placeholder
+                // Reached by the NON_STRATEGY_SELECTOR_TYPES (`page`/`table`/`column`/`frame`, whose
+                // consumers read the entry or `selectorType` rather than `strategy`) and by a type this
+                // compiler does not know at all — YAML is untyped at run time, so a misspelling lands
+                // here too. The placeholder result is inert for the first group and wrong for the second,
+                // but it MUST NOT throw: `page` alone reaches this branch on every page assertion.
+                // What must never arrive here is a STRATEGY type — that is the #690 defect, and
+                // tests/codegen/selector-type-dispatch.run.ts fails the build if one does (it checks the
+                // resolved strategy, so an early return above satisfies it as well as a `case` here).
                 return withExtras({
                     strategy: 'placeholder',
                     value,
@@ -661,13 +817,17 @@ class SelectorResolver {
      * Returns metadata only - no framework-specific code
      */
     resolveByPriority(element) {
+        // The legacy format never passes through the SG-W018 file check (that walks new-format
+        // entries), so it is normalised here instead — a template must never see an index it cannot
+        // express, whichever door the entry came through.
+        const nth = (0, selector_nth_validation_1.normalizeNth)(element.nth);
         // Extract data-testid from locator if present
         const testIdMatch = element.locator.match(/\[data-testid=["']([^"']+)["']\]/);
         if (testIdMatch) {
             return {
                 strategy: 'testid',
                 value: testIdMatch[1],
-                nth: element.nth,
+                nth,
             };
         }
         // Check type-based strategies
@@ -677,28 +837,28 @@ class SelectorResolver {
                 role: 'button',
                 name: element.value,
                 value: element.value,
-                nth: element.nth,
+                nth,
             };
         }
         if (element.type === 'placeholder' && element.value) {
             return {
                 strategy: 'placeholder',
                 value: element.value,
-                nth: element.nth,
+                nth,
             };
         }
         if (element.type === 'label' && element.value) {
             return {
                 strategy: 'label',
                 value: element.value,
-                nth: element.nth,
+                nth,
             };
         }
         if (element.type === 'text' && element.value) {
             return {
                 strategy: 'text',
                 value: element.value,
-                nth: element.nth,
+                nth,
             };
         }
         // Extract #id from locator if present
@@ -708,7 +868,7 @@ class SelectorResolver {
                 strategy: 'id',
                 value: idMatch[1],
                 locator: `#${idMatch[1]}`,
-                nth: element.nth,
+                nth,
             };
         }
         // Fallback to CSS locator
@@ -716,7 +876,7 @@ class SelectorResolver {
             strategy: 'css',
             value: element.locator,
             locator: element.locator,
-            nth: element.nth,
+            nth,
         };
     }
     /**
@@ -760,6 +920,26 @@ class SelectorResolver {
                 Object.assign(selectors, SelectorResolver.normalizeKeys(featureSelectors));
             }
         }
+        // SG-W004 — a field nothing reads (#712). Reported HERE, at the one cached load point, so a
+        // table named by twenty row steps warns once rather than twenty times.
+        (0, selector_entry_fields_1.reportUnknownEntryFields)(selectors, {
+            feature: featureName,
+            diagnostics: this.diagnostics,
+        });
+        // SG-E027 — a `type:` nothing dispatches (#711). Same load point and same once-per-file
+        // reason as SG-W004 above: the two checks are the same question one level apart (an unknown
+        // KEY vs an unknown VALUE for a known key), and both want the file in hand to name the entry.
+        (0, selector_type_validation_1.reportUnknownSelectorTypes)(selectors, {
+            feature: featureName,
+            diagnostics: this.diagnostics,
+        });
+        // SG-W018 — an `nth:` value outside the contract (#720). Third of the same family at the same
+        // load point: SG-W004 asks whether anything READS the key, SG-E027 whether the `type:` VALUE
+        // dispatches, this one whether the `nth:` VALUE is an index the adapters can express.
+        (0, selector_nth_validation_1.reportInvalidNth)(selectors, {
+            feature: featureName,
+            diagnostics: this.diagnostics,
+        });
         this.selectorCache.set(cacheKey, selectors);
         return selectors;
     }