@overkill-dev/run 0.0.65 → 0.0.67

package/config/profile-file-discovery.js

@@ -0,0 +1,88 @@
+import { resolve } from 'node:path';
+import { invalidProfileFileGlobMessage, invalidProfileFileSetNameMessage } from "./profile-patterns.js";
+export class ProfileFileDiscoveryError extends Error {
+    failureReason;
+    constructor(message, options, reason) {
+        super(message, options);
+        this.name = 'ProfileFileDiscoveryError';
+        this.failureReason = reason;
+    }
+    reason() {
+        return this.failureReason;
+    }
+}
+function validatePatterns(files, fieldPrefix) {
+    const fields = ['include', 'exclude'];
+    for (const field of fields) {
+        const patterns = files[field];
+        for (const pattern of patterns) {
+            const message = invalidProfileFileGlobMessage(`${fieldPrefix}${field}`, pattern);
+            if (message !== null) {
+                throw new ProfileFileDiscoveryError(message, undefined, 'invalid-policy');
+            }
+        }
+    }
+}
+function validateSets(sets) {
+    const entries = Object.entries(sets);
+    if (entries.length === 0) {
+        throw new ProfileFileDiscoveryError('Invalid profile files.sets: at least one file set is required.', undefined, 'invalid-policy');
+    }
+    for (const [name, set] of entries) {
+        const message = invalidProfileFileSetNameMessage(name);
+        if (message !== null) {
+            throw new ProfileFileDiscoveryError(message, undefined, 'invalid-policy');
+        }
+        validatePatterns(set, `sets.${name}.`);
+    }
+}
+function validateFiles(files) {
+    if (files.sets === undefined) {
+        validatePatterns(files, '');
+    }
+    else {
+        validateSets(files.sets);
+    }
+}
+async function discoverPatterns(cwd, files, fileSet, dependencies) {
+    const discovered = new Map();
+    const matches = dependencies.glob(files.include, { cwd, exclude: files.exclude, followSymlinks: false });
+    for await (const match of matches) {
+        const path = await dependencies.realpath(resolve(cwd, match));
+        const stats = await dependencies.stat(path);
+        if (stats.isFile()) {
+            discovered.set(path, { path, fileSet });
+        }
+    }
+    return Array.from(discovered.values()).toSorted(function compareProfileFiles(first, second) {
+        return first.path.localeCompare(second.path);
+    });
+}
+function validateSetOwnership(files) {
+    const owners = new Map();
+    for (const file of files) {
+        if (owners.has(file.path)) {
+            throw new ProfileFileDiscoveryError(`Profile file sets must not overlap: ${file.path} matched ${owners.get(file.path)} and ${file.fileSet}.`, undefined, 'overlap');
+        }
+        owners.set(file.path, file.fileSet);
+    }
+}
+export async function discoverProfileFiles(request, dependencies) {
+    validateFiles(request.files);
+    if (request.files.sets === undefined) {
+        return await discoverPatterns(request.cwd, request.files, null, dependencies);
+    }
+    const sets = await Promise.all(Object.entries(request.files.sets).map(async function discoverSet([name, files]) {
+        const matches = await discoverPatterns(request.cwd, files, name, dependencies);
+        if (matches.length === 0) {
+            throw new ProfileFileDiscoveryError(`Profile files.sets.${name} matched no test files.`, undefined, 'empty-set');
+        }
+        return matches;
+    }));
+    const files = sets.flat();
+    validateSetOwnership(files);
+    return files.toSorted(function compareProfileFiles(first, second) {
+        return first.path.localeCompare(second.path);
+    });
+}
+//# sourceMappingURL=profile-file-discovery.js.map

package/config/profile-file-discovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-file-discovery.js","sourceRoot":"","sources":["../../../../source/config/profile-file-discovery.ts"],"names":[],"mappings":"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"}

package/{run/profile-config-normalization.js → config/profile-normalization.js}

@@ -1,12 +1,12 @@
 import path from 'node:path';
