@gfdelarue/testkit 0.4.5 → 0.6.0

package/dist/config/loader/database-materialization.d.ts

@@ -1,19 +0,0 @@
-export interface DatabaseMaterializationInput {
-    image?: string;
-    maxConnections?: number;
-    password?: string;
-    reservedConnections?: number;
-    runtimeConnections?: number;
-    user?: string;
-}
-export interface MaterializedDatabaseDefaults {
-    image: string;
-    maxConnections: number;
-    password: string;
-    reservedConnections: number;
-    runtimeConnections: number;
-    user: string;
-}
-export type MaterializedDatabaseConfig<T extends object = DatabaseMaterializationInput> = Omit<T, keyof DatabaseMaterializationInput> & MaterializedDatabaseDefaults;
-export declare function materializeDatabaseConfig<T extends object>(database: T & DatabaseMaterializationInput): MaterializedDatabaseConfig<T>;
-export declare function materializeDatabaseConfig(database: null | undefined): undefined;

package/dist/config/loader/database-roles.d.ts

@@ -1,2 +0,0 @@
-import type { DatabaseRoleConfig } from "../authoring/index.js";
-export declare function normalizeDatabaseRoles(value: unknown, serviceName: string, bootstrapUser: string): DatabaseRoleConfig[];

package/dist/config/loader/database.d.ts

@@ -1,55 +0,0 @@
-import { type DatabaseBinding } from "./execution-model.js";
-import type { DatabaseRoleConfig, PostgresDatabaseConfig } from "../authoring/index.js";
-import { type NormalizedConfiguredStep } from "../../steps/configured-steps.js";
-type FalsyDatabaseConfig = "" | 0 | false | null | undefined;
-export type DatabaseConfigInput = PostgresDatabaseConfig;
-export interface DatabaseServiceConfigInput {
-    readonly database?: unknown;
-    readonly databaseFrom?: unknown;
-}
-export interface NormalizedDatabaseTemplateConfig {
-    inputs: string[];
-    migrate: NormalizedConfiguredStep[];
-    seed: NormalizedConfiguredStep[];
-    verify: NormalizedConfiguredStep[];
-}
-export interface NormalizedSourceSchemaConfigBase {
-    refresh: NormalizedSourceSchemaRefresh;
-    unavailable: NormalizedSourceSchemaUnavailable;
-    verify: boolean;
-}
-export interface NormalizedAutomaticSourceSchemaConfig extends NormalizedSourceSchemaConfigBase {
-    kind: "auto";
-}
-export interface NormalizedEnvironmentSourceSchemaConfig extends NormalizedSourceSchemaConfigBase {
-    env: string;
-    kind: "env";
-}
-export type NormalizedSourceSchemaConfig = NormalizedAutomaticSourceSchemaConfig | NormalizedEnvironmentSourceSchemaConfig;
-export type NormalizedSourceSchemaRefresh = {
-    mode: "always" | "auto";
-} | {
-    mode: "ttl";
-    ttlSeconds: number;
-};
-export type NormalizedSourceSchemaUnavailable = "auto" | "fail" | "warn-cache";
-export interface NormalizedDatabaseFields {
-    binding: DatabaseBinding;
-    maxConnections: number | undefined;
-    reservedConnections: number | undefined;
-    reset: boolean;
-    roles: DatabaseRoleConfig[];
-    runtimeConnections: number | undefined;
-    serviceName: string;
-    sourceSchema: NormalizedSourceSchemaConfig | null;
-    template: NormalizedDatabaseTemplateConfig;
-}
-export type NormalizedDatabaseConfig<Input extends object = DatabaseConfigInput> = Omit<Input, keyof NormalizedDatabaseFields> & NormalizedDatabaseFields;
-export type LooselyNormalizedDatabaseConfig = NormalizedDatabaseFields & Record<PropertyKey, unknown>;
-type CompatibleDatabaseConfigInput<Input extends object> = Input & Pick<DatabaseConfigInput, Extract<keyof DatabaseConfigInput, keyof Input>>;
-export declare function normalizeDatabaseConfig<Input extends object>(explicitService: Readonly<DatabaseServiceConfigInput & {
-    database?: CompatibleDatabaseConfigInput<Input> | FalsyDatabaseConfig;
-}>, serviceName: string): NormalizedDatabaseConfig<Input> | undefined;
-export declare function normalizeDatabaseConfig(explicitService: Readonly<DatabaseServiceConfigInput>, serviceName: string): LooselyNormalizedDatabaseConfig | undefined;
-export declare function normalizeDatabaseTemplateConfig(value: unknown, serviceName: string): NormalizedDatabaseTemplateConfig;
-export {};

