creevey 0.10.0-beta.4 → 0.10.0-beta.41

package/src/server/testsFiles/parser.ts

@@ -1,8 +1,58 @@
 import { pathToFileURL } from 'url';
-import { toId, storyNameFromExport } from '@storybook/csf';
 import { CreeveyStoryParams, CreeveyTestFunction } from '../../types.js';
 import { loadThroughTSX } from '../utils.js';
 
+// NOTE: Copy-pasted from @storybook/csf
+function toStartCaseStr(str: string) {
+  return str
+    .replace(/_/g, ' ')
+    .replace(/-/g, ' ')
+    .replace(/\./g, ' ')
+    .replace(/([^\n])([A-Z])([a-z])/g, (_, $1, $2, $3) => `${$1} ${$2}${$3}`)
+    .replace(/([a-z])([A-Z])/g, (_, $1, $2) => `${$1} ${$2}`)
+    .replace(/([a-z])([0-9])/gi, (_, $1, $2) => `${$1} ${$2}`)
+    .replace(/([0-9])([a-z])/gi, (_, $1, $2) => `${$1} ${$2}`)
+    .replace(/(\s|^)(\w)/g, (_, $1, $2: string) => `${$1}${$2.toUpperCase()}`)
+    .replace(/ +/g, ' ')
+    .trim();
+}
+
+/**
+ * Remove punctuation and illegal characters from a story ID.
+ *
+ * See https://gist.github.com/davidjrice/9d2af51100e41c6c4b4a
+ */
+const sanitize = (string: string) => {
+  return (
+    string
+      .toLowerCase()
+      // eslint-disable-next-line no-useless-escape
+      .replace(/[ ’–—―′¿'`~!@#$%^&*()_|+\-=?;:'",.<>\{\}\[\]\\\/]/gi, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-+/, '')
+      .replace(/-+$/, '')
+  );
+};
+
+const sanitizeSafe = (string: string, part: string) => {
+  const sanitized = sanitize(string);
+  if (sanitized === '') {
+    throw new Error(`Invalid ${part} '${string}', must include alphanumeric characters`);
+  }
+  return sanitized;
+};
+
+/**
+ * Generate a storybook ID from a component/kind and story name.
+ */
+const toId = (kind: string, name?: string) =>
+  `${sanitizeSafe(kind, 'kind')}${name ? `--${sanitizeSafe(name, 'name')}` : ''}`;
+
+/**
+ * Transform a CSF named export into a readable story name
+ */
+const storyNameFromExport = (key: string) => toStartCaseStr(key);
+
 export type CreeveyParamsByStoryId = Record<string, CreeveyStoryParams>;
 
 export default async function parse(files: string[]): Promise<CreeveyParamsByStoryId> {
@@ -55,8 +105,6 @@ export const story = (
 
 export const test = (title: string, testFn: CreeveyTestFunction): void => {
   const storyId = getStoryId(kindTitle, storyTitle);
-  if (!result[storyId]) {
-    result[storyId] = {};
-  }
+  result[storyId] ??= {};
   result[storyId].tests = Object.assign({}, result[storyId].tests, { [title]: testFn });
 };

package/src/server/utils.ts

@@ -1,13 +1,16 @@
 import fs from 'fs';
-import { get } from 'https';
+import https from 'https';
+import http from 'http';
 import cluster from 'cluster';
 import { dirname } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { createRequire } from 'module';
 import { register as esmRegister } from 'tsx/esm/api';
 import { register as cjsRegister } from 'tsx/cjs/api';
-import { SkipOptions, SkipOption, isDefined, TestData, noop, ServerTest } from '../types.js';
+import { SkipOptions, SkipOption, isDefined, TestData, noop, ServerTest, Worker } from '../types.js';
 import { emitShutdownMessage, sendShutdownMessage } from './messages.js';
+import { LOCALHOST_REGEXP } from './webdriver.js';
+import assert from 'assert';
+import pidtree from 'pidtree';
 
 const importMetaUrl = pathToFileURL(__filename).href;
 
@@ -15,6 +18,19 @@ export const isShuttingDown = { current: false };
 
 export const configExt = ['.js', '.mjs', '.ts', '.cjs', '.mts', '.cts'];
 
+const browserTypes = {
+  chromium: 'chromium',
+  'chromium-headless-shell': 'chromium',
+  chrome: 'chromium',
+  'chrome-beta': 'chromium',
+  msedge: 'chromium',
+  'msedge-beta': 'chromium',
+  'msedge-dev': 'chromium',
+  'bidi-chromium': 'chromium',
+  firefox: 'firefox',
+  webkit: 'webkit',
+} as const;
+
 export const skipOptionKeys = ['in', 'kinds', 'stories', 'tests', 'reason'];
 
 function matchBy(pattern: string | string[] | RegExp | undefined, value: string): boolean {
@@ -83,19 +99,56 @@ export async function shutdownWorkers(): Promise<void> {
         (worker) =>
           new Promise<void>((resolve) => {
             const timeout = setTimeout(() => {
-              worker.kill();
-            }, 10000);
+              if (worker.process.pid) void killTree(worker.process.pid);
+            }, 10_000);
             worker.on('exit', () => {
               clearTimeout(timeout);
               resolve();
             });
             sendShutdownMessage(worker);
+            worker.disconnect();
           }),
       ),
   );
   emitShutdownMessage();
 }
 
+export function gracefullyKill(worker: Worker): void {
+  worker.isShuttingDown = true;
+  const timeout = setTimeout(() => {
+    if (worker.process.pid) void killTree(worker.process.pid);
+  }, 10000);
+  worker.on('exit', () => {
+    clearTimeout(timeout);
+  });
+  sendShutdownMessage(worker);
+}
+
+export async function killTree(rootPid: number): Promise<void> {
+  const pids = await pidtree(rootPid, { root: true });
+
+  pids.forEach((pid) => {
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      /* noop */
+    }
+  });
+}
+
+export function shutdownWithError(): void {
+  process.exit(1);
+}
+
+export function resolvePlaywrightBrowserType(browserName: string): (typeof browserTypes)[keyof typeof browserTypes] {
+  assert(
+    browserName in browserTypes,
+    new Error(`Failed to match browser name "${browserName}" to playwright browserType`),
+  );
+
+  return browserTypes[browserName as keyof typeof browserTypes];
+}
+
 export async function getCreeveyCache(): Promise<string | undefined> {
   const { default: findCacheDir } = await import('find-cache-dir');
   return findCacheDir({ name: 'creevey', cwd: dirname(fileURLToPath(importMetaUrl)) });
@@ -131,11 +184,12 @@ export function testsToImages(tests: (TestData | undefined)[]): Set<string> {
 
 // https://tuhrig.de/how-to-know-you-are-inside-a-docker-container/
 export const isInsideDocker =
-  fs.existsSync('/proc/1/cgroup') && fs.readFileSync('/proc/1/cgroup', 'utf-8').includes('docker');
+  (fs.existsSync('/proc/1/cgroup') && fs.readFileSync('/proc/1/cgroup', 'utf-8').includes('docker')) ||
+  process.env.DOCKER === 'true';
 
 export const downloadBinary = (downloadUrl: string, destination: string): Promise<void> =>
   new Promise((resolve, reject) =>
-    get(downloadUrl, (response) => {
+    https.get(downloadUrl, (response) => {
       if (response.statusCode == 302) {
         const { location } = response.headers;
         if (!location) {
@@ -175,10 +229,10 @@ export function readDirRecursive(dirPath: string): string[] {
   );
 }
 
-const _require = createRequire(importMetaUrl);
 export function tryToLoadTestsData(filename: string): Partial<Record<string, ServerTest>> | undefined {
   try {
-    return _require(filename) as Partial<Record<string, ServerTest>>;
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require(filename) as Partial<Record<string, ServerTest>>;
   } catch {
     /* noop */
   }
@@ -204,3 +258,37 @@ export async function loadThroughTSX<T>(
 
   return result;
 }
+
+export function waitOnUrl(waitUrl: string, timeout: number, delay: number) {
+  const urls = [waitUrl];
+  if (!LOCALHOST_REGEXP.test(waitUrl)) {
+    const parsedUrl = new URL(waitUrl);
+    parsedUrl.host = 'localhost';
+    urls.push(parsedUrl.toString());
+  }
+  const startTime = Date.now();
+  return Promise.race(
+    urls.map(
+      (url) =>
+        new Promise<void>((resolve, reject) => {
+          const interval = setInterval(() => {
+            http
+              .get(url, (response) => {
+                if (response.statusCode === 200) {
+                  clearInterval(interval);
+                  resolve();
+                }
+              })
+              .on('error', () => {
+                // Ignore HTTP errors
+              });
+
+            if (Date.now() - startTime > timeout) {
+              clearInterval(interval);
+              reject(new Error(`${url} didn't respond within ${timeout / 1000} seconds`));
+            }
+          }, delay);
+        }),
+    ),
+  );
+}

package/src/server/webdriver.ts

@@ -1,8 +1,7 @@
-import Logger from 'loglevel';
 import chalk from 'chalk';
 import { networkInterfaces } from 'os';
-import { logger as defaultLogger } from './logger.js';
-import { Args } from '@storybook/csf';
+import { logger } from './logger.js';
+import type { Args } from '@storybook/types';
 import {
   isDefined,
   StoryInput,
@@ -19,18 +18,31 @@ export const storybookRootID = 'storybook-root';
 export const LOCALHOST_REGEXP = /(localhost|127\.0\.0\.1)/i;
 const DOCKER_INTERNAL = 'host.docker.internal';
 
+let browserClosePromise: Promise<void> | null = null;
+
+export const openBrowser = () => {
+  let resolve: () => void;
+  browserClosePromise = new Promise((r) => (resolve = r));
+  return () => {
+    resolve();
+    browserClosePromise = null;
+  };
+};
+
+export const waitForBrowserClose = () => browserClosePromise;
+
 export async function resolveStorybookUrl(
   storybookUrl: string,
   checkUrl: (url: string) => Promise<boolean>,
-  logger: Logger.Logger = defaultLogger,
 ): Promise<string> {
-  logger.debug('Resolving storybook url');
+  logger().debug('Resolving storybook url');
   const addresses = getAddresses();
+  // TODO Use Promise.race?
   for (const ip of addresses) {
     const resolvedUrl = storybookUrl.replace(LOCALHOST_REGEXP, ip);
-    logger.debug(`Checking storybook availability on ${chalk.magenta(resolvedUrl)}`);
+    logger().debug(`Checking storybook availability on ${chalk.magenta(resolvedUrl)}`);
     if (await checkUrl(resolvedUrl)) {
-      logger.debug(`Resolved storybook url ${chalk.magenta(resolvedUrl)}`);
+      logger().debug(`Resolved storybook url ${chalk.magenta(resolvedUrl)}`);
       return resolvedUrl;
     }
   }
@@ -74,11 +86,7 @@ export abstract class CreeveyWebdriverBase implements CreeveyWebdriver {
 
   abstract afterTest(test: ServerTest): Promise<void>;
 
-  async switchStory(
-    story: StoryInput,
-    context: BaseCreeveyTestContext,
-    logger: Logger.Logger,
-  ): Promise<CreeveyTestContext> {
+  async switchStory(story: StoryInput, context: BaseCreeveyTestContext): Promise<CreeveyTestContext> {
     const { id, title, name, parameters } = story;
     const {
       captureElement = `#${storybookRootID}`,
@@ -86,7 +94,7 @@ export abstract class CreeveyWebdriverBase implements CreeveyWebdriver {
       ignoreElements,
     } = (parameters.creevey ?? {}) as CreeveyStoryParams;
 
-    logger.debug(`Switching to story ${chalk.cyan(title)}/${chalk.cyan(name)} by id ${chalk.magenta(id)}`);
+    logger().debug(`Switching to story ${chalk.cyan(title)}/${chalk.cyan(name)} by id ${chalk.magenta(id)}`);
 
     let storyPlayResolver: (isCompleted: boolean) => void;
     let waitForComplete = new Promise<boolean>((resolve) => (storyPlayResolver = resolve));
@@ -107,7 +115,7 @@ export abstract class CreeveyWebdriverBase implements CreeveyWebdriver {
     const isCaptureCalled = await this.selectStory(id, waitForReady);
 
     if (isCaptureCalled) {
-      logger.debug(`Capturing screenshots from ${chalk.magenta(id)} story's \`play()\` function`);
+      logger().debug(`Capturing screenshots from ${chalk.magenta(id)} story's \`play()\` function`);
       while (!(await waitForComplete)) {
         waitForComplete = new Promise<boolean>((resolve) => (storyPlayResolver = resolve));
       }
@@ -115,8 +123,8 @@ export abstract class CreeveyWebdriverBase implements CreeveyWebdriver {
 
     unsubscribe();
 
-    if (isCaptureCalled) logger.debug(`Story ${chalk.magenta(id)} completed capturing`);
-    else logger.debug(`Story ${chalk.magenta(id)} ready for capturing`);
+    if (isCaptureCalled) logger().debug(`Story ${chalk.magenta(id)} completed capturing`);
+    else logger().debug(`Story ${chalk.magenta(id)} ready for capturing`);
 
     return Object.assign(
       {

package/src/server/worker/chai-image.ts

@@ -1,8 +1,8 @@
-import Logger from 'loglevel';
+import { logger } from '../logger';
+
 export default function (
   matchImage: (image: Buffer, imageName?: string) => Promise<void>,
   matchImages: (images: Record<string, Buffer>) => Promise<void>,
-  logger: Logger.Logger,
 ) {
   let isWarningShown = false;
   return function chaiImage({ Assertion }: Chai.ChaiStatic, utils: Chai.ChaiUtils): void {
@@ -11,7 +11,7 @@ export default function (
       'matchImage',
       async function (this: Record<string, unknown>, imageName?: string) {
         if (!isWarningShown) {
-          logger.warn(
+          logger().warn(
             '`expect(...).to.matchImage()` is deprecated and will be removed in the next major release. Please use `context.matchImage()` instead.',
           );
           isWarningShown = true;
@@ -23,7 +23,7 @@ export default function (
 
     utils.addMethod(Assertion.prototype, 'matchImages', async function (this: Record<string, unknown>) {
       if (!isWarningShown) {
-        logger.warn(
+        logger().warn(
           '`expect(...).to.matchImages()` is deprecated and will be removed in the next major release. Please use `context.matchImages()` instead.',
         );
         isWarningShown = true;

package/src/server/worker/context.ts

@@ -0,0 +1,14 @@
+import type { Container } from 'dockerode';
+
+let workerContainer: Container | null = null;
+
+export function setWorkerContainer(container: Container): void {
+  workerContainer = container;
+}
+
+export async function removeWorkerContainer(): Promise<void> {
+  if (workerContainer) {
+    await workerContainer.remove({ force: true });
+    workerContainer = null;
+  }
+}

package/src/server/worker/match-image.ts

@@ -21,6 +21,10 @@ interface ImagePaths {
   reportImageDir: string;
 }
 
+function toBuffer(bufferOrBase64: Buffer | string) {
+  return typeof bufferOrBase64 === 'string' ? Buffer.from(bufferOrBase64, 'base64') : bufferOrBase64;
+}
+
 async function getStat(filePath: string): Promise<Stats | null> {
   try {
     return await stat(filePath);
@@ -228,17 +232,17 @@ export async function getMatchers(ctx: ImageContext, config: Config) {
   }
 
   return {
-    matchImage: async (image: Buffer, imageName?: string) => {
-      const errorMessage = await assertImage(image, imageName);
+    matchImage: async (image: Buffer | string, imageName?: string) => {
+      const errorMessage = await assertImage(toBuffer(image), imageName);
       if (errorMessage) {
         throw createImageError(imageName ? { [imageName]: errorMessage } : errorMessage);
       }
     },
-    matchImages: async (images: Record<string, Buffer>) => {
+    matchImages: async (images: Record<string, Buffer | string>) => {
       const errors: Record<string, string> = {};
       await Promise.all(
         Object.entries(images).map(async ([imageName, image]) => {
-          const errorMessage = await assertImage(image, imageName);
+          const errorMessage = await assertImage(toBuffer(image), imageName);
           if (errorMessage) {
             errors[imageName] = errorMessage;
           }
@@ -279,17 +283,17 @@ export function getOdiffMatchers(ctx: ImageContext, config: Config) {
   }
 
   return {
-    matchImage: async (image: Buffer, imageName?: string) => {
-      const errorMessage = await assertImage(image, imageName);
+    matchImage: async (image: Buffer | string, imageName?: string) => {
+      const errorMessage = await assertImage(toBuffer(image), imageName);
       if (errorMessage) {
         throw createImageError(imageName ? { [imageName]: errorMessage } : errorMessage);
       }
     },
-    matchImages: async (images: Record<string, Buffer>) => {
+    matchImages: async (images: Record<string, Buffer | string>) => {
       const errors: Record<string, string> = {};
       await Promise.all(
         Object.entries(images).map(async ([imageName, image]) => {
-          const errorMessage = await assertImage(image, imageName);
+          const errorMessage = await assertImage(toBuffer(image), imageName);
           if (errorMessage) {
             errors[imageName] = errorMessage;
           }

package/src/server/worker/start.ts

@@ -1,18 +1,12 @@
 import chai from 'chai';
-import chalk from 'chalk';
-import Logger from 'loglevel';
-import EventEmitter from 'events';
 import {
   BaseCreeveyTestContext,
   Config,
   CreeveyWebdriver,
-  FakeSuite,
-  FakeTest,
-  Images,
   Options,
   ServerTest,
-  TEST_EVENTS,
   TestMessage,
+  TestResult,
   isDefined,
   isImageError,
 } from '../../types.js';
@@ -47,9 +41,10 @@ async function getTestsFromStories(
   return testsById;
 }
 
-function runHandler(browserName: string, images: Partial<Record<string, Images>>, error?: unknown): void {
+function runHandler(browserName: string, result: Omit<TestResult, 'status'>, error?: unknown): void {
   // TODO How handle browser corruption?
-  if (isImageError(error)) {
+  const { images } = result;
+  if (images != null && isImageError(error)) {
     if (typeof error.images == 'string') {
       const image = images[browserName];
       if (image) image.error = error.images;
@@ -62,31 +57,37 @@ function runHandler(browserName: string, images: Partial<Record<string, Images>>
     }
   }
 
-  if (error || Object.values(images).some((image) => image?.error != null)) {
-    const errorMessage = serializeError(error);
+  if (error || (images != null && Object.values(images).some((image) => image?.error != null))) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const errorMessage = result.error!;
 
     const isUnexpectedError =
       hasTimeout(errorMessage) ||
       hasDisconnected(errorMessage) ||
-      Object.values(images).some((image) => hasTimeout(image?.error));
+      (images != null && Object.values(images).some((image) => hasTimeout(image?.error)));
     if (isUnexpectedError) emitWorkerMessage({ type: 'error', payload: { subtype: 'unknown', error: errorMessage } });
     else
       emitTestMessage({
         type: 'end',
         payload: {
           status: 'failed',
-          images,
-          error: errorMessage,
+          ...result,
         },
       });
   } else {
-    emitTestMessage({ type: 'end', payload: { status: 'success', images } });
+    emitTestMessage({
+      type: 'end',
+      payload: {
+        status: 'success',
+        ...result,
+      },
+    });
   }
 }
 
 async function setupWebdriver(webdriver: CreeveyWebdriver): Promise<[string, CreeveyWebdriver] | undefined> {
   if ((await webdriver.openBrowser(true)) == null) {
-    logger.error('Failed to start browser');
+    logger().error('Failed to start browser');
     emitWorkerMessage({
       type: 'error',
       payload: { subtype: 'browser', error: 'Failed to start browser' },
@@ -114,7 +115,6 @@ function hasTimeout(str: string | null | undefined): boolean {
 }
 
 export async function start(browser: string, gridUrl: string, config: Config, options: Options): Promise<void> {
-  let retries = 0;
   const imagesContext: ImageContext = {
     attachments: [],
     testFullPath: [],
@@ -125,38 +125,16 @@ export async function start(browser: string, gridUrl: string, config: Config, op
 
   if (!webdriver || !sessionId) return;
 
-  const workerLogger = Logger.getLogger(`${browser}:${chalk.gray(sessionId)}`);
-
-  const reporterOptions = {
-    ...config.reporterOptions,
-    creevey: {
-      sessionId,
-      reportDir: config.reportDir,
-      browserName: browser,
-      get willRetry() {
-        return retries < config.maxRetries;
-      },
-      get images() {
-        return imagesContext.images;
-      },
-    },
-  };
-
-  class FakeRunner extends EventEmitter {}
-  const runner = new FakeRunner();
-  const Reporter = config.reporter;
-  new Reporter(runner, { reporterOptions });
-
   const { matchImage, matchImages } = options.odiff
     ? getOdiffMatchers(imagesContext, config)
     : await getMatchers(imagesContext, config);
-  chai.use(chaiImage(matchImage, matchImages, workerLogger));
+  chai.use(chaiImage(matchImage, matchImages));
 
   const tests = await (async () => {
     try {
       return await getTestsFromStories(config, browser, webdriver);
     } catch (error) {
-      workerLogger.error('Failed to get tests from stories:', error);
+      logger().error('Failed to get tests from stories:', error);
       emitWorkerMessage({
         type: 'error',
         payload: { subtype: 'browser', error: serializeError(error) },
@@ -174,7 +152,7 @@ export async function start(browser: string, gridUrl: string, config: Config, op
 
     if (!test) {
       const error = `Test with id ${message.payload.id} not found`;
-      workerLogger.error(error);
+      logger().error(error);
       emitWorkerMessage({
         type: 'error',
         payload: { subtype: 'test', error },
@@ -200,68 +178,55 @@ export async function start(browser: string, gridUrl: string, config: Config, op
     imagesContext.testFullPath = getTestPath(test);
     imagesContext.images = {};
 
-    retries = message.payload.retries;
     let error = undefined;
 
-    const fakeSuite: FakeSuite = {
-      title: test.storyPath.slice(0, -1).join('/'),
-      fullTitle: () => fakeSuite.title,
-      titlePath: () => [fakeSuite.title],
-      tests: [],
-    };
-
-    const fakeTest: FakeTest = {
-      parent: fakeSuite,
-      title: [test.story.name, test.testName, test.browser].filter(isDefined).join('/'),
-      fullTitle: () => getTestPath(test).join('/'),
-      titlePath: () => getTestPath(test),
-      currentRetry: () => retries,
-      retires: () => config.maxRetries,
-      slow: () => 1000,
-    };
-
-    fakeSuite.tests.push(fakeTest);
-
     void (async () => {
-      runner.emit(TEST_EVENTS.RUN_BEGIN);
-      runner.emit(TEST_EVENTS.TEST_BEGIN, fakeTest);
-
+      let timeout;
+      let isRejected = false;
       const start = Date.now();
       try {
         await Promise.race([
-          new Promise((reject) =>
-            setTimeout(() => {
-              reject(`Timeout of ${config.testTimeout}ms exceeded`);
-            }, config.testTimeout),
+          new Promise(
+            (_, reject) =>
+              (timeout = setTimeout(() => {
+                isRejected = true;
+                reject(new Error(`Timeout of ${config.testTimeout}ms exceeded`));
+              }, config.testTimeout)),
           ),
           (async () => {
-            const context = await webdriver.switchStory(test.story, baseContext, workerLogger);
+            const context = await webdriver.switchStory(test.story, baseContext);
             await test.fn(context);
           })(),
         ]);
       } catch (testError) {
         error = testError;
-        fakeTest.err = error;
       }
       const duration = Date.now() - start;
-      fakeTest.attachments = imagesContext.attachments;
-      fakeTest.state = error ? 'failed' : 'passed';
-      fakeTest.duration = duration;
-      fakeTest.speed = duration > fakeTest.slow() ? 'slow' : duration / 2 > fakeTest.slow() ? 'medium' : 'fast';
-
-      if (error) {
-        runner.emit(TEST_EVENTS.TEST_FAIL, fakeTest, error);
-      } else {
-        runner.emit(TEST_EVENTS.TEST_PASS, fakeTest);
-      }
-      runner.emit(TEST_EVENTS.TEST_END, fakeTest);
-      runner.emit(TEST_EVENTS.RUN_END);
+      clearTimeout(timeout);
 
       await webdriver.afterTest(test);
 
-      runHandler(baseContext.browserName, imagesContext.images, error);
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (isRejected) {
+        emitWorkerMessage({
+          type: 'error',
+          payload: { subtype: 'unknown', error: serializeError(error) },
+        });
+      } else {
+        const result = {
+          sessionId,
+          browserName: baseContext.browserName,
+          workerId: process.pid,
+          images: imagesContext.images,
+          error: serializeError(error),
+          duration,
+          attachments: imagesContext.attachments,
+          retries: message.payload.retries,
+        };
+        runHandler(baseContext.browserName, result, error);
+      }
     })().catch((error: unknown) => {
-      workerLogger.error('Unexpected error:', error);
+      logger().error('Unexpected error:', error);
       emitWorkerMessage({
         type: 'error',
         payload: { subtype: 'test', error: serializeError(error) },
@@ -269,7 +234,7 @@ export async function start(browser: string, gridUrl: string, config: Config, op
     });
   });
 
-  workerLogger.info('Browser is ready');
+  logger().info('Browser is ready');
 
   emitWorkerMessage({ type: 'ready' });
 }

package/src/shared/index.ts

@@ -1,5 +1,5 @@
 import _ from 'lodash';
-import { Parameters } from '@storybook/csf';
+import type { Parameters } from '@storybook/types';
 import { SetStoriesData, StoriesRaw, CreeveyStoryParams, StoryInput } from '../types.js';
 import { deserializeRegExp, isSerializedRegExp, isRegExp, serializeRegExp } from './serializeRegExp.js';