@dungarees/test-environment 0.11.4

package/constants.d.ts

@@ -0,0 +1 @@
+export declare const NODE_CONTAINER_IMAGE: "node:24-bullseye";

package/constants.js

@@ -0,0 +1 @@
+export const NODE_CONTAINER_IMAGE = 'node:24-bullseye';

package/cucumber-test-environment.d.ts

@@ -0,0 +1,11 @@
+import type { ServiceConfig } from './type.ts';
+import type { TestEnvironmentWorld } from './world.ts';
+type CucumberTestEnvironment<SERVICES extends Record<string, ServiceConfig>> = {
+    Given: (step: string, callback: (world: TestEnvironmentWorld<SERVICES>) => Promise<void>) => void;
+    When: (step: string, callback: (world: TestEnvironmentWorld<SERVICES>) => Promise<void>) => void;
+    Then: (step: string, callback: (world: TestEnvironmentWorld<SERVICES>) => Promise<void>) => void;
+};
+export declare const createCucumberTestEnvironment: <SERVICES extends Record<string, ServiceConfig>>(services: SERVICES, options?: {
+    timeout?: number;
+}) => CucumberTestEnvironment<SERVICES>;
+export {};

package/cucumber-test-environment.js

@@ -0,0 +1,63 @@
+import { createTestEnvironment } from './test-environment.js';
+import { After, AfterAll, Before, BeforeAll, Given as CucumberGiven, Then as CucumberThen, When as CucumberWhen, setDefaultTimeout, setWorldConstructor, Status, World, } from '@cucumber/cucumber';
+export const createCucumberTestEnvironment = (services, options = {}) => {
+    setDefaultTimeout(options.timeout ?? 60 * 1000);
+    const testEnvironment = createTestEnvironment(services);
+    class TestEnvironmentWorld extends World {
+        constructor() {
+            super(...arguments);
+            this.debug = false;
+            this.testEnvironmentWorld = testEnvironment.createWorld();
+        }
+    }
+    setWorldConstructor(TestEnvironmentWorld);
+    BeforeAll(async function () {
+        const entry$ = await testEnvironment.onBeforeAll();
+        entry$.subscribe(({ entry, type }) => {
+            console.log(entry, type);
+        });
+    });
+    Before({ tags: '@ignore' }, function () {
+        return 'skipped';
+    });
+    Before({ tags: '@debug' }, function () {
+        this.debug = true;
+    });
+    Before(async function () {
+        const entry$ = await testEnvironment.onBefore(this.testEnvironmentWorld);
+        entry$.subscribe(({ entry, type }) => {
+            this.attach(entry, type);
+        });
+    });
+    After(async function ({ result, pickle }) {
+        if (result?.status !== Status.PASSED) {
+            const testName = pickle.name.replace(/\W/g, '-');
+            const entries = await testEnvironment.onFailure(this.testEnvironmentWorld, testName);
+            for (const { entry, type } of entries) {
+                this.attach(entry, type);
+            }
+        }
+        this.attach(`Status: ${result?.status ?? ''}. Duration:${result?.duration?.seconds ?? ''}s`);
+        const entry$ = await testEnvironment.onAfter(this.testEnvironmentWorld);
+        entry$.subscribe(({ entry, type }) => {
+            this.attach(entry, type);
+        });
+    });
+    AfterAll(async function () {
+        const entry$ = await testEnvironment.onAfterAll();
+        entry$.subscribe(({ entry, type }) => {
+            console.log(entry, type);
+        });
+    });
+    return {
+        Given: (step, callback) => CucumberGiven(step, async function () {
+            await callback(this.testEnvironmentWorld);
+        }),
+        When: (step, callback) => CucumberWhen(step, async function () {
+            await callback(this.testEnvironmentWorld);
+        }),
+        Then: (step, callback) => CucumberThen(step, async function () {
+            await callback(this.testEnvironmentWorld);
+        }),
+    };
+};

package/guards.d.ts

@@ -0,0 +1,6 @@
+import type { InteractorConfig, RunnerConfig, ServiceConfig } from './type.ts';
+import type { FilterRecord, GetKey, RecordToEntries } from '@dungarees/core/type-util.ts';
+export type InteractorNames<SERVICES extends Record<string, ServiceConfig>> = GetKey<RecordToEntries<FilterRecord<SERVICES, InteractorConfig>>>;
+export type RunnerNames<SERVICES extends Record<string, ServiceConfig>> = GetKey<RecordToEntries<FilterRecord<SERVICES, RunnerConfig>>>;
+export declare const isInteractorName: <SERVICES extends Record<string, ServiceConfig>>(serviceConfigs: SERVICES, name: string) => name is InteractorNames<SERVICES> & string;
+export declare const isRunnerName: <SERVICES extends Record<string, ServiceConfig>>(serviceConfigs: SERVICES, name: string) => name is RunnerNames<SERVICES> & string;

package/guards.js

@@ -0,0 +1,5 @@
+// Narrows the name, not the config. A guard on the config alone tells TypeScript nothing about
+// which key it came from, so the interactor and runner maps — keyed by their own subset of the
+// service names — cannot be written to without it.
+export const isInteractorName = (serviceConfigs, name) => serviceConfigs[name]?.type === 'interactor';
+export const isRunnerName = (serviceConfigs, name) => serviceConfigs[name]?.type === 'runner';

package/interactors/browser.d.ts

@@ -0,0 +1,19 @@
+import { type Interactor } from '@bobcats-coding/skid/test/type.js';
+import type { APIRequestContext, BrowserContext, LaunchOptions, Page } from '@playwright/test';
+export type BrowserInteractorContext = {
+    context: BrowserContext;
+    page: Page;
+};
+export type RequestInteractorContext = {
+    context: APIRequestContext;
+};
+export declare const VALID_BROWSERS: readonly ["firefox", "webkit", "chromium"];
+export type BrowserTypes = (typeof VALID_BROWSERS)[number];
+export type BrowserInteractorConfig = {
+    browserOptions: LaunchOptions;
+    browser: BrowserTypes;
+    tracesDir: string;
+    screenshotsDir: string;
+    isVideoEnabled: boolean;
+};
+export declare const browserInteractor: (config: BrowserInteractorConfig) => Interactor<BrowserInteractorContext>;

