@solidxai/core 0.1.15 → 0.1.16-beta.0

package/src/testing/core/resource-store.ts

@@ -1,11 +1,15 @@
 import type { ResourceStore } from "../contracts/runtime-context.types";
+import { parsePathSegments } from "./path-segments";
 
 export class SimpleResourceStore implements ResourceStore {
   private readonly data: Record<string, any> = {};
 
   get(path: string): unknown {
     if (!path) return undefined;
-    const parts = path.split(".");
+    // Dot and bracket notation both resolve here, so `${res:r.bodyJson.result[0].id}` and
+    // `${res:r.bodyJson.result.0.id}` are equivalent — matching `${data:...}`, which has always
+    // accepted brackets. `has()` delegates to this, so it follows automatically.
+    const parts = parsePathSegments(path);
     let current: any = this.data;
     for (const part of parts) {
       if (current == null || typeof current !== "object") return undefined;
@@ -16,7 +20,9 @@ export class SimpleResourceStore implements ResourceStore {
 
   set(path: string, value: unknown): void {
     if (!path) return;
-    const parts = path.split(".");
+    // Parsed the same way as `get`, so any path that can be read back can also be written.
+    const parts = parsePathSegments(path);
+    if (!parts.length) return;
     let current: any = this.data;
     for (let i = 0; i < parts.length - 1; i += 1) {
       const part = parts[i];

package/src/testing/core/testing-engine.ts

@@ -39,6 +39,9 @@ export class TestingEngine {
       let scenarioError: unknown;
 
       reporter.onScenarioStart(scenario);
+      // Start a clean capture window for this scenario (UI adapter buffers console/network
+      // events; they're only flushed to the reporter if the scenario fails below).
+      ctx.ui?.resetCapture();
 
       try {
         const execute = async () => {
@@ -60,6 +63,25 @@ export class TestingEngine {
       } catch (err: any) {
         scenarioError = err;
       } finally {
+        // On failure, flush the UI adapter's captured artifacts (console + network) BEFORE
+        // onScenarioEnd — the lifecycle reporter snapshots the attached artifacts inside
+        // onScenarioEnd. No page (e.g. API scenarios) → nothing captured.
+        if (scenarioError && ctx.ui?.page && reporter.attach) {
+          try {
+            const artifacts = await ctx.ui.collectFailureArtifacts();
+            for (const a of artifacts) {
+              reporter.attach({
+                scenarioId: ctx.scenarioId,
+                name: a.name,
+                contentType: a.contentType,
+                data: a.data,
+              });
+            }
+          } catch {
+            // Artifact capture is best-effort; never let it mask the scenario error.
+          }
+        }
+
         const durationMs = Date.now() - scenarioStart;
         reporter.onScenarioEnd(scenario, {
           ok: !scenarioError,

package/src/testing/reporter/artifact-sink.ts

@@ -0,0 +1,16 @@
+/**
+ * Contract for persisting binary test artifacts (screenshots, video, HAR) to shared
+ * storage and returning a reference. The concrete {@link FileServiceArtifactSink}
+ * (backed by the core FILE_SERVICE) is added in Phase 2 (A6). Kept as a standalone
+ * interface so {@link LifecycleWebhookReporter} can depend on it without pulling in
+ * Nest DI.
+ */
+export interface IArtifactSink {
+  put(args: {
+    runId: string;
+    scenarioId: string;
+    name: string;
+    contentType: string;
+    data: Buffer | NodeJS.ReadableStream;
+  }): Promise<{ storageKey: string; url: string; sizeBytes: number }>;
+}

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

@@ -236,6 +236,15 @@ export class ConsoleReporter implements Reporter {
   }): void {
     const header = `ATTACH ${args.name} (${args.contentType})`;
     console.log(indentLines(header, `${STEP_INDENT}${INDENT}`));
+    // Don't dump binary payloads (e.g. screenshot bytes) to stdout — just note the size.
+    const ct = args.contentType.toLowerCase();
+    const isBinary =
+      Buffer.isBuffer(args.data) &&
+      (ct.startsWith("image/") || ct.startsWith("video/") || ct === "application/octet-stream");
+    if (isBinary) {
+      console.log(indentLines(`<${(args.data as Buffer).byteLength} bytes>`, `${STEP_INDENT}${INDENT}${INDENT}`));
+      return;
+    }
     const dataText = Buffer.isBuffer(args.data) ? args.data.toString("utf8") : String(args.data ?? "");
     if (!dataText.length) return;
     console.log(indentLines(dataText, `${STEP_INDENT}${INDENT}${INDENT}`));

package/src/testing/reporter/file-service-artifact-sink.ts

@@ -0,0 +1,46 @@
+import type { Readable } from 'stream';
+import type { IFileService } from '../../services/file/file-service.interface';
+import type { IArtifactSink } from './artifact-sink';
+
+async function toBuffer(data: Buffer | NodeJS.ReadableStream): Promise<Buffer> {
+  if (Buffer.isBuffer(data)) return data;
+  const chunks: Buffer[] = [];
+  for await (const chunk of data as Readable) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+
+/**
+ * Concrete {@link IArtifactSink} backed by the core {@link IFileService}. Persists binary
+ * test artifacts (screenshots, video, HAR) to shared storage — disk by default, S3 when
+ * `DEFAULT_FILE_SERVICE=s3` — so webhook payloads stay small and the DB never holds blobs.
+ *
+ * Keys are laid out as `<prefix>/<runId>/<scenarioId>/<name>`. Callers that need a durable,
+ * provider-agnostic URL (e.g. a private S3 bucket) should serve by `storageKey` through their
+ * own proxy rather than relying on the raw `url` (which for S3 is the un-signed object URL).
+ */
+export class FileServiceArtifactSink implements IArtifactSink {
+  constructor(
+    private readonly fileService: IFileService,
+    private readonly opts: { prefix?: string; region?: string } = {},
+  ) {}
+
+  async put(args: {
+    runId: string;
+    scenarioId: string;
+    name: string;
+    contentType: string;
+    data: Buffer | NodeJS.ReadableStream;
+  }): Promise<{ storageKey: string; url: string; sizeBytes: number }> {
+    const prefix = this.opts.prefix ?? 'test-artifacts';
+    const safe = (s: string) => String(s || '').replace(/[^a-zA-Z0-9._-]+/g, '_').slice(0, 120) || 'artifact';
+    const storageKey = `${prefix}/${safe(args.runId)}/${safe(args.scenarioId)}/${safe(args.name)}`;
+    const buffer = await toBuffer(args.data);
+    const url = await this.fileService.write(storageKey, buffer, {
+      contentType: args.contentType,
+      region: this.opts.region,
+    });
+    return { storageKey, url, sizeBytes: buffer.byteLength };
+  }
+}

package/src/testing/reporter/lifecycle-events.types.ts

@@ -0,0 +1,103 @@
+import type { ScenarioType } from "../contracts/testing-metadata.types";
+
+/**
+ * Incremental lifecycle events emitted by {@link LifecycleWebhookReporter} so an
+ * external consumer (e.g. testingHub) can persist run progress live, instead of
+ * only receiving a single final payload (as the legacy WebhookReporter does).
+ */
+export type LifecycleEventType =
+  | "run.start"
+  | "scenario.start"
+  | "scenario.end"
+  | "run.end";
+
+/**
+ * Reference to a captured artifact (console/network/api log, screenshot, video, HAR).
+ * Text artifacts travel inline; binary artifacts are uploaded to shared storage and
+ * referenced by `storageKey`/`url` to keep webhook payloads small.
+ */
+export interface ArtifactRef {
+  kind: "console" | "network" | "screenshot" | "video" | "har" | "api-log";
+  name: string;
+  contentType: string;
+  transport: "inline" | "storage";
+  /** base64 (binary) or raw text/JSON (text); present when transport === 'inline'. */
+  inlineData?: string;
+  /** file-service key; present when transport === 'storage'. */
+  storageKey?: string;
+  /** resolved getUrl(); present when transport === 'storage'. */
+  url?: string;
+  sizeBytes?: number;
+}
+
+export interface StepResultData {
+  phase: string;
+  operation: string;
+  name?: string;
+  ok: boolean;
+  durationMs: number;
+  error?: string;
+}
+
+/** Minimal descriptor of a scenario in the run, so consumers can snapshot the full suite at run time. */
+export interface ScenarioDescriptor {
+  id: string;
+  name?: string;
+  type: ScenarioType;
+}
+
+export interface RunStartData {
+  total: number;
+  scenarioIds: string[];
+  scenarios: ScenarioDescriptor[];
+  startedAt: string;
+}
+
+export interface ScenarioStartData {
+  scenarioId: string;
+  name?: string;
+  type: ScenarioType;
+  index: number;
+  total: number;
+}
+
+export interface ScenarioEndData {
+  scenarioId: string;
+  name?: string;
+  ok: boolean;
+  durationMs: number;
+  error?: string;
+  steps: StepResultData[];
+  /** console/network/api-log/screenshot/video for THIS scenario. */
+  artifacts: ArtifactRef[];
+}
+
+export interface RunEndData {
+  ok: boolean;
+  total: number;
+  passed: number;
+  failed: number;
+  durationMs: number;
+  exitCode?: number;
+  error?: string;
+  /** run-level artifacts (e.g. the whole-run video). */
+  artifacts?: ArtifactRef[];
+}
+
+/**
+ * Envelope wrapping every lifecycle event. `externalRunId` correlates the event to
+ * the caller's own record (e.g. a testingHub TestRun id); `seq` lets an out-of-order
+ * receiver reorder/deduplicate.
+ */
+export interface LifecycleEnvelope<T = unknown> {
+  event: LifecycleEventType;
+  /** correlation id supplied by the caller (e.g. testingHub TestRun id). */
+  externalRunId?: string;
+  /** runner-generated uuid for this process run. */
+  runId: string;
+  runName: string;
+  /** 0-based, increments per emitted event. */
+  seq: number;
+  emittedAt: string;
+  data: T;
+}

package/src/testing/reporter/lifecycle-webhook-reporter.ts

@@ -0,0 +1,385 @@
+import { randomUUID } from "crypto";
+
+import { ConsoleReporter } from "./console-reporter";
+import type { IArtifactSink } from "./artifact-sink";
+import type {
+  ArtifactRef,
+  LifecycleEnvelope,
+  LifecycleEventType,
+  ScenarioDescriptor,
+  ScenarioEndData,
+  StepResultData,
+} from "./lifecycle-events.types";
+import type { OpStep, ScenarioSpec, ScenarioType } from "../contracts/testing-metadata.types";
+import type { StepPhase } from "../contracts/runtime-context.types";
+
+/**
+ * Pluggable POST function so the reporter stays DI-agnostic. The default uses the
+ * global `fetch`; the Nest worker can inject an axios-backed implementation that
+ * shares the existing HttpModule stack.
+ */
+export type WebhookPostFn = (
+  url: string,
+  body: unknown,
+  opts: { headers?: Record<string, string>; timeoutMs?: number },
+) => Promise<{ ok: boolean; status: number }>;
+
+export interface LifecycleWebhookReporterOptions {
+  webhookUrl: string;
+  runName: string;
+  /** correlation id supplied by the caller (e.g. testingHub TestRun id). */
+  externalRunId?: string;
+  /** runner-generated uuid for this process run; auto-generated when omitted. */
+  runId?: string;
+  /** Phase 2: sink for binary artifacts (screenshots/video/HAR). */
+  artifactSink?: IArtifactSink;
+  headers?: Record<string, string>;
+  post?: WebhookPostFn;
+}
+
+const DEFAULT_TIMEOUT_MS = 10_000;
+/** Cap inline text artifacts so a webhook body never blows past receiver limits. */
+const INLINE_TEXT_CAP = 1_000_000;
+
+function formatError(err: unknown): string {
+  if (!err) return "";
+  if (err instanceof Error) return err.stack || err.message;
+  return String(err);
+}
+
+const defaultPost: WebhookPostFn = async (url, body, opts) => {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...(opts.headers ?? {}) },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+  });
+  return { ok: res.ok, status: res.status };
+};
+
+/** Map an `attach()` payload to an ArtifactRef. Covers API/console/network + video/screenshots. */
+function classifyAttachment(name: string, contentType: string): ArtifactRef["kind"] {
+  const hint = `${name} ${contentType}`.toLowerCase();
+  if (contentType.startsWith("video/") || hint.includes("video")) return "video";
+  if (hint.includes("screenshot") || contentType.startsWith("image/")) return "screenshot";
+  if (hint.includes("console")) return "console";
+  if (hint.includes("network") || hint.includes("har")) return "network";
+  if (hint.includes("api")) return "api-log";
+  return "api-log";
+}
+
+function isBinaryContentType(contentType: string): boolean {
+  const ct = contentType.toLowerCase();
+  return ct.startsWith("image/") || ct.startsWith("video/") || ct === "application/octet-stream";
+}
+
+/**
+ * Emits incremental lifecycle webhooks (run.start → scenario.start → scenario.end →
+ * run.end) to a single URL, while still printing to the console (extends
+ * ConsoleReporter). Deliveries are serialized through an async chain so ordering is
+ * preserved without blocking step execution, and a failed POST never throws into the
+ * run. Distinct from the legacy {@link WebhookReporter}, which only fires once on flush.
+ */
+export class LifecycleWebhookReporter extends ConsoleReporter {
+  private readonly webhookUrl: string;
+  private readonly runName: string;
+  private readonly externalRunId?: string;
+  private readonly runId: string;
+  private readonly headers?: Record<string, string>;
+  private readonly post: WebhookPostFn;
+  /** Phase 2: used to upload binary artifacts in onScenarioEnd. */
+  protected readonly artifactSink?: IArtifactSink;
+
+  private seq = 0;
+  private startedAtMs = Date.now();
+  private total = 0;
+  private scenarioIndex = 0;
+  private passed = 0;
+  private failed = 0;
+  private currentSteps: StepResultData[] = [];
+  private currentArtifacts: ArtifactRef[] = [];
+  /** Run-level artifacts (e.g. the whole-run video); emitted on run.end. */
+  private runArtifacts: ArtifactRef[] = [];
+  /** Serializes webhook deliveries to preserve order. */
+  private chain: Promise<void> = Promise.resolve();
+
+  constructor(opts: LifecycleWebhookReporterOptions) {
+    super();
+    this.webhookUrl = opts.webhookUrl;
+    this.runName = opts.runName;
+    this.externalRunId = opts.externalRunId;
+    this.runId = opts.runId ?? randomUUID();
+    this.artifactSink = opts.artifactSink;
+    this.headers = opts.headers;
+    this.post = opts.post ?? defaultPost;
+  }
+
+  getRunId(): string {
+    return this.runId;
+  }
+
+  onRunStart(args: {
+    total: number;
+    startedAt: string;
+    scenarioIds: string[];
+    scenarios?: ScenarioDescriptor[];
+  }): void {
+    this.total = args.total;
+    this.startedAtMs = Date.now();
+    this.emit("run.start", {
+      total: args.total,
+      scenarioIds: args.scenarioIds,
+      scenarios: args.scenarios ?? args.scenarioIds.map((id) => ({ id, type: "api" as ScenarioType })),
+      startedAt: args.startedAt,
+    });
+  }
+
+  override onScenarioStart(scenario: ScenarioSpec): void {
+    super.onScenarioStart(scenario);
+    this.currentSteps = [];
+    this.currentArtifacts = [];
+    const index = this.scenarioIndex++;
+    this.emit("scenario.start", {
+      scenarioId: scenario.id,
+      name: scenario.name,
+      type: scenario.type,
+      index,
+      total: this.total,
+    });
+  }
+
+  override onStepEnd(args: {
+    scenarioId: string;
+    phase: StepPhase;
+    step: OpStep;
+    ok: boolean;
+    error?: unknown;
+    durationMs: number;
+  }): void {
+    super.onStepEnd(args);
+    this.currentSteps.push({
+      phase: String(args.phase),
+      operation: args.step.op,
+      name: args.step.name,
+      ok: args.ok,
+      durationMs: args.durationMs,
+      error: args.error ? formatError(args.error) : undefined,
+    });
+  }
+
+  override attach(args: {
+    scenarioId: string;
+    name: string;
+    contentType: string;
+    data: Buffer | string;
+  }): void {
+    super.attach(args);
+    const kind = classifyAttachment(args.name, args.contentType);
+    const binary = Buffer.isBuffer(args.data) && isBinaryContentType(args.contentType);
+
+    // Binary artifacts (screenshots, video): when a storage sink is configured, upload the bytes
+    // to shared storage and reference them by storageKey/url — never ship blobs inline (the
+    // inline cap would silently drop anything large, e.g. a video). The ref is mutated in place
+    // by an upload queued onto the delivery chain, so it resolves before scenario.end is posted.
+    if (binary && this.artifactSink) {
+      const buf = args.data as Buffer;
+      const artifact: ArtifactRef = {
+        kind,
+        name: args.name,
+        contentType: args.contentType,
+        transport: "storage",
+        sizeBytes: buf.byteLength,
+      };
+      this.currentArtifacts.push(artifact);
+      const runId = this.externalRunId ?? this.runId;
+      const scenarioId = args.scenarioId;
+      this.chain = this.chain
+        .then(async () => {
+          const ref = await this.artifactSink!.put({
+            runId,
+            scenarioId,
+            name: args.name,
+            contentType: args.contentType,
+            data: buf,
+          });
+          artifact.storageKey = ref.storageKey;
+          artifact.url = ref.url;
+        })
+        .catch(() => {
+          /* upload failed — leave the ref without a key; the ingest side skips empty refs */
+        });
+      return;
+    }
+
+    if (binary) {
+      // Binary (e.g. a screenshot JPEG): base64-encode — a utf8 decode would corrupt the
+      // bytes. Truncating base64 also corrupts it, so if it somehow exceeds the inline cap
+      // we drop the payload rather than ship a broken image (viewport JPEGs stay well under).
+      const bytes = args.data as Buffer;
+      const base64 = bytes.toString("base64");
+      const artifact: ArtifactRef = {
+        kind,
+        name: args.name,
+        contentType: args.contentType,
+        transport: "inline",
+        sizeBytes: bytes.byteLength,
+      };
+      if (base64.length <= INLINE_TEXT_CAP) {
+        artifact.inlineData = base64;
+      }
+      this.currentArtifacts.push(artifact);
+      return;
+    }
+
+    const text = Buffer.isBuffer(args.data)
+      ? args.data.toString("utf8")
+      : String(args.data ?? "");
+    this.currentArtifacts.push({
+      kind,
+      name: args.name,
+      contentType: args.contentType,
+      transport: "inline",
+      inlineData: text.length > INLINE_TEXT_CAP ? text.slice(0, INLINE_TEXT_CAP) : text,
+      sizeBytes: Buffer.byteLength(text),
+    });
+  }
+
+  override onScenarioEnd(
+    scenario: ScenarioSpec,
+    result: { ok: boolean; error?: unknown; durationMs: number },
+  ): void {
+    super.onScenarioEnd(scenario, result);
+    if (result.ok) {
+      this.passed += 1;
+    } else {
+      this.failed += 1;
+    }
+    const data: ScenarioEndData = {
+      scenarioId: scenario.id,
+      name: scenario.name,
+      ok: result.ok,
+      durationMs: result.durationMs,
+      error: result.error ? formatError(result.error) : undefined,
+      steps: [...this.currentSteps],
+      artifacts: [...this.currentArtifacts],
+    };
+    this.emit("scenario.end", data);
+  }
+
+  /**
+   * Attach a run-level binary artifact (e.g. the whole-run video). Uploaded to shared storage
+   * via the sink (never inline for a video) and referenced by storageKey/url on run.end. Must
+   * be called before {@link flushPending} so the upload is queued ahead of the run.end delivery.
+   */
+  attachRunArtifact(args: { name: string; contentType: string; data: Buffer | string }): void {
+    const kind = classifyAttachment(args.name, args.contentType);
+    const binary = Buffer.isBuffer(args.data) && isBinaryContentType(args.contentType);
+
+    if (binary && this.artifactSink) {
+      const buf = args.data as Buffer;
+      const artifact: ArtifactRef = {
+        kind,
+        name: args.name,
+        contentType: args.contentType,
+        transport: "storage",
+        sizeBytes: buf.byteLength,
+      };
+      this.runArtifacts.push(artifact);
+      const runId = this.externalRunId ?? this.runId;
+      this.chain = this.chain
+        .then(async () => {
+          const ref = await this.artifactSink!.put({
+            runId,
+            scenarioId: "run",
+            name: args.name,
+            contentType: args.contentType,
+            data: buf,
+          });
+          artifact.storageKey = ref.storageKey;
+          artifact.url = ref.url;
+        })
+        .catch(() => {
+          /* upload failed — leave the ref without a key; ingest skips empty refs */
+        });
+      return;
+    }
+
+    // No sink: fall back to inline (a large video base64 that exceeds the cap is dropped).
+    if (binary) {
+      const bytes = args.data as Buffer;
+      const base64 = bytes.toString("base64");
+      const artifact: ArtifactRef = {
+        kind,
+        name: args.name,
+        contentType: args.contentType,
+        transport: "inline",
+        sizeBytes: bytes.byteLength,
+      };
+      if (base64.length <= INLINE_TEXT_CAP) artifact.inlineData = base64;
+      this.runArtifacts.push(artifact);
+      return;
+    }
+
+    const text = Buffer.isBuffer(args.data) ? args.data.toString("utf8") : String(args.data ?? "");
+    this.runArtifacts.push({
+      kind,
+      name: args.name,
+      contentType: args.contentType,
+      transport: "inline",
+      inlineData: text.length > INLINE_TEXT_CAP ? text.slice(0, INLINE_TEXT_CAP) : text,
+      sizeBytes: Buffer.byteLength(text),
+    });
+  }
+
+  /**
+   * Emit run.end and wait for all queued deliveries to complete. `error` names a
+   * run-level failure reason (e.g. an unreadable scenario file) so a run that failed
+   * before any scenario ran carries a clear message rather than a bare count.
+   */
+  async flushPending(exitCode?: number, error?: string): Promise<void> {
+    this.emit("run.end", {
+      // A non-zero exitCode (e.g. the runner threw before any scenario ran) must
+      // mark the run failed even when failed === 0.
+      ok: this.failed === 0 && (exitCode === undefined || exitCode === 0),
+      total: this.total || this.passed + this.failed,
+      passed: this.passed,
+      failed: this.failed,
+      durationMs: Date.now() - this.startedAtMs,
+      exitCode,
+      error,
+      artifacts: this.runArtifacts.length ? [...this.runArtifacts] : undefined,
+    });
+    await this.chain;
+  }
+
+  private emit<T>(event: LifecycleEventType, data: T): void {
+    const envelope: LifecycleEnvelope<T> = {
+      event,
+      externalRunId: this.externalRunId,
+      runId: this.runId,
+      runName: this.runName,
+      seq: this.seq++,
+      emittedAt: new Date().toISOString(),
+      data,
+    };
+    this.chain = this.chain.then(() => this.deliver(envelope)).catch(() => {});
+  }
+
+  private async deliver(envelope: LifecycleEnvelope): Promise<void> {
+    try {
+      const res = await this.post(this.webhookUrl, envelope, {
+        headers: this.headers,
+        timeoutMs: DEFAULT_TIMEOUT_MS,
+      });
+      if (!res.ok) {
+        console.warn(
+          `[LifecycleWebhookReporter] ${envelope.event} → HTTP ${res.status}`,
+        );
+      }
+    } catch (err) {
+      console.warn(
+        `[LifecycleWebhookReporter] failed to deliver ${envelope.event}: ${err}`,
+      );
+    }
+  }
+}

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

@@ -4,6 +4,8 @@ import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
 import type { SolidTestSpecResult } from "../contracts/test-spec.types";
 import type { Reporter } from "./reporter.types";
 
+type RunStartArgs = Parameters<NonNullable<Reporter["onRunStart"]>>[0];
+
 const ANSI_BOLD = "\u001b[1m";
 const ANSI_BOLD_OFF = "\u001b[22m";
 const ANSI_DIM = "\u001b[2m";
@@ -24,7 +26,7 @@ export class ProgressReporter implements Reporter {
 
   constructor(private readonly delegate: Reporter) {}
 
-  onRunStart(args: { total: number }): void {
+  onRunStart(args: RunStartArgs): void {
     this.total = args.total;
     this.startedAt = Date.now();
     this.completed = 0;

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

@@ -1,10 +1,13 @@
 import type { StepPhase } from "../contracts/runtime-context.types";
-import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
+import type { OpStep, ScenarioSpec, ScenarioType } from "../contracts/testing-metadata.types";
 import type { SolidTestSpecResult } from "../contracts/test-spec.types";
 
 export interface Reporter {
   onRunStart?(args: {
     total: number;
+    startedAt: string;
+    scenarioIds: string[];
+    scenarios?: Array<{ id: string; name?: string; type: ScenarioType }>;
   }): void;
   onScenarioStart(scenario: ScenarioSpec): void;
   onScenarioEnd(
@@ -36,6 +39,12 @@ export interface Reporter {
     contentType: string;
     data: Buffer | string;
   }): void;
+  /** Attach a run-level artifact (e.g. the whole-run video), emitted on run.end. */
+  attachRunArtifact?(args: {
+    name: string;
+    contentType: string;
+    data: Buffer | string;
+  }): void;
   onRunEnd?(args: {
     ok: boolean;
     total: number;