@verdeect/kit 0.0.0-stage → 1.0.0-rc.2

package/dist/testing/repo-files.js

@@ -0,0 +1,401 @@
+// Чтение файлов репозитория сервиса для assertRepoConventions (prd.md §3.8, AC-1.8): compose, env_file, CI, Dockerfile,
+// package.json, src/redaction.ts. Разбор compose — эталон O test/support/compose-env.spec.ts (yaml, merge, !reset);
+// образы в тексте CI — эталон BFF test/image-tags.spec.ts (тег по regex, адреса вида postgres:5432 — не образ).
+// Всё синхронно; пути в результатах — относительно root, через `/`.
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, posix, relative, sep } from 'node:path';
+import { parse, Scalar, YAMLMap, YAMLSeq } from 'yaml';
+/** Значение `!reset` Compose: ключ сброшен к умолчанию, значение базового файла не наследуется. */
+export const RESET = Symbol('compose !reset');
+const COMPOSE_FILE = /^(docker-)?compose(\.[\w-]+)*\.ya?ml$/;
+const DOCKERFILE = /^Dockerfile(\.[\w-]+)?$/;
+const WORKFLOW_FILE = /\.ya?ml$/;
+/**
+ * Предел раскрытий алиасов YAML на файл compose. Умолчание yaml (100) меньше реальных файлов с x-* якорями и `<<:`
+ * (verdeect-orchestrator compose.e2e.yml); предел конечный: файл сверх него — ошибка разбора с именем файла, а не
+ * зависание на «бомбе алиасов».
+ */
+const MAX_ALIAS_COUNT = 1000;
+/** Метки тегов Compose в результате разбора yaml (строки: yaml оборачивает их в скаляр). */
+const RESET_MARK = '\u0000kit:reset';
+const OVERRIDE_MARK = '\u0000kit:override';
+// Теги Compose: !reset — сброс значения к умолчанию, !override — замена значения базового файла вместо слияния.
+const CUSTOM_TAGS = [
+    { tag: '!reset', resolve: () => RESET_MARK },
+    { tag: '!reset', collection: 'map', nodeClass: YAMLMap, resolve: () => new Scalar(RESET_MARK) },
+    { tag: '!reset', collection: 'seq', nodeClass: YAMLSeq, resolve: () => new Scalar(RESET_MARK) },
+    { tag: '!override', resolve: (value) => value },
+    {
+        tag: '!override',
+        collection: 'map',
+        nodeClass: YAMLMap,
+        resolve: (map) => {
+            if (map instanceof YAMLMap) {
+                map.set(OVERRIDE_MARK, true);
+            }
+            return map;
+        },
+    },
+    {
+        tag: '!override',
+        collection: 'seq',
+        nodeClass: YAMLSeq,
+        resolve: (seq) => {
+            if (seq instanceof YAMLSeq) {
+                seq.add(OVERRIDE_MARK);
+            }
+            return seq;
+        },
+    },
+];
+function toPosix(path) {
+    return path.split(sep).join(posix.sep);
+}
+function rel(root, path) {
+    return toPosix(relative(root, path));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function listFiles(dir, pattern) {
+    if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+        return [];
+    }
+    return readdirSync(dir)
+        .filter((name) => pattern.test(name) && statSync(join(dir, name)).isFile())
+        .sort()
+        .map((name) => join(dir, name));
+}
+function listDirs(dir) {
+    if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+        return [];
+    }
+    return readdirSync(dir)
+        .filter((name) => statSync(join(dir, name)).isDirectory())
+        .sort()
+        .map((name) => join(dir, name));
+}
+function parseFailure(root, file, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return new Error(`assertRepoConventions: не удалось разобрать ${rel(root, file)}: ${message}`, {
+        cause: error,
+    });
+}
+/** Интерполяции `${VAR:-default}` и `${VAR-default}` → `default`; `${VAR}` без умолчания не меняется. */
+export function expandDefaults(text) {
+    return text.replace(/\$\{[A-Za-z_][A-Za-z0-9_]*:?-([^}]*)\}/g, '$1');
+}
+/**
+ * Разбор env-файла: `KEY=VALUE`, комментарии `#` и пустые строки пропускаются, `export ` и кавычки снимаются; у
+ * значения без кавычек снимается ` #…` (как в Compose).
+ */
+export function parseEnvFile(text) {
+    const env = new Map();
+    for (const source of text.split(/\r?\n/)) {
+        const line = source.trim().replace(/^export\s+/, '');
+        if (line === '' || line.startsWith('#')) {
+            continue;
+        }
+        const eq = line.indexOf('=');
+        if (eq === -1) {
+            continue;
+        }
+        const key = line.slice(0, eq).trim();
+        const raw = line.slice(eq + 1).trim();
+        // Как Compose: значение в кавычках — до парной кавычки (` #…` после неё — комментарий); у значения без
+        // кавычек ` #…` — комментарий.
+        const quoted = /^(['"])(.*?)\1(?:\s+#.*)?$/.exec(raw);
+        env.set(key, quoted === null ? raw.replace(/\s+#.*$/, '') : (quoted[2] ?? ''));
+    }
+    return env;
+}
+const DOCKER_HUB_PREFIXES = ['docker.io/library/', 'docker.io/'];
+/**
+ * Значение `image:` как ссылка на образ: подстановка `${VAR:-default}`, снятие префикса Docker Hub, отдельно
+ * дайджест `@sha256:…`; тег — после последнего `:` за последним `/` (порт реестра — не тег), без тега — `latest`.
+ */
+export function parseImageRef(image) {
+    let name = expandDefaults(image).trim();
+    const at = name.indexOf('@');
+    if (at !== -1) {
+        name = name.slice(0, at);
+    }
+    const prefix = DOCKER_HUB_PREFIXES.find((candidate) => name.startsWith(candidate));
+    if (prefix !== undefined) {
+        name = name.slice(prefix.length);
+    }
+    const colon = name.indexOf(':', name.lastIndexOf('/') + 1);
+    const repository = colon === -1 ? name : name.slice(0, colon);
+    const tag = colon === -1 ? 'latest' : name.slice(colon + 1);
+    return {
+        repository: repository === '' || repository.includes('$') ? null : repository,
+        tag,
+        tagUnresolved: tag.includes('$'),
+    };
+}
+/** Префикс Docker Hub в свободном тексте (`docker.io/library/`, `docker.io/`) — снимается, как в parseImageRef. */
+const DOCKER_HUB_PREFIX_IN_TEXT = /(?<![\w./@-])docker\.io\/(?:library\/)?/g;
+/**
+ * Образы репозитория `repository` в свободном тексте (CI): `<repo>:<тег>`; префикс Docker Hub снимается; тег
+ * учитывается, только если в нём есть точка или буква.
+ */
+export function imageTags(text, repository) {
+    const escaped = repository.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+    const pattern = new RegExp(`(?<![\\w./@-])${escaped}:([A-Za-z0-9][\\w.-]*)`, 'g');
+    const normalized = expandDefaults(text).replace(DOCKER_HUB_PREFIX_IN_TEXT, '');
+    return [...normalized.matchAll(pattern)]
+        .map((match) => match[1] ?? '')
+        .filter((tag) => /[.A-Za-z]/.test(tag));
+}
+function scalar(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return typeof value === 'string' ? value : String(value);
+}
+function environmentOf(value) {
+    const env = new Map();
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const text = String(item);
+            const eq = text.indexOf('=');
+            env.set(eq === -1 ? text : text.slice(0, eq), eq === -1 ? null : text.slice(eq + 1));
+        }
+    }
+    else if (isRecord(value)) {
+        for (const [key, item] of Object.entries(value)) {
+            env.set(key, scalar(item));
+        }
+    }
+    return env;
+}
+function envFilePaths(value) {
+    const items = Array.isArray(value)
+        ? value
+        : value === undefined || value === null
+            ? []
+            : [value];
+    return items.flatMap((item) => {
+        if (typeof item === 'string') {
+            return [item];
+        }
+        if (isRecord(item) && typeof item.path === 'string') {
+            return [item.path];
+        }
+        return [];
+    });
+}
+function isReset(value) {
+    return value === RESET_MARK;
+}
+function commandField(value) {
+    if (isReset(value)) {
+        return RESET;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    return Array.isArray(value) ? value.map(String) : undefined;
+}
+function scalarField(value) {
+    if (isReset(value)) {
+        return RESET;
+    }
+    return scalar(value) ?? undefined;
+}
+/** `build:` — строка (каталог контекста) или `{context, dockerfile, target}`; путь Dockerfile — от каталога compose. */
+function buildField(value, root, composeDir) {
+    if (isReset(value)) {
+        return RESET;
+    }
+    const spec = typeof value === 'string' ? { context: value } : isRecord(value) ? value : null;
+    if (spec === null) {
+        return undefined;
+    }
+    const context = typeof spec.context === 'string' ? spec.context : '.';
+    const dockerfile = typeof spec.dockerfile === 'string' ? spec.dockerfile : 'Dockerfile';
+    return {
+        dockerfile: rel(root, join(composeDir, context, dockerfile)),
+        target: typeof spec.target === 'string' ? spec.target : null,
+    };
+}
+function withoutMarks(value) {
+    if (Array.isArray(value)) {
+        return value.filter((item) => item !== OVERRIDE_MARK);
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).filter(([key]) => key !== OVERRIDE_MARK));
+    }
+    return value;
+}
+function hasOverrideMark(value) {
+    return Array.isArray(value)
+        ? value.includes(OVERRIDE_MARK)
+        : isRecord(value) && OVERRIDE_MARK in value;
+}
+function readComposeFile(root, path) {
+    let document;
+    try {
+        document = parse(readFileSync(path, 'utf8'), {
+            merge: true,
+            customTags: CUSTOM_TAGS,
+            maxAliasCount: MAX_ALIAS_COUNT,
+        });
+    }
+    catch (error) {
+        throw parseFailure(root, path, error);
+    }
+    const services = isRecord(document) && isRecord(document.services) ? document.services : {};
+    const file = rel(root, path);
+    return Object.entries(services).map(([name, raw]) => {
+        const service = isRecord(raw) ? raw : {};
+        const env = new Map();
+        const envSource = new Map();
+        if (!isReset(service.env_file)) {
+            for (const envFile of envFilePaths(withoutMarks(service.env_file))) {
+                const envPath = join(dirname(path), envFile);
+                if (!existsSync(envPath)) {
+                    continue;
+                }
+                for (const [key, value] of parseEnvFile(readFileSync(envPath, 'utf8'))) {
+                    env.set(key, value);
+                    envSource.set(key, rel(root, envPath));
+                }
+            }
+        }
+        if (!isReset(service.environment)) {
+            for (const [key, value] of environmentOf(withoutMarks(service.environment))) {
+                env.set(key, value);
+                envSource.set(key, file);
+            }
+        }
+        const envMode = isReset(service.environment) || isReset(service.env_file)
+            ? 'reset'
+            : hasOverrideMark(service.environment) || hasOverrideMark(service.env_file)
+                ? 'override'
+                : 'merge';
+        return {
+            file,
+            name,
+            image: scalar(service.image),
+            env,
+            envSource,
+            envMode,
+            stopGracePeriod: scalarField(service.stop_grace_period),
+            command: commandField(withoutMarks(service.command)),
+            entrypoint: commandField(withoutMarks(service.entrypoint)),
+            build: buildField(service.build, root, dirname(path)),
+        };
+    });
+}
+/** Exec-форма инструкции или null: невалидный JSON (`['node', …]`) Docker выполняет как shell-форму. */
+function execForm(body) {
+    if (!body.startsWith('[')) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(body);
+        return Array.isArray(parsed) ? parsed.map(String) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Стадии Dockerfile по правилам Docker: продолжение строки `\` (с пробелами и табуляцией до перевода строки),
+ * последние CMD/ENTRYPOINT стадии перекрывают предыдущие, `FROM <стадия>` наследует её ENTRYPOINT и CMD, ENTRYPOINT
+ * сбрасывает унаследованный CMD. CMD внутри HEALTHCHECK — не CMD стадии.
+ */
+function readDockerfile(root, path) {
+    const text = readFileSync(path, 'utf8').replace(/\\[ \t]*\r?\n/g, ' ');
+    const file = rel(root, path);
+    const stages = [];
+    for (const line of text.split(/\r?\n/)) {
+        const from = /^\s*FROM\s+(?:--\S+\s+)*(\S+)(?:\s+AS\s+(\S+))?/i.exec(line);
+        if (from !== null) {
+            const image = (from[1] ?? '').toLowerCase();
+            const parent = stages.find((stage) => stage.name === image);
+            stages.push({
+                name: from[2]?.toLowerCase() ?? null,
+                entrypoint: parent?.entrypoint ?? null,
+                cmd: parent?.cmd ?? null,
+                cmdInherited: parent?.cmd != null,
+            });
+            continue;
+        }
+        const stage = stages.at(-1);
+        const match = /^\s*(CMD|ENTRYPOINT)\s+(.*)$/i.exec(line);
+        if (stage === undefined || match === null) {
+            continue;
+        }
+        const body = (match[2] ?? '').trim();
+        const instruction = { exec: execForm(body), shell: body };
+        if ((match[1] ?? '').toUpperCase() === 'CMD') {
+            stage.cmd = instruction;
+            stage.cmdInherited = false;
+        }
+        else {
+            stage.entrypoint = instruction;
+            if (stage.cmdInherited) {
+                stage.cmd = null;
+                stage.cmdInherited = false;
+            }
+        }
+    }
+    return stages.map((stage, index) => ({
+        file,
+        name: stage.name,
+        last: index === stages.length - 1,
+        entrypoint: stage.entrypoint,
+        cmd: stage.cmd,
+    }));
+}
+function readManifest(root, path) {
+    let json;
+    try {
+        json = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (error) {
+        throw parseFailure(root, path, error);
+    }
+    const manifest = isRecord(json) ? json : {};
+    const dependencies = new Map();
+    for (const field of ['dependencies', 'devDependencies']) {
+        const section = manifest[field];
+        if (isRecord(section)) {
+            for (const [name, version] of Object.entries(section)) {
+                dependencies.set(name, String(version));
+            }
+        }
+    }
+    const scripts = isRecord(manifest.scripts) ? manifest.scripts : {};
+    return {
+        file: rel(root, path),
+        dependencies,
+        start: typeof scripts.start === 'string' ? scripts.start : null,
+    };
+}
+function readText(root, path) {
+    return { file: rel(root, path), text: readFileSync(path, 'utf8') };
+}
+function existing(paths) {
+    return paths.filter((path) => existsSync(path) && statSync(path).isFile());
+}
+/** Находит и разбирает файлы репозитория сервиса; отсутствующий каталог — пустой список. */
+export function readRepoFiles(root) {
+    const apps = listDirs(join(root, 'apps'));
+    const packages = listDirs(join(root, 'packages'));
+    const ciFiles = [
+        ...existing([join(root, '.gitlab-ci.yml')]),
+        ...listFiles(join(root, '.github', 'workflows'), WORKFLOW_FILE),
+    ];
+    return {
+        compose: listFiles(root, COMPOSE_FILE).flatMap((path) => readComposeFile(root, path)),
+        ci: ciFiles.map((path) => readText(root, path)),
+        docker: [root, ...apps]
+            .flatMap((dir) => listFiles(dir, DOCKERFILE))
+            .flatMap((path) => readDockerfile(root, path)),
+        manifests: existing([root, ...apps, ...packages].map((dir) => join(dir, 'package.json'))).map((path) => readManifest(root, path)),
+        redaction: existing([root, ...apps].map((dir) => join(dir, 'src', 'redaction.ts'))).map((path) => readText(root, path)),
+    };
+}

package/dist/testing/scratch-database.d.ts

@@ -0,0 +1,19 @@
+/** Пустая мигрированная БД теста (§3.8). */
+export interface KitScratchDatabase {
+    /** Имя БД `<svc>_s<8 hex>`. */
+    readonly name: string;
+    /** Роль приложения `<svc>_app`. */
+    readonly url: string;
+    /** Роль владельца `<svc>_owner`. */
+    readonly ownerUrl: string;
+    /** Суперпользователь. */
+    readonly adminUrl: string;
+    /** Удаляет БД (`WITH (FORCE)`); повторный вызов — без ошибки. */
+    readonly drop: () => Promise<void>;
+}
+/**
+ * Пустая мигрированная БД из шаблона `startTestStack` за доли секунды (AC-4.18); права ролей сервиса выданы. Тест
+ * сам вызывает `drop()` в `afterAll`/`afterEach`.
+ * @throws {Error} `startTestStack({postgres: true})` не запускался (нет `kitDatabaseTemplate`).
+ */
+export declare function createScratchDatabase(): Promise<KitScratchDatabase>;

package/dist/testing/scratch-database.js

@@ -0,0 +1,75 @@
+// createScratchDatabase (prd.md §3.8, AC-4.18, UC-14): CREATE DATABASE … TEMPLATE <svc>_template; адреса — из inject
+// (startTestStack). pg и vitest — loadPeer внутри функции: /testing импортируется без pg.
+import { randomBytes } from 'node:crypto';
+import { loadPeer } from '../internal/peer.js';
+import { quoteIdentifier } from '../internal/sql-identifier.js';
+/** Шаблон занят другим копированием (`CREATE DATABASE … TEMPLATE`). */
+const OBJECT_IN_USE = '55006';
+const MAX_ATTEMPTS = 5;
+const RETRY_STEP_MS = 50;
+function withDatabase(base, database) {
+    const url = new URL(base);
+    url.pathname = `/${database}`;
+    return url.toString();
+}
+async function withClient(pg, url, work) {
+    const client = new pg.Client({ connectionString: url });
+    client.on('error', () => undefined);
+    await client.connect();
+    try {
+        await work(client);
+    }
+    finally {
+        await client.end();
+    }
+}
+async function createFromTemplate(pg, url, sql) {
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            await withClient(pg, url, async (client) => {
+                await client.query(sql);
+            });
+            return;
+        }
+        catch (error) {
+            if (error.code !== OBJECT_IN_USE || attempt >= MAX_ATTEMPTS) {
+                throw error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, RETRY_STEP_MS * attempt));
+        }
+    }
+}
+function required(value) {
+    if (value === undefined) {
+        throw new Error('createScratchDatabase: startTestStack({postgres: true}) не запускался');
+    }
+    return value;
+}
+/**
+ * Пустая мигрированная БД из шаблона `startTestStack` за доли секунды (AC-4.18); права ролей сервиса выданы. Тест
+ * сам вызывает `drop()` в `afterAll`/`afterEach`.
+ * @throws {Error} `startTestStack({postgres: true})` не запускался (нет `kitDatabaseTemplate`).
+ */
+export async function createScratchDatabase() {
+    const { inject } = await loadPeer('vitest', 'testing');
+    const template = required(inject('kitDatabaseTemplate'));
+    const service = required(inject('kitDatabaseService'));
+    const postgresUrl = required(inject('kitPostgresUrl'));
+    const appUrl = required(inject('kitDatabaseUrl'));
+    const ownerUrl = required(inject('kitDatabaseOwnerUrl'));
+    const adminUrl = required(inject('kitDatabaseAdminUrl'));
+    const pg = (await loadPeer('pg', 'testing')).default;
+    const { grantDatabaseAccess } = await import('../database/prepare-database.js');
+    const name = `${service}_s${randomBytes(4).toString('hex')}`;
+    await createFromTemplate(pg, postgresUrl, `CREATE DATABASE ${quoteIdentifier(name)} TEMPLATE ${quoteIdentifier(template)}`);
+    await withClient(pg, postgresUrl, (client) => grantDatabaseAccess(client, service, name));
+    return {
+        name,
+        url: withDatabase(appUrl, name),
+        ownerUrl: withDatabase(ownerUrl, name),
+        adminUrl: withDatabase(adminUrl, name),
+        drop: () => withClient(pg, postgresUrl, async (client) => {
+            await client.query(`DROP DATABASE IF EXISTS ${quoteIdentifier(name)} WITH (FORCE)`);
+        }),
+    };
+}

package/dist/testing/start-test-stack.d.ts

@@ -0,0 +1,85 @@
+import type { TestProject } from 'vitest/node';
+import type { KitEvent } from '../messaging/define-event.js';
+import { type KitRabbitWorker } from './rabbitmq-admin.js';
+/** Параметры startTestStack в E1 (§3.8). */
+export interface TestStackOptions {
+    /** Имя экземпляра сервиса (^[a-z][a-z0-9-]{1,31}$); метка verdeect.kit.service контейнеров. */
+    readonly service: string;
+    /** PostgreSQL TEST_IMAGES.postgres, суперпользователь — kitPostgresUrl; с E4 — prepareDatabase и шаблон БД. */
+    readonly postgres?: boolean;
+    /**
+     * Папка миграций drizzle-kit относительно `process.cwd()`: применяется к шаблону под ролью `<svc>_owner`, журнал —
+     * `<svc>.__migrations`; без `postgres: true` — `TypeError` при вызове `startTestStack`.
+     */
+    readonly migrations?: string;
+    /** mailpit — kitSmtpUrl, kitMailpitUrl. */
+    readonly mailpit?: boolean;
+    /** MinIO — kitS3Endpoint, kitS3AccessKey, kitS3SecretKey. */
+    readonly minio?: boolean;
+    /**
+     * RabbitMQ TEST_IMAGES.rabbitmq: definitions.json сервиса (как `verdeect-kit rabbitmq definitions`), vhost и
+     * пользователь на воркер; адреса — kitRabbitmqUrl, kitRabbitmqManagementUrl, kitRabbitmqWorkers. Teardown удаляет
+     * vhost и пользователей с префиксом `<svc>-test-` (AC-5.18).
+     */
+    readonly rabbitmq?: boolean;
+    /**
+     * Redis TEST_IMAGES.redis с aclfile (тот же генератор, что `verdeect-kit redis acl`): пользователь сервиса
+     * `~<svc>:* &<svc>:*` — kitRedisUrl, администратор теста — kitRedisAdminUrl, имя сервиса — kitRedisService. Пользователей
+     * на воркер нет: префикс воркера `<svc>:w<N>:` лежит внутри прав сервиса (AC-8.5).
+     */
+    readonly redis?: boolean;
+    /**
+     * События, которые публикует сервис: каталог покрытия прогона (`kitOutboxCoverageDir`); при `KIT_OUTBOX_COVERAGE=1`
+     * teardown падает со списком событий без успешного `expectOutbox` (GAP-2, AC-5.13).
+     */
+    readonly outboxEvents?: readonly KitEvent[];
+}
+declare module 'vitest' {
+    interface ProvidedContext {
+        /** postgres://postgres:<пароль>@<host>:<port>/postgres — суперпользователь (флаг postgres). */
+        readonly kitPostgresUrl?: string;
+        /** Роль `<svc>_app` к БД `<svc>` — значение `DATABASE_URL` тестов (флаг postgres). */
+        readonly kitDatabaseUrl?: string;
+        /** Роль `<svc>_owner` к БД `<svc>` — `DATABASE_MIGRATOR_URL` (флаг postgres). */
+        readonly kitDatabaseOwnerUrl?: string;
+        /** Суперпользователь к БД `<svc>` (флаг postgres). */
+        readonly kitDatabaseAdminUrl?: string;
+        /** Имя сервиса: схема и роли БД (флаг postgres). */
+        readonly kitDatabaseService?: string;
+        /** Шаблонная БД `<svc>_template` для `createScratchDatabase` (флаг postgres). */
+        readonly kitDatabaseTemplate?: string;
+        /** smtp://<host>:<port 1025> (флаг mailpit). */
+        readonly kitSmtpUrl?: string;
+        /** http://<host>:<port 8025> — HTTP API mailpit (флаг mailpit). */
+        readonly kitMailpitUrl?: string;
+        /** http://<host>:<port 9000> (флаг minio). */
+        readonly kitS3Endpoint?: string;
+        /** Пользователь MinIO (флаг minio). */
+        readonly kitS3AccessKey?: string;
+        /** Пароль MinIO, случайный на прогон (флаг minio). */
+        readonly kitS3SecretKey?: string;
+        /** amqp://<администратор>:<пароль>@<host>:<port> — vhost `/`, полные права (флаг rabbitmq). */
+        readonly kitRabbitmqUrl?: string;
+        /** http://<host>:<port 15672> — management API без учётных данных (флаг rabbitmq). */
+        readonly kitRabbitmqManagementUrl?: string;
+        /**
+         * vhost воркеров: индекс — `VITEST_POOL_ID − 1`; `url` — пользователь воркера с правами M3 сервиса, `adminUrl` —
+         * администратор того же vhost (флаг rabbitmq).
+         */
+        readonly kitRabbitmqWorkers?: readonly KitRabbitWorker[];
+        /** redis://<svc>:<пароль>@<host>:<port> — пользователь сервиса из aclfile, `REDIS_URL` тестов (флаг redis). */
+        readonly kitRedisUrl?: string;
+        /** redis://kit-test-admin:<пароль>@<host>:<port> — администратор теста: CLIENT LIST, ACL LOG, очистка (флаг redis). */
+        readonly kitRedisAdminUrl?: string;
+        /** Имя сервиса — пользователь Redis и префикс `workerScope().redisPrefix` (флаг redis). */
+        readonly kitRedisService?: string;
+        /** Каталог покрытия outbox прогона: файлы воркеров `w<N>.txt` (флаг outboxEvents). */
+        readonly kitOutboxCoverageDir?: string;
+    }
+}
+/** Число воркеров прогона: `maxWorkers` проектов (число ≥ 1), иначе `os.availableParallelism()`. */
+export declare function maxWorkersOf(configs: readonly {
+    readonly maxWorkers?: unknown;
+}[]): number;
+/** globalSetup Vitest: `export default startTestStack({...})`; teardown останавливает контейнеры (§3.8). */
+export declare function startTestStack(options: TestStackOptions): (project: TestProject) => Promise<() => Promise<void>>;