package/interactors/browser.js

@@ -0,0 +1,54 @@
+import { chromium, firefox, webkit } from '@playwright/test';
+import { ensureDir } from 'fs-extra';
+import { fromEventPattern, map } from 'rxjs';
+export const VALID_BROWSERS = ['firefox', 'webkit', 'chromium'];
+export const browserInteractor = (config) => {
+    const BROWSERS = {
+        firefox,
+        webkit,
+        chromium,
+    };
+    let browser;
+    return {
+        start: async () => {
+            browser = await (BROWSERS[config.browser] ?? chromium).launch(config.browserOptions);
+            await ensureDir(config.tracesDir);
+        },
+        stop: async () => {
+            await browser.close();
+        },
+        startContext: async () => {
+            const context = await browser.newContext({
+                acceptDownloads: true,
+                viewport: { width: 1200, height: 800 },
+                ...(config.isVideoEnabled ? { recordVideo: { dir: 'reports/screenshots' } } : {}),
+            });
+            await context.tracing.start({ screenshots: true, snapshots: true });
+            const page = await context.newPage();
+            const console$ = fromEventPattern((handler) => page.on('console', (msg) => {
+                handler(`${msg.type()}: ${msg.text()}`);
+            }));
+            return {
+                context: { page, context },
+                reportEntry$: console$.pipe(map((log) => ({
+                    entry: `console -> ${log}`,
+                    type: 'text/plain',
+                }))),
+            };
+        },
+        stopContext: async ({ page, context }) => {
+            await page.close();
+            await context.close();
+        },
+        onFailure: async ({ page, context }, testName) => {
+            const image = await page.screenshot();
+            await context.tracing.stop({
+                path: `${config.tracesDir}/${testName}-${new Date().toISOString().split('.')[0] ?? ''}-trace.zip`,
+            });
+            return {
+                entry: image,
+                type: 'image/png',
+            };
+        },
+    };
+};

package/interactors/network.d.ts

@@ -0,0 +1,5 @@
+import { type Interactor } from '../type.ts';
+import { type StartedNetwork } from 'testcontainers';
+export declare const networkInteractor: () => Interactor<{
+    network: StartedNetwork;
+}>;

package/interactors/network.js

@@ -0,0 +1,34 @@
+import { EMPTY } from 'rxjs';
+import { Network } from 'testcontainers';
+export const networkInteractor = () => {
+    const network = new Network();
+    let startedNetwork;
+    return {
+        start: async () => {
+            startedNetwork = await network.start();
+        },
+        stop: async () => {
+            if (startedNetwork !== undefined) {
+                await startedNetwork.stop();
+            }
+        },
+        startContext: async () => {
+            if (startedNetwork === undefined) {
+                throw new Error('Network not started');
+            }
+            return {
+                context: {
+                    network: startedNetwork,
+                },
+                reportEntry$: EMPTY,
+            };
+        },
+        stopContext: async () => { },
+        onFailure: async () => {
+            return {
+                entry: 'Network failed to start',
+                type: 'text/plain',
+            };
+        },
+    };
+};

package/interactors/node-command-line.d.ts

@@ -0,0 +1,23 @@
+import type { Interactor } from '../type.ts';
+import type { StartedNetwork } from 'testcontainers';
+export type CommandResult = {
+    output: string;
+    exitCode: number;
+};
+export type ExecContext = {
+    user: string;
+    workingDir: string;
+    environment: Record<string, string>;
+};
+export type NodeCommandLineContext = {
+    exec: (command: string, context?: Partial<ExecContext>) => Promise<CommandResult>;
+    execWithAssertions: (command: string, context?: Partial<ExecContext>) => Promise<CommandResult>;
+};
+export type NodeCommandLineConfig = {
+    workingDir: string;
+    environment?: Record<string, string>;
+    network?: StartedNetwork;
+    path?: string;
+    bindMount?: string;
+};
+export declare const nodeCommandLineInteractor: ({ workingDir, environment, network, path, bindMount, }: NodeCommandLineConfig) => Interactor<NodeCommandLineContext>;

package/interactors/node-command-line.js

