@solidxai/core 0.1.13-beta.11 → 0.1.13-beta.13

package/src/commands/run-tests.command.ts

@@ -3,6 +3,7 @@ import { SubCommand, CommandRunner, Option } from 'nest-commander';
 import * as path from 'path';
 import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
 import { ConsoleReporter } from 'src/testing/reporter/console-reporter';
+import { ProgressReporter } from 'src/testing/reporter/progress-reporter';
 import { WebhookReporter } from 'src/testing/reporter/webhook-reporter';
 import { runFromMetadata } from 'src/testing/runner/run-from-metadata';
 import type { TestingMetadata } from 'src/testing/contracts/testing-metadata.types';
@@ -27,6 +28,7 @@ interface TestRunCommandOptions {
   listSpecs?: boolean;
   printApiLogs?: boolean;
   runName?: string;
+  progress?: boolean;
 }
 
 @SubCommand({
@@ -106,9 +108,12 @@ export class TestRunCommand extends CommandRunner {
 
       const webhookUrl = process.env.SOLIDCTL_WEBHOOK_URL;
       const runName = options?.runName ?? `run-${Date.now()}`;
-      const reporter = webhookUrl
+      const baseReporter = webhookUrl
         ? new WebhookReporter(webhookUrl, runName)
         : new ConsoleReporter();
+      const reporter = options?.progress === false
+        ? baseReporter
+        : new ProgressReporter(baseReporter);
 
       try {
         await runFromMetadata({
@@ -138,8 +143,8 @@ export class TestRunCommand extends CommandRunner {
         console.error('Run tests command failed');
         process.exitCode = 1;
       } finally {
-        if (reporter instanceof WebhookReporter) {
-          await reporter.flush(Number(process.exitCode ?? 0));
+        if (baseReporter instanceof WebhookReporter) {
+          await baseReporter.flush(Number(process.exitCode ?? 0));
         }
       }
       return;
@@ -289,6 +294,15 @@ export class TestRunCommand extends CommandRunner {
   parseRunName(val: string): string {
     return val;
   }
+
+  @Option({
+    flags: '--no-progress',
+    description: 'Disable the interactive test progress footer.',
+    required: false,
+  })
+  parseNoProgress(): boolean {
+    return false;
+  }
 }
 
 function splitCsv(value?: string): string[] | undefined {

package/src/seeders/seed-data/solid-core-metadata.json

@@ -12591,7 +12591,7 @@
             50
           ],
           "enableGlobalSearch": true,
-          "create": true,
+          "create": false,
           "edit": true,
           "delete": true,
           "import": true,

package/src/services/1.js

@@ -0,0 +1,6 @@
+1. Do i need to create a storeStreams method for aws service too?
+    - Handle later
+2. queues handling -> if queues is enabled by default, i.e triggerExport(exportTransactionEntity.id).
+    - startExport should either return the data or return the transaction id
+3. How to handle scenarios wherein, nested related exist.(do i need to only get the userkey)
+    - show the userKey

package/src/services/chatter-message.service.ts

@@ -37,6 +37,16 @@ interface ChatterMention {
     id?: string | number;
 }
 
+/**
+ * Server-side-only overrides for `postMessage`. Not part of `PostChatterMessageDto`, so
+ * nothing here is settable over HTTP - only in-process callers such as migration or
+ * back-fill services can supply it.
+ */
+export interface PostChatterMessageOptions {
+    /** Backdate the message instead of stamping it with the current time. */
+    createdAt?: Date;
+}
+
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage> {
     private readonly _logger = new Logger(ChatterMessageService.name);
@@ -389,7 +399,14 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         return this.trimMessageUser(savedMessage);
     }
 
-    async postMessage(postDto: PostChatterMessageDto, files: Express.Multer.File[] = []) {
+    /**
+     * Post a chatter message.
+     *
+     * `options` is deliberately kept out of `PostChatterMessageDto` so it can only be supplied
+     * by server-side callers (migrations, back-fills). The controller binds the DTO alone, so
+     * an API client has no way to backdate a message.
+     */
+    async postMessage(postDto: PostChatterMessageDto, files: Express.Multer.File[] = [], options: PostChatterMessageOptions = {}) {
         const coModelName = lowerFirst(postDto.coModelName);
         await this.assertRecordAccess(coModelName, postDto.coModelEntityId);
 
@@ -404,6 +421,10 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         chatterMessage.coModelEntityId = postDto.coModelEntityId;
         chatterMessage.coModelName = coModelName;
         chatterMessage.modelUserKey = postDto.modelUserKey ?? null;
+        // Left unset otherwise, so the @CreateDateColumn default still applies.
+        if (options.createdAt) {
+            chatterMessage.createdAt = options.createdAt;
+        }
 
         const model = await this.modelMetadataRepo.findOne({
             where: { singularName: coModelName },

package/src/services/crud-helper.service.ts

@@ -889,25 +889,25 @@ export class CrudHelperService {
         };
     }
 
-    async countGroupedRecords(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string) { //TODO : Check how to pass a type to SelectQueryBuilder instead of any
-        const { limit, offset, ...rest } = basicFilterDto;
-        const filteredDto = { ...rest, limit: undefined, offset: undefined };
+    // async countGroupedRecords(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string, internationalisation?: boolean, draftPublishWorkflow?: boolean, moduleRef?: any) { //TODO : Check how to pass a type to SelectQueryBuilder instead of any
+    //     const { limit, offset, ...rest } = basicFilterDto;
+    //     const filteredDto = { ...rest, limit: undefined, offset: undefined };
 
-        const filteredQB = this.buildFilterQuery(qb, filteredDto as BasicFilterDto, entityAlias, undefined, undefined, undefined, FilterCombinator.AND, false, false);
+    //     const filteredQB = this.buildFilterQuery(qb, filteredDto as BasicFilterDto, entityAlias, internationalisation, draftPublishWorkflow, moduleRef, FilterCombinator.AND, false, false);
 
-        const groupByFields = this.normalize(filteredDto.groupBy);
+    //     const groupByFields = this.normalize(filteredDto.groupBy);
 
-        if (!groupByFields || groupByFields.length === 0) {
-            throw new Error(ERROR_MESSAGES.INVALID_GROUP_BY_COUNT);
-        }
+    //     if (!groupByFields || groupByFields.length === 0) {
+    //         throw new Error(ERROR_MESSAGES.INVALID_GROUP_BY_COUNT);
+    //     }
 
-        this.applyGroupBySelections(filteredQB, groupByFields, entityAlias);
-        this.applyAggregates(filteredQB, ['count'], entityAlias);
-        filteredQB.limit(undefined).offset(undefined).take(undefined).skip(undefined);
+    //     this.applyGroupBySelections(filteredQB, groupByFields, entityAlias);
+    //     this.applyAggregates(filteredQB, ['count'], entityAlias);
+    //     filteredQB.limit(undefined).offset(undefined).take(undefined).skip(undefined);
 
-        const rawResults = await filteredQB.getRawMany();
-        return rawResults.length;
-    }
+    //     const rawResults = await filteredQB.getRawMany();
+    //     return rawResults.length;
+    // }
 
     hasReadPermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
         const permissionNames = [`${classify(modelName)}Controller.findOne`, `${classify(modelName)}Controller.findMany`];
@@ -980,7 +980,10 @@ export class CrudHelperService {
         basicFilterDto: BasicFilterDto,
         alias: string,
         createQbFn: () => Promise<SelectQueryBuilder<T>>,
-        postProcessEntities?: (entities: T[]) => Promise<void>
+        postProcessEntities?: (entities: T[]) => Promise<void>,
+        internationalisation?: boolean,
+        draftPublishWorkflow?: boolean,
+        moduleRef?: any
     ): Promise<{ meta: { totalRecords: number }; groupMeta: any[]; groupRecords: any[] }> {
         const groupByFields = this.normalize(basicFilterDto.groupBy);
         if (!groupByFields.length) throw new BadRequestException(ERROR_MESSAGES.INVALID_GROUP_BY_COUNT);
@@ -1015,7 +1018,7 @@ export class CrudHelperService {
                     aggregates: undefined,
                     sort: basicFilterDto.groupFilter?.sort,
                 };
-                groupQb = this.buildFilterQuery(groupQb, groupFilterDto, alias);
+                groupQb = this.buildFilterQuery(groupQb, groupFilterDto, alias, internationalisation, draftPublishWorkflow, moduleRef);
                 groupQb = this.buildGroupByRecordsQuery(groupQb, group, alias, groupAliasMap, aggregateAliasMap, groupExpressionMap);
                 const [entities, count] = await groupQb.getManyAndCount();
                 if (postProcessEntities) await postProcessEntities(entities);

package/src/services/crud.service.ts

@@ -583,7 +583,8 @@ private async prepareManyToManyAuditSnapshot(entity: T,id: number,modelSingularN
                 async (entities) => {
                     if (populateUserIdFields?.length) await this.handlePopulateUserIdFields(populateUserIdFields, entities);
                     if (populateMedia?.length) await this.handlePopulateMedia(populateMedia, entities);
-                }
+                },
+                internationalisation, draftPublishWorkflow, this.moduleRef
             );
         }
         else {

package/src/services/draft-publish-helper.service.ts

@@ -333,13 +333,65 @@ export class DraftPublishHelperService {
             throw new BadRequestException(`${modelName} with id ${id} is already unpublished`);
         }
 
-        return repo.save({
-            ...entity,
-            isPublished: false,
-            updatedBy: activeUser?.sub ?? entity.updatedBy,
+        const chainId = entity.initialEntityVersionId || entity.id;
+
+        return repo.manager.transaction(async (manager) => {
+            const transactionalRepo = manager.getRepository(repo.metadata.target);
+
+            // Release the "na" published tracker before anything else can claim it, mirroring
+            // publishRecord's archive-others-then-publish ordering in reverse. unpublishRecord
+            // only ever acts on the latest version (see loadLatestEntityForPublishAction), so
+            // this always becomes a Draft rather than an Archived version — clear publishedAt
+            // to match applyCreateDefaults' Draft convention instead of leaving a stale date.
+            const unpublishedEntity = await transactionalRepo.save({
+                ...entity,
+                isPublished: false,
+                publishedAt: null,
+                publishedTracker: this.createPublishedVersionTracker(entity.id),
+                updatedBy: activeUser?.sub ?? entity.updatedBy,
+            } as any) as unknown as T;
+
+            const chainVersions = await transactionalRepo.find({
+                where: [
+                    { initialEntityVersionId: chainId },
+                    { id: chainId },
+                ] as any,
+            }) as unknown as T[];
+
+            const versionToRestore = this.pickMostRecentlyPublishedVersion(
+                chainVersions.filter(version => version.id !== entity.id),
+            );
+
+            if (versionToRestore) {
+                await transactionalRepo.save({
+                    ...versionToRestore,
+                    isPublished: true,
+                    publishedAt: new Date(),
+                    publishedTracker: "na",
+                } as any);
+            }
+
+            return unpublishedEntity;
         });
     }
 
+    /**
+     * Among the other versions in a chain, find the one that was live most recently before
+     * being superseded (i.e. the "Archived" version unpublishRecord should restore). Ties on
+     * publishedAt fall back to the highest id, matching pickCurrentLocaleRecord's ordering.
+     */
+    private pickMostRecentlyPublishedVersion<T extends CommonEntity>(versions: T[]): T | null {
+        const previouslyPublished = versions.filter(version => Boolean(version.publishedAt));
+        if (previouslyPublished.length === 0) return null;
+
+        return previouslyPublished.sort((a, b) => {
+            const aPublishedAt = new Date(a.publishedAt as any).getTime();
+            const bPublishedAt = new Date(b.publishedAt as any).getTime();
+            if (aPublishedAt !== bPublishedAt) return bPublishedAt - aPublishedAt;
+            return Number(b.id) - Number(a.id);
+        })[0];
+    }
+
     /**
      * Load the latest version of a draft/publish-enabled record for a publish/unpublish
      * action, applying the two checks both actions share (workflow enabled, version is latest).

package/src/services/settings/default-settings-provider.service.ts

@@ -6,6 +6,7 @@ import {
   SettingDefinition,
   SettingLevel,
 } from "src/interfaces";
+import { getDefaultThemeKey, getThemesByMode } from "src/theme/theme-registry";
 
 export const DEFAULT_MEDIA_UPLOAD_DIR = "media-uploads";
 export const DEFAULT_MEDIA_FILE_STORAGE_DIR = "media-files-storage";
@@ -224,14 +225,44 @@ const getSolidCoreSettings = (isProd: boolean) =>
     },
     {
       moduleName: "solid-core",
-      key: "enableDarkMode",
+      key: "showThemeToggle",
       value: true,
       level: SettingLevel.SystemAdminEditable,
-      label: "Enable Dark Mode",
+      label: "Show Theme Toggle",
       group: "app-settings",
       sortOrder: 120,
       controlType: "boolean",
-      helpText: "Enables dark theme support for frontend surfaces that honor the global appearance setting.",
+      helpText: "Shows the theme toggle in the frontend so users can switch between light and dark themes.",
+    },
+    {
+      moduleName: "solid-core",
+      key: "lightTheme",
+      value: getDefaultThemeKey("light"),
+      level: SettingLevel.SystemAdminEditable,
+      label: "Light Theme",
+      group: "app-settings",
+      sortOrder: 125,
+      controlType: "selectionStatic",
+      options: getThemesByMode("light").map((theme) => ({
+        label: theme.label,
+        value: theme.key,
+      })),
+      helpText: "Selects the theme used whenever the application is in light mode.",
+    },
+    {
+      moduleName: "solid-core",
+      key: "darkTheme",
+      value: getDefaultThemeKey("dark"),
+      level: SettingLevel.SystemAdminEditable,
+      label: "Dark Theme",
+      group: "app-settings",
+      sortOrder: 126,
+      controlType: "selectionStatic",
+      options: getThemesByMode("dark").map((theme) => ({
+        label: theme.label,
+        value: theme.key,
+      })),
+      helpText: "Selects the theme used whenever the application is in dark mode.",
     },
     {
       moduleName: "solid-core",

package/src/testing/README.md

@@ -479,10 +479,11 @@ Common `test run` flags (all pass through solidctl unchanged):
 - `--ui-navigation-timeout-ms <number>` — default wait for `ui.goto`
 - `--timeout-ms <number>` / `--retries <number>` — scenario-level guard and retry count
 - `--scenario-ids <ids>` / `--include-tags <tags>` / `--skip-scenario-ids <ids>`
+- `--no-progress` — disable the interactive test progress footer
 
 ## Add A New Step (SOP)
 1. Create a new `*.step.ts` in the right domain folder.
 2. Implement a `registerXSteps(registry)` function and `registry.register("op.name", handler)`.
 3. Validate required `step.with` fields and throw clear errors.
 4. Use adapters via `ctx.api` / `ctx.ui` and update `ctx.last` when helpful.
-5. Export and register it from the domain `index.ts`.
+5. Export and register it from the domain `index.ts`.

package/src/testing/reporter/console-reporter.ts

@@ -150,6 +150,10 @@ export class ConsoleReporter implements Reporter {
   private passedScenarios = 0;
   private failedScenarios = 0;
 
+  onRunStart(_args: { total: number }): void {
+    // Progress-aware reporters use this hook; the plain console reporter has no setup.
+  }
+
   onScenarioStart(scenario: { id: string; name?: string }): void {
     const label = scenario.name ? `${scenario.id} (${scenario.name})` : scenario.id;
     console.log(`\n▶ Scenario: ${label}`);

package/src/testing/reporter/progress-reporter.ts

@@ -0,0 +1,251 @@
+import * as readline from "readline";
+import type { StepPhase } from "../contracts/runtime-context.types";
+import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
+import type { SolidTestSpecResult } from "../contracts/test-spec.types";
+import type { Reporter } from "./reporter.types";
+
+const ANSI_BOLD = "\u001b[1m";
+const ANSI_BOLD_OFF = "\u001b[22m";
+const ANSI_DIM = "\u001b[2m";
+const ANSI_GREEN = "\u001b[32m";
+const ANSI_COLOR_OFF = "\u001b[39m";
+const ANSI_RED = "\u001b[31m";
+const ANSI_INVERSE = "\u001b[7m";
+const ANSI_INVERSE_OFF = "\u001b[27m";
+
+export class ProgressReporter implements Reporter {
+  private startedAt = Date.now();
+  private total = 0;
+  private completed = 0;
+  private passed = 0;
+  private failed = 0;
+  private timer?: NodeJS.Timeout;
+  private rendered = false;
+
+  constructor(private readonly delegate: Reporter) {}
+
+  onRunStart(args: { total: number }): void {
+    this.total = args.total;
+    this.startedAt = Date.now();
+    this.completed = 0;
+    this.passed = 0;
+    this.failed = 0;
+    this.delegate.onRunStart?.(args);
+    this.startTimer();
+    this.renderFooter();
+  }
+
+  onScenarioStart(scenario: ScenarioSpec): void {
+    this.withFooterPaused(() => this.delegate.onScenarioStart(scenario));
+  }
+
+  onScenarioEnd(
+    scenario: ScenarioSpec,
+    result: { ok: boolean; error?: unknown; durationMs: number },
+  ): void {
+    this.completed += 1;
+    if (result.ok) {
+      this.passed += 1;
+    } else {
+      this.failed += 1;
+    }
+    this.withFooterPaused(() => this.delegate.onScenarioEnd(scenario, result));
+  }
+
+  onStepStart(args: {
+    scenarioId: string;
+    phase: StepPhase;
+    step: OpStep;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onStepStart(args));
+  }
+
+  onStepEnd(args: {
+    scenarioId: string;
+    phase: StepPhase;
+    step: OpStep;
+    ok: boolean;
+    error?: unknown;
+    durationMs: number;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onStepEnd(args));
+  }
+
+  onSpecResult(args: {
+    scenarioId: string;
+    specId: string;
+    stepName?: string;
+    result: SolidTestSpecResult;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onSpecResult?.(args));
+  }
+
+  attach(args: {
+    scenarioId: string;
+    name: string;
+    contentType: string;
+    data: Buffer | string;
+  }): void {
+    this.withFooterPaused(() => this.delegate.attach?.(args));
+  }
+
+  onRunEnd(args: {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+  }): void {
+    this.completed = args.passed + args.failed;
+    this.passed = args.passed;
+    this.failed = args.failed;
+    this.total = args.total;
+    this.stopTimer();
+    this.withFooterPaused(() => this.delegate.onRunEnd?.(args), false);
+  }
+
+  private startTimer(): void {
+    this.stopTimer();
+    if (!this.isInteractive()) {
+      return;
+    }
+    this.timer = setInterval(() => this.renderFooter(), 1_000);
+    this.timer.unref?.();
+  }
+
+  private stopTimer(): void {
+    if (!this.timer) {
+      return;
+    }
+    clearInterval(this.timer);
+    this.timer = undefined;
+  }
+
+  private withFooterPaused(callback: () => void, renderAfter = true): void {
+    this.clearFooter();
+    callback();
+    if (renderAfter) {
+      this.renderFooter();
+    }
+  }
+
+  private renderFooter(): void {
+    if (!this.isInteractive()) {
+      return;
+    }
+
+    const terminalWidth = process.stdout.columns || 80;
+    const elapsed = formatElapsed(Date.now() - this.startedAt);
+    const progressText = `${this.completed}/${this.total}`;
+    const resultText = `${ANSI_GREEN}${this.passed} passed${ANSI_COLOR_OFF}${ANSI_DIM} | ${ANSI_BOLD_OFF}${this.failed ? ANSI_RED : ANSI_DIM}${this.failed} failed${this.failed ? ANSI_COLOR_OFF : ANSI_BOLD_OFF}`;
+    const footer = [
+      `${ANSI_BOLD}Tests${ANSI_BOLD_OFF}: ${this.renderProgressBar(terminalWidth)} ${progressText}`,
+      `${ANSI_BOLD}Elapsed${ANSI_BOLD_OFF}: ${elapsed}`,
+      resultText,
+    ].join(`${ANSI_DIM} | ${ANSI_BOLD_OFF}`);
+
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    process.stdout.write(truncateAnsiText(`${ANSI_INVERSE} ${footer} ${ANSI_INVERSE_OFF}`, terminalWidth));
+    this.rendered = true;
+  }
+
+  private clearFooter(): void {
+    if (!this.rendered || !this.isInteractive()) {
+      return;
+    }
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    this.rendered = false;
+  }
+
+  private renderProgressBar(terminalWidth: number): string {
+    const width = terminalWidth >= 120 ? 30 : terminalWidth >= 90 ? 22 : 14;
+    const ratio = this.total > 0 ? Math.min(1, this.completed / this.total) : 0;
+    const filled = Math.round(width * ratio);
+    const empty = Math.max(0, width - filled);
+    return `[${ANSI_GREEN}${"=".repeat(filled)}${ANSI_COLOR_OFF}${" ".repeat(empty)}]`;
+  }
+
+  private isInteractive(): boolean {
+    return Boolean(process.stdout.isTTY || process.env.SOLIDCTL_TEST_PROGRESS === "1");
+  }
+}
+
+function formatElapsed(durationMs: number): string {
+  const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes < 60) {
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}:${remainingMinutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+}
+
+function truncateAnsiText(text: string, maxWidth: number): string {
+  if (maxWidth <= 0) {
+    return "";
+  }
+
+  let visibleWidth = 0;
+  let index = 0;
+  let output = "";
+  let hasEscape = false;
+
+  while (index < text.length) {
+    if (text[index] === "\u001b") {
+      const match = /\u001b\[[0-9;]*m/.exec(text.slice(index));
+      if (!match) {
+        break;
+      }
+      output += match[0];
+      hasEscape = true;
+      index += match[0].length;
+      continue;
+    }
+
+    if (visibleWidth >= maxWidth) {
+      break;
+    }
+
+    output += text[index];
+    visibleWidth += 1;
+    index += 1;
+  }
+
+  if (index < text.length && maxWidth >= 1) {
+    output = trimAnsiText(output, maxWidth - 1) + "…";
+  }
+
+  if (hasEscape && !output.endsWith(ANSI_INVERSE_OFF)) {
+    output += ANSI_INVERSE_OFF;
+  }
+
+  return output;
+}
+
+function trimAnsiText(text: string, maxWidth: number): string {
+  let visibleWidth = 0;
+  let index = 0;
+  let output = "";
+
+  while (index < text.length && visibleWidth < maxWidth) {
+    if (text[index] === "\u001b") {
+      const match = /\u001b\[[0-9;]*m/.exec(text.slice(index));
+      if (!match) {
+        break;
+      }
+      output += match[0];
+      index += match[0].length;
+      continue;
+    }
+
+    output += text[index];
+    visibleWidth += 1;
+    index += 1;
+  }
+
+  return output;
+}

package/src/testing/reporter/reporter.types.ts

@@ -3,6 +3,9 @@ import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
 import type { SolidTestSpecResult } from "../contracts/test-spec.types";
 
 export interface Reporter {
+  onRunStart?(args: {
+    total: number;
+  }): void;
   onScenarioStart(scenario: ScenarioSpec): void;
   onScenarioEnd(
     scenario: ScenarioSpec,

package/src/testing/runner/run-from-metadata.ts

@@ -67,6 +67,7 @@ export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
 
   const resources = new SimpleResourceStore();
   const reporter = opts.reporter ?? new ConsoleReporter();
+  reporter.onRunStart?.({ total: scenarios.length });
   const api = new ApiAdapter(opts.api);
   const { PlaywrightAdapter } = await import("../adapters/ui/playwright-adapter");
   const ui = new PlaywrightAdapter(opts.ui);