-import { invalidProfileFileGlobConfigMessage, invalidRunProfileFileSetNameMessage, invalidRunProfileNameMessage } from "./profile-file-glob.js";
-import { defaultCoveragePolicy, defaultWorkDistribution } from "./run-config-defaults.js";
-import { RunConfigError } from "./run-errors.js";
-import { invalidWorkDistributionConfigMessage, normalizeWorkDistribution } from "./work-distribution-config.js";
+import { invalidProfileFileGlobConfigMessage, invalidProfileFileSetNameMessage, invalidProfileNameMessage } from "./profile-patterns.js";
+import { defaultCoveragePolicy, defaultWorkDistribution } from "./defaults.js";
+import { ConfigError } from "./config-error.js";
+import { invalidWorkDistributionConfigMessage, normalizeWorkDistribution } from "./work-distribution.js";
 function assertValidProfileGlob(field, pattern) {
     const message = invalidProfileFileGlobConfigMessage(field, pattern);
     if (message !== null) {
-        throw new RunConfigError(message);
+        throw new ConfigError(message);
     }
 }
 function normalizeCoverageOutputs(outputs) {
@@ -54,7 +54,7 @@ function normalizeCoverageOutputDirectory(outputDirectory, configPath) {
         return null;
     }
     if (configPath === null) {
-        throw new RunConfigError('Coverage outputDir requires a loaded config file.');
+        throw new ConfigError('Coverage outputDir requires a loaded config file.');
     }
     return path.isAbsolute(outputDirectory)
         ? path.resolve(outputDirectory)
@@ -85,15 +85,15 @@ function normalizeProfileFilePatterns(files, fieldPrefix) {
     };
 }
 function assertValidProfileFileSetName(name) {
-    const message = invalidRunProfileFileSetNameMessage(name);
+    const message = invalidProfileFileSetNameMessage(name);
     if (message !== null) {
-        throw new RunConfigError(message);
+        throw new ConfigError(message);
     }
 }
 function normalizeProfileFileSets(files) {
     const entries = Object.entries(files.sets);
     if (entries.length === 0) {
-        throw new RunConfigError('Invalid profile files.sets: at least one file set is required.');
+        throw new ConfigError('Invalid profile files.sets: at least one file set is required.');
     }
     return {
         sets: Object.fromEntries(entries.map(function normalizeProfileFileSet([name, set]) {
@@ -119,18 +119,18 @@ export function normalizeRequiredProfileFiles(files) {
         : normalizeProfileFilePatterns(files, null);
 }
 export function assertValidProfileName(profileName) {
-    const message = invalidRunProfileNameMessage(profileName);
+    const message = invalidProfileNameMessage(profileName);
     if (message !== null) {
-        throw new RunConfigError(message);
+        throw new ConfigError(message);
     }
 }
 export function assertValidWorkDistribution(execution, files) {
     const message = invalidWorkDistributionConfigMessage(execution, files);
     if (message !== null) {
-        throw new RunConfigError(message);
+        throw new ConfigError(message);
     }
 }
 export function normalizedWorkDistribution(execution) {
     return normalizeWorkDistribution(execution, defaultWorkDistribution);
 }
-//# sourceMappingURL=profile-config-normalization.js.map
+//# sourceMappingURL=profile-normalization.js.map

package/config/profile-normalization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-normalization.js","sourceRoot":"","sources":["../../../../source/config/profile-normalization.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAO7B,OAAO,EACH,mCAAmC,EACnC,gCAAgC,EAChC,yBAAyB,EAC5B,MAAM,uBAAuB,CAAC;AAK/B,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAShD,OAAO,EACH,oCAAoC,EACpC,yBAAyB,EAC5B,MAAM,wBAAwB,CAAC;AAWhC,SAAS,sBAAsB,CAAC,KAAa,EAAE,OAAe;IAC1D,MAAM,OAAO,GAAG,mCAAmC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAEpE,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACnB,MAAM,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;AACL,CAAC;AAED,SAAS,wBAAwB,CAC7B,OAAyC;IAEzC,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,OAAO,IAAI,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,SAAS,wBAAwB,CAAC,OAAsC;IACpE,MAAM,QAAQ,GAAG,OAAO,IAAI,EAAE,CAAC;IAE/B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC7B,sBAAsB,CAAC,0BAA0B,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAChC,CAAC;AAED,SAAS,wBAAwB,CAC7B,OAA2C;IAE3C,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO;YACH,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,OAAO,CAAC;YAC1D,IAAI,EAAE,QAAQ;SACjB,CAAC;IACN,CAAC;IAED,MAAM,OAAO,GAAG,wBAAwB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAE1D,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IACvC,CAAC;IAED,KAAK,MAAM,OAAO,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACpC,sBAAsB,CAAC,0BAA0B,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC;IAED,OAAO;QACH,OAAO;QACP,OAAO,EAAE,CAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE;QAC5D,IAAI,EAAE,KAAK;KACd,CAAC;AACN,CAAC;AAED,SAAS,cAAc,CAAC,KAAyB;IAC7C,OAAO,KAAK,IAAI,IAAI,CAAC;AACzB,CAAC;AAED,SAAS,2BAA2B,CAChC,UAAiD;IAEjD,OAAO;QACH,QAAQ,EAAE,cAAc,CAAC,UAAU,EAAE,QAAQ,CAAC;QAC9C,SAAS,EAAE,cAAc,CAAC,UAAU,EAAE,SAAS,CAAC;QAChD,KAAK,EAAE,cAAc,CAAC,UAAU,EAAE,KAAK,CAAC;KAC3C,CAAC;AACN,CAAC;AAED,SAAS,gCAAgC,CACrC,eAAmC,EACnC,UAAyB;IAEzB,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;QAChC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QACtB,MAAM,IAAI,WAAW,CAAC,mDAAmD,CAAC,CAAC;IAC/E,CAAC;IAED,OAAO,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC;QACnC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC;QAC/B,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC,CAAC;AAClE,CAAC;AAED,MAAM,UAAU,uBAAuB,CACnC,MAAyC,EACzC,UAAyB;IAEzB,OAAO;QACH,eAAe,EAAE,gCAAgC,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC;QAChF,OAAO,EAAE,wBAAwB,CAAC,MAAM,EAAE,OAAO,CAAC;QAClD,OAAO,EAAE,wBAAwB,CAAC,MAAM,EAAE,OAAO,CAAC;QAClD,UAAU,EAAE,2BAA2B,CAAC,MAAM,EAAE,UAAU,CAAC;KAC9D,CAAC;AACN,CAAC;AAED,SAAS,oBAAoB,CAAC,WAA0B,EAAE,KAA4B;IAClF,OAAO,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,WAAW,IAAI,KAAK,EAAE,CAAC;AACpE,CAAC;AAED,SAAS,4BAA4B,CACjC,KAAiC,EACjC,WAA0B;IAE1B,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;QAClC,sBAAsB,CAAC,oBAAoB,CAAC,WAAW,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC;IAClF,CAAC;IAED,MAAM,eAAe,GAAG,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC;IAE5C,KAAK,MAAM,OAAO,IAAI,eAAe,EAAE,CAAC;QACpC,sBAAsB,CAAC,oBAAoB,CAAC,WAAW,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC;IAClF,CAAC;IAED,OAAO;QACH,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC;QACpC,OAAO,EAAE,CAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE;KAC3D,CAAC;AACN,CAAC;AAED,SAAS,6BAA6B,CAAC,IAAY;IAC/C,MAAM,OAAO,GAAG,gCAAgC,CAAC,IAAI,CAAC,CAAC;IAEvD,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACnB,MAAM,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;AACL,CAAC;AAED,SAAS,wBAAwB,CAAC,KAA6B;IAC3D,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAE3C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,WAAW,CAAC,gEAAgE,CAAC,CAAC;IAC5F,CAAC;IAED,OAAO;QACH,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,uBAAuB,CAAC,CAAE,IAAI,EAAE,GAAG,CAAE;YAC/E,6BAA6B,CAAC,IAAI,CAAC,CAAC;YAEpC,OAAO,CAAE,IAAI,EAAE,4BAA4B,CAAC,GAAG,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAE,CAAC;QACvE,CAAC,CAAC,CAAC;KACN,CAAC;AACN,CAAC;AAED,SAAS,kBAAkB,CAAC,KAA0B;IAClD,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,KAAsC;IACxE,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,OAAO,kBAAkB,CAAC,KAAK,CAAC;QAC5B,CAAC,CAAC,wBAAwB,CAAC,KAAK,CAAC;QACjC,CAAC,CAAC,4BAA4B,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACpD,CAAC;AAED,MAAM,UAAU,6BAA6B,CAAC,KAA0B;IACpE,OAAO,kBAAkB,CAAC,KAAK,CAAC;QAC5B,CAAC,CAAC,wBAAwB,CAAC,KAAK,CAAC;QACjC,CAAC,CAAC,4BAA4B,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACpD,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,WAAmB;IACtD,MAAM,OAAO,GAAG,yBAAyB,CAAC,WAAW,CAAC,CAAC;IAEvD,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACnB,MAAM,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,2BAA2B,CACvC,SAA+B,EAC/B,KAAmB;IAEnB,MAAM,OAAO,GAAG,oCAAoC,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAEvE,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACnB,MAAM,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,0BAA0B,CACtC,SAAkD;IAElD,OAAO,yBAAyB,CAAC,SAAS,EAAE,uBAAuB,CAAC,CAAC;AACzE,CAAC"}

package/{run/profile-file-glob.js → config/profile-patterns.js}

@@ -1,18 +1,14 @@
 import { isAbsolute } from 'node:path';
-const runProfileNamePattern = /^[A-Za-z0-9._-]+$/u;
-const reservedBenchmarkProfileName = 'benchmark';
-export function invalidRunProfileNameMessage(profileName) {
-    if (!runProfileNamePattern.test(profileName)) {
+const profileNamePattern = /^[A-Za-z0-9._-]+$/u;
+export function invalidProfileNameMessage(profileName) {
+    if (!profileNamePattern.test(profileName)) {
         return `Invalid profile name "${profileName}". ` +
             'Profile names may only contain letters, numbers, dots, underscores, and hyphens.';
     }
-    if (profileName === reservedBenchmarkProfileName) {
-        return 'Invalid profile name "benchmark". The "benchmark" profile name is reserved for benchmark commands.';
-    }
     return null;
 }
-export function invalidRunProfileFileSetNameMessage(fileSetName) {
-    return runProfileNamePattern.test(fileSetName)
+export function invalidProfileFileSetNameMessage(fileSetName) {
+    return profileNamePattern.test(fileSetName)
         ? null
         : `Invalid profile file set name "${fileSetName}". ` +
             'Profile file set names may only contain letters, numbers, dots, underscores, and hyphens.';
@@ -43,4 +39,4 @@ export function invalidProfileFileGlobConfigMessage(field, pattern) {
     const message = invalidProfileFileGlobMessage(field, pattern);
     return message === null ? null : configMessage(message);
 }
-//# sourceMappingURL=profile-file-glob.js.map
+//# sourceMappingURL=profile-patterns.js.map

package/config/profile-patterns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-patterns.js","sourceRoot":"","sources":["../../../../source/config/profile-patterns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC,MAAM,kBAAkB,GAAG,oBAAoB,CAAC;AAEhD,MAAM,UAAU,yBAAyB,CAAC,WAAmB;IACzD,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;QACxC,OAAO,yBAAyB,WAAW,KAAK;YAC5C,kFAAkF,CAAC;IAC3F,CAAC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,gCAAgC,CAAC,WAAmB;IAChE,OAAO,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC;QACvC,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,kCAAkC,WAAW,KAAK;YAChD,2FAA2F,CAAC;AACxG,CAAC;AAED,SAAS,YAAY,CAAC,OAAe;IACjC,OAAO,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;AACpC,CAAC;AAED,SAAS,aAAa,CAAC,OAAe;IAClC,OAAO,WAAW,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AAC3E,CAAC;AAED,MAAM,UAAU,6BAA6B,CAAC,KAAa,EAAE,OAAe;IACxE,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAEtC,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,iBAAiB,KAAK,kCAAkC,CAAC;IACpE,CAAC;IAED,IAAI,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QACjC,OAAO,iBAAiB,KAAK,2CAA2C,CAAC;IAC7E,CAAC;IAED,IAAI,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QACtB,OAAO,iBAAiB,KAAK,wCAAwC,CAAC;IAC1E,CAAC;IAED,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACvC,OAAO,iBAAiB,KAAK,iDAAiD,CAAC;IACnF,CAAC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,mCAAmC,CAAC,KAAa,EAAE,OAAe;IAC9E,MAAM,OAAO,GAAG,6BAA6B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAE9D,OAAO,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;AAC5D,CAAC"}

package/{run/run-config-schema.d.ts → config/schema.d.ts}

@@ -1,7 +1,7 @@
 import { z } from 'zod/v4';
 import { type DefinedOutputRenderer } from '../engine/reporter-output.ts';
 import { type DefinedReporter } from '../engine/reporter.ts';
-import { type RunProjectCoverageOutput as CoverageOutput, type RunProjectCoveragePolicy as CoveragePolicy, type RunProjectCoverageSources as CoverageSources, type RunProjectCoverageThresholds as CoverageThresholds } from './coverage-config-schema.ts';
+import { type ProjectCoverageOutput as CoverageOutput, type ProjectCoveragePolicy as CoveragePolicy, type ProjectCoverageSources as CoverageSources, type ProjectCoverageThresholds as CoverageThresholds } from './coverage-schema.ts';
 declare const integrationRetryPolicySchema: z.ZodReadonly<z.ZodObject<{
     artifacts: z.ZodOptional<z.ZodEnum<{
         all: "all";
@@ -10,7 +10,7 @@ declare const integrationRetryPolicySchema: z.ZodReadonly<z.ZodObject<{
     }>>;
     maxAttempts: z.ZodNumber;
 }, z.core.$strict>>;
-export type RunProjectIntegrationRetryPolicy = z.infer<typeof integrationRetryPolicySchema>;
+export type ProjectIntegrationRetryPolicy = z.infer<typeof integrationRetryPolicySchema>;
 declare const profileFilesSchema: z.ZodReadonly<z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
     exclude: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
     include: z.ZodReadonly<z.ZodTuple<[z.ZodString], z.ZodString>>;
@@ -74,7 +74,10 @@ export declare const microtestExecutionSchema: z.ZodDiscriminatedUnion<[z.ZodRea
 export declare const integrationExecutionSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
     maxConcurrency: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>>;
     processModel: z.ZodLiteral<"supervised-process">;
-    scheduling: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"concurrent">, z.ZodLiteral<"serial">]>>;
+    scheduling: z.ZodOptional<z.ZodEnum<{
+        serial: "serial";
+        concurrent: "concurrent";
+    }>>;
 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
     assignmentPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"case-count-balanced">, z.ZodLiteral<"duration-history-balanced">, z.ZodLiteral<"stable">]>>;
     dispatchPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"dynamic-lease">, z.ZodLiteral<"static-assignment">]>>;
@@ -88,7 +91,10 @@ export declare const integrationExecutionSchema: z.ZodDiscriminatedUnion<[z.ZodR
     maxConcurrency: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>>;
     maxWorkers: z.ZodOptional<z.ZodNumber>;
     processModel: z.ZodLiteral<"worker-pool">;
-    scheduling: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"concurrent">, z.ZodLiteral<"serial">]>>;
+    scheduling: z.ZodOptional<z.ZodEnum<{
+        serial: "serial";
+        concurrent: "concurrent";
+    }>>;
     workDistribution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
         mode: z.ZodLiteral<"file">;
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
@@ -188,7 +194,7 @@ export declare const attachmentLimitsSchema: z.ZodDefault<z.ZodReadonly<z.ZodObj
     maxScopeBytes: z.ZodDefault<z.ZodNumber>;
     maxScopeAttachments: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>>>;
-export type RunProjectAttachmentLimits = z.input<typeof attachmentLimitsSchema>;
+export type ProjectAttachmentLimits = z.input<typeof attachmentLimitsSchema>;
 export declare const integrationProfileSchema: z.ZodReadonly<z.ZodObject<{
     attachments: z.ZodDefault<z.ZodReadonly<z.ZodObject<{
         maxInlineBytes: z.ZodDefault<z.ZodNumber>;
@@ -199,7 +205,10 @@ export declare const integrationProfileSchema: z.ZodReadonly<z.ZodObject<{
     execution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
         maxConcurrency: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>>;
         processModel: z.ZodLiteral<"supervised-process">;
-        scheduling: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"concurrent">, z.ZodLiteral<"serial">]>>;
+        scheduling: z.ZodOptional<z.ZodEnum<{
+            serial: "serial";
+            concurrent: "concurrent";
+        }>>;
     }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
         assignmentPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"case-count-balanced">, z.ZodLiteral<"duration-history-balanced">, z.ZodLiteral<"stable">]>>;
         dispatchPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"dynamic-lease">, z.ZodLiteral<"static-assignment">]>>;
@@ -213,7 +222,10 @@ export declare const integrationProfileSchema: z.ZodReadonly<z.ZodObject<{
         maxConcurrency: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>>;
         maxWorkers: z.ZodOptional<z.ZodNumber>;
         processModel: z.ZodLiteral<"worker-pool">;
-        scheduling: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"concurrent">, z.ZodLiteral<"serial">]>>;
+        scheduling: z.ZodOptional<z.ZodEnum<{
+            serial: "serial";
+            concurrent: "concurrent";
+        }>>;
         workDistribution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
             mode: z.ZodLiteral<"file">;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
@@ -282,6 +294,88 @@ export declare const integrationProfileSchema: z.ZodReadonly<z.ZodObject<{
         softMilliseconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>;
 }, z.core.$strict>>;
+declare const benchmarkProfileSchema: z.ZodReadonly<z.ZodObject<{
+    attachments: z.ZodDefault<z.ZodReadonly<z.ZodObject<{
+        maxInlineBytes: z.ZodDefault<z.ZodNumber>;
+        maxArtifactBytes: z.ZodDefault<z.ZodNumber>;
+        maxScopeBytes: z.ZodDefault<z.ZodNumber>;
+        maxScopeAttachments: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    execution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        processModel: z.ZodLiteral<"supervised-process">;
+        maxConcurrency: z.ZodOptional<z.ZodLiteral<1>>;
+        scheduling: z.ZodOptional<z.ZodLiteral<"serial">>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        hedging: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            mode: z.ZodLiteral<"off">;
+        }, z.core.$strict>>>;
+        maxConcurrency: z.ZodOptional<z.ZodLiteral<1>>;
+        scheduling: z.ZodOptional<z.ZodLiteral<"serial">>;
+        assignmentPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"case-count-balanced">, z.ZodLiteral<"duration-history-balanced">, z.ZodLiteral<"stable">]>>;
+        dispatchPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"dynamic-lease">, z.ZodLiteral<"static-assignment">]>>;
+        maxWorkers: z.ZodOptional<z.ZodNumber>;
+        processModel: z.ZodLiteral<"worker-pool">;
+        workDistribution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            mode: z.ZodLiteral<"file">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            mode: z.ZodLiteral<"case">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            groups: z.ZodReadonly<z.ZodTuple<[z.ZodReadonly<z.ZodObject<{
+                fileSets: z.ZodReadonly<z.ZodTuple<[z.ZodString], z.ZodString>>;
+                granularity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"case">, z.ZodLiteral<"file">, z.ZodLiteral<"group">]>>;
+                name: z.ZodString;
+                order: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"lexical">, z.ZodLiteral<"plan">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"seeded">]>>;
+                scheduling: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"concurrent">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"serial">]>>;
+                workerLifecycle: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"fresh-worker-per-unit">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"reuse">]>>;
+            }, z.core.$strict>>], z.ZodReadonly<z.ZodObject<{
+                fileSets: z.ZodReadonly<z.ZodTuple<[z.ZodString], z.ZodString>>;
+                granularity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"case">, z.ZodLiteral<"file">, z.ZodLiteral<"group">]>>;
+                name: z.ZodString;
+                order: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"lexical">, z.ZodLiteral<"plan">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"seeded">]>>;
+                scheduling: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"concurrent">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"serial">]>>;
+                workerLifecycle: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"fresh-worker-per-unit">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"reuse">]>>;
+            }, z.core.$strict>>>>;
+            mode: z.ZodLiteral<"group">;
+            unmatched: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"file">, z.ZodLiteral<"reject">]>>;
+        }, z.core.$strict>>], "mode">>;
+        workerLifecycle: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"fresh-worker-per-unit">, z.ZodLiteral<"reuse">]>>;
+    }, z.core.$strict>>], "processModel">>;
+    files: z.ZodReadonly<z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+        exclude: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        include: z.ZodReadonly<z.ZodTuple<[z.ZodString], z.ZodString>>;
+        sets: z.ZodOptional<z.ZodNever>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        exclude: z.ZodOptional<z.ZodNever>;
+        include: z.ZodOptional<z.ZodNever>;
+        sets: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodReadonly<z.ZodObject<{
+            exclude: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            include: z.ZodReadonly<z.ZodTuple<[z.ZodString], z.ZodString>>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>]>>;
+    reporters: z.ZodOptional<z.ZodReadonly<z.ZodTuple<[z.ZodCustom<DefinedReporter, DefinedReporter>], z.ZodCustom<DefinedReporter, DefinedReporter>>>>;
+    resourceUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+        budgets: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            activeResourceCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            javaScriptEngineHeapBytes: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            residentSetBytes: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            residentSetGrowthBytesPerSecond: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>>>;
+        measure: z.ZodLiteral<true>;
+        samplingIntervalMilliseconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        measure: z.ZodOptional<z.ZodLiteral<false>>;
+    }, z.core.$strict>>]>>;
+    testFamily: z.ZodLiteral<"benchmark">;
+    timings: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        collection: z.ZodUnion<readonly [z.ZodLiteral<"precise">, z.ZodLiteral<"summary">]>;
+    }, z.core.$strict>>>;
+    timeouts: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        collectionMilliseconds: z.ZodOptional<z.ZodNumber>;
+        hardMilliseconds: z.ZodOptional<z.ZodNumber>;
+        softMilliseconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export type ProjectBenchmarkProfileConfig = z.input<typeof benchmarkProfileSchema>;
 export declare const projectConfigSchema: z.ZodReadonly<z.ZodObject<{
     loader: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
         sourceMaps: z.ZodBoolean;
@@ -289,6 +383,86 @@ export declare const projectConfigSchema: z.ZodReadonly<z.ZodObject<{
     }, z.core.$strict>>>;
     outputRenderer: z.ZodOptional<z.ZodCustom<DefinedOutputRenderer, DefinedOutputRenderer>>;
     profiles: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        attachments: z.ZodDefault<z.ZodReadonly<z.ZodObject<{
+            maxInlineBytes: z.ZodDefault<z.ZodNumber>;
+            maxArtifactBytes: z.ZodDefault<z.ZodNumber>;
+            maxScopeBytes: z.ZodDefault<z.ZodNumber>;
+            maxScopeAttachments: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        execution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            processModel: z.ZodLiteral<"supervised-process">;
+            maxConcurrency: z.ZodOptional<z.ZodLiteral<1>>;
+            scheduling: z.ZodOptional<z.ZodLiteral<"serial">>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            hedging: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                mode: z.ZodLiteral<"off">;
+            }, z.core.$strict>>>;
+            maxConcurrency: z.ZodOptional<z.ZodLiteral<1>>;
+            scheduling: z.ZodOptional<z.ZodLiteral<"serial">>;
+            assignmentPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"case-count-balanced">, z.ZodLiteral<"duration-history-balanced">, z.ZodLiteral<"stable">]>>;
+            dispatchPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"dynamic-lease">, z.ZodLiteral<"static-assignment">]>>;
+            maxWorkers: z.ZodOptional<z.ZodNumber>;
+            processModel: z.ZodLiteral<"worker-pool">;
+            workDistribution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                mode: z.ZodLiteral<"file">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                mode: z.ZodLiteral<"case">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                groups: z.ZodReadonly<z.ZodTuple<[z.ZodReadonly<z.ZodObject<{
+                    fileSets: z.ZodReadonly<z.ZodTuple<[z.ZodString], z.ZodString>>;
+                    granularity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"case">, z.ZodLiteral<"file">, z.ZodLiteral<"group">]>>;
+                    name: z.ZodString;
+                    order: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"lexical">, z.ZodLiteral<"plan">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"seeded">]>>;
+                    scheduling: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"concurrent">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"serial">]>>;
+                    workerLifecycle: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"fresh-worker-per-unit">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"reuse">]>>;
+                }, z.core.$strict>>], z.ZodReadonly<z.ZodObject<{
+                    fileSets: z.ZodReadonly<z.ZodTuple<[z.ZodString], z.ZodString>>;
+                    granularity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"case">, z.ZodLiteral<"file">, z.ZodLiteral<"group">]>>;
+                    name: z.ZodString;
+                    order: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"lexical">, z.ZodLiteral<"plan">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"seeded">]>>;
+                    scheduling: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"concurrent">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"serial">]>>;
+                    workerLifecycle: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"fresh-worker-per-unit">, z.ZodLiteral<"profile-default">, z.ZodLiteral<"reuse">]>>;
+                }, z.core.$strict>>>>;
+                mode: z.ZodLiteral<"group">;
+                unmatched: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"file">, z.ZodLiteral<"reject">]>>;
+            }, z.core.$strict>>], "mode">>;
+            workerLifecycle: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"fresh-worker-per-unit">, z.ZodLiteral<"reuse">]>>;
+        }, z.core.$strict>>], "processModel">>;
+        files: z.ZodReadonly<z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+            exclude: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            include: z.ZodReadonly<z.ZodTuple<[z.ZodString], z.ZodString>>;
+            sets: z.ZodOptional<z.ZodNever>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            exclude: z.ZodOptional<z.ZodNever>;
+            include: z.ZodOptional<z.ZodNever>;
+            sets: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodReadonly<z.ZodObject<{
+                exclude: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                include: z.ZodReadonly<z.ZodTuple<[z.ZodString], z.ZodString>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>>]>>;
+        reporters: z.ZodOptional<z.ZodReadonly<z.ZodTuple<[z.ZodCustom<DefinedReporter, DefinedReporter>], z.ZodCustom<DefinedReporter, DefinedReporter>>>>;
+        resourceUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+            budgets: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                activeResourceCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                javaScriptEngineHeapBytes: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                residentSetBytes: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                residentSetGrowthBytesPerSecond: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>>;
+            measure: z.ZodLiteral<true>;
+            samplingIntervalMilliseconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            measure: z.ZodOptional<z.ZodLiteral<false>>;
+        }, z.core.$strict>>]>>;
+        testFamily: z.ZodLiteral<"benchmark">;
+        timings: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            collection: z.ZodUnion<readonly [z.ZodLiteral<"precise">, z.ZodLiteral<"summary">]>;
+        }, z.core.$strict>>>;
+        timeouts: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            collectionMilliseconds: z.ZodOptional<z.ZodNumber>;
+            hardMilliseconds: z.ZodOptional<z.ZodNumber>;
+            softMilliseconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
         attachments: z.ZodDefault<z.ZodReadonly<z.ZodObject<{
             maxInlineBytes: z.ZodDefault<z.ZodNumber>;
             maxArtifactBytes: z.ZodDefault<z.ZodNumber>;
@@ -298,7 +472,10 @@ export declare const projectConfigSchema: z.ZodReadonly<z.ZodObject<{
         execution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
             maxConcurrency: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>>;
             processModel: z.ZodLiteral<"supervised-process">;
-            scheduling: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"concurrent">, z.ZodLiteral<"serial">]>>;
+            scheduling: z.ZodOptional<z.ZodEnum<{
+                serial: "serial";
+                concurrent: "concurrent";
+            }>>;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
             assignmentPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"case-count-balanced">, z.ZodLiteral<"duration-history-balanced">, z.ZodLiteral<"stable">]>>;
             dispatchPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"dynamic-lease">, z.ZodLiteral<"static-assignment">]>>;