@@ -0,0 +1,99 @@
+import { NODE_CONTAINER_IMAGE } from '../constants.js';
+import { ReplaySubject } from 'rxjs';
+import { GenericContainer } from 'testcontainers';
+export const nodeCommandLineInteractor = ({ workingDir, environment = {}, network, path, bindMount, }) => {
+    let runningContainer;
+    const reportEntry$ = new ReplaySubject();
+    const container = new GenericContainer(NODE_CONTAINER_IMAGE)
+        .withWorkingDir(workingDir)
+        .withEnvironment(environment)
+        // Keep container running with tail -f
+        .withCommand(['tail', '-f', '/dev/null'])
+        .withLogConsumer((stream) => {
+        stream.on('data', (line) => {
+            console.log(line);
+        });
+        stream.on('err', (line) => {
+            console.error(line);
+        });
+        stream.on('end', () => {
+            console.log(`Container closed: ${NODE_CONTAINER_IMAGE}`);
+        });
+    });
+    if (network !== undefined) {
+        container.withNetwork(network);
+    }
+    if (bindMount !== undefined) {
+        container.withBindMounts([
+            {
+                source: bindMount,
+                target: '/opt/app/',
+                mode: 'rw',
+            },
+        ]);
+    }
+    else if (path !== undefined) {
+        container.withCopyDirectoriesToContainer([
+            {
+                source: path,
+                target: '/opt/app/',
+            },
+        ]);
+    }
+    const createContext = (container) => {
+        const runCommand = async (command, context) => {
+            // Unfortunately, testcontainers does not support reading stderr
+            const redirectedCommand = `${command} 2>&1`;
+            const result = await container.exec(['sh', '-c', redirectedCommand], {
+                ...(context?.user === undefined ? {} : { user: context.user }),
+                ...(context?.workingDir === undefined ? {} : { workingDir: context.workingDir }),
+                env: { ...environment, ...context?.environment },
+            });
+            reportEntry$.next({
+                entry: `Command executed: ${command}\nExit code: ${result.exitCode}`,
+                type: 'text/plain',
+            });
+            return result;
+        };
+        return {
+            exec: async (command, context) => {
+                return runCommand(command, context);
+            },
+            execWithAssertions: async (command, context) => {
+                const result = await runCommand(command, context);
+                if (result.exitCode !== 0) {
+                    console.error(result.output);
+                    throw new Error(`Command failed: ${command}\nExit code: ${result.exitCode}\nOutput: ${result.output}`);
+                }
+                return result;
+            },
+        };
+    };
+    return {
+        start: async () => {
+            runningContainer = await container.start();
+        },
+        stop: async () => {
+            if (runningContainer !== undefined) {
+                await runningContainer.stop();
+                console.log(`Container stopped: ${workingDir}`);
+            }
+        },
+        startContext: async () => {
+            if (!runningContainer) {
+                throw new Error('Container not started');
+            }
+            return {
+                context: createContext(runningContainer),
+                reportEntry$: reportEntry$.asObservable(),
+            };
+        },
+        stopContext: async () => {
+            // Context cleanup handled in stop()
+        },
+        onFailure: async (testName) => ({
+            entry: `Node command line failed during test: ${testName}`,
+            type: 'text/plain',
+        }),
+    };
+};

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@dungarees/test-environment",
+  "engines": {
+    "node": ">=25.0.0"
+  },
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
+  "type": "module",
+  "dependencies": {
+    "@dungarees/core": "*",
+    "rxjs": "^7.8.1"
+  },
+  "devDependencies": {
+    "@bobcats-coding/skid": "*",
+    "@cucumber/cucumber": "^10.9.0",
+    "@playwright/test": "^1.54.1",
+    "@testcontainers/postgresql": "^10.28.0",
+    "fs-extra": "^11.3.0",
+    "testcontainers": "^10.28.0",
+    "vite": "^5.0.12",
+    "vitest": "^3.0.2"
+  },
+  "author": "info@productkind.com",
+  "license": "MIT",
+  "version": "0.11.4",
+  "exports": {
+    "./constants.ts": {
+      "import": "./constants.js",
+      "types": "./constants.d.ts"
+    },
+    "./cucumber-test-environment.ts": {
+      "import": "./cucumber-test-environment.js",
+      "types": "./cucumber-test-environment.d.ts"
+    },
+    "./guards.ts": {
+      "import": "./guards.js",
+      "types": "./guards.d.ts"
+    },
+    "./interactors/browser.ts": {
+      "import": "./interactors/browser.js",
+      "types": "./interactors/browser.d.ts"
+    },
+    "./interactors/network.ts": {
+      "import": "./interactors/network.js",
+      "types": "./interactors/network.d.ts"
+    },
+    "./interactors/node-command-line.ts": {
+      "import": "./interactors/node-command-line.js",
+      "types": "./interactors/node-command-line.d.ts"
+    },
+    "./runners/dev-server.ts": {
+      "import": "./runners/dev-server.js",
+      "types": "./runners/dev-server.d.ts"
+    },
+    "./runners/node-process.ts": {
+      "import": "./runners/node-process.js",
+      "types": "./runners/node-process.d.ts"
+    },
+    "./runners/npm-registry.ts": {
+      "import": "./runners/npm-registry.js",
+      "types": "./runners/npm-registry.d.ts"
+    },
+    "./runners/postgres.ts": {
+      "import": "./runners/postgres.js",
+      "types": "./runners/postgres.d.ts"
+    },
+    "./test-environment.test.ts": {
+      "import": "./test-environment.test.js",
+      "types": "./test-environment.test.d.ts"
+    },
+    "./test-environment.ts": {
+      "import": "./test-environment.js",
+      "types": "./test-environment.d.ts"
+    },
+    "./type.ts": {
+      "import": "./type.js",
+      "types": "./type.d.ts"
+    },
+    "./world.ts": {
+      "import": "./world.js",
+      "types": "./world.d.ts"
+    }
+  }
+}

package/runners/dev-server.d.ts

@@ -0,0 +1,6 @@
+import { type Runner } from '@bobcats-coding/skid/test/type.js';
+export type DevServerRunnerConfig = {
+    rootDir: string;
+    port: number;
+};
+export declare const devServerRunner: (config: DevServerRunnerConfig) => Runner;

package/runners/dev-server.js

@@ -0,0 +1,19 @@
+import { createServer } from 'vite';
+export const devServerRunner = (config) => {
+    let viteServer;
+    return {
+        start: async () => {
+            viteServer = await createServer({
+                root: config.rootDir,
+                server: {
+                    port: config.port,
+                },
+                logLevel: 'error',
+            });
+            await viteServer.listen();
+        },
+        stop: async () => {
+            await viteServer.close();
+        },
+    };
+};

package/runners/node-process.d.ts

@@ -0,0 +1,10 @@
+import type { Runner } from '@bobcats-coding/skid/test/type.js';
+import type { StartedNetwork } from 'testcontainers';
+export type NodeProcessRunnerConfig = {
+    path: string;
+    args: string[];
+    port: number;
+    environment?: Record<string, string>;
+    network?: StartedNetwork;
+};
+export declare const nodeProcessRunner: ({ path, args, port, environment, network, }: NodeProcessRunnerConfig) => Runner;

package/runners/node-process.js

@@ -0,0 +1,44 @@
+import { GenericContainer, Wait } from 'testcontainers';
+export const nodeProcessRunner = ({ path, args, port, environment = {}, network, }) => {
+    let runningContainer;
+    const container = new GenericContainer('node:24-bullseye')
+        .withWorkingDir('/opt/app')
+        .withEnvironment(environment)
+        .withCopyDirectoriesToContainer([
+        {
+            source: path,
+            target: '/opt/app/',
+        },
+    ])
+        .withExposedPorts({
+        container: port,
+        host: port,
+    })
+        .withEntrypoint(args)
+        .withLogConsumer((stream) => {
+        stream.on('data', (line) => {
+            console.log(line);
+        });
+        stream.on('err', (line) => {
+            console.error(line);
+        });
+        stream.on('end', () => {
+            console.log(`Container closed: ${path} ${args.join(' ')}}`);
+        });
+    })
+        .withWaitStrategy(Wait.forListeningPorts().withStartupTimeout(300000));
+    if (network !== undefined) {
+        container.withNetwork(network);
+    }
+    return {
+        start: async () => {
+            runningContainer = await container.start();
+        },
+        stop: async () => {
+            if (runningContainer !== undefined) {
+                await runningContainer.stop();
+                console.log(`Container stopped: ${path} ${args.join(' ')}}`);
+            }
+        },
+    };
+};

