@sun-asterisk/sungen 2.6.8 → 2.6.10

package/src/dashboard/types.ts

@@ -33,7 +33,7 @@ export interface AggregateSummary {
   na: number;
   notCompiled: number;
   passRate: number;                    // 0..1, only counting executed (passed+failed)
-  byPriority: Record<string, number>;  // Critical/High/Normal/Low
+  byPriority: Record<string, number>;  // High/Normal/Low
   byCategory: Record<string, number>;  // Accessing/GUI/Function
   byType: Record<string, number>;      // Auto/Manual/Not compiled
 }

package/src/exporters/csv-exporter.ts

@@ -15,7 +15,7 @@ import {
   mapVpToCategory2,
   splitVpAndName,
 } from './feature-parser';
-import { formatNumberedSteps, formatPrecondition, cleanStepLine } from './step-formatter';
+import { formatFeatureSteps, formatPrecondition, keepActor, stripActor } from './step-formatter';
 import { formatTestData } from './test-data-resolver';
 import {
   formatExecutedDate,
@@ -27,6 +27,10 @@ import { EnvironmentInfo, PlaywrightResult, ScreenSummary, TestCaseRow } from '.
 export interface BuildCsvInput {
   screen: string;
   featureName: string;
+  /** URL path for the screen/flow entry point — concatenated onto baseURL
+   *  when building the Test Environment column so QA can see the exact URL
+   *  the test targets. */
+  featurePath?: string;
   merged: MergedScenario[];
   testData: Record<string, string>;
   results: Map<string, PlaywrightResult> | null;
@@ -50,23 +54,26 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
     const testcaseType = extractTestcaseType(m.feature.tags);
     const authRole = extractAuthRole(m.feature.tags);
 
-    // Prefer .spec.ts resolved comments for Steps/Expected if available
-    let steps: string;
-    let expectedResults: string;
-    let precondition: string;
+    // Pre-condition is auth-only. Steps section = Background + @extend base
+    // (entire) + own pre-Then. Expected = own's Then-onwards only.
+    const precondition = formatPrecondition(authRole);
+    const formatStep = (s: { text: string; bucket: 'given' | 'when' | 'then' }) =>
+      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 =
+      stepLines.length === 0 ? '' :
+      stepLines.length === 1 ? stepLines[0] :
+      stepLines.map((l, i) => `${i + 1}. ${l}`).join('\n');
+    const expectedResults =
+      expectedLines.length === 0 ? '' :
+      expectedLines.length === 1 ? expectedLines[0] :
+      expectedLines.map((l, i) => `${i + 1}. ${l}`).join('\n');
 
-    if (m.spec) {
-      precondition = formatPrecondition(authRole, m.spec.precondition);
-      steps = formatNumberedSteps(m.spec.steps);
-      expectedResults = formatNumberedSteps(m.spec.expectations);
-    } else {
-      // Fallback to .feature raw steps
-      precondition = formatPrecondition(authRole, m.feature.rawGivenSteps);
-      steps = formatNumberedSteps(m.feature.rawWhenSteps);
-      expectedResults = formatNumberedSteps(m.feature.rawThenSteps);
-    }
-
-    const testData = formatTestData(m.feature.referencedVars, input.testData);
+    // 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.
+    const testData = formatTestData(m.feature.referencedVars, input.testData, Infinity, '\n');
 
     // Match Playwright result by test title (from .spec.ts) OR by scenarioName
     let result: PlaywrightResult | undefined;
@@ -94,13 +101,13 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
       testResult = statusToTestResult(result.status);
       executedDate = formatExecutedDate(result.startTime);
       note = formatNote(result);
-      environment = `${input.env.baseURL} (${input.env.projectName})`;
+      environment = formatEnv(input.env.baseURL, input.featurePath, input.env.projectName);
       executor = input.env.executor;
     }
 
     // If we have environment info and the test actually ran, populate env + executor
     if (testResult !== 'Pending' && testResult !== 'N/A') {
-      if (!environment) environment = `${input.env.baseURL} (${input.env.projectName})`;
+      if (!environment) environment = formatEnv(input.env.baseURL, input.featurePath, input.env.projectName);
       if (!executor) executor = input.env.executor;
     }
 
@@ -159,6 +166,18 @@ export function buildSummary(screen: string, rows: TestCaseRow[], outputFile: st
  * Escape a CSV cell per RFC 4180.
  * Wrap in quotes if contains: comma, newline, quote. Escape embedded " as "".
  */
+/**
+ * Compose the "Environment" cell. Concatenates the entry-point path onto
+ * the baseURL so the deliverable shows the exact URL each test targets
+ * (e.g. `https://staging.example.com/kudos (chromium)`).
+ */
+function formatEnv(baseURL: string, featurePath: string | undefined, projectName: string): string {
+  const base = (baseURL || '').replace(/\/+$/, '');
+  const p = (featurePath || '').replace(/^\/+/, '');
+  const url = p ? `${base}/${p}` : base;
+  return `${url} (${projectName})`;
+}
+
 function csvCell(v: string | number | undefined | null): string {
   if (v === null || v === undefined) return '';
   const s = String(v);
@@ -204,10 +223,10 @@ export function renderCsv(summary: ScreenSummary, rows: TestCaseRow[], specLink:
   lines.push(csvRow(['*: Mandatory', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '']));
   lines.push(csvRow([
     'TC ID*',
-    '{Category 1}',
-    '{Category 2}',
-    '{Category 3}',
-    '{Category 4}',
+    'Screen/Function',
+    'Big item',
+    'Medium item',
+    'Test Object',
     'Pre-condition',
     'Test Data',
     'Steps*',
@@ -239,10 +258,10 @@ export function renderCsv(summary: ScreenSummary, rows: TestCaseRow[], specLink:
     for (const row of groupRows) {
       lines.push(csvRow([
         row.tcId,
-        row.category1,
         '',
         '',
         '',
+        row.category1,
         row.precondition,
         row.testData,
         row.steps,
@@ -264,10 +283,10 @@ export function renderCsv(summary: ScreenSummary, rows: TestCaseRow[], specLink:
     for (const row of groupRows) {
       lines.push(csvRow([
         row.tcId,
-        row.category1,
         '',
         '',
         '',
+        row.category1,
         row.precondition,
         row.testData,
         row.steps,
@@ -300,5 +319,3 @@ export function writeCsv(cwd: string, screen: string, csvContent: string): strin
   return outPath;
 }
 
-// mark unused import to silence TS if needed
-void cleanStepLine;

package/src/exporters/feature-parser.ts

@@ -4,7 +4,7 @@
  */
 
 import { GherkinParser, ParsedFeature, ParsedScenario } from '../generators/gherkin-parser';
-import { FeatureMetadata, ScenarioMetadata } from './types';
+import { FeatureMetadata, OrderedStep, ScenarioMetadata } from './types';
 
 /**
  * Variables referenced in a scenario: find all {{var_name}} in step text.
@@ -12,7 +12,7 @@ import { FeatureMetadata, ScenarioMetadata } from './types';
 function extractReferencedVars(scenario: ParsedScenario): string[] {
   const vars = new Set<string>();
   for (const step of scenario.steps) {
-    const matches = step.text.matchAll(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g);
+    const matches = step.text.matchAll(/\{\{([a-zA-Z_][a-zA-Z0-9_.-]*)\}\}/g);
     for (const match of matches) {
       vars.add(match[1]);
     }
@@ -20,7 +20,7 @@ function extractReferencedVars(scenario: ParsedScenario): string[] {
     if (step.dataTable) {
       for (const row of step.dataTable.rows) {
         for (const cell of row.cells) {
-          const cellMatches = cell.matchAll(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g);
+          const cellMatches = cell.matchAll(/\{\{([a-zA-Z_][a-zA-Z0-9_.-]*)\}\}/g);
           for (const match of cellMatches) {
             vars.add(match[1]);
           }
@@ -35,10 +35,16 @@ function extractReferencedVars(scenario: ParsedScenario): string[] {
  * Classify each step into Given / When / Then bucket based on its preceding
  * explicit keyword. "And" inherits from the previous explicit keyword.
  */
-function classifySteps(scenario: ParsedScenario): { given: string[]; when: string[]; then: string[] } {
+function classifySteps(scenario: ParsedScenario): {
+  given: string[];
+  when: string[];
+  then: string[];
+  ordered: OrderedStep[];
+} {
   const given: string[] = [];
   const when: string[] = [];
   const then: string[] = [];
+  const ordered: OrderedStep[] = [];
   let currentBucket: 'given' | 'when' | 'then' = 'given';
 
   for (const step of scenario.steps) {
@@ -51,9 +57,11 @@ function classifySteps(scenario: ParsedScenario): { given: string[]; when: strin
     if (currentBucket === 'given') given.push(step.text);
     else if (currentBucket === 'when') when.push(step.text);
     else then.push(step.text);
+
+    ordered.push({ text: step.text, bucket: currentBucket });
   }
 
-  return { given, when, then };
+  return { given, when, then, ordered };
 }
 
 /**
@@ -63,8 +71,14 @@ export function parseFeatureMetadata(featureFilePath: string): FeatureMetadata {
   const parser = new GherkinParser();
   const parsed: ParsedFeature = parser.parseFeatureFile(featureFilePath);
 
+  // Background block — classify once and surface on FeatureMetadata so the
+  // merger can prepend it to each runnable scenario without re-parsing.
+  const bg = parsed.background
+    ? classifySteps(parsed.background)
+    : { given: [], when: [], then: [], ordered: [] as OrderedStep[] };
+
   const scenarios: ScenarioMetadata[] = parsed.scenarios.map((sc) => {
-    const { given, when, then } = classifySteps(sc);
+    const { given, when, then, ordered } = classifySteps(sc);
 
     return {
       name: sc.name,
@@ -73,8 +87,9 @@ export function parseFeatureMetadata(featureFilePath: string): FeatureMetadata {
       extendsName: sc.extendsName,
       referencedVars: extractReferencedVars(sc),
       rawGivenSteps: given,
-      rawWhenSteps: when,
-      rawThenSteps: then,
+      rawWhenSteps:  when,
+      rawThenSteps:  then,
+      orderedSteps:  ordered,
     };
   });
 
@@ -82,6 +97,10 @@ export function parseFeatureMetadata(featureFilePath: string): FeatureMetadata {
     featureName: parsed.name,
     featurePath: parsed.path,
     featureTags: parsed.tags,
+    backgroundGivenSteps:   bg.given,
+    backgroundWhenSteps:    bg.when,
+    backgroundThenSteps:    bg.then,
+    backgroundOrderedSteps: bg.ordered,
     scenarios,
   };
 }

package/src/exporters/json-exporter.ts

@@ -14,7 +14,7 @@ import {
   mapVpToCategory2,
   splitVpAndName,
 } from './feature-parser';
-import { formatPrecondition, cleanStepLine } from './step-formatter';
+import { formatPrecondition, keepActor, stripActor } from './step-formatter';
 import { formatTestData } from './test-data-resolver';
 import {
   formatExecutedDate,
@@ -56,24 +56,17 @@ export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnap
     const baseType = extractTestcaseType(m.feature.tags);
     const authRole = extractAuthRole(m.feature.tags);
 
-    let stepsRaw: string[];
-    let expectedRaw: string[];
-    let givenForPrecondition: string[];
-
-    if (m.spec) {
-      givenForPrecondition = m.spec.precondition;
-      stepsRaw = m.spec.steps;
-      expectedRaw = m.spec.expectations;
-    } else {
-      givenForPrecondition = m.feature.rawGivenSteps;
-      stepsRaw = m.feature.rawWhenSteps;
-      expectedRaw = m.feature.rawThenSteps;
-    }
-
-    const precondition = formatPrecondition(authRole, givenForPrecondition);
-    const steps = stepsRaw.map(cleanStepLine).filter(Boolean);
-    const expectedResults = expectedRaw.map(cleanStepLine).filter(Boolean);
-    const testDataStr = formatTestData(m.feature.referencedVars, input.testData);
+    // Pre-condition is auth-only. Steps section = Background + @extend base
+    // (all of it, including its Then) + own pre-Then. Expected = own's
+    // Then-onwards only. Given → keepActor (state), When/Then → stripActor.
+    const precondition = formatPrecondition(authRole);
+    const formatStep = (s: { text: string; bucket: 'given' | 'when' | 'then' }) =>
+      s.bucket === 'given' ? keepActor(s.text) : stripActor(s.text);
+    const steps = m.resolvedSteps.map(formatStep).filter(Boolean);
+    const expectedResults = m.resolvedExpected.map(formatStep).filter(Boolean);
+    // Dashboard modal uses whitespace-pre-wrap — pass '\n' to render one
+    // 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) {
@@ -98,9 +91,13 @@ export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnap
       } else {
         status = statusToTestResult(result.status) as ScenarioSnapshot['status'];
         executedDate = formatExecutedDate(result.startTime);
-        if (result.error) errorMessage = String(result.error).split('\n')[0].trim();
+        if (result.error) {
+          // Strip a leading "Error:" so consumers (dashboard / CSV `Note`)
+          // can prepend their own label without ending up with `Error: Error:`.
+          errorMessage = String(result.error).split('\n')[0].trim().replace(/^Error:\s*/i, '');
+        }
         if (result.tracePath) tracePath = result.tracePath;
-        testEnvironment = `${input.env.baseURL} (${input.env.projectName})`;
+        testEnvironment = formatTestEnvironment(input.env.baseURL, input.featurePath, input.env.projectName);
         testExecutor = input.env.executor;
       }
     }
@@ -139,6 +136,19 @@ export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnap
   };
 }
 
+/**
+ * Compose the "Environment" string with the screen/flow entry-point path
+ * concatenated to the baseURL. Strips trailing `/` from baseURL and leading
+ * `/` from path to avoid `//` when joining. Falls back to baseURL only when
+ * the path is missing.
+ */
+function formatTestEnvironment(baseURL: string, featurePath: string | undefined, projectName: string): string {
+  const base = (baseURL || '').replace(/\/+$/, '');
+  const p = (featurePath || '').replace(/^\/+/, '');
+  const url = p ? `${base}/${p}` : base;
+  return `${url} (${projectName})`;
+}
+
 function summarizeScreen(scenarios: ScenarioSnapshot[]): ScreenSummaryStats {
   const stats: ScreenSummaryStats = {
     total: scenarios.length,

package/src/exporters/playwright-report-parser.ts

@@ -80,7 +80,7 @@ export function loadPlaywrightReport(reportPath: string): Map<string, Playwright
     const results = test?.results || [];
     const res = results[results.length - 1];
     const status = normalizeStatus(res?.status);
-    const errorMsg = res?.error?.message || '';
+    const errorMsg = stripAnsi(res?.error?.message || '');
     const trace = res?.attachments?.find((a) => a.name === 'trace' || a.contentType === 'application/zip')?.path;
 
     // Strip the leading file-path suite title if present.
@@ -99,6 +99,18 @@ export function loadPlaywrightReport(reportPath: string): Map<string, Playwright
   return result;
 }
 
+/**
+ * Strip ANSI escape sequences (terminal color/style codes) that Playwright
+ * embeds in error messages. The dashboard and CSV render plain text, so
+ * codes like  and  must be removed.
+ */
+function stripAnsi(s: string): string {
+  // CSI sequences: ESC '[' params final-byte. Covers SGR colors plus most
+  // other cursor/erase codes Playwright might emit.
+  // eslint-disable-next-line no-control-regex
+  return s.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '');
+}
+
 /**
  * Normalize playwright status strings to our enum.
  */
@@ -166,10 +178,16 @@ export function formatExecutedDate(startTime: string | undefined): string {
 export function formatNote(result: PlaywrightResult | undefined): string {
   if (!result) return '';
   if (result.status !== 'failed' && result.status !== 'timedOut') return '';
-  const firstLine = (result.error || '').split('\n')[0].trim();
+  // Some Playwright error messages already start with `Error:` — strip it
+  // so we don't end up rendering `Error: Error: …` once we prepend the label.
+  const firstLine = (result.error || '').split('\n')[0].trim().replace(/^Error:\s*/i, '');
   const truncated = firstLine.length > 200 ? firstLine.substring(0, 197) + '…' : firstLine;
   const parts: string[] = [];
-  if (truncated) parts.push(`Error: ${truncated}`);
-  if (result.tracePath) parts.push(`Trace: ${result.tracePath}`);
-  return parts.join('. ');
+  if (truncated)        parts.push(`• Error: ${truncated}`);
+  if (result.tracePath) parts.push(`• Trace: ${result.tracePath}`);
+  // Newline-separated bullets so each field lands on its own row when the
+  // cell wraps — matches the Test Data column's `• key: value` formatting.
+  // Excel/CSV honour `\n` inside quoted cells; the dashboard modal already
+  // renders this with whitespace-pre-wrap.
+  return parts.join('\n');
 }

package/src/exporters/scenario-merger.ts

@@ -8,7 +8,7 @@
  *   - Scenarios in .feature but NOT in .spec.ts → marked "Not compiled"
  */
 
-import { FeatureMetadata, ScenarioMetadata, SpecFileData, SpecTest } from './types';
+import { FeatureMetadata, OrderedStep, ScenarioMetadata, SpecFileData, SpecTest } from './types';
 import { isStepsBaseScenario, isSampleScaffoldScenario } from './feature-parser';
 
 export interface MergedScenario {
@@ -17,6 +17,29 @@ export interface MergedScenario {
 
   /** Matched compiled test from .spec.ts, or null if not compiled. */
   spec: SpecTest | null;
+
+  /**
+   * When/Then/Given steps with any `@extend:<name>` chain pre-resolved
+   * against the matching `@steps:<name>` base scenario (its steps are
+   * prepended). Use these for surfaces that show the test case text
+   * (dashboard Steps section) so we get the canonical feature wording
+   * without re-parsing compiled spec.ts comments.
+   */
+  resolvedWhenSteps:  string[];
+  resolvedThenSteps:  string[];
+  resolvedGivenSteps: string[];
+  /**
+   * Steps section for display, in chronological order:
+   *   Background (all) → @extend base (all incl. its Then) → own up to the
+   *   first `Then`. Base's `Then` stays here because it's mid-flow setup,
+   *   not the scenario's final assertion.
+   */
+  resolvedSteps: OrderedStep[];
+  /**
+   * Expected results — own scenario's first `Then` onwards. Empty when the
+   * scenario has no `Then`.
+   */
+  resolvedExpected: OrderedStep[];
 }
 
 /**
@@ -28,14 +51,55 @@ export function mergeFeatureAndSpec(
 ): MergedScenario[] {
   const result: MergedScenario[] = [];
 
+  // Index @steps base scenarios so @extend can resolve them.
+  const stepsBaseByName = new Map<string, ScenarioMetadata>();
+  for (const sc of feature.scenarios) {
+    if (sc.stepsName) stepsBaseByName.set(sc.stepsName, sc);
+  }
+
   for (const scenario of feature.scenarios) {
     if (isStepsBaseScenario(scenario)) continue;       // skip @steps base scenarios
     if (isSampleScaffoldScenario(scenario)) continue;  // skip default sample
 
     const specTest = findMatchingSpecTest(scenario, spec.tests);
+    const base = scenario.extendsName ? stepsBaseByName.get(scenario.extendsName) : undefined;
+
+    // Order of execution for a runnable scenario:
+    //   1. Feature Background (once) — all buckets are setup, stay in Steps.
+    //   2. @extend base scenario's own steps (if any) — *including* its Then,
+    //      because the base's Then is a mid-flow assertion, not the scenario's
+    //      final verification.
+    //   3. This scenario's own steps in original sequence, split at the
+    //      first `Then`: pre-Then → Steps, Then-onwards → Expected results.
+    const ownOrdered = scenario.orderedSteps;
+    const firstThenIdx = ownOrdered.findIndex((s) => s.bucket === 'then');
+    const ownPreThen = firstThenIdx >= 0 ? ownOrdered.slice(0, firstThenIdx) : ownOrdered;
+    const ownPostThen = firstThenIdx >= 0 ? ownOrdered.slice(firstThenIdx) : [];
+
     result.push({
       feature: scenario,
       spec: specTest,
+      resolvedWhenSteps: [
+        ...feature.backgroundWhenSteps,
+        ...(base?.rawWhenSteps ?? []),
+        ...scenario.rawWhenSteps,
+      ],
+      resolvedThenSteps: [
+        ...feature.backgroundThenSteps,
+        ...(base?.rawThenSteps ?? []),
+        ...scenario.rawThenSteps,
+      ],
+      resolvedGivenSteps: [
+        ...feature.backgroundGivenSteps,
+        ...(base?.rawGivenSteps ?? []),
+        ...scenario.rawGivenSteps,
+      ],
+      resolvedSteps: [
+        ...feature.backgroundOrderedSteps,
+        ...(base?.orderedSteps ?? []),
+        ...ownPreThen,
+      ],
+      resolvedExpected: ownPostThen,
     });
   }
 

package/src/exporters/step-formatter.ts

@@ -20,6 +20,41 @@ export function formatNumberedSteps(lines: string[]): string {
   return cleaned.map((line, idx) => `${idx + 1}. ${line}`).join('\n');
 }
 
+/**
+ * Strip the leading actor (`User `) from a raw Gherkin step and capitalise
+ * the first letter. Brackets `[ref]`, `{{var}}` placeholders and element
+ * types are kept verbatim. Use for When/Then steps where "User click X"
+ * reads more naturally as "Click X".
+ */
+export function stripActor(raw: string): string {
+  const out = raw.replace(/^\s*User\s+/i, '').trim();
+  return out.length > 0 ? out.charAt(0).toUpperCase() + out.slice(1) : out;
+}
+
+/**
+ * Capitalise the first letter of a raw Gherkin step but keep the "User"
+ * actor. Use for Given/Background steps where "User is on X" reads more
+ * naturally than "Is on X".
+ */
+export function keepActor(raw: string): string {
+  const out = raw.trim();
+  return out.length > 0 ? out.charAt(0).toUpperCase() + out.slice(1) : out;
+}
+
+/**
+ * Number a list of raw feature steps. Mirrors `formatNumberedSteps` but
+ * preserves the original Gherkin punctuation (no bracket-to-quote conversion).
+ * The mapper picks between `stripActor` (When/Then) and `keepActor`
+ * (Given) so the actor word matches the step's grammatical role.
+ * Use this for feature-direct rendering (dashboard + delivery).
+ */
+export function formatFeatureSteps(lines: string[], mapper: (s: string) => string = stripActor): string {
+  const cleaned = lines.map(mapper).filter((l) => l.length > 0);
+  if (cleaned.length === 0) return '';
+  if (cleaned.length === 1) return cleaned[0];
+  return cleaned.map((line, idx) => `${idx + 1}. ${line}`).join('\n');
+}
+
 /**
  * Clean a raw step line (either Gherkin text or .spec.ts comment).
  *
@@ -53,28 +88,18 @@ export function cleanStepLine(raw: string): string {
 }
 
 /**
- * Natural language for Given → Pre-condition.
- * Combines auth info + Given steps into a single sentence.
+ * Pre-condition — login/auth context only.
+ *
+ *   `@auth:user`   → `Logged in as user`
+ *   `@no-auth`     → `Not authenticated`
+ *   (no auth tag)  → empty string
+ *
+ * Background and Given steps are no longer echoed here — they're rendered as
+ * the first entries in the Steps list so the chain of actions reads as one
+ * uninterrupted sequence.
  */
-export function formatPrecondition(
-  authRole: string | null,
-  givenLines: string[]
-): string {
-  const parts: string[] = [];
-
-  // Auth prefix
-  if (authRole === 'no-auth') {
-    parts.push('Not authenticated.');
-  } else if (authRole) {
-    parts.push(`Logged in as ${authRole}.`);
-  }
-
-  // Given lines (clean + period-separated)
-  for (const line of givenLines) {
-    const cleaned = cleanStepLine(line);
-    if (!cleaned) continue;
-    parts.push(cleaned.endsWith('.') ? cleaned : cleaned + '.');
-  }
-
-  return parts.join(' ').trim();
+export function formatPrecondition(authRole: string | null, _givenLines: string[] = []): string {
+  if (authRole === 'no-auth') return 'Not authenticated';
+  if (authRole)               return `Logged in as ${authRole}`;
+  return '';
 }

package/src/exporters/sun-logo.ts

@@ -0,0 +1,10 @@
+/**
+ * Sun* logo embedded as base64 PNG. Sourced once from template_report.xlsx
+ * (Sample sheet, anchored over A1:C3) and inlined here so the xlsx exporter
+ * has no filesystem dependency at runtime.
+ *
+ * Decode + use:
+ *   wb.addImage({ base64: SUN_LOGO_PNG_BASE64, extension: 'png' });
+ */
+export const SUN_LOGO_PNG_BASE64 =
+  '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';