package/dist/config/loader/decode-discovery.d.ts

@@ -1,5 +0,0 @@
-import { type NormalizedDiscoveryConfig } from "./path-policy.js";
-export interface DiscoveryConfigNormalizationOptions {
-    allowRoots?: boolean;
-}
-export declare function normalizeDiscoveryConfig(value: unknown, { allowRoots }?: DiscoveryConfigNormalizationOptions): NormalizedDiscoveryConfig;

package/dist/config/loader/decode-execution.d.ts

@@ -1,7 +0,0 @@
-import type { DatabaseBinding, ExecutionConfigInput, ResolveExecutionConfigInput, NormalizedExecutionConfig } from "./execution-model.js";
-export declare function parseTaskConcurrencyOptions(taskConcurrency: unknown, workers?: unknown): number | null;
-export declare function normalizeRuntimeInstances(value: unknown, label?: string): number;
-export declare function normalizeRuntimeMaxConcurrentTasks(value: unknown, label?: string): number;
-export declare function normalizeDatabaseBinding(value: unknown, label?: string): DatabaseBinding;
-export declare function resolveExecutionConfig({ cli, repo, }?: ResolveExecutionConfigInput): NormalizedExecutionConfig;
-export declare function normalizeExecutionConfig(input?: ExecutionConfigInput): NormalizedExecutionConfig;

package/dist/config/loader/dependencies.d.ts

@@ -1,7 +0,0 @@
-export interface RuntimeDependencyConfig {
-    name: string;
-    testkit: {
-        dependsOn?: readonly string[];
-    };
-}
-export declare function resolveRuntimeConfigs<Config extends RuntimeDependencyConfig>(targetConfig: Config, configMap: ReadonlyMap<string, Config>): Config[];

package/dist/config/loader/discover-tests.d.ts

@@ -1,111 +0,0 @@
-import type { EngineId, RunnerProfileId } from "../../domain/identifiers.js";
-import { type NormalizedConfigContext } from "./load.js";
-import { type RunType } from "../../domain/test-types.js";
-import { type PublicTestType } from "../../domain/identifiers.js";
-import { type RuntimeIsolationPolicy as ConfigRuntimeIsolationPolicy } from "./runtime-isolation.js";
-import { resolveEngineProfile } from "../../engines/catalog.js";
-import { type DiscoverySummary } from "./discovery-summary.js";
-declare const DISCOVERY_SCHEMA_VERSION: 9;
-export type DiscoveryTestType = PublicTestType;
-export type RuntimeIsolationPolicy = ConfigRuntimeIsolationPolicy;
-export type { DiscoverySummary } from "./discovery-summary.js";
-export interface DiscoveryDiagnostic {
-    code: string;
-    message: string;
-    path?: string;
-    serviceNames?: string[];
-    severity: "error" | "warning";
-}
-export interface DiscoveryService {
-    activeFileCount: number;
-    dependsOn: string[];
-    discovered: boolean;
-    fileCount: number;
-    localCwd: string;
-    name: string;
-    skippedFileCount: number;
-    suiteCount: number;
-}
-export interface DiscoveryTestContract {
-    authoringApi?: string;
-    executionHost: ReturnType<typeof resolveEngineProfile>["capabilities"]["executionHost"];
-    summary?: string;
-}
-export interface DiscoverySuite {
-    activeFileCount: number;
-    contract: DiscoveryTestContract;
-    dependsOn: string[];
-    displayName: string;
-    engineId: EngineId;
-    fileCount: number;
-    filePaths: string[];
-    groupLabel: string;
-    id: string;
-    locks: string[];
-    name: string;
-    profileId: RunnerProfileId;
-    service: string;
-    skippedFileCount: number;
-    testType: DiscoveryTestType;
-}
-export interface DiscoveryFile {
-    contract: DiscoveryTestContract;
-    dependsOn: string[];
-    displayName: string;
-    engineId: EngineId;
-    groupLabel: string;
-    id: string;
-    locks: string[];
-    path: string;
-    profileId: RunnerProfileId;
-    runtimeIsolation: RuntimeIsolationPolicy;
-    service: string;
-    skipped: boolean;
-    skipReason: null | string;
-    suiteName: string;
-    testType: DiscoveryTestType;
-}
-export interface DiscoveryResult {
-    configFile: null | string;
-    diagnostics: DiscoveryDiagnostic[];
-    files: DiscoveryFile[];
-    filters: {
-        diagnostics: "error" | "report";
-        fileNames: string[];
-        runnableOnly: boolean;
-        service: null | string;
-        suiteSelectors: string[];
-        types: RunType[];
-    };
-    product: {
-        directory: string;
-        name: string;
-    };
-    schemaVersion: typeof DISCOVERY_SCHEMA_VERSION;
-    services: DiscoveryService[];
-    source: "testkit-discovery";
-    suites: DiscoverySuite[];
-    summary: DiscoverySummary;
-}
-export interface DiscoverTestsOptions {
-    diagnostics?: "error" | "report";
-    dir?: null | string;
-    file?: null | string | readonly string[];
-    runnableOnly?: boolean;
-    service?: null | string;
-    suite?: null | string | readonly string[];
-    type?: null | string | readonly string[];
-}
-export declare function discoverTests(options?: Readonly<DiscoverTestsOptions>): Promise<DiscoveryResult>;
-export declare function loadDiscoveredConfigContext(options?: Readonly<Pick<DiscoverTestsOptions, "dir">>): Promise<{
-    context: NormalizedConfigContext;
-    discovery: DiscoveryResult;
-}>;
-export interface LoadedDiscoveryContext {
-    discovery: DiscoveryResult;
-    context: NormalizedConfigContext | null;
-}
-export declare function loadDiscoveryContext(options?: Readonly<DiscoverTestsOptions>, context?: NormalizedConfigContext): Promise<LoadedDiscoveryContext>;
-export declare function formatDisplayName(value: unknown): string;
-export declare function testTypeContract(testType: DiscoveryTestType, engineId: EngineId, profileId: RunnerProfileId): DiscoveryTestContract;
-export declare function fileDisplayName(filePath: string): string;