package/runners/npm-registry.d.ts

@@ -0,0 +1,10 @@
+import type { Runner } from '../type.ts';
+import type { StartedNetwork } from 'testcontainers';
+export type NpmRegistryRunnerConfig = {
+    port: number;
+    environment?: Record<string, string>;
+    network?: StartedNetwork;
+    alias?: string;
+    localScopes?: string[];
+};
+export declare const npmRegistryRunner: ({ port, environment, network, alias, localScopes, }: NpmRegistryRunnerConfig) => Runner;

package/runners/npm-registry.js

@@ -0,0 +1,70 @@
+import { GenericContainer, Wait } from 'testcontainers';
+const generateVerdaccioConfig = (localScopes) => {
+    const localScopeRules = localScopes
+        .map((scope) => `  '${scope}/*':\n    access: $all\n    publish: $authenticated`)
+        .join('\n');
+    return `storage: /verdaccio/storage/data
+auth:
+  htpasswd:
+    file: /verdaccio/storage/htpasswd
+uplinks:
+  npmjs:
+    url: https://registry.npmjs.org/
+packages:
+${localScopeRules}
+  '@*/*':
+    access: $all
+    publish: $authenticated
+    proxy: npmjs
+  '**':
+    access: $all
+    publish: $authenticated
+    proxy: npmjs
+`;
+};
+export const npmRegistryRunner = ({ port, environment = {}, network, alias, localScopes, }) => {
+    let runningContainer;
+    const container = new GenericContainer('verdaccio/verdaccio')
+        .withExposedPorts({
+        container: port,
+        host: port,
+    })
+        .withEnvironment(environment)
+        .withLogConsumer((stream) => {
+        stream.on('data', (line) => {
+            console.log(line);
+        });
+        stream.on('err', (line) => {
+            console.error(line);
+        });
+        stream.on('end', () => {
+            console.log('Verdaccio container closed');
+        });
+    })
+        .withWaitStrategy(Wait.forListeningPorts().withStartupTimeout(300000));
+    if (localScopes !== undefined) {
+        container.withCopyContentToContainer([
+            {
+                content: generateVerdaccioConfig(localScopes),
+                target: '/verdaccio/conf/config.yaml',
+            },
+        ]);
+    }
+    if (alias !== undefined) {
+        container.withName(alias);
+    }
+    if (network !== undefined) {
+        container.withNetwork(network);
+    }
+    return {
+        start: async () => {
+            runningContainer = await container.start();
+        },
+        stop: async () => {
+            if (runningContainer !== undefined) {
+                await runningContainer.stop();
+                console.log(`Verdaccio container stopped: ${alias ?? 'npm-registry'}`);
+            }
+        },
+    };
+};

package/runners/postgres.d.ts

@@ -0,0 +1,8 @@
+import type { Runner } from '@bobcats-coding/skid/test/type.js';
+import type { StartedNetwork } from 'testcontainers';
+export type PostgresRunnerConfig = {
+    port: number;
+    environment?: Record<string, string>;
+    network?: StartedNetwork;
+};
+export declare const postgresRunner: ({ port, environment, network, }: PostgresRunnerConfig) => Runner;

package/runners/postgres.js

@@ -0,0 +1,37 @@
+import { PostgreSqlContainer } from '@testcontainers/postgresql';
+import { Wait } from 'testcontainers';
+export const postgresRunner = ({ port, environment = {}, network, }) => {
+    let runningContainer;
+    const container = new PostgreSqlContainer()
+        .withEnvironment(environment)
+        .withExposedPorts({
+        container: port,
+        host: port,
+    })
+        .withLogConsumer((stream) => {
+        stream.on('data', (line) => {
+            console.log(line);
+        });
+        stream.on('err', (line) => {
+            console.error(line);
+        });
+        stream.on('end', () => {
+            console.log('Container closed');
+        });
+    })
+        .withWaitStrategy(Wait.forListeningPorts().withStartupTimeout(300000));
+    if (network !== undefined) {
+        container.withNetwork(network).withNetworkAliases('postgres');
+    }
+    return {
+        start: async () => {
+            runningContainer = await container.start();
+        },
+        stop: async () => {
+            if (runningContainer !== undefined) {
+                await runningContainer.stop();
+                console.log('Container stopped');
+            }
+        },
+    };
+};

package/test-environment.d.ts

@@ -0,0 +1,17 @@
+import type { DefaultConfig, Interactor, ReportEntry, Runner, ServiceConfig } from './type.ts';
+import type { TestEnvironmentWorld } from './world.ts';
+import type { Observable } from 'rxjs';
+export type TestEnviornment<SERVICES extends Record<string, ServiceConfig>> = {
+    onBeforeAll: () => Promise<Observable<ReportEntry>>;
+    onAfterAll: () => Promise<Observable<ReportEntry>>;
+    onBefore: (world: TestEnvironmentWorld<SERVICES>) => Promise<Observable<ReportEntry>>;
+    onAfter: (world: TestEnvironmentWorld<SERVICES>) => Promise<Observable<ReportEntry>>;
+    onFailure: (world: TestEnvironmentWorld<SERVICES>, testName: string) => Promise<ReportEntry[]>;
+    createWorld: () => TestEnvironmentWorld<SERVICES>;
+};
+export declare const instantiateService: <ARGS extends unknown[], INSTANCE extends Interactor | Runner>({ creator, hook }: {
+    creator: (...args: ARGS) => INSTANCE | Promise<INSTANCE>;
+} & DefaultConfig, ...args: ARGS) => Promise<{
+    instance: INSTANCE;
+} & DefaultConfig>;
+export declare const createTestEnvironment: <const SERVICES extends Record<string, ServiceConfig>>(serviceConfigs: SERVICES) => TestEnviornment<SERVICES>;