@@ -312,7 +489,10 @@ export declare const projectConfigSchema: z.ZodReadonly<z.ZodObject<{
             maxConcurrency: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>>;
             maxWorkers: z.ZodOptional<z.ZodNumber>;
             processModel: z.ZodLiteral<"worker-pool">;
-            scheduling: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"concurrent">, z.ZodLiteral<"serial">]>>;
+            scheduling: z.ZodOptional<z.ZodEnum<{
+                serial: "serial";
+                concurrent: "concurrent";
+            }>>;
             workDistribution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
                 mode: z.ZodLiteral<"file">;
             }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
@@ -451,21 +631,21 @@ export declare const projectConfigSchema: z.ZodReadonly<z.ZodObject<{
     reporters: z.ZodOptional<z.ZodReadonly<z.ZodTuple<[z.ZodCustom<DefinedReporter, DefinedReporter>], z.ZodCustom<DefinedReporter, DefinedReporter>>>>;
     runtimeStateDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>>;
-export type RunProjectResourceBudgets = z.infer<typeof resourceBudgetsSchema>;
-export type RunProjectCoverageOutput = CoverageOutput;
-export type RunProjectCoveragePolicy = CoveragePolicy;
-export type RunProjectCoverageSources = CoverageSources;
-export type RunProjectCoverageThresholds = CoverageThresholds;
-export type RunProjectProfileFiles = z.infer<typeof profileFilesSchema>;
-export type RunProjectMeasuredResourceUsage = z.infer<typeof measuredResourceUsageSchema>;
-export type RunProjectUnmeasuredResourceUsage = z.infer<typeof unmeasuredResourceUsageSchema>;
-export type RunProjectResourceUsageConfig = z.infer<typeof resourceUsageSchema>;
-export type RunProjectTimingProfilePolicy = z.infer<typeof timingProfilePolicySchema>;
-export type RunProjectTimeoutConfig = z.infer<typeof timeoutSchema>;
-export type RunProjectIntegrationExecution = z.infer<typeof integrationExecutionSchema>;
-export type RunProjectIntegrationProfileConfig = z.infer<typeof integrationProfileSchema>;
-export type RunProjectMicrotestExecution = z.infer<typeof microtestExecutionSchema>;
-export type RunProjectMicrotestProfileConfig = z.infer<typeof microtestProfileSchema>;
-export type RunProjectConfig = z.infer<typeof projectConfigSchema>;
+export type ProjectResourceBudgets = z.infer<typeof resourceBudgetsSchema>;
+export type ProjectCoverageOutput = CoverageOutput;
+export type ProjectCoveragePolicy = CoveragePolicy;
+export type ProjectCoverageSources = CoverageSources;
+export type ProjectCoverageThresholds = CoverageThresholds;
+export type ProjectProfileFiles = z.infer<typeof profileFilesSchema>;
+export type ProjectMeasuredResourceUsage = z.infer<typeof measuredResourceUsageSchema>;
+export type ProjectUnmeasuredResourceUsage = z.infer<typeof unmeasuredResourceUsageSchema>;
+export type ProjectResourceUsageConfig = z.infer<typeof resourceUsageSchema>;
+export type ProjectTimingProfilePolicy = z.infer<typeof timingProfilePolicySchema>;
+export type ProjectTimeoutConfig = z.infer<typeof timeoutSchema>;
+export type ProjectIntegrationExecution = z.infer<typeof integrationExecutionSchema>;
+export type ProjectIntegrationProfileConfig = z.infer<typeof integrationProfileSchema>;
+export type ProjectMicrotestExecution = z.infer<typeof microtestExecutionSchema>;
+export type ProjectMicrotestProfileConfig = z.infer<typeof microtestProfileSchema>;
+export type Config = z.infer<typeof projectConfigSchema>;
 export {};
-//# sourceMappingURL=run-config-schema.d.ts.map
+//# sourceMappingURL=schema.d.ts.map

package/config/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../source/config/schema.ts"],"names":[],"mappings":"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"}

package/{run/run-config-schema.js → config/schema.js}

@@ -2,7 +2,7 @@ import { z } from 'zod/v4';
 import { defaultAttachmentLimits } from "../engine/runtime-attachment.js";
 import { isOutputRenderer } from "../engine/reporter-output.js";
 import { isReporter } from "../engine/reporter.js";
-import { coveragePolicySchema } from "./coverage-config-schema.js";
+import { coveragePolicySchema } from "./coverage-schema.js";
 const reporterSchema = z.custom(isReporter, 'must be created with defineReporter(...)');
 const outputRendererSchema = z.custom(isOutputRenderer, 'must be created with defineOutputRenderer(...)');
 const loaderSchema = z
@@ -173,25 +173,38 @@ const workDistributionSchema = z.discriminatedUnion('mode', [
     })
         .readonly()
 ]);