package/dist/config/loader/discovery-summary.d.ts

@@ -1,29 +0,0 @@
-export interface DiscoverySummary {
-    activeFiles: number;
-    byService: Record<string, number>;
-    byTestType: Record<string, number>;
-    diagnostics: {
-        errors: number;
-        warnings: number;
-    };
-    files: number;
-    services: number;
-    skippedFiles: number;
-    suites: number;
-}
-export interface DiscoverySummaryDiagnosticInput {
-    severity: "error" | "warning";
-}
-export interface DiscoverySummaryFileInput {
-    service: string;
-    skipped: boolean;
-    testType: string;
-}
-export interface BuildDiscoverySummaryInput {
-    diagnostics: readonly DiscoverySummaryDiagnosticInput[];
-    files: readonly DiscoverySummaryFileInput[];
-    serviceCount: number;
-    suiteCount: number;
-}
-export declare function buildDiscoverySummary(input: Readonly<BuildDiscoverySummaryInput>): DiscoverySummary;
-export declare function emptyDiscoverySummary(): DiscoverySummary;

package/dist/config/loader/discovery.d.ts

@@ -1,53 +0,0 @@
-import type { PublicTestType } from "../../domain/identifiers.js";
-import type { ServiceConfig } from "../authoring/index.js";
-export type DiscoveryServiceConfig = Pick<ServiceConfig, "discovery" | "local">;
-export type DiscoveryServices = Readonly<Record<string, DiscoveryServiceConfig | null | undefined>>;
-export interface DiscoveryOptions {
-    discovery?: unknown;
-    strict?: boolean;
-}
-export interface DiscoveredService {
-    inferredLocalCwd: string;
-    name: string;
-    source: string;
-}
-export interface DiscoveredSuite {
-    files: string[];
-    name: string;
-}
-export type DiscoveredSuitesByService = Partial<Record<string, Partial<Record<PublicTestType, DiscoveredSuite[]>>>>;
-export interface DiscoveredFile {
-    filePath: string;
-    serviceName: string;
-    suiteName: string;
-    suitePath: string[];
-    testType: PublicTestType;
-}
-interface DiscoveryDiagnosticBase {
-    message: string;
-    path: string;
-    severity: "error";
-}
-export interface LegacyDiscoveryDiagnostic extends DiscoveryDiagnosticBase {
-    code: "legacy_path";
-}
-export interface UnownedDiscoveryDiagnostic extends DiscoveryDiagnosticBase {
-    code: "unowned_test";
-}
-export interface AmbiguousDiscoveryDiagnostic extends DiscoveryDiagnosticBase {
-    code: "ambiguous_test";
-    serviceNames: string[];
-}
-export type DiscoveryDiagnostic = AmbiguousDiscoveryDiagnostic | LegacyDiscoveryDiagnostic | UnownedDiscoveryDiagnostic;
-export interface DiscoveryProject {
-    diagnostics: DiscoveryDiagnostic[];
-    files: DiscoveredFile[];
-    services: Partial<Record<string, DiscoveredService>>;
-    suitesByService: DiscoveredSuitesByService;
-}
-export declare function discoverProject(productDir: string, explicitServices?: DiscoveryServices, options?: DiscoveryOptions): DiscoveryProject;
-export declare function hasDiscoveryErrors(diagnostics?: readonly ({
-    severity?: unknown;
-} | null | undefined)[]): boolean;
-export declare function buildDiscoveryErrorFromDiagnostics(diagnostics?: readonly DiscoveryDiagnostic[]): Error;
-export {};