package/test-environment.js

@@ -0,0 +1,100 @@
+import { isInteractorName, isRunnerName } from './guards.js';
+import { createWorld } from './world.js';
+import { map, merge, ReplaySubject } from 'rxjs';
+export const instantiateService = async ({ creator, hook }, ...args) => {
+    return {
+        instance: await creator(...args),
+        ...(hook === undefined ? {} : { hook }),
+    };
+};
+export const createTestEnvironment = (serviceConfigs) => {
+    const state = {
+        serviceConfigs,
+        interactors: new Map(),
+        runners: new Map(),
+    };
+    const isBeforeAll = ({ hook }) => hook === 'before-all';
+    const isNotBeforeAll = ({ hook }) => hook !== 'before-all';
+    const isBefore = ({ hook }) => hook === 'before';
+    const keyValueToObject = ([name, service]) => ({
+        name,
+        ...service,
+    });
+    const asyncTransform = async (iterable, transform) => await Promise.all(transform([...iterable]));
+    // The two maps are keyed by different subsets of the service names, so iterating them
+    // separately keeps each key correlated with its own instance type; merging them first
+    // collapses both to a union and loses that.
+    const forEachService = async ({ hasHook, mapper, }) => {
+        await Promise.all([
+            ...[...state.runners.entries()].map(keyValueToObject).filter(hasHook).map(mapper),
+            ...[...state.interactors.entries()].map(keyValueToObject).filter(hasHook).map(mapper),
+        ]);
+    };
+    const forEachBeforeAllService = async (mapper) => await forEachService({ hasHook: isBeforeAll, mapper });
+    const forEachScenarioService = async (mapper) => await forEachService({ hasHook: isNotBeforeAll, mapper });
+    const forEachBeforeService = async (mapper) => {
+        await asyncTransform([...state.interactors.values(), ...state.runners.values()], (list) => list.filter(isBefore).map(mapper));
+    };
+    const mapInteractors = async (mapper) => await asyncTransform(state.interactors.entries(), (list) => list.map(async ([name, interactor]) => await mapper({ name, ...interactor })));
+    const instantiateAll = async (filter) => {
+        await Promise.all(Object.entries(serviceConfigs)
+            .filter(([_, config]) => filter(config))
+            .map(async ([key, service]) => {
+            if (service.type === 'interactor' && isInteractorName(serviceConfigs, key)) {
+                state.interactors.set(key, await instantiateService(service));
+            }
+            if (service.type === 'runner' && isRunnerName(serviceConfigs, key)) {
+                state.runners.set(key, await instantiateService(service));
+            }
+        }));
+    };
+    return {
+        onBeforeAll: async () => {
+            const entries$ = new ReplaySubject();
+            await instantiateAll(isBeforeAll);
+            await forEachBeforeAllService(async ({ instance, name }) => {
+                await instance.start();
+                const message = `${name}: Started in before-all`;
+                entries$.next({ entry: message, type: 'text/plain' });
+                console.log(message);
+            });
+            return entries$.asObservable();
+        },
+        onAfterAll: async () => {
+            const entries$ = new ReplaySubject();
+            await forEachBeforeAllService(async ({ instance, name }) => {
+                await instance.stop();
+                const message = `${name}: Stopped in after-all`;
+                entries$.next({ entry: message, type: 'text/plain' });
+                console.log(message);
+            });
+            return entries$.asObservable();
+        },
+        onBefore: async (world) => {
+            await instantiateAll(isBefore);
+            await forEachBeforeService(async ({ instance }) => {
+                await instance.start();
+            });
+            const reportEntries = await mapInteractors(async ({ name, instance }) => {
+                const { context, reportEntry$ } = await instance.startContext();
+                world.register(name, context);
+                return reportEntry$.pipe(map(({ entry, type }) => type === 'text/plain' ? { type, entry: `${String(name)}: ${entry}` } : { type, entry }));
+            });
+            return merge(...reportEntries);
+        },
+        onAfter: async () => {
+            const entries$ = new ReplaySubject();
+            await mapInteractors(async ({ instance }) => {
+                await instance.stopContext();
+            });
+            await forEachScenarioService(async ({ instance, name }) => {
+                await instance.stop();
+                const message = `${name}: Stopped in after`;
+                entries$.next({ entry: message, type: 'text/plain' });
+            });
+            return entries$.asObservable();
+        },
+        onFailure: async (_world, testName) => await mapInteractors(async ({ instance }) => await instance.onFailure(testName)),
+        createWorld: () => createWorld(state),
+    };
+};

package/test-environment.test.d.ts

@@ -0,0 +1 @@
+export {};

package/test-environment.test.js

