@elench/testkit 0.1.69 → 0.1.71

package/README.md

@@ -4,7 +4,7 @@
 filesystem, starts local services, provisions Docker-managed local Postgres
 databases, and runs HTTP, DAL, and Playwright suites.
 
-The package is now driven by `testkit.setup.ts`, not `testkit.config.json`.
+The package is now driven by `testkit.config.ts`, not `testkit.config.json`.
 
 ## Usage
 
@@ -81,23 +81,83 @@ persisted under `.testkit/results/` and inspected on demand with `show`,
 run counts, pass/fail/skip counts, average duration, and last observed status,
 and those summaries are exposed in compact, verbose, and JSON discovery output.
 
+## Tooling Adapters
+
+`testkit` also ships tool-specific config helpers so consumer repos do not need
+repo-local runtime policy files just to cooperate with managed runs.
+
+```ts
+// drizzle.config.ts
+import { defineConfig } from "@elench/testkit/drizzle";
+
+export default defineConfig({
+  schema: "./src/db/schema/index.ts",
+  out: "./src/db/migrations",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+```
+
+```ts
+// vitest.config.ts
+import { defineConfig } from "@elench/testkit/vitest";
+
+export default defineConfig({
+  test: {
+    include: ["src/**/*.test.ts"],
+  },
+});
+```
+
+```ts
+// playwright.config.ts
+import { defineConfig } from "@elench/testkit/playwright";
+import { devices } from "@playwright/test";
+
+export default defineConfig({
+  testDir: "./__testkit__",
+  projects: [{ name: "chromium", use: { ...devices["Desktop Chrome"] } }],
+}, {
+  dotenvFiles: [".env.local"],
+});
+```
+
+For scripts and app-runtime code, `@elench/testkit/env` provides shared helpers
+for managed runtime detection, dotenv loading, and local-database safety:
+
+```ts
+import {
+  assertLocalDatabaseUrl,
+  loadDotenvFiles,
+  shouldLoadDotenv,
+} from "@elench/testkit/env";
+
+if (shouldLoadDotenv()) {
+  loadDotenvFiles({ files: [".env", ".env.local"] });
+}
+
+assertLocalDatabaseUrl(process.env, "seed.ts");
+```
+
 ## Setup
 
-Create `testkit.setup.ts` at repo root:
+Create `testkit.config.ts` at repo root:
 
 ```ts
 import {
-  defineTestkitSetup,
-  defineTestkitFile,
+  defineConfig,
+  defineFile,
   nextApp,
   nodeToolchain,
   nodeApp,
   seedCommand,
   templateDatabase,
   verifyModule,
-} from "@elench/testkit/setup";
+} from "@elench/testkit/config";
 
-export default defineTestkitSetup({
+export default defineConfig({
   execution: {
     workers: 8,
     fileTimeoutSeconds: 60,
@@ -157,15 +217,15 @@ export default defineTestkitSetup({
 File-local execution metadata now lives next to the test when possible:
 
 ```ts
-import { defineTestkitFile } from "@elench/testkit/setup";
+import { defineFile } from "@elench/testkit/config";
 