package/dist/config/loader/env.d.ts

@@ -1,4 +0,0 @@
-import { parseDotenv } from "../../process/files/dotenv.js";
-export { parseDotenv };
-export declare function inferEnvFiles(productDir: string, explicitService: unknown, local: unknown): string[];
-export declare function loadServiceEnv(productDir: string, envFiles: readonly string[]): Record<string, string>;

package/dist/config/loader/execution-model.d.ts

@@ -1,15 +0,0 @@
-export type DatabaseBinding = "per-runtime" | "shared";
-export interface ExecutionConfigInput {
-    readonly [key: string]: unknown;
-    readonly fileTimeoutSeconds?: unknown;
-    readonly taskConcurrency?: unknown;
-    readonly workers?: unknown;
-}
-export interface ResolveExecutionConfigInput {
-    cli?: ExecutionConfigInput;
-    repo?: ExecutionConfigInput;
-}
-export interface NormalizedExecutionConfig {
-    fileTimeoutSeconds: number;
-    taskConcurrency: number;
-}

package/dist/config/loader/file-metadata.d.ts

@@ -1,19 +0,0 @@
-import type ts from "typescript";
-import { type EngineId, type RunnerProfileId } from "../../domain/identifiers.js";
-import { type RuntimeIsolationPolicy } from "../../domain/runtime-isolation-contract.js";
-import { type EngineAuthoringProfile } from "../../engines/catalog.js";
-export interface TestFileMetadata {
-    engineId: EngineId;
-    locks: string[];
-    profileId: RunnerProfileId;
-    runtimeIsolation: null | RuntimeIsolationPolicy;
-    skipReason: null | string;
-}
-export interface TestFileMetadataSuite {
-    files?: readonly string[];
-}
-export type TestFileMetadataSuitesByService = Readonly<Record<string, Readonly<Record<string, readonly TestFileMetadataSuite[] | undefined>> | undefined>>;
-export declare function loadTestFileMetadataMap(productDir: string, suitesByService?: null | TestFileMetadataSuitesByService, metadataByPath?: Map<string, TestFileMetadata>): Map<string, TestFileMetadata>;
-export declare function readTestFileMetadata(productDir: string, filePath: string): TestFileMetadata;
-export declare function requireMatchingEngineAuthoringImports(sourceFile: ts.SourceFile, filePath: string, metadata: Readonly<EngineAuthoringProfile>): void;
-export declare function collectModuleSpecifiers(sourceFile: ts.SourceFile): ReadonlySet<string>;

package/dist/config/loader/groups.d.ts

@@ -1,33 +0,0 @@
-export declare const ROOT_GROUP = "root";
-export declare const LEGACY_OWNERSHIP_NOTICE = "testkit.config.ts has services but no groups, so each service owns the tests under its directory as a group of the same name. Legacy ownership will be removed; declare groups with roots and uses instead.";
-export type TestGroupSource = "groups" | "implicit" | "services";
-export interface TestGroup {
-    name: string;
-    roots: string[];
-    source: TestGroupSource;
-    uses: string[];
-}
-export interface GroupCandidate {
-    kind: "plain" | "typed";
-    path: string;
-}
-export type GroupAssignment = {
-    group: string;
-    path: string;
-    relativePath: string;
-    status: "owned";
-} | {
-    groups: string[];
-    path: string;
-    status: "ambiguous";
-} | {
-    path: string;
-    status: "excluded";
-};
-export interface GroupResolution {
-    assignments: GroupAssignment[];
-    groups: TestGroup[];
-    notice: null | string;
-    problems: string[];
-}
-export declare function resolveGroups(config: null | object | undefined, candidates: readonly GroupCandidate[]): GroupResolution;

