@sun-asterisk/sungen 3.2.4 → 3.2.6

package/src/dashboard/types.ts

@@ -39,8 +39,12 @@ export interface AggregateSummary {
 }
 
 export interface ScreenSnapshot {
-  name: string;                        // "kudos" or "flow/checkout" — the screen DIRECTORY name
+  name: string;                        // "kudos", "flow/checkout", or "api/login" — the unit label
   isFlow: boolean;
+  /** Unit kind — screen | flow | api. Drives the dashboard's suite badge so API
+   *  suites read as API rather than being mislabelled "web". Optional so history
+   *  snapshots written before this field still parse (they render as screen). */
+  kind?: 'screen' | 'flow' | 'api';
   platform?: 'web' | 'android' | 'ios' | 'mobile'; // 'mobile' = @platform:mobile screen (per-OS features below)
   featureName: string;                 // name of the primary (first) feature; kept for backwards compat
   featurePath?: string;                // entry-point path of the primary feature

package/src/exporters/api-testcase-formatter.ts

@@ -0,0 +1,325 @@
+/**
+ * Render an API test case's Steps / Expected-results cells for the delivery report.
+ *
+ * API scenarios carry no Given/When steps and assert against runtime response
+ * refs (`expect {{endpoint.status}} is 201`), so the generic row builder leaves
+ * the Steps cell empty and the Expected cell showing raw `{{…}}`. This module
+ * turns the scenario's `@api:<name>(args)` tag + the apis.yaml catalog into a
+ * human-readable request block (Method / API / Header / Body) and rewrites the
+ * assertions into "Status / Response" language.
+ *
+ * Deterministic — no AI, no network. Everything is sourced from the catalog +
+ * scenario tags + test-data, mirroring exactly what the generated request sends
+ * (see orchestrator/templates/specs-api.ts: catalog headers + a Content-Type
+ * implied by the body wire format; `:param` falls back to the same-named
+ * test-data key when the tag omits it).
+ */
+
+import { ApiCatalogEntry } from './types';
+
+/** A single `@api:<name>(k=v,…)` invocation parsed from a scenario's tags. */
+export interface ApiCall {
+  name: string;
+  /** param → value expression, kept raw: `{{new_email}}`, `"literal"`, `3`. */
+  args: Record<string, string>;
+}
+
+/** True when the scenario invokes at least one `@api:` endpoint. */
+export function hasApiCalls(tags: string[]): boolean {
+  return tags.some((t) => t.startsWith('@api:'));
+}
+
+/**
+ * Parse the ordered `@api:<name>(arg=expr,…)` invocations from a scenario's tags.
+ * Mirrors the driver's override grammar: split the top-level comma list, then the
+ * first `=` per pair. Values stay as raw expressions so the caller resolves them
+ * the same way the runtime does.
+ */
+/**
+ * Same shape the runtime accepts (`driver-api/src/index.ts`): `@api:<name>` with an
+ * optional balanced `(...)` arg list. A malformed tag (e.g. unclosed paren) is rejected
+ * here too, so the report never documents a call the runtime silently dropped.
+ */
+const API_TAG = /^@api:([A-Za-z_][A-Za-z0-9_]*)(?:\((.*)\))?$/;
+
+export function parseApiCalls(tags: string[]): ApiCall[] {
+  const calls: ApiCall[] = [];
+  for (const t of tags) {
+    const m = API_TAG.exec(t);
+    if (!m) continue;
+    const args: Record<string, string> = {};
+    for (const pair of splitTopLevel(m[2] ?? '')) {
+      const eq = pair.indexOf('=');
+      if (eq < 0) continue;
+      args[pair.slice(0, eq).trim()] = pair.slice(eq + 1).trim();
+    }
+    calls.push({ name: m[1], args });
+  }
+  return calls;
+}
+
+/**
+ * Build the "Steps" cell for an API test case: one block per invoked endpoint,
+ * showing Method / API (resolved path) / Header / Body. Endpoints absent from the
+ * catalog are skipped. Returns '' when nothing resolves (caller keeps generic Steps).
+ *
+ * `localize` resolves `{{var}}` test-data placeholders (and selector keys) to
+ * concrete values — the same resolver the row builder uses for UI steps.
+ */
+export function formatApiRequest(
+  tags: string[],
+  catalog: Record<string, ApiCatalogEntry>,
+  localize: (text: string) => string,
+): string {
+  const calls = parseApiCalls(tags).filter((c) => catalog[c.name]);
+  if (calls.length === 0) return '';
+
+  const blocks = calls.map((call) => {
+    const entry = catalog[call.name];
+    const resolve = (raw: string): string => localize(bindParams(raw, call.args));
+    // Coerce method/path — loadApiCatalog is a raw passthrough, so a malformed entry
+    // (numeric method/path) must degrade gracefully, not crash the unit's export.
+    const method = String(entry.method ?? '').toUpperCase() || '—';
+    const api = entry.path ? resolve(String(entry.path)) : '—';
+    const header = formatHeaders(entry, call.args, localize);
+    const bodyStr = formatBody(entry.body, call.args, localize);
+    return [`Method: ${method}`, `API: ${api}`, `Header: ${header}`, `Body: ${bodyStr}`].join('\n');
+  });
+
+  if (blocks.length === 1) return blocks[0];
+  // Multiple endpoints (flow) — number them so the call order is explicit.
+  return blocks
+    .map((b, i) => b.split('\n').map((l, j) => (j === 0 ? `${i + 1}. ${l}` : `   ${l}`)).join('\n'))
+    .join('\n');
+}
+
+/**
+ * Rewrite an API scenario's `Then` assertions into readable Status / Response lines.
+ * Raw assertions reference the runtime response object
+ * (`expect {{endpoint.status}} is 201`, `expect {{endpoint.body.email}} is {{x}}`);
+ * we strip the endpoint prefix (a runtime var, meaningless to a reader), keep the
+ * field path, label status vs body, and resolve `{{var}}` on the right-hand side.
+ */
+export function formatApiExpected(
+  expectedSteps: Array<{ text: string }>,
+  tags: string[],
+  localize: (text: string) => string,
+): string {
+  const endpointNames = parseApiCalls(tags).map((c) => c.name);
+  const oracleNames = parseQueryOracles(tags);
+  const lines = expectedSteps
+    .map((s) => humanizeAssertion(s.text, endpointNames, oracleNames, localize))
+    .filter((l) => l.length > 0);
+  if (lines.length === 0) return '';
+  if (lines.length === 1) return lines[0];
+  return lines.map((l, i) => `${i + 1}. ${l}`).join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Internals
+// ---------------------------------------------------------------------------
+
+/** Split a comma list, ignoring commas nested inside {}/[]/() so `{a,b}` stays whole. */
+function splitTopLevel(s: string): string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let cur = '';
+  for (const ch of s) {
+    if (ch === '{' || ch === '[' || ch === '(') depth++;
+    else if (ch === '}' || ch === ']' || ch === ')') depth = Math.max(0, depth - 1);
+    if (ch === ',' && depth === 0) {
+      out.push(cur);
+      cur = '';
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur.trim().length > 0) out.push(cur);
+  return out;
+}
+
+/**
+ * Substitute `:param` tokens (path / body / header templates) with the invocation's
+ * arg expression, falling back to `{{param}}` when the tag omits it — matching the
+ * runtime, where an unbound param resolves from the same-named test-data key.
+ */
+function bindParams(raw: string, args: Record<string, string>): string {
+  return raw.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, (_m, p: string) => {
+    const expr = p in args ? args[p] : `{{${p}}}`;
+    return unquoteExpr(expr);
+  });
+}
+
+/** Strip a matching pair of surrounding quotes from a tag-arg literal (`"x"` → `x`). */
+function unquoteExpr(e: string): string {
+  const m = e.match(/^"(.*)"$/) || e.match(/^'(.*)'$/);
+  return m ? m[1] : e;
+}
+
+/**
+ * Compose the Header cell from catalog `headers:` (with `:param` bound + `{{var}}`
+ * resolved) plus the Content-Type implied by the body wire format — Playwright sets
+ * that Content-Type from the encoding option at runtime (specs-api.ts), shown only
+ * when a body is sent and the catalog didn't already declare one. Returns '—' when
+ * the request has none.
+ *
+ * Scope: this reflects the per-endpoint catalog headers only. Datasource-level headers
+ * (`conf.headers` from the datasources config, merged at runtime) are NOT read here —
+ * the exporter doesn't load `.env.qa`/datasources — so the cell is a catalog view, not
+ * a byte-for-byte copy of the wire request.
+ */
+function formatHeaders(
+  entry: ApiCatalogEntry,
+  args: Record<string, string>,
+  localize: (text: string) => string,
+): string {
+  const explicit = entry.headers && typeof entry.headers === 'object' ? entry.headers : {};
+  const hasContentType = Object.keys(explicit).some((k) => k.toLowerCase() === 'content-type');
+  // Auth headers (authorization/cookie/api-key…) carry credentials — show the scheme
+  // but mask the value. A value-based redaction pass (redactSecrets) backstops this.
+  const parts = Object.entries(explicit).map(([k, v]) =>
+    isSensitiveHeader(k) ? `${k}: ${maskHeaderValue(String(v))}` : `${k}: ${localize(bindParams(String(v), args))}`,
+  );
+  if (!hasContentType && entry.body !== undefined && entry.body !== null) {
+    parts.push(`Content-Type: ${contentTypeFor(entry.encoding)}`);
+  }
+  return parts.length > 0 ? parts.join('\n') : '—';
+}
+
+function contentTypeFor(encoding?: string): string {
+  if (encoding === 'form') return 'application/x-www-form-urlencoded';
+  if (encoding === 'multipart') return 'multipart/form-data';
+  return 'application/json';
+}
+
+/**
+ * Compose the Body cell, masking credential fields. When the body is a flat object
+ * with a sensitive key (password/token/secret/…), each value is rendered per-key so
+ * that field can be replaced with `***`; otherwise the body resolves wholesale
+ * (preserving numbers/nesting exactly as before).
+ */
+function formatBody(body: unknown, args: Record<string, string>, localize: (text: string) => string): string {
+  if (body === undefined || body === null) return '—';
+  if (isPlainObject(body)) {
+    const obj = body as Record<string, unknown>;
+    if (Object.keys(obj).some(isSensitiveField)) {
+      const out: Record<string, string> = {};
+      for (const [k, v] of Object.entries(obj)) {
+        out[k] = isSensitiveField(k) ? '***' : localize(bindParams(typeof v === 'string' ? v : JSON.stringify(v), args));
+      }
+      return JSON.stringify(out);
+    }
+  }
+  return localize(bindParams(typeof body === 'string' ? body : JSON.stringify(body), args));
+}
+
+function isPlainObject(v: unknown): boolean {
+  return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+/**
+ * Credential name matcher (substring, not anchored) for both body-field keys and
+ * test-data keys — catches variants like confirmPassword / new_password /
+ * password_confirmation / access_token / client_secret / otp / passcode.
+ */
+const SENSITIVE_NAME = /pass(word|code)?|passwd|pwd|secret|token|otp|api[-_]?key|apikey|credential|authorization/i;
+function isSensitiveField(key: string): boolean {
+  return SENSITIVE_NAME.test(key);
+}
+
+/**
+ * Resolved values of sensitive test-data keys — used for a value-based redaction pass
+ * over the finished Steps/Expected cells, closing the paths key-based masking misses
+ * (nested request bodies, query-string credentials, and the Expected assertion cell).
+ * Values shorter than 3 chars are skipped to avoid masking trivial/coincidental text.
+ */
+export function collectSecretValues(testData: Record<string, string>): string[] {
+  const secrets: string[] = [];
+  for (const [k, v] of Object.entries(testData)) {
+    if (typeof v === 'string' && v.length >= 3 && SENSITIVE_NAME.test(k)) secrets.push(v);
+  }
+  // Longest-first so a longer secret is redacted before any shorter substring of it.
+  return [...new Set(secrets)].sort((a, b) => b.length - a.length);
+}
+
+/** Replace every occurrence of each secret value with `***` (literal, not regex). */
+export function redactSecrets(text: string, secrets: string[]): string {
+  if (secrets.length === 0 || !text) return text;
+  let out = text;
+  for (const s of secrets) out = out.split(s).join('***');
+  return out;
+}
+
+/** Header names that carry credentials — value masked, scheme kept. */
+const SENSITIVE_HEADER = /^(authorization|proxy-authorization|cookie|set-cookie|x-api-key|api-key|x-auth-token|x-access-token|x-session-token)$/i;
+function isSensitiveHeader(name: string): boolean {
+  return SENSITIVE_HEADER.test(name);
+}
+
+/** Keep an auth scheme prefix (Bearer/Basic/…) but hide the credential. */
+function maskHeaderValue(value: string): string {
+  const m = value.match(/^(Bearer|Basic|Digest|Token)\b/i);
+  return m ? `${m[1]} ***` : '***';
+}
+
+/** Ordered `@query:<oracle>` DB-oracle names (a @concurrent idempotency cross-check). */
+function parseQueryOracles(tags: string[]): string[] {
+  return tags
+    .filter((t) => t.startsWith('@query:'))
+    .map((t) => {
+      const body = t.slice('@query:'.length);
+      const parenIdx = body.indexOf('(');
+      return parenIdx >= 0 ? body.slice(0, parenIdx) : body;
+    });
+}
+
+/**
+ * Turn one raw assertion line into a readable Status/Response statement.
+ * `{{<endpoint>.<field>}}` → a labelled response reference; `{{<oracle>.<field>}}`
+ * (a @query DB oracle) → the plain dotted path; remaining `{{var}}` (genuine
+ * test-data on the right-hand side) is resolved by `localize`.
+ */
+function humanizeAssertion(
+  raw: string,
+  endpointNames: string[],
+  oracleNames: string[],
+  localize: (text: string) => string,
+): string {
+  let s = raw.trim().replace(/^expect\s+/i, '');
+  // Field path allows array-index segments so @concurrent refs like
+  // `{{login.responses[0].body.token}}` are matched, not left as raw `{{…}}`.
+  const FIELD = '(?:[\\w.]|\\[\\d+\\])+';
+  if (endpointNames.length > 0) {
+    const alt = endpointNames.map(escapeRe).join('|');
+    s = s.replace(new RegExp(`\\{\\{\\s*(?:${alt})\\.(${FIELD})\\s*\\}\\}`, 'g'), (_m, field: string) =>
+      responseFieldLabel(field),
+    );
+  }
+  if (oracleNames.length > 0) {
+    // @query oracle refs read as a DB check — strip the `{{ }}` noise, keep `oracle.field`.
+    const alt = oracleNames.map(escapeRe).join('|');
+    s = s.replace(new RegExp(`\\{\\{\\s*((?:${alt})\\.${FIELD})\\s*\\}\\}`, 'g'), (_m, ref: string) => ref);
+  }
+  s = localize(s);
+  if (s.length === 0) return s;
+  // Don't recase a line that leads with a @query oracle identifier (a code name) —
+  // `user_count.count is 1` must not become `User_count.count is 1`.
+  const leadsWithOracle = oracleNames.some((o) => s === o || s.startsWith(`${o}.`));
+  return leadsWithOracle ? s : s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+/** Map a response field path (after the `<endpoint>.` prefix) to reader-friendly text. */
+function responseFieldLabel(field: string): string {
+  if (field === 'status') return 'Status';
+  if (field === 'ok') return 'Response ok';
+  if (field === 'ok_count') return 'Success count';
+  if (field === 'body') return 'Response body';
+  if (field.startsWith('body.')) return `Response body.${field.slice('body.'.length)}`;
+  if (field.startsWith('status_counts.')) return `Count of ${field.slice('status_counts.'.length)} responses`;
+  if (field.startsWith('headers.')) return `Response header "${field.slice('headers.'.length)}"`;
+  return `Response ${field}`;
+}
+
+function escapeRe(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/exporters/csv-exporter.ts

@@ -22,8 +22,10 @@ import {
   formatNote,
   statusToTestResult,
 } from './playwright-report-parser';
-import { EnvironmentInfo, PlaywrightResult, ScreenSummary, TestCaseRow } from './types';
+import { ApiCatalogEntry, EnvironmentInfo, PlaywrightResult, ScreenSummary, TestCaseRow } from './types';
+import { collectSecretValues, formatApiExpected, formatApiRequest, hasApiCalls, redactSecrets } from './api-testcase-formatter';
 import { SelectorKeyMap, substituteSelectorKeysInStep } from './selector-key-resolver';
+import { resolveResultVariants } from './result-variants';
 
 export interface BuildCsvInput {
   screen: string;
@@ -43,6 +45,18 @@ export interface BuildCsvInput {
    * instead of the VI selector key "Click [VỀ KUDOS] link".
    */
   selectorKeyMap?: SelectorKeyMap;
+  /**
+   * Unit kind. When `'api'`, the row builder renders the request contract
+   * (Method/API/Header/Body) into the Steps cell and the response contract
+   * (Status + Response) into the Expected cell — API scenarios otherwise leave
+   * Steps empty and Expected showing raw `{{endpoint.field}}` refs.
+   */
+  kind?: 'screen' | 'flow' | 'api';
+  /**
+   * apis.yaml catalog (keyed by endpoint name) for api-kind units. Supplies the
+   * Method/path/headers/body/encoding the readable request block is built from.
+   */
+  apiCatalog?: Record<string, ApiCatalogEntry>;
 }
 
 /**
@@ -53,21 +67,10 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
   let fallbackIndex = 1;
 
   for (const m of input.merged) {
-    // Data-driven (@cases): one scenario ran once per input row — emit one CSV row per
-    // executed input. The Playwright results are titled "<scenario> — <label>"; expand
-    // by matching that prefix. With no results yet, fall back to a single (Pending) row.
-    const isCases = m.feature.tags.some((t) => t.startsWith('@cases:'));
-    let variants: Array<{ nameSuffix: string; result?: PlaywrightResult }> = [{ nameSuffix: '' }];
-    if (isCases && input.results) {
-      // Result titles are "<describe> > <scenario> — <label>"; match the scenario+label marker.
-      const marker = `${m.feature.name} — `;
-      const rowResults = [...input.results.entries()].filter(([t]) => t.includes(marker));
-      if (rowResults.length) {
-        variants = rowResults.map(([t, r]) => ({ nameSuffix: ` — ${t.slice(t.indexOf(marker) + marker.length)}`, result: r }));
-      }
-    } else if (input.results && m.spec) {
-      variants = [{ nameSuffix: '', result: input.results.get(m.spec.testTitle) }];
-    }
+    // Data-driven (@cases): expand to one CSV row per executed dataset input (Playwright titles
+    // "<scenario> — <label>"); plain scenarios resolve their single result. Shared with the
+    // dashboard/JSON exporter via resolveResultVariants so the two can't drift on @cases handling.
+    const variants = resolveResultVariants(m, input.results);
 
    for (const variant of variants) {
     const displayName = `${m.feature.name}${variant.nameSuffix}`;
@@ -97,15 +100,35 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
       localize(s.bucket === 'given' ? keepActor(s.text) : stripActor(s.text));
     const stepLines    = m.resolvedSteps.map(formatStep).filter(Boolean);
     const expectedLines = m.resolvedExpected.map(formatStep).filter(Boolean);
-    const steps =
+    let steps =
       stepLines.length === 0 ? '' :
       stepLines.length === 1 ? stepLines[0] :
       stepLines.map((l, i) => `${i + 1}. ${l}`).join('\n');
-    const expectedResults =
+    let expectedResults =
       expectedLines.length === 0 ? '' :
       expectedLines.length === 1 ? expectedLines[0] :
       expectedLines.map((l, i) => `${i + 1}. ${l}`).join('\n');
 
+    // API test cases: the scenario has no Given/When (Steps empty) and asserts
+    // against runtime response refs (`{{endpoint.status}}` — left literal since
+    // they aren't test-data keys). Render the request contract into Steps and the
+    // response contract into Expected from the @api tag + apis.yaml catalog, so
+    // QA reads Method/API/Header/Body and Status/Response instead of raw refs.
+    if (input.kind === 'api' && input.apiCatalog && hasApiCalls(m.feature.tags)) {
+      const apiRequest = formatApiRequest(m.feature.tags, input.apiCatalog, localize);
+      if (apiRequest) steps = steps ? `${steps}\n\n${apiRequest}` : apiRequest;
+      const apiExpected = formatApiExpected(m.resolvedExpected, m.feature.tags, localize);
+      if (apiExpected) expectedResults = apiExpected;
+      // Value-based redaction backstop: mask resolved credential values (from
+      // sensitively-named test-data keys) anywhere in the API cells — closes the
+      // nested-body, query-string and Expected-cell paths key-based masking misses.
+      const secrets = collectSecretValues(input.testData);
+      if (secrets.length > 0) {
+        steps = redactSecrets(steps, secrets);
+        expectedResults = redactSecrets(expectedResults, secrets);
+      }
+    }
+
     // Multi-line bullet format keeps delivery CSV/XLSX in sync with the
     // dashboard's Test data section. Multi-line CSV cells are valid (quoted
     // automatically) and render natively as multi-line in XLSX.
@@ -121,21 +144,26 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
     let environment = '';
     let executor = '';
 
-    if (!m.spec) {
-      // Scenario not compiled → Manual if @manual, else Not compiled
+    if (result) {
+      // An execution record exists → the scenario compiled AND ran; that is authoritative and
+      // MUST win over the `!m.spec` "not compiled" heuristic below. A @cases scenario compiles to
+      // per-row test titles carrying a `— <label>` suffix, so `findMatchingSpecTest` (base-name
+      // match) frequently leaves `m.spec` null even though the rows ran — without checking `result`
+      // first, those already-passed/failed rows were mislabelled N/A ("not compiled").
+      testResult = statusToTestResult(result.status);
+      executedDate = formatExecutedDate(result.startTime);
+      note = formatNote(result, expectedResults);
+      environment = formatEnv(input.env.baseURL, input.featurePath, result.projectName || input.env.projectName);
+      executor = input.env.executor;
+    } else if (!m.spec) {
+      // No execution record AND no compiled test → Manual if @manual, else genuinely not compiled.
       testResult = testcaseType === 'Manual' ? 'Pending' : 'N/A';
       if (testcaseType !== 'Manual') {
         note = 'Scenario not compiled — re-run `sungen generate --screen ' + input.screen + '`';
       }
-    } else if (!result) {
+    } else {
       // Compiled but no execution record → Pending
       testResult = 'Pending';
-    } else {
-      testResult = statusToTestResult(result.status);
-      executedDate = formatExecutedDate(result.startTime);
-      note = formatNote(result, expectedResults);
-      environment = formatEnv(input.env.baseURL, input.featurePath, result.projectName || input.env.projectName);
-      executor = input.env.executor;
     }
 
     // If we have environment info and the test actually ran, populate env + executor

package/src/exporters/feature-parser.ts

@@ -144,11 +144,17 @@ export function extractTestcaseType(tags: string[]): 'Auto' | 'Manual' {
 
 /**
  * Extract auth role from tags. Returns 'no-auth' if @no-auth, else role name or null.
+ *
+ * Merged tag arrays put feature-level tags before scenario-level ones
+ * (`parseFeatureMetadata` builds `[...featureTags, ...scenarioTags]`), so the
+ * LAST @auth: tag is the most specific — a scenario-level @auth:owner must
+ * override a feature-level @auth:user in the delivery Pre-condition column,
+ * matching the codegen precedence (getEffectiveAuthRole: Scenario > Feature).
  */
 export function extractAuthRole(tags: string[]): string | null {
   if (tags.includes('@no-auth')) return 'no-auth';
-  const authTag = tags.find((t) => t.startsWith('@auth:'));
-  if (authTag) return authTag.replace('@auth:', '');
+  const authTags = tags.filter((t) => t.startsWith('@auth:'));
+  if (authTags.length > 0) return authTags[authTags.length - 1].replace('@auth:', '');
   return null;
 }
 

package/src/exporters/json-exporter.ts

@@ -22,6 +22,7 @@ import {
 } from './playwright-report-parser';
 import { EnvironmentInfo, PlaywrightResult } from './types';
 import { SelectorKeyMap, substituteSelectorKeysInStep } from './selector-key-resolver';
+import { resolveResultVariants } from './result-variants';
 import {
   ScenarioSnapshot,
   ScreenSnapshot,
@@ -62,11 +63,6 @@ export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnap
   let fallbackIndex = 1;
 
   for (const m of input.merged) {
-    const { vpId, category1 } = splitVpAndName(m.feature.name);
-    const tcId = generateTcId(input.screen, vpId, fallbackIndex);
-    if (!vpId) fallbackIndex++;
-
-    const category2 = mapVpToCategory2(vpId, category1);
     const priority = extractPriority(m.feature.tags) as ScenarioSnapshot['priority'];
     const baseType = extractTestcaseType(m.feature.tags);
     const authRole = extractAuthRole(m.feature.tags);
@@ -87,27 +83,32 @@ export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnap
     // key/value per line instead of the CSV-friendly "; " join.
     const testDataStr = formatTestData(m.feature.referencedVars, input.testData, Infinity, '\n');
 
-    let result: PlaywrightResult | undefined;
-    if (input.results && m.spec) {
-      result = input.results.get(m.spec.testTitle);
-    }
+    // @cases scenarios expand to one snapshot entry per executed dataset row (shared with the CSV
+    // exporter via resolveResultVariants), so their per-row pass/fail is counted — not collapsed
+    // into one Pending/N/A entry as before.
+    const variants = resolveResultVariants(m, input.results ?? null);
+    for (const variant of variants) {
+      const displayName = `${m.feature.name}${variant.nameSuffix}`;
+      const { vpId, category1 } = splitVpAndName(displayName);
+      const tcId = generateTcId(input.screen, vpId, fallbackIndex);
+      if (!vpId) fallbackIndex++;
+      const category2 = mapVpToCategory2(vpId, category1);
+      const result = variant.result;
 
-    let status: ScenarioSnapshot['status'];
-    let executedDate: string | undefined;
-    let errorMessage: string | undefined;
-    let tracePath: string | undefined;
-    let testEnvironment: string | undefined;
-    let testExecutor: string | undefined;
-    let type: ScenarioSnapshot['type'];
+      let status: ScenarioSnapshot['status'];
+      let executedDate: string | undefined;
+      let errorMessage: string | undefined;
+      let tracePath: string | undefined;
+      let testEnvironment: string | undefined;
+      let testExecutor: string | undefined;
+      let type: ScenarioSnapshot['type'];
 
-    if (!m.spec) {
-      type = baseType === 'Manual' ? 'Manual' : 'Not compiled';
-      status = baseType === 'Manual' ? 'Pending' : 'N/A';
-    } else {
-      type = baseType;
-      if (!result) {
-        status = 'Pending';
-      } else {
+      if (result) {
+        // A result exists → the scenario compiled AND ran; authoritative over the `!m.spec`
+        // "not compiled" heuristic. A @cases test title carries a `— <label>` suffix, so
+        // findMatchingSpecTest (base-name match) often leaves m.spec null even though rows ran —
+        // without checking `result` first, those passed/failed rows were mislabelled N/A / Pending.
+        type = baseType;
         status = statusToTestResult(result.status) as ScenarioSnapshot['status'];
         executedDate = formatExecutedDate(result.startTime);
         if (result.error) {
@@ -126,31 +127,39 @@ export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnap
         if (result.tracePath) tracePath = result.tracePath;
         testEnvironment = formatTestEnvironment(input.env.baseURL, input.featurePath, result.projectName || input.env.projectName);
         testExecutor = input.env.executor;
+      } else if (!m.spec) {
+        // No result AND no compiled test → Manual if @manual, else genuinely not compiled.
+        type = baseType === 'Manual' ? 'Manual' : 'Not compiled';
+        status = baseType === 'Manual' ? 'Pending' : 'N/A';
+      } else {
+        // Compiled but no execution record → Pending.
+        type = baseType;
+        status = 'Pending';
       }
-    }
 
-    scenarios.push({
-      tcId,
-      category1,
-      category2,
-      category3: input.featureName,
-      category4: input.screen,
-      featureBaseName: input.featureBaseName ?? input.screen,
-      vpId,
-      priority,
-      type,
-      status,
-      tags: m.feature.tags,
-      precondition,
-      testData: testDataStr,
-      steps,
-      expectedResults,
-      executedDate,
-      errorMessage,
-      tracePath,
-      testEnvironment,
-      testExecutor,
-    });
+      scenarios.push({
+        tcId,
+        category1,
+        category2,
+        category3: input.featureName,
+        category4: input.screen,
+        featureBaseName: input.featureBaseName ?? input.screen,
+        vpId,
+        priority,
+        type,
+        status,
+        tags: m.feature.tags,
+        precondition,
+        testData: testDataStr,
+        steps,
+        expectedResults,
+        executedDate,
+        errorMessage,
+        tracePath,
+        testEnvironment,
+        testExecutor,
+      });
+    }
   }
 
   return {