-export const testkit = defineTestkitFile({
+export const testkit = defineFile({
   skip: "Billing is still stubbed locally",
   locks: ["global-worker-loop"],
 });
 ```
 
-`testkit.setup.ts` is optional for simple repos, but it is the primary escape hatch
+`testkit.config.ts` is optional for simple repos, but it is the primary escape hatch
 for:
 
 - worker count and per-file runtime budget
@@ -305,7 +365,7 @@ export default suite;
 `testkit` suite files should default-export the suite object returned by
 `defineHttpSuite(...)` or `defineDalSuite(...)`.
 
-Named HTTP profiles live in `testkit.setup.ts` and can be referenced by name:
+Named HTTP profiles live in `testkit.config.ts` and can be referenced by name:
 
 ```ts
 import { defineHttpSuite } from "@elench/testkit";

package/lib/app/doctor.mjs

@@ -13,7 +13,7 @@ export async function runDoctor(options = {}) {
   checks.push({
     code: "config-load",
     level: "pass",
-    message: "Loaded testkit setup and service config",
+    message: "Loaded testkit config and service config",
   });
 
   const discovery = await discoverTests({ dir: productDir, diagnostics: "report" });

package/lib/app/typecheck.mjs

@@ -16,7 +16,7 @@ export async function runTestkitTypecheck(options = {}) {
   const checks = [];
   const rootTsconfig = writeRootTypecheckConfig({
     productDir,
-    setupFile: context.setupFile,
+    configFile: context.configFile,
     outputDir: tempDir,
   });
   checks.push({
@@ -63,7 +63,7 @@ export async function runTestkitTypecheck(options = {}) {
   };
 }
 
-function writeRootTypecheckConfig({ productDir, setupFile, outputDir }) {
+function writeRootTypecheckConfig({ productDir, configFile, outputDir }) {
   const tsconfigPath = path.join(outputDir, "repo.tsconfig.json");
   const extendsPath = findExistingTsconfig(productDir) || null;
   const config = {
@@ -78,7 +78,7 @@ function writeRootTypecheckConfig({ productDir, setupFile, outputDir }) {
       target: "ES2022",
     },
     include: [
-      setupFile ? relativeJsonPath(tsconfigPath, setupFile) : "testkit.setup.ts",
+      configFile ? relativeJsonPath(tsconfigPath, configFile) : "testkit.config.ts",
       "**/*.int.testkit.ts",
       "**/*.e2e.testkit.ts",
       "**/*.scenario.testkit.ts",
@@ -197,7 +197,11 @@ function serviceExists(rootDir, relativePath) {
 function packageTypePaths(tsconfigPath) {
   return {
     "@elench/testkit": [relativeJsonPath(tsconfigPath, path.join(PACKAGE_ROOT, "lib", "index.d.ts"))],
-    "@elench/testkit/setup": [relativeJsonPath(tsconfigPath, path.join(PACKAGE_ROOT, "lib", "setup", "index.d.ts"))],
+    "@elench/testkit/config": [relativeJsonPath(tsconfigPath, path.join(PACKAGE_ROOT, "lib", "config-api", "index.d.ts"))],
+    "@elench/testkit/drizzle": [relativeJsonPath(tsconfigPath, path.join(PACKAGE_ROOT, "lib", "drizzle", "index.d.ts"))],
+    "@elench/testkit/env": [relativeJsonPath(tsconfigPath, path.join(PACKAGE_ROOT, "lib", "env", "index.d.ts"))],
+    "@elench/testkit/playwright": [relativeJsonPath(tsconfigPath, path.join(PACKAGE_ROOT, "lib", "playwright", "index.d.ts"))],
     "@elench/testkit/runtime": [relativeJsonPath(tsconfigPath, path.join(PACKAGE_ROOT, "lib", "runtime", "index.d.ts"))],
+    "@elench/testkit/vitest": [relativeJsonPath(tsconfigPath, path.join(PACKAGE_ROOT, "lib", "vitest", "index.d.ts"))],
   };
 }

package/lib/bundler/index.mjs

@@ -4,11 +4,11 @@ import path from "path";
 import crypto from "crypto";
 import { build } from "esbuild";
 import { fileURLToPath } from "url";
-import { findSetupFile } from "../config/setup-loader.mjs";
+import { findConfigFile } from "../config/config-loader.mjs";
 
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 const ROOT_ENTRY = path.join(PACKAGE_ROOT, "lib", "index.mjs");
-const SETUP_ENTRY = path.join(PACKAGE_ROOT, "lib", "setup", "index.mjs");
+const CONFIG_ENTRY = path.join(PACKAGE_ROOT, "lib", "config-api", "index.mjs");
 const RUNTIME_ENTRY = path.join(PACKAGE_ROOT, "lib", "runtime", "index.mjs");
 const bundleCache = new Map();
 
@@ -21,8 +21,8 @@ export async function bundleK6File({
   const bundleDir = path.join(productDir, ".testkit", "_bundles", serviceName || "shared");
   fs.mkdirSync(bundleDir, { recursive: true });
 
-  const setupFile = findSetupFile(productDir);
-  const cacheKey = await buildCacheKey(absoluteSource, setupFile);
+  const configFile = findConfigFile(productDir);
+  const cacheKey = await buildCacheKey(absoluteSource, configFile);
   const cached = bundleCache.get(cacheKey);
   if (cached && fs.existsSync(cached)) {
     return cached;
@@ -38,7 +38,7 @@ export async function bundleK6File({
   );
   fs.writeFileSync(entryFile, buildBundleEntryModule({
     sourceFile: absoluteSource,
-    setupFile,
+    configFile,
   }));
 
   await build({
@@ -62,7 +62,7 @@ export async function bundleK6File({
   return outputFile;
 }
 
-async function buildCacheKey(sourceFile, setupFile = null) {
+async function buildCacheKey(sourceFile, configFile = null) {
   const source = await fs.promises.readFile(sourceFile, "utf8");
   const packageJson = await fs.promises.readFile(path.join(PACKAGE_ROOT, "package.json"), "utf8");
   const hash = crypto
@@ -73,9 +73,9 @@ async function buildCacheKey(sourceFile, setupFile = null) {
     .update("\0")
     .update(packageJson);
 
-  if (setupFile && fs.existsSync(setupFile)) {
-    hash.update("\0").update(setupFile).update("\0");
-    hash.update(await fs.promises.readFile(setupFile, "utf8"));
+  if (configFile && fs.existsSync(configFile)) {
+    hash.update("\0").update(configFile).update("\0");
+    hash.update(await fs.promises.readFile(configFile, "utf8"));
   }
 
   return hash.digest("hex");
@@ -98,27 +98,27 @@ function testkitPackageAliasPlugin() {
 function resolvePackageSubpath(specifier) {
   const subpath = specifier.slice("@elench/testkit".length);
   if (!subpath) return ROOT_ENTRY;
-  if (subpath === "/setup") return SETUP_ENTRY;
+  if (subpath === "/config") return CONFIG_ENTRY;
   if (subpath === "/runtime") return RUNTIME_ENTRY;
 
   throw new Error(`Unsupported @elench/testkit import "${specifier}" in ${os.platform()}`);
 }
 
-function buildBundleEntryModule({ sourceFile, setupFile }) {
+function buildBundleEntryModule({ sourceFile, configFile }) {
   const sourceImport = JSON.stringify(sourceFile);
-  const setupRegistration = setupFile
+  const configRegistration = configFile
     ? `
-import * as repoSetupModule from ${JSON.stringify(setupFile)};
-registerRepoSetup(repoSetupModule.default || repoSetupModule || null);
+import * as repoConfigModule from ${JSON.stringify(configFile)};
+registerRepoConfig(repoConfigModule.default || repoConfigModule || null);
 `
     : `
-registerRepoSetup(null);
+registerRepoConfig(null);
 `;
 
   return `
-import { registerRepoSetup } from "@elench/testkit/setup";
+import { registerRepoConfig } from "@elench/testkit/config";
 import * as suiteModule from ${sourceImport};
-${setupRegistration}
+${configRegistration}
 const suite = normalizeTestkitSuite(suiteModule);
 export const options = suite.options;
 export function setup(...args) {

package/lib/cli/command-helpers.mjs

@@ -59,7 +59,7 @@ export const runFlags = {
     default: false,
   }),
   "ignore-skip-rules": Flags.boolean({
-    description: "Run files even if testkit.setup.ts marks them skipped",
+    description: "Run files even if testkit.config.ts marks them skipped",
     default: false,
   }),
   "output-mode": Flags.string({

package/lib/cli/commands/doctor.mjs

@@ -2,7 +2,7 @@ import { Command, Flags } from "@oclif/core";
 import { runDoctor } from "../../app/doctor.mjs";
 
 export default class DoctorCommand extends Command {
-  static summary = "Run built-in setup, discovery, and hygiene checks";
+  static summary = "Run built-in config, discovery, and hygiene checks";
 
   static enableJsonFlag = true;
 

package/lib/cli/commands/typecheck.mjs

@@ -2,7 +2,7 @@ import { Command, Flags } from "@oclif/core";
 import { runTestkitTypecheck } from "../../app/typecheck.mjs";
 
 export default class TypecheckCommand extends Command {
-  static summary = "Typecheck testkit setup, helpers, and suites";
+  static summary = "Typecheck testkit config, helpers, and suites";
 
   static enableJsonFlag = true;
 

package/lib/cli/known-failures.mjs

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { resolveProductDir } from "../config/index.mjs";
-import { loadTestkitSetup } from "../config/setup-loader.mjs";
+import { loadTestkitConfig } from "../config/config-loader.mjs";
 import {
   buildKnownFailureIssueValidationSummaryLines,
   normalizeKnownFailureIssueValidationConfig,
@@ -106,14 +106,14 @@ export async function runKnownFailuresValidateCommand(options = {}) {
 
 async function resolveKnownFailuresContext(options) {
   const productDir = resolveProductDir(process.cwd(), options.dir);
-  const { setup } = await loadTestkitSetup(productDir);
-  const reporting = setup?.reporting || {};
+  const { config } = await loadTestkitConfig(productDir);
+  const reporting = config?.reporting || {};
 
   const knownFailuresRelativePath = normalizeOptionalString(options.input)
     || normalizeOptionalString(reporting.knownFailuresFile);
   if (!knownFailuresRelativePath) {
     throw new Error(
-      "Known failures file not configured. Set reporting.knownFailuresFile in testkit.setup.ts or pass --input."
+      "Known failures file not configured. Set reporting.knownFailuresFile in testkit.config.ts or pass --input."
     );
   }
 

package/lib/cli/presentation/discovery-reporter.mjs

@@ -57,8 +57,8 @@ function buildCompactLines(result) {
 function buildVerboseLines(result) {
   const lines = [];
   lines.push(`${colorHeading("Summary")} ${JSON.stringify(result.summary)}`);
-  if (result.setupFile) {
-    lines.push(`setup ${result.setupFile}`);
+  if (result.configFile) {
+    lines.push(`config ${result.configFile}`);
   }
   if (result.history?.available) {
     lines.push(`history ${result.history.path}`);

package/lib/config/{setup-loader.mjs → config-loader.mjs}

@@ -6,17 +6,17 @@ import { fileURLToPath, pathToFileURL } from "url";
 
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 const ROOT_ENTRY = path.join(PACKAGE_ROOT, "lib", "index.mjs");
-const SETUP_ENTRY = path.join(PACKAGE_ROOT, "lib", "setup", "index.mjs");
+const CONFIG_ENTRY = path.join(PACKAGE_ROOT, "lib", "config-api", "index.mjs");
 const RUNTIME_ENTRY = path.join(PACKAGE_ROOT, "lib", "runtime", "index.mjs");
-const SETUP_FILES = [
-  "testkit.setup.ts",
-  "testkit.setup.mts",
-  "testkit.setup.mjs",
-  "testkit.setup.js",
+const CONFIG_FILES = [
+  "testkit.config.ts",
+  "testkit.config.mts",
+  "testkit.config.mjs",
+  "testkit.config.js",
 ];
 
-export function findSetupFile(productDir) {
-  for (const candidate of SETUP_FILES) {
+export function findConfigFile(productDir) {
+  for (const candidate of CONFIG_FILES) {
     const absolute = path.join(productDir, candidate);
     if (fs.existsSync(absolute)) {
       return absolute;
@@ -25,54 +25,54 @@ export function findSetupFile(productDir) {
   return null;
 }
 
-export async function loadTestkitSetup(productDir) {
-  const setupFile = findSetupFile(productDir);
-  if (!setupFile) {
+export async function loadTestkitConfig(productDir) {
+  const configFile = findConfigFile(productDir);
+  if (!configFile) {
     return {
-      setup: {},
-      setupFile: null,
+      config: {},
+      configFile: null,
     };
   }
 
-  const bundleDir = path.join(productDir, ".testkit", "_setup");
+  const bundleDir = path.join(productDir, ".testkit", "_config");
   fs.mkdirSync(bundleDir, { recursive: true });
 
-  const cacheKey = buildSetupCacheKey(setupFile);
-  const outputFile = path.join(bundleDir, `setup-${cacheKey.slice(0, 12)}.mjs`);
+  const cacheKey = buildConfigCacheKey(configFile);
+  const outputFile = path.join(bundleDir, `config-${cacheKey.slice(0, 12)}.mjs`);
 
   await build({
     absWorkingDir: productDir,
     bundle: true,
-    entryPoints: [setupFile],
+    entryPoints: [configFile],
     format: "esm",
     legalComments: "none",
     outfile: outputFile,
     platform: "node",
     sourcemap: "inline",
     target: "es2020",
-    plugins: [testkitSetupAliasPlugin()],
+    plugins: [testkitConfigAliasPlugin()],
   });
 
   const imported = await import(`${pathToFileURL(outputFile).href}?v=${cacheKey}`);
-  const setup = imported.default || imported.setup || {};
-  if (!setup || typeof setup !== "object") {
-    throw new Error(`testkit setup file must export an object: ${path.basename(setupFile)}`);
+  const config = imported.default || imported.config || {};
+  if (!config || typeof config !== "object") {
+    throw new Error(`testkit config file must export an object: ${path.basename(configFile)}`);
   }
 
   return {
-    setup,
-    setupFile,
+    config,
+    configFile,
   };
 }
 
-function buildSetupCacheKey(setupFile) {
-  const content = fs.readFileSync(setupFile, "utf8");
-  return crypto.createHash("sha256").update(setupFile).update("\0").update(content).digest("hex");
+function buildConfigCacheKey(configFile) {
+  const content = fs.readFileSync(configFile, "utf8");
+  return crypto.createHash("sha256").update(configFile).update("\0").update(content).digest("hex");
 }
 
-function testkitSetupAliasPlugin() {
+function testkitConfigAliasPlugin() {
   return {
-    name: "testkit-setup-alias",
+    name: "testkit-config-alias",
     setup(buildApi) {
       buildApi.onResolve({ filter: /^@elench\/testkit(?:\/.*)?$/ }, (args) => ({
         namespace: "file",
@@ -85,14 +85,14 @@ function testkitSetupAliasPlugin() {
 function resolvePackageSubpath(specifier) {
   const subpath = specifier.slice("@elench/testkit".length);
   if (!subpath) return ROOT_ENTRY;
-  if (subpath === "/setup") return SETUP_ENTRY;
+  if (subpath === "/config") return CONFIG_ENTRY;
   if (subpath === "/runtime") {
     throw new Error(
-      "testkit.setup.ts may not import @elench/testkit/runtime. " +
-        "Use @elench/testkit/setup runtime helpers instead."
+      "testkit.config.ts may not import @elench/testkit/runtime. " +
+        "Use @elench/testkit/config helpers instead."
     );
   }
   if (subpath === "/runtime/index.mjs") return RUNTIME_ENTRY;
 
-  throw new Error(`Unsupported @elench/testkit import "${specifier}" while loading testkit setup`);
+  throw new Error(`Unsupported @elench/testkit import "${specifier}" while loading testkit config`);
 }

package/lib/config/index.mjs

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { discoverProject } from "./discovery.mjs";
-import { loadTestkitSetup } from "./setup-loader.mjs";
+import { loadTestkitConfig } from "./config-loader.mjs";
 import { normalizeToolchainRegistry } from "../toolchains/index.mjs";
 import { loadTestFileMetadataMap } from "../discovery/file-metadata.mjs";
 import { mergeDiscoveryConfigs } from "../discovery/path-policy.mjs";
@@ -27,13 +27,13 @@ export { parseDotenv, resolveProductDir, resolveServiceCwd };
 
 export async function loadConfigContext(opts = {}) {
   const productDir = resolveProductDir(process.cwd(), opts.dir);
-  const setupContext = opts.setupContext || (await loadTestkitSetup(productDir));
-  const { setup, setupFile } = setupContext;
-  const execution = normalizeRepoExecution(setup.execution);
-  const reporting = normalizeReportingConfig(setup.reporting);
-  const toolchains = normalizeToolchainRegistry(setup.toolchains);
-  const discoveryConfig = normalizeRepoDiscoveryConfig(setup.discovery);
-  const explicitServices = setup.services || {};
+  const configContext = opts.configContext || (await loadTestkitConfig(productDir));
+  const { config, configFile } = configContext;
+  const execution = normalizeRepoExecution(config.execution);
+  const reporting = normalizeReportingConfig(config.reporting);
+  const toolchains = normalizeToolchainRegistry(config.toolchains);
+  const discoveryConfig = normalizeRepoDiscoveryConfig(config.discovery);
+  const explicitServices = config.services || {};
   const discovery = discoverProject(productDir, explicitServices, {
     ...(opts.discoveryOptions || {}),
     discovery: discoveryConfig,
@@ -50,8 +50,8 @@ export async function loadConfigContext(opts = {}) {
       normalizeServiceConfig({
         name,
         productDir,
-        setup,
-        setupFile,
+        config,
+        configFile,
         execution,
         discovery: discoveryConfig,
         reporting,
@@ -67,8 +67,8 @@ export async function loadConfigContext(opts = {}) {
 
   return {
     productDir,
-    setup,
-    setupFile,
+    config,
+    configFile,
     execution,
     discovery: discoveryConfig,
     reporting,
@@ -98,8 +98,8 @@ export { resolveDalBinary, resolveK6Binary } from "./binaries.mjs";
 function normalizeServiceConfig({
   name,
   productDir,
-  setup,
-  setupFile,
+  config,
+  configFile,
   execution,
   discovery,
   reporting,
@@ -150,9 +150,9 @@ function normalizeServiceConfig({
   return {
     name,
     productDir,
-    setupFile,
+    configFile,
     stateDir: path.join(productDir, ".testkit", name),
-    telemetry: normalizeTelemetryConfig(setup.telemetry),
+    telemetry: normalizeTelemetryConfig(config.telemetry),
     suites,
     testkit: {
       execution,

package/lib/config/runtime.mjs

@@ -24,7 +24,7 @@ export function normalizeReportingConfig(value) {
 
   const knownFailuresFile = normalizeOptionalString(value.knownFailuresFile);
   if (!knownFailuresFile) {
-    throw new Error('testkit.setup.ts reporting.knownFailuresFile must be a non-empty string');
+    throw new Error('testkit.config.ts reporting.knownFailuresFile must be a non-empty string');
   }
 
   const issueValidation = normalizeKnownFailureIssueValidationConfig(value.issueValidation);

package/lib/config/telemetry.mjs

@@ -5,18 +5,18 @@ export function normalizeTelemetryConfig(telemetry) {
     try {
       parsed = new URL(telemetry.endpoint);
     } catch {
-      throw new Error("testkit.setup telemetry.endpoint must be a valid URL");
+      throw new Error("testkit.config telemetry.endpoint must be a valid URL");
     }
     if (!["http:", "https:"].includes(parsed.protocol)) {
-      throw new Error("testkit.setup telemetry.endpoint must use http or https");
+      throw new Error("testkit.config telemetry.endpoint must use http or https");
     }
   }
   if (telemetry.enabled === true) {
     if (!telemetry.endpoint) {
-      throw new Error("testkit.setup telemetry.endpoint is required when telemetry.enabled is true");
+      throw new Error("testkit.config telemetry.endpoint is required when telemetry.enabled is true");
     }
     if (!telemetry.tokenEnv) {
-      throw new Error("testkit.setup telemetry.tokenEnv is required when telemetry.enabled is true");
+      throw new Error("testkit.config telemetry.tokenEnv is required when telemetry.enabled is true");
     }
   }
   return {

package/lib/config/validation.mjs

@@ -32,7 +32,7 @@ export function validateServiceConfig({
 
   if (usesLocalExecution && !local) {
     throw new Error(
-      `Service "${name}" defines non-DAL suites but no local runtime could be resolved. Add it in testkit.setup.ts.`
+      `Service "${name}" defines non-DAL suites but no local runtime could be resolved. Add it in testkit.config.ts.`
     );
   }
 

package/lib/{setup → config-api}/index.d.ts

@@ -215,11 +215,11 @@ export interface NextAppOptions extends Omit<ServiceConfig, "local" | "runtime">
   toolchain?: string | NodeToolchainConfig;
 }
 
-export interface TestkitSetup {
+export interface TestkitConfig {
   discovery?: DiscoveryConfig;
   execution?: TestkitExecutionConfig;
   profiles?: {
-    http?: Record<string, HttpSuiteConfig>;
+    http?: Record<string, HttpSuiteConfig<any>>;
   };
   reporting?: {
     knownFailuresFile?: string;
@@ -235,9 +235,9 @@ export interface TestkitSetup {
   };
 }
 
-export declare function defineTestkitSetup<T extends TestkitSetup>(setup: T): T;
+export declare function defineConfig<T extends TestkitConfig>(config: T): T;
 export declare function defineHttpProfile<T extends HttpSuiteConfig>(profile: T): T;
-export declare function defineTestkitFile<T extends TestkitFileMetadata>(metadata: T): T;
+export declare function defineFile<T extends TestkitFileMetadata>(metadata: T): T;
 export declare function postgresDatabase(options?: Omit<LocalDatabaseConfig, "provider">): LocalDatabaseConfig;
 export declare function commandStep(
   cmd: string,
@@ -309,9 +309,9 @@ export declare function jsonSessionProfile(options?: {
   usernameEnv?: string;
 }): HttpSuiteConfig;
 
-export declare function registerRepoSetup(setup: unknown): void;
-export declare function getRepoSetup(): unknown;
-export declare function clearRepoSetup(): void;
+export declare function registerRepoConfig(config: unknown): void;
+export declare function getRepoConfig(): unknown;
+export declare function clearRepoConfig(): void;
 export declare function registerRuntimeContext(context: unknown): void;
 export declare function getRuntimeContext(): unknown;
 export declare function clearRuntimeContext(): void;