package/dist/config/loader/index.d.ts

@@ -1,10 +0,0 @@
-export { loadConfigContext, loadConfigs, parseDotenv, resolveProductDir, resolveServiceCwd, type LoadConfigContextOptions, type LoadConfigsOptions, type NormalizedConfigContext, type NormalizedLoadedDatabaseConfig, type NormalizedLocalServiceConfig, type NormalizedServiceConfig, type NormalizedServiceTestkitConfig, type NormalizedSuiteConfig, type ServiceSuites, } from "./load.js";
-export { discoverTests, loadDiscoveredConfigContext, loadDiscoveryContext, type LoadedDiscoveryContext, fileDisplayName, formatDisplayName, testTypeContract, type DiscoverTestsOptions, type DiscoveryDiagnostic, type DiscoveryFile, type DiscoveryResult, type DiscoveryService, type DiscoverySuite, type DiscoverySummary, type DiscoveryTestContract, type DiscoveryTestType, } from "./discover-tests.js";
-export { findConfigFile, loadTestkitConfig } from "./config-loader.js";
-export { materializeDatabaseConfig, type DatabaseMaterializationInput, type MaterializedDatabaseConfig, } from "./database-materialization.js";
-export type { NormalizedDatabaseConfig, NormalizedDatabaseTemplateConfig, NormalizedSourceSchemaConfig, } from "./database.js";
-export { detectNextApp, type NormalizedRuntimeConfig } from "./runtime.js";
-export { DEFAULT_RUNTIME_ISOLATION_POLICY, resolveRuntimeIsolationPolicy, type RuntimeIsolationFileMetadata, type RuntimeIsolationPolicy, type RuntimeIsolationResolutionSuite, type RuntimeIsolationResolverConfig, type RuntimeIsolationResolverTestkitConfig, } from "./runtime-isolation.js";
-export { collectModuleSpecifiers, requireMatchingEngineAuthoringImports, type TestFileMetadata, } from "./file-metadata.js";
-export type { NormalizedSkipConfig } from "./skip-config.js";
-export { hasDiscoveryErrors, buildDiscoveryErrorFromDiagnostics } from "./discovery.js";

package/dist/config/loader/load.d.ts