@@ -0,0 +1,442 @@
+import { createTestEnvironment } from './test-environment.js';
+import { of } from 'rxjs';
+import { expect, test } from 'vitest';
+test('onBeforeAll hook starts the runners', async () => {
+    const { state: state1, creator: creator1 } = setupFakeRunner();
+    const { state: state2, creator: creator2 } = setupFakeRunner();
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'runner', creator: creator1, hook: 'before-all' },
+        service2: { type: 'runner', creator: creator2, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    expect(state1.isStarted).toBe(true);
+    expect(state2.isStarted).toBe(true);
+});
+test('onBeforeAll hook starts the interactors', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before-all' },
+        service2: { type: 'interactor', creator: creator2, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    expect(state1.isStarted).toBe(true);
+    expect(state2.isStarted).toBe(true);
+});
+test('onAfterAll hook stops the runners', async () => {
+    const { state: state1, creator: creator1 } = setupFakeRunner();
+    const { state: state2, creator: creator2 } = setupFakeRunner();
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'runner', creator: creator1, hook: 'before-all' },
+        service2: { type: 'runner', creator: creator2, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    await testEnvironment.onAfterAll();
+    expect(state1.isStarted).toBe(false);
+    expect(state2.isStarted).toBe(false);
+});
+test('onAfterAll hook stops the interactors', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before-all' },
+        service2: { type: 'interactor', creator: creator2, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    await testEnvironment.onAfterAll();
+    expect(state1.isStarted).toBe(false);
+    expect(state2.isStarted).toBe(false);
+});
+test('onBefore hook starts the contexts', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before-all' },
+        service2: { type: 'interactor', creator: creator2, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    const world = testEnvironment.createWorld();
+    await testEnvironment.onBefore(world);
+    expect(state1.isContextStarted).toBe(true);
+    expect(state2.isContextStarted).toBe(true);
+    expect(world.get('service1')).toBe(1);
+    expect(world.get('service2')).toBe(2);
+});
+test('world keys should be typesafe', async () => {
+    const { creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { creator: creator2 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before-all' },
+        service2: { type: 'interactor', creator: creator2, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    const world = testEnvironment.createWorld();
+    await testEnvironment.onBefore(world);
+    // @ts-expect-error service3 is not in the configuration
+    expect(() => world.get('service3')).toThrow();
+    const a = world.get('service1');
+    expect(a).toBe(1);
+});
+test('onBefore hook starts the "before" services', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before' },
+        service2: { type: 'interactor', creator: creator2, hook: 'before-all' },
+    });
+    const world = testEnvironment.createWorld();
+    await testEnvironment.onBefore(world);
+    expect(state1.isStarted).toBe(true);
+    expect(state2.isStarted).toBe(false);
+});
+test('onBeforeAll hook only starts the "before-all" services', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before' },
+        service2: { type: 'interactor', creator: creator2, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    expect(state1.isStarted).toBe(false);
+    expect(state2.isStarted).toBe(true);
+});
+test('onAfter hook stops the "before" services', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeRunner();
+    const { state: state3, creator: creator3 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before' },
+        service2: { type: 'runner', creator: creator2, hook: 'before' },
+        service3: { type: 'interactor', creator: creator3, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    const world = testEnvironment.createWorld();
+    await testEnvironment.onBefore(world);
+    await testEnvironment.onAfter(world);
+    expect(state1.isStarted).toBe(false);
+    expect(state2.isStarted).toBe(false);
+    expect(state3.isStarted).toBe(true);
+});
+test('onAfterAll hook only stops the "before-all" services', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeRunner();
+    const { state: state3, creator: creator3 } = setupFakeInteractor({ context: 2 });
+    const { state: state4, creator: creator4 } = setupFakeRunner();
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before' },
+        service2: { type: 'runner', creator: creator2, hook: 'before' },
+        service3: { type: 'interactor', creator: creator3, hook: 'before-all' },
+        service4: { type: 'runner', creator: creator4, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    const world = testEnvironment.createWorld();
+    await testEnvironment.onBefore(world);
+    await testEnvironment.onAfterAll();
+    expect(state1.isStarted).toBe(true);
+    expect(state2.isStarted).toBe(true);
+    expect(state3.isStarted).toBe(false);
+    expect(state4.isStarted).toBe(false);
+});
+test('start service from the world', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeRunner();
+    const { state: state3, creator: creator3 } = setupFakeInteractor({ context: 3 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1 },
+        service2: { type: 'runner', creator: creator2 },
+        service3: { type: 'interactor', creator: creator3, hook: 'before-all' },
+    });
+    const world = testEnvironment.createWorld();
+    expect(state1.isStarted).toBe(false);
+    expect(state2.isStarted).toBe(false);
+    expect(state3.isStarted).toBe(false);
+    await world.start('service1');
+    await world.start('service2');
+    expect(state1.isStarted).toBe(true);
+    expect(state2.isStarted).toBe(true);
+    expect(state3.isStarted).toBe(false);
+});
+test('world should be able to get the started service', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1 },
+        service2: { type: 'interactor', creator: creator2, hook: 'before-all' },
+    });
+    const world = testEnvironment.createWorld();
+    expect(state1.isStarted).toBe(false);
+    expect(state2.isStarted).toBe(false);
+    await world.start('service1');
+    const context = world.get('service1');
+    expect(context).toBe(1);
+});
+test('world should be able to pass params when starts a service', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeRunner();
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1 },
+        service2: { type: 'runner', creator: creator2 },
+    });
+    const world = testEnvironment.createWorld();
+    await world.start('service1', 2);
+    await world.start('service2', 3);
+    expect(state1.startArg).toBe(2);
+    expect(state2.startArg).toBe(3);
+});
+test('should not start non hook services', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeRunner();
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1 },
+        service2: { type: 'runner', creator: creator2 },
+    });
+    const world = testEnvironment.createWorld();
+    await testEnvironment.onBeforeAll();
+    await testEnvironment.onBefore(world);
+    expect(state1.isStarted).toBe(false);
+    expect(state2.isStarted).toBe(false);
+});
+test('onAfter stops services started from the world', async () => {
+    const { state: state1, creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { state: state2, creator: creator2 } = setupFakeRunner();
+    const { state: state3, creator: creator3 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1 },
+        service2: { type: 'runner', creator: creator2 },
+        service3: { type: 'interactor', creator: creator3, hook: 'before-all' },
+    });
+    const world = testEnvironment.createWorld();
+    await testEnvironment.onBefore(world);
+    await world.start('service1');
+    await world.start('service2');
+    await testEnvironment.onAfter(world);
+    expect(state1.isStarted).toBe(false);
+    expect(state2.isStarted).toBe(false);
+    expect(state3.isStarted).toBe(false);
+});
+test('start should be type-safe', async () => {
+    const { creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { creator: creator2 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1 },
+        service2: { type: 'interactor', creator: creator2, hook: 'before-all' },
+    });
+    const world = testEnvironment.createWorld();
+    await expect(async () => {
+        // @ts-expect-error service3 is not in the configuration
+        await world.start('service3');
+    }).rejects.toThrow('Service "service3" is not in the configuration');
+});
+test('start is typesafe', async () => {
+    const { creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { creator: creator2 } = setupFakeInteractor({ context: 2 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1 },
+        service2: { type: 'interactor', creator: creator2, hook: 'before-all' },
+    });
+    const world = testEnvironment.createWorld();
+    await expect(async () => {
+        // @ts-expect-error service3 is not in the configuration
+        await world.start('service3');
+    }).rejects.toThrow('Service "service3" is not in the configuration');
+});
+test('start context shows its log entries', async () => {
+    const { creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { creator: creator2 } = setupFakeRunner();
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before' },
+        service2: { type: 'runner', creator: creator2, hook: 'before' },
+    });
+    const world = testEnvironment.createWorld();
+    const entries$ = await testEnvironment.onBefore(world);
+    const messages = new Set();
+    entries$.subscribe(({ entry }) => {
+        messages.add(entry);
+    });
+    expect(messages).toEqual(new Set(['service1: Coming from context start']));
+});
+test('onBeforeAll should log the started services', async () => {
+    const { creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { creator: creator2 } = setupFakeRunner();
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before-all' },
+        service2: { type: 'runner', creator: creator2, hook: 'before-all' },
+    });
+    const entries$ = await testEnvironment.onBeforeAll();
+    const messages = new Set();
+    entries$.subscribe(({ entry }) => {
+        messages.add(entry);
+    });
+    expect(messages).toEqual(new Set(['service1: Started in before-all', 'service2: Started in before-all']));
+});
+test('onAfterAll should log the stopped services', async () => {
+    const { creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { creator: creator2 } = setupFakeRunner();
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before-all' },
+        service2: { type: 'runner', creator: creator2, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    const entries$ = await testEnvironment.onAfterAll();
+    const messages = new Set();
+    entries$.subscribe(({ entry }) => {
+        messages.add(entry);
+    });
+    expect(messages).toEqual(new Set(['service1: Stopped in after-all', 'service2: Stopped in after-all']));
+});
+test('onAfter should log the stopped services', async () => {
+    const { creator: creator1 } = setupFakeInteractor({ context: 1 });
+    const { creator: creator2 } = setupFakeRunner();
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'interactor', creator: creator1, hook: 'before' },
+        service2: { type: 'runner', creator: creator2, hook: 'before' },
+    });
+    const world = testEnvironment.createWorld();
+    await testEnvironment.onBefore(world);
+    const entries$ = await testEnvironment.onAfter(world);
+    const messages = new Set();
+    entries$.subscribe(({ entry }) => {
+        messages.add(entry);
+    });
+    expect(messages).toEqual(new Set(['service1: Stopped in after', 'service2: Stopped in after']));
+});
+test('it should handle an async creator', async () => {
+    const { creator: creator1, state: state1 } = setupFakeAsyncRunner();
+    const { creator: creator2, state: state2 } = setupFakeAsyncInteractor({ context: 1 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'runner', creator: creator1 },
+        service2: { type: 'interactor', creator: creator2 },
+    });
+    const world = testEnvironment.createWorld();
+    await world.start('service1');
+    await world.start('service2');
+    expect(state1.isStarted).toBe(true);
+    expect(state2.isStarted).toBe(true);
+});
+test('it should handle an async creator', async () => {
+    const { creator: creator1, state: state1 } = setupFakeAsyncRunner();
+    const { creator: creator2, state: state2 } = setupFakeAsyncInteractor({ context: 1 });
+    const testEnvironment = createTestEnvironment({
+        service1: { type: 'runner', creator: creator1, hook: 'before-all' },
+        service2: { type: 'interactor', creator: creator2, hook: 'before-all' },
+    });
+    await testEnvironment.onBeforeAll();
+    expect(state1.isStarted).toBe(true);
+    expect(state2.isStarted).toBe(true);
+});
+const setupFakeInteractor = ({ context, isContextStarted, }) => {
+    const state = {
+        isStarted: false,
+        isContextStarted: isContextStarted ?? false,
+        startArg: undefined,
+    };
+    const creator = (arg) => ({
+        start: async () => {
+            state.isStarted = true;
+            state.startArg = arg;
+        },
+        stop: async () => {
+            state.isStarted = false;
+        },
+        startContext: async () => {
+            state.isContextStarted = true;
+            return {
+                context,
+                reportEntry$: of({
+                    entry: 'Coming from context start',
+                    type: 'text/plain',
+                }),
+            };
+        },
+        stopContext: async () => {
+            state.isContextStarted = false;
+        },
+        onFailure: async (name) => {
+            return {
+                entry: `Failure in context ${String(context)} for test ${name}`,
+                type: 'text/plain',
+            };
+        },
+    });
+    return {
+        state,
+        creator,
+    };
+};
+const setupFakeAsyncInteractor = ({ context, isContextStarted, }) => {
+    const state = {
+        isStarted: false,
+        isContextStarted: isContextStarted ?? false,
+        startArg: undefined,
+    };
+    const creator = async (arg) => ({
+        start: async () => {
+            state.isStarted = true;
+            state.startArg = arg;
+        },
+        stop: async () => {
+            state.isStarted = false;
+        },
+        startContext: async () => {
+            state.isContextStarted = true;
+            return {
+                context,
+                reportEntry$: of({
+                    entry: 'Coming from context start',
+                    type: 'text/plain',
+                }),
+            };
+        },
+        stopContext: async () => {
+            state.isContextStarted = false;
+        },
+        onFailure: async (name) => {
+            return {
+                entry: `Failure in context ${String(context)} for test ${name}`,
+                type: 'text/plain',
+            };
+        },
+    });
+    return {
+        state,
+        creator,
+    };
+};
+const setupFakeRunner = () => {
+    const state = {
+        isStarted: false,
+        startArg: undefined,
+    };
+    const creator = (arg) => ({
+        start: async () => {
+            state.isStarted = true;
+            state.startArg = arg;
+        },
+        stop: async () => {
+            state.isStarted = false;
+        },
+    });
+    return {
+        state,
+        creator,
+    };
+};
+const setupFakeAsyncRunner = () => {
+    const state = {
+        isStarted: false,
+        startArg: undefined,
+    };
+    const creator = async (arg) => ({
+        start: async () => {
+            state.isStarted = true;
+            state.startArg = arg;
+        },
+        stop: async () => {
+            state.isStarted = false;
+        },
+    });
+    return {
+        state,
+        creator,
+    };
+};