+const workerPoolExecutionFields = {
+    assignmentPolicy: z.optional(workerPoolAssignmentPolicySchema),
+    dispatchPolicy: z.optional(workerPoolDispatchPolicySchema),
+    hedging: z.optional(workerPoolHedgingSchema),
+    maxConcurrency: z.optional(maxConcurrencySchema),
+    maxWorkers: z.optional(positiveSafeIntegerSchema),
+    processModel: z.literal('worker-pool'),
+    scheduling: z.optional(z.enum(['concurrent', 'serial'])),
+    workDistribution: z.optional(workDistributionSchema),
+    workerLifecycle: z.optional(workerLifecycleSchema)
+};
 export const integrationExecutionSchema = z.discriminatedUnion('processModel', [
     z
         .strictObject({
         maxConcurrency: z.optional(maxConcurrencySchema),
         processModel: z.literal('supervised-process'),
-        scheduling: z.optional(z.union([z.literal('concurrent'), z.literal('serial')]))
+        scheduling: z.optional(z.enum(['concurrent', 'serial']))
     })
         .readonly(),
+    z.strictObject(workerPoolExecutionFields).readonly()
+]);
+const benchmarkAdmissionFields = {
+    maxConcurrency: z.optional(z.literal(1)),
+    scheduling: z.optional(z.literal('serial'))
+};
+const benchmarkExecutionSchema = z.discriminatedUnion('processModel', [
+    z.strictObject({ ...benchmarkAdmissionFields, processModel: z.literal('supervised-process') }).readonly(),
     z
         .strictObject({
-        assignmentPolicy: z.optional(workerPoolAssignmentPolicySchema),
-        dispatchPolicy: z.optional(workerPoolDispatchPolicySchema),
-        hedging: z.optional(workerPoolHedgingSchema),
-        maxConcurrency: z.optional(maxConcurrencySchema),
-        maxWorkers: z.optional(positiveSafeIntegerSchema),
-        processModel: z.literal('worker-pool'),
-        scheduling: z.optional(z.union([z.literal('concurrent'), z.literal('serial')])),
-        workDistribution: z.optional(workDistributionSchema),
-        workerLifecycle: z.optional(workerLifecycleSchema)
+        ...workerPoolExecutionFields,
+        ...benchmarkAdmissionFields,
+        hedging: z.optional(z.strictObject({ mode: z.literal('off') }).readonly())
     })
         .readonly()
 ]);
@@ -229,7 +242,20 @@ export const integrationProfileSchema = z
     timeouts: z.optional(timeoutSchema)
 })
     .readonly();
+const benchmarkProfileSchema = z
+    .strictObject({
+    attachments: attachmentLimitsSchema,
+    execution: z.optional(benchmarkExecutionSchema),
+    files: profileFilesSchema,
+    reporters: z.optional(z.tuple([reporterSchema]).rest(reporterSchema).readonly()),
+    resourceUsage: z.optional(resourceUsageSchema),
+    testFamily: z.literal('benchmark'),
+    timings: z.optional(timingProfilePolicySchema),
+    timeouts: z.optional(timeoutSchema)
+})
+    .readonly();
 const profileSchema = z.discriminatedUnion('testFamily', [
+    benchmarkProfileSchema,
     integrationProfileSchema,
     microtestProfileSchema
 ]);
@@ -246,4 +272,4 @@ export const projectConfigSchema = z
 export function workerPoolProjectExecution(execution) {
     return execution?.processModel === 'worker-pool' ? execution : null;
 }
-//# sourceMappingURL=run-config-schema.js.map
+//# sourceMappingURL=schema.js.map