@@ -1,89 +0,0 @@
-import { type TestFileSelection } from "./test-selection.js";
-import { type EngineConfigurations } from "../../engines/catalog.js";
-import { type EngineId, type PublicTestType, type RunnerProfileId } from "../../domain/identifiers.js";
-import { type DiscoveredSuite, type DiscoveryOptions, type DiscoveryProject } from "./discovery.js";
-import { type NormalizedToolchainRegistry } from "../../toolchains/index.js";
-import { type TestFileMetadata } from "./file-metadata.js";
-import { type NormalizedDiscoveryConfig } from "./path-policy.js";
-import { type FingerprintPolicy } from "../../repo/fingerprint-policy.js";
-import { type NormalizedDatabaseConfig } from "./database.js";
-import { parseDotenv } from "./env.js";
-import { type NormalizedRuntimeIsolationConfig } from "./runtime-isolation.js";
-import { resolveProductDir, resolveServiceCwd } from "./paths.js";
-import { type NormalizedRuntimeConfig } from "./runtime.js";
-import { type NormalizedServiceRequirements, type NormalizedSkipConfig } from "./skip-config.js";
-import { type NormalizedArtifactArchiveConfig } from "../../evidence/index.js";
-import type { NormalizedExecutionConfig } from "./execution-model.js";
-type UnknownRecord = Record<string, unknown>;
-export interface NormalizedSuiteConfig extends DiscoveredSuite {
-    engineId: EngineId;
-    profileId: RunnerProfileId;
-    testType: PublicTestType;
-}
-export type ServiceSuites = Partial<Record<PublicTestType, NormalizedSuiteConfig[]>>;
-export interface NormalizedLocalServiceConfig {
-    baseUrl: string;
-    cwd: string;
-    env: Record<string, string>;
-    readyTimeoutMs?: number;
-    shutdownTimeoutMs?: number;
-    readyUrl?: false | null | string;
-    start: string;
-}
-export interface NormalizedServiceTestkitConfig {
-    database: NormalizedLoadedDatabaseConfig | undefined;
-    databaseFrom: string | undefined;
-    dependsOn: string[];
-    discovery: NormalizedDiscoveryConfig;
-    envFiles: string[];
-    execution: NormalizedExecutionConfig;
-    fileMetadataByPath: Map<string, TestFileMetadata>;
-    fingerprints: FingerprintPolicy;
-    local: NormalizedLocalServiceConfig | undefined;
-    requirements: NormalizedServiceRequirements;
-    runtime: NormalizedRuntimeConfig;
-    runtimeIsolation: NormalizedRuntimeIsolationConfig;
-    serviceEnv: Record<string, string>;
-    skip: NormalizedSkipConfig | undefined;
-    ui: unknown;
-}
-export type NormalizedLoadedDatabaseConfig = NormalizedDatabaseConfig & Record<PropertyKey, unknown>;
-export interface NormalizedServiceConfig {
-    artifacts: NormalizedArtifactArchiveConfig;
-    configFile: null | string;
-    engineConfigurations?: EngineConfigurations;
-    name: string;
-    productDir: string;
-    stateDir: string;
-    suites: ServiceSuites;
-    testkit: NormalizedServiceTestkitConfig;
-}
-export interface PreparedDiscovery {
-    readonly project: DiscoveryProject;
-    readonly fileMetadataByPath: Map<string, TestFileMetadata>;
-}
-export interface LoadConfigContextOptions {
-    testSelection?: TestFileSelection;
-    preparedDiscovery?: PreparedDiscovery;
-    configContext?: unknown;
-    configImportCacheSalt?: string;
-    dir?: null | string;
-    discoveryOptions?: Omit<DiscoveryOptions, "discovery">;
-}
-export interface LoadConfigsOptions extends LoadConfigContextOptions {
-    service?: null | string;
-}
-export interface NormalizedConfigContext {
-    config: object;
-    configFile: null | string;
-    configs: NormalizedServiceConfig[];
-    discovery: DiscoveryProject;
-    execution: NormalizedExecutionConfig;
-    explicitServices: Partial<Record<string, UnknownRecord>>;
-    fingerprints: FingerprintPolicy;
-    productDir: string;
-    toolchains: NormalizedToolchainRegistry;
-}
-export { parseDotenv, resolveProductDir, resolveServiceCwd };
-export declare function loadConfigContext(opts?: Readonly<LoadConfigContextOptions>): Promise<NormalizedConfigContext>;
-export declare function loadConfigs(opts?: Readonly<LoadConfigsOptions>): Promise<NormalizedServiceConfig[]>;

package/dist/config/loader/managed-configs.d.ts

@@ -1,23 +0,0 @@
-import type { TestFileSelection } from "./test-selection.js";
-import { type NormalizedServiceConfig } from "./load.js";
-export interface LoadManagedConfigsOptions {
-    testSelection?: TestFileSelection;
-    dir?: string;
-    service?: null | string;
-}
-export interface ManagedConfigCollection {
-    allConfigs: NormalizedServiceConfig[];
-    configs: NormalizedServiceConfig[];
-}
-export interface ManagedConfigDependencyNode {
-    name: string;
-    testkit: {
-        database?: unknown;
-        dependsOn: readonly string[];
-    };
-}
-export declare function loadManagedConfigs(options?: Readonly<LoadManagedConfigsOptions>): Promise<ManagedConfigCollection>;
-export declare function filterConfigsByService<Config extends ManagedConfigDependencyNode>(allConfigs: Config[], serviceName: null | string): Config[];
-export declare function resolveTargetConfig<Config extends ManagedConfigDependencyNode>(configs: readonly Config[], serviceName?: null | string): Config;
-export declare function collectRequiredConfigs<Config extends ManagedConfigDependencyNode>(configs: readonly Config[], targetName: string): Config[];
-export declare function topologicallySortConfigs<Config extends ManagedConfigDependencyNode>(configs: readonly Config[]): Config[];

package/dist/config/loader/path-policy.d.ts