package/type.d.ts

@@ -0,0 +1,50 @@
+import type { EntryTuple, FilterRecord, GetKey, RecordToEntries } from '@dungarees/core/type-util.ts';
+import type { Observable } from 'rxjs';
+export type Runner = {
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+};
+export type Interactor<CONTEXT = unknown> = {
+    startContext: () => Promise<{
+        context: CONTEXT;
+        reportEntry$: Observable<ReportEntry>;
+    }>;
+    stopContext: () => Promise<void>;
+    onFailure: (testName: string) => Promise<ReportEntry>;
+} & Runner;
+export type InstanceEntry<NAME extends string = string, INSTANCE extends Interactor | Runner = Interactor | Runner> = EntryTuple<NAME, INSTANCE>;
+export type ConfigEntry<NAME extends string = string, CONFIG extends ServiceConfig = ServiceConfig> = EntryTuple<NAME, CONFIG>;
+export type ServiceConfig = InteractorConfig | RunnerConfig;
+export type TestEnviornmentConfig = Record<string, ServiceConfig>;
+export type GetInstance<CONFIG extends ServiceConfig> = Awaited<ReturnType<CONFIG['creator']>>;
+export type GetInstanceEntry<CONFIG extends ConfigEntry> = CONFIG extends ConfigEntry<infer N, infer C> ? InstanceEntry<N, GetInstance<C>> : never;
+export type GetContext<INTERACTOR extends Interactor | Runner> = INTERACTOR extends Interactor<infer CONTEXT> ? CONTEXT : never;
+export type ReportEntry = {
+    entry: string;
+    type: 'text/plain';
+} | {
+    entry: Buffer;
+    type: 'image/png';
+};
+export type DefaultConfig = {
+    hook?: 'before-all' | 'before';
+};
+export type RunnerConfig<RUNNER extends Runner = Runner, ARGS extends never[] = never[]> = {
+    type: 'runner';
+    creator: (...args: ARGS) => RUNNER | Promise<RUNNER>;
+} & DefaultConfig;
+export type InteractorConfig<INTERACTOR extends Interactor = Interactor, ARGS extends never[] = never[]> = {
+    type: 'interactor';
+    creator: (...args: ARGS) => INTERACTOR | Promise<INTERACTOR>;
+} & DefaultConfig;
+export type RunnerInstance = {
+    instance: Runner;
+} & DefaultConfig;
+export type InteractorInstance = {
+    instance: Interactor;
+} & DefaultConfig;
+export type TestEnviornmentState<SERVICES extends Record<string, ServiceConfig>, INTERACTORS extends InstanceEntry = GetInstanceEntry<RecordToEntries<FilterRecord<SERVICES, InteractorConfig>>>, RUNNERS extends InstanceEntry = GetInstanceEntry<RecordToEntries<FilterRecord<SERVICES, RunnerConfig>>>> = {
+    serviceConfigs: SERVICES;
+    interactors: Map<GetKey<INTERACTORS>, InteractorInstance>;
+    runners: Map<GetKey<RUNNERS>, RunnerInstance>;
+};

package/type.js

@@ -0,0 +1 @@
+export {};

package/world.d.ts

@@ -0,0 +1,8 @@
+import type { ConfigEntry, GetContext, GetInstance, InteractorConfig, ServiceConfig, TestEnviornmentState } from './type.ts';
+import type { FilterRecord, GetKey, GetValueByKey, RecordToEntries } from '@dungarees/core/type-util.ts';
+export type TestEnvironmentWorld<SERVICES extends Record<string, ServiceConfig>, INTERACTORS extends ConfigEntry = RecordToEntries<FilterRecord<SERVICES, InteractorConfig>>, SERVICE_NAMES extends GetKey<RecordToEntries<SERVICES>> = GetKey<RecordToEntries<SERVICES>>> = {
+    get: <NAME extends GetKey<INTERACTORS>>(name: NAME) => GetContext<GetInstance<GetValueByKey<INTERACTORS, NAME>>>;
+    register: (name: GetKey<INTERACTORS>, context: unknown) => void;
+    start: (name: SERVICE_NAMES, ...args: Parameters<SERVICES[SERVICE_NAMES]['creator']>) => Promise<void>;
+};
+export declare const createWorld: <SERVICES extends Record<string, ServiceConfig>>(state: TestEnviornmentState<SERVICES>) => TestEnvironmentWorld<SERVICES>;

package/world.js

@@ -0,0 +1,35 @@
+import { isInteractorName, isRunnerName } from './guards.js';
+import { instantiateService } from './test-environment.js';
+import { assertDefined, assertTypeByGuard } from '@dungarees/core/util.ts';
+export const createWorld = (state) => {
+    const interactorContexts = new Map();
+    const get = (name) => assertTypeByGuard({
+        value: interactorContexts.get(name),
+        guard: (context) => context !== undefined,
+        message: `Interactor "${String(name)}" is not registered`,
+    });
+    const start = async (name, ...arg) => {
+        const service = assertDefined(state.serviceConfigs[name], `Service "${String(name)}" is not in the configuration`);
+        if (service.type === 'interactor' && isInteractorName(state.serviceConfigs, name)) {
+            const instantiatedService = await instantiateService(service, ...arg);
+            await instantiatedService.instance.start();
+            const { context } = await instantiatedService.instance.startContext();
+            register(name, context);
+            state.interactors.set(name, instantiatedService);
+        }
+        if (service.type === 'runner' && isRunnerName(state.serviceConfigs, name)) {
+            const instantiatedService = await instantiateService(service, ...arg);
+            await instantiatedService.instance.start();
+            state.runners.set(name, instantiatedService);
+        }
+        console.log(`${name}: Started in step`);
+    };
+    const register = (name, context) => {
+        interactorContexts.set(name, context);
+    };
+    return {
+        get,
+        start,
+        register,
+    };
+};