@@ -1,9 +0,0 @@
-export interface NormalizedDiscoveryConfig {
-    exclude?: string[];
-    roots?: string[];
-}
-export declare const DEFAULT_DISCOVERY_EXCLUDES: readonly string[];
-export declare function mergeDiscoveryConfigs(...configs: readonly (NormalizedDiscoveryConfig | null | undefined)[]): NormalizedDiscoveryConfig;
-export declare function resolveDiscoveryRoots(baseDir: string, roots: null | readonly unknown[] | undefined, defaultRoot?: unknown): string[];
-export declare function shouldExcludeDiscoveryPath(relativePath: unknown, exclude?: readonly string[]): boolean;
-export declare function normalizeDiscoveryPath(value: unknown): string;

package/dist/config/loader/paths.d.ts

@@ -1,5 +0,0 @@
-export declare function resolveServiceCwd(productDir: string, maybeRelative?: string | null): string;
-export declare function ensureExistingPath(productDir: string, relativePath: string, label: string): void;
-export declare function ensureExistingContainedPath(productDir: string, relativePath: string, label: string): void;
-export declare function normalizePath(value?: string | null): string;
-export { resolveProductDir } from "../../process/files/product-dir.js";

package/dist/config/loader/runtime-isolation.d.ts

@@ -1,44 +0,0 @@
-import { type TypedSuiteSelector } from "../../domain/suite-selection.js";
-import type { PublicTestType } from "../../domain/identifiers.js";
-import { type RuntimeIsolationPolicy } from "../../domain/runtime-isolation-contract.js";
-export { DEFAULT_RUNTIME_ISOLATION_POLICY, isRuntimeIsolationPolicy, normalizeRuntimeIsolationPolicy, RUNTIME_ISOLATION_POLICIES, type RuntimeIsolationPolicy, } from "../../domain/runtime-isolation-contract.js";
-export interface RuntimeIsolationSuiteInput {
-    files?: readonly string[];
-    name: string;
-    testType: PublicTestType;
-}
-export type RuntimeIsolationSuiteCollection = Readonly<Record<string, readonly RuntimeIsolationSuiteInput[] | undefined>>;
-export interface RuntimeIsolationNormalizationOptions {
-    name: string;
-    suites?: null | RuntimeIsolationSuiteCollection;
-}
-export interface NormalizedSuiteRuntimeIsolationRule {
-    policy: RuntimeIsolationPolicy;
-    selector: TypedSuiteSelector;
-}
-export interface NormalizedFileRuntimeIsolationRule {
-    path: string;
-    policy: RuntimeIsolationPolicy;
-}
-export interface NormalizedRuntimeIsolationConfig {
-    defaultPolicy: RuntimeIsolationPolicy;
-    filePolicyByPath: ReadonlyMap<string, RuntimeIsolationPolicy>;
-    files: NormalizedFileRuntimeIsolationRule[];
-    suites: NormalizedSuiteRuntimeIsolationRule[];
-}
-export interface RuntimeIsolationFileMetadata<Policy extends string = RuntimeIsolationPolicy> {
-    runtimeIsolation?: null | Policy;
-}
-export interface RuntimeIsolationResolverTestkitConfig<Policy extends string = string> {
-    fileMetadataByPath?: ReadonlyMap<string, RuntimeIsolationFileMetadata<Policy>>;
-    runtimeIsolation?: NormalizedRuntimeIsolationConfig;
-}
-export interface RuntimeIsolationResolverConfig<Policy extends string = string> {
-    testkit?: RuntimeIsolationResolverTestkitConfig<Policy>;
-}
-export interface RuntimeIsolationResolutionSuite {
-    name: string;
-    testType: PublicTestType;
-}
-export declare function normalizeRuntimeIsolationConfig(value: unknown, { name, suites }: RuntimeIsolationNormalizationOptions): NormalizedRuntimeIsolationConfig;
-export declare function resolveRuntimeIsolationPolicy<Policy extends string>(config: RuntimeIsolationResolverConfig<Policy>, suite: RuntimeIsolationResolutionSuite, filePath: string): Policy | RuntimeIsolationPolicy;

package/dist/config/loader/runtime.d.ts

@@ -1,16 +0,0 @@
-import { type ExecutionConfigInput, type NormalizedExecutionConfig } from "./execution-model.js";
-import { type NormalizedBuildConfig, type NormalizedBuildPrepareConfig } from "../../steps/build-config.js";
-import { type NormalizedRuntimeToolchain, type NormalizedToolchainRegistry } from "../../toolchains/index.js";
-export type { NormalizedNodeToolchainConfig, NormalizedRuntimeToolchain, NormalizedToolchainRegistry, } from "../../toolchains/index.js";
-export interface NormalizedRuntimeConfig {
-    build: NormalizedBuildConfig | null;
-    instances: number;
-    maxConcurrentTasks: number;
-    prepare: NormalizedBuildPrepareConfig;
-    toolchain: NormalizedRuntimeToolchain | null;
-}
-export declare function normalizeRuntimeConfig(value: unknown, serviceName: string, toolchains: NormalizedToolchainRegistry | null | undefined): NormalizedRuntimeConfig;
-export declare function normalizeRuntimePrepareConfig(value: unknown, serviceName: string): NormalizedBuildPrepareConfig;
-export declare function normalizeRepoExecution(execution: ExecutionConfigInput | null | undefined): NormalizedExecutionConfig;
-export declare function detectNextApp(cwd: string): boolean;
-export { normalizeConfiguredStep as normalizeTemplateLifecycleStep, normalizeConfiguredSteps as normalizeTemplateLifecycleSteps, normalizeOptionalString, parseModuleSpecifier, } from "../../steps/configured-steps.js";

package/dist/config/loader/skip-config.d.ts

@@ -1,44 +0,0 @@
-import type { EngineId, PublicTestType, RunnerProfileId } from "../../domain/identifiers.js";
-import { type SuiteSelector, type TypedSuiteSelector } from "../../domain/suite-selection.js";
-export interface SelectableSuite {
-    engineId: EngineId;
-    files: readonly string[];
-    name: string;
-    profileId: RunnerProfileId;
-    testType: PublicTestType;
-}
-export type ServiceSuiteCollection = Readonly<Partial<Record<PublicTestType, null | readonly SelectableSuite[] | undefined>>>;
-export interface SkipConfigNormalizationContext {
-    name: string;
-    suites: Readonly<Partial<Record<PublicTestType, null | readonly Pick<SelectableSuite, "name" | "testType" | "files">[] | undefined>>>;
-}
-export interface NormalizedSkipFileRule {
-    path: string;
-    reason: string;
-}
-export interface NormalizedSkipSuiteRule {
-    reason: string;
-    selector: SuiteSelector;
-}
-export interface NormalizedSkipConfig {
-    fileReasonByPath: Map<string, string>;
-    files: NormalizedSkipFileRule[];
-    suites: NormalizedSkipSuiteRule[];
-}
-export interface NormalizedRequirementFileRule {
-    locks: string[];
-    path: string;
-}
-export interface NormalizedRequirementSuiteRule {
-    locks: string[];
-    selector: TypedSuiteSelector;
-}
-export interface NormalizedServiceRequirements {
-    fileLocksByPath: Map<string, string[]>;
-    files: NormalizedRequirementFileRule[];
-    suites: NormalizedRequirementSuiteRule[];
-}
-export declare function normalizeSkipReason(reason: unknown, label: string): string;
-export declare function normalizeSkipConfig(value: unknown, { name, suites }: Readonly<SkipConfigNormalizationContext>): NormalizedSkipConfig | undefined;
-export declare function normalizeServiceRequirements(value: unknown, { name, suites }: Readonly<SkipConfigNormalizationContext>): NormalizedServiceRequirements;
-export declare function normalizeRequirementLocks(value: unknown, label: string): string[];

package/dist/config/loader/test-selection.d.ts

@@ -1,15 +0,0 @@
-import { type SuiteSelector } from "../../domain/suite-selection.js";
-import { type PublicTestType } from "../../domain/identifiers.js";
-import type { DiscoveredSuitesByService, DiscoveredSuite } from "./discovery.js";
-export interface TestFileSelection {
-    service?: null | string;
-    fileNames?: readonly string[];
-    typeValues?: readonly string[];
-    suiteSelectors?: readonly SuiteSelector[];
-}
-/** Select by discovered paths/types before reading engine metadata. */
-export declare function selectDiscoveredSuites(discovered: DiscoveredSuitesByService, selection: Readonly<TestFileSelection>): DiscoveredSuitesByService;
-/** Global configuration selectors still validate against every discovered path. */
-export declare function discoveredRuleSuites(suites: Partial<Record<PublicTestType, DiscoveredSuite[]>>): Partial<Record<PublicTestType, Array<DiscoveredSuite & {
-    testType: PublicTestType;
-}>>>;