@gfdelarue/testkit 0.4.4 → 0.5.0

package/dist/app/run/engine-execution.d.ts

@@ -1,63 +0,0 @@
-import { type EngineExecutionResult, type EngineTaskOutcome } from "../../engines/api/index.js";
-import { type EngineId } from "../../domain/identifiers.js";
-import { type TestOutcomeStatus } from "../../domain/test-outcomes.js";
-import type { ResolvedEngineExecutionSession } from "../../engines/manager.js";
-import { type PersistedArtifactReference } from "../../evidence/index.js";
-export { EngineExecutionBridgeError, type EngineExecutionBridgeDisposition, type EngineExecutionRuntimeImpact, } from "./engine-execution-failures.js";
-import { type EndpointReadinessResult } from "./endpoint-readiness.js";
-import { type NormalizedCheckDetail, type TaskFailureDetail } from "./failure-details.js";
-import type { RuntimeTaskReporter } from "./runtime-task-types.js";
-import type { ScheduledTask } from "./scheduler/index.js";
-import type { TaskBatch } from "./task-batches.js";
-import type { ExecutionEnvironmentLease } from "../../steps/index.js";
-import type { ReadyEnvironment } from "../../environment/ready-environment.js";
-export type EngineExecutableTask = ScheduledTask | TaskBatch<ScheduledTask>;
-export interface EngineExecutionManager {
-    withEngine<Result>(engineId: EngineId, signal: AbortSignal, operation: (session: ResolvedEngineExecutionSession) => Result | PromiseLike<Result>): Promise<Result>;
-}
-export interface EngineExecutionLifecycle {
-    isStopRequested(): boolean;
-    readonly runId: string;
-    readonly signal: AbortSignal;
-}
-export interface EngineExecutionLease extends ExecutionEnvironmentLease {
-    readonly engineCacheDirectory?: string;
-    readonly engineWorkspaceDirectory?: string;
-    readonly leaseDir: string;
-    readonly leaseId: string;
-}
-export interface EngineTaskExecutionOutcome {
-    artifacts: PersistedArtifactReference[];
-    blockedByRuntime: boolean;
-    checkDetails: NormalizedCheckDetail[];
-    durationMs: number;
-    error: null | string;
-    failureDetails: TaskFailureDetail[];
-    finishedAt: number;
-    infraFailed: boolean;
-    reason: null | string;
-    runtimeBatch?: {
-        fileCount: number;
-        files: string[];
-        id: string;
-        index: number;
-    };
-    startedAt: number;
-    status: TestOutcomeStatus;
-    task: ScheduledTask;
-}
-export interface EngineTaskExecutionResult {
-    outcomes: EngineTaskExecutionOutcome[];
-}
-export interface EngineExecutionReporter extends RuntimeTaskReporter<ScheduledTask> {
-    taskFinished?(task: Readonly<ScheduledTask>, outcome: Readonly<EngineTaskExecutionOutcome>): unknown;
-}
-export declare function executeEngineTask(manager: EngineExecutionManager, environment: ReadyEnvironment, executableTask: EngineExecutableTask, lifecycle: EngineExecutionLifecycle, reporter?: null | EngineExecutionReporter): Promise<EngineTaskExecutionResult>;
-export declare function mapEngineOutcomes(tasks: readonly ScheduledTask[], result: Readonly<EngineExecutionResult>): Array<{
-    outcome: EngineTaskOutcome;
-    task: ScheduledTask;
-}>;
-export declare function buildEndpointReadinessOutcomes(tasks: readonly ScheduledTask[], executableTask: EngineExecutableTask, readiness: Extract<EndpointReadinessResult, {
-    ok: false;
-}>, cancelled: boolean, startedAt: number, finishedAt: number): EngineTaskExecutionOutcome[];
-export declare function mapEngineOutcome(outcome: Readonly<EngineTaskOutcome>, task: ScheduledTask, artifacts: PersistedArtifactReference[], executableTask: EngineExecutableTask, batchIndex: number): EngineTaskExecutionOutcome;

package/dist/app/run/engine-failure-stack.d.ts

@@ -1 +0,0 @@
-export declare function formatEngineInvocationStack(error: unknown): string | undefined;

package/dist/app/run/engine-orchestration.d.ts

@@ -1,49 +0,0 @@
-import { type EngineExecutionInputs, type EngineJsonObject, type RunnerProfileDescriptor } from "../../engines/api/index.js";
-import { type EngineId, type RunnerProfileId } from "../../domain/identifiers.js";
-import type { DatabaseInfo } from "../../database/index.js";
-import type { ScheduledTask } from "./scheduler/index.js";
-import { type ExecutionEnvironmentConfig, type ExecutionEnvironmentLease } from "../../steps/index.js";
-import type { EndpointReadinessOwner } from "../../engines/definitions.js";
-export type { EndpointReadinessOwner } from "../../engines/definitions.js";
-export interface EngineOrchestrationTargetConfig extends ExecutionEnvironmentConfig {
-    readonly engineConfigurations?: Readonly<Partial<Record<EngineId, EngineJsonObject>>>;
-    readonly stateDir: string;
-    readonly testkit: ExecutionEnvironmentConfig["testkit"] & {
-        readonly local?: (NonNullable<ExecutionEnvironmentConfig["testkit"]["local"]> & {
-            readonly baseUrl?: null | string;
-            readonly cwd?: string;
-        }) | null;
-    };
-}
-export interface EngineOrchestrationLease extends ExecutionEnvironmentLease {
-    readonly leaseDir: string;
-    readonly leaseId: number | string;
-}
-export interface EngineInputPreparationContext {
-    readonly baseUrl: null | string;
-    readonly lease: EngineOrchestrationLease;
-    readonly profile: RunnerProfileDescriptor;
-    readonly runtimeEnvironment: Readonly<Record<string, string>>;
-    readonly targetConfig: EngineOrchestrationTargetConfig;
-    readonly task: ScheduledTask;
-}
-export interface EngineRuntimePreparationContext {
-    readonly baseUrl: null | string;
-    readonly database: Readonly<DatabaseInfo> | null;
-    readonly targetConfig: EngineOrchestrationTargetConfig;
-    readonly task: ScheduledTask;
-}
-export interface EngineOrchestrationIntegration {
-    buildEnvironment(context: Readonly<EngineInputPreparationContext>): Readonly<Record<string, string>>;
-    buildRuntimeEnvironment(context: Readonly<EngineRuntimePreparationContext>): Readonly<Record<string, string>>;
-    readonly endpointReadinessOwner: EndpointReadinessOwner;
-    readonly engineId: EngineId;
-    readonly profileId: RunnerProfileId;
-    resolveConfiguration(context: Readonly<EngineInputPreparationContext>): EngineExecutionInputs["configuration"];
-    resolveSupportModules(context: Readonly<EngineInputPreparationContext>): EngineExecutionInputs["supportModules"];
-}
-export interface EngineOrchestrationRegistry {
-    readonly integrations: readonly EngineOrchestrationIntegration[];
-    resolve(profile: Readonly<RunnerProfileDescriptor>): EngineOrchestrationIntegration;
-}
-export declare const BUILT_IN_ENGINE_ORCHESTRATION: EngineOrchestrationRegistry;

package/dist/app/run/failure-details.d.ts

@@ -1,37 +0,0 @@
-import type { ReportingFailureDetail } from "../../evidence/index.js";
-export interface FailureDetailJsonRecord {
-    [key: string]: FailureDetailJsonValue;
-}
-export type FailureDetailJsonValue = boolean | FailureDetailJsonRecord | FailureDetailJsonValue[] | null | number | string;
-export interface NormalizedFailureDetail extends ReportingFailureDetail {
-    actual?: FailureDetailJsonValue;
-    checkName?: string;
-    classification?: string;
-    count: number;
-    expected?: FailureDetailJsonValue;
-    groupPath?: string[];
-    key: string;
-    kind: string;
-    labelled?: boolean;
-    location?: FailureDetailJsonRecord;
-    message?: string;
-    phase?: string;
-    request?: FailureDetailJsonRecord;
-    response?: FailureDetailJsonRecord;
-    stack?: string;
-    suitePath?: string[];
-    title: string;
-    traceId?: string;
-}
-export type TaskFailureDetail = NormalizedFailureDetail;
-export interface NormalizedCheckDetail {
-    fails: number;
-    name: string;
-    passed: boolean;
-    passes: number;
-    path: string[];
-}
-export declare function normalizeFailureDetail(detail: unknown): NormalizedFailureDetail | null;
-export declare function mergeFailureDetails(details: readonly NormalizedFailureDetail[]): NormalizedFailureDetail[];
-export declare function collectFailureDetailsFromRuntimeArtifacts(artifacts: unknown): NormalizedFailureDetail[];
-export declare function collectCheckDetailsFromRuntimeArtifacts(artifacts: unknown): NormalizedCheckDetail[];

package/dist/app/run/live-run.d.ts

@@ -1,27 +0,0 @@
-import { type ServiceTracker } from "./results.js";
-import { type BuildLiveRunArtifactOptions, type ReportingRecord } from "../../evidence/index.js";
-import type { RunLogRegistry } from "../../evidence/logs.js";
-import type { OperationTimingRegistry } from "../../evidence/operation-timings.js";
-import type { SetupOperationRegistry } from "../../evidence/setup-progress.js";
-interface LiveRunServiceConfig {
-    name: string;
-}
-type LiveRunWorkerState = Pick<BuildLiveRunArtifactOptions, "runtimeInstanceCount" | "runtimeStats" | "workerCount">;
-interface LiveRunSelection extends Pick<BuildLiveRunArtifactOptions, "fileNames" | "serviceFilter" | "suiteSelectors" | "typeValues"> {
-    planning?: null | ReportingRecord;
-}
-interface LiveRunReporter {
-    warning?(message: string): unknown;
-}
-export interface CreateLiveSnapshotWriterOptions extends Pick<BuildLiveRunArtifactOptions, "archiveConfig" | "declaredEnvironmentKeys" | "execution" | "metadata" | "productDir" | "runId" | "startedAt"> {
-    configs: readonly LiveRunServiceConfig[];
-    logRegistry: Pick<RunLogRegistry, "listServiceLogs" | "listSetupLogs">;
-    operationTimingRegistry?: null | OperationTimingRegistry;
-    reporter?: LiveRunReporter | null;
-    selection: LiveRunSelection;
-    setupRegistry: Pick<SetupOperationRegistry, "listOperations">;
-    trackers: ReadonlyMap<string, ServiceTracker>;
-    workerState: LiveRunWorkerState;
-}
-export declare function createLiveSnapshotWriter({ productDir, runId, configs, trackers, startedAt, execution, workerState, selection, archiveConfig, declaredEnvironmentKeys, metadata, logRegistry, setupRegistry, operationTimingRegistry, reporter, }: CreateLiveSnapshotWriterOptions): () => void;
-export {};

package/dist/app/run/operation-progress.d.ts

@@ -1,13 +0,0 @@
-import type { ReportingOperationTimingInput } from "../../evidence/index.js";
-export interface OperationProgressInput extends ReportingOperationTimingInput {
-    id: string;
-    status: string;
-}
-export interface OperationProgressReporter {
-    operationFinished?(operation: OperationProgressInput): void;
-    operationProgress?(operation: OperationProgressInput): void;
-    operationStarted?(operation: OperationProgressInput): void;
-}
-export type OperationReporterBridge = (operations?: readonly OperationProgressInput[]) => void;
-export declare function createOperationReporterBridge(reporter?: OperationProgressReporter | null): OperationReporterBridge;
-export declare function operationProgressSignature(operation?: ReportingOperationTimingInput): string | undefined;

package/dist/app/run/orchestrator.d.ts

@@ -1,68 +0,0 @@
-import { type CollectedSuite, type CollectSuitesOptions, type PlanningServicePlan } from "./planning.js";
-import { type FinalizedServiceResult } from "./results.js";
-import { type RunEventListener } from "./run-events.js";
-import type { NormalizedServiceConfig, NormalizedSuiteConfig } from "../../config/loader/index.js";
-import { type RuntimeManagerRuntimeOptions } from "../../environment/run-environment.js";
-import { type WorkerReporter, type WorkerResult } from "./worker-loop.js";
-import { type CreateLiveSnapshotWriterOptions } from "./live-run.js";
-import { type FinalizedRunArtifacts, type FinalizeRunArtifactsOptions } from "./run-finalization.js";
-import { type OperationProgressReporter } from "./operation-progress.js";
-import { type SerializedError } from "../../kernel/error-serialization.js";
-import type { NormalizedExecutionConfig } from "../../config/loader/execution-model.js";
-import type { SuiteSelector } from "../../domain/suite-selection.js";
-type NormalizedServicePlanBase = Omit<PlanningServicePlan<NormalizedServiceConfig>, "runtimeKey" | "skipped" | "suites"> & {
-    execution: NormalizedExecutionConfig;
-};
-export interface ExecutableServicePlan extends NormalizedServicePlanBase {
-    runtimeKey: string;
-    skipped: false;
-    suites: readonly CollectedSuite<NormalizedSuiteConfig>[];
-}
-export interface SkippedServicePlan extends NormalizedServicePlanBase {
-    runtimeConfigs: readonly [];
-    runtimeKey: null;
-    runtimeNames: readonly [];
-    skipped: true;
-    suites: readonly [];
-}
-export type ServicePlan = ExecutableServicePlan | SkippedServicePlan;
-export interface PlannedSkip {
-    engineId: CollectedSuite["engineId"];
-    file: string;
-    profileId: CollectedSuite["profileId"];
-    reason: string;
-    serviceName: string;
-    testType: CollectedSuite["testType"];
-}
-interface OrchestratorReporter {
-    plannedSkip?(entry: Readonly<PlannedSkip>): void;
-    serviceSkipped?(config: Readonly<NormalizedServiceConfig>, reason: string): void;
-    setServicePlans?(plans: readonly ServicePlan[]): void;
-    setTotalFileCount?(count: number): void;
-}
-type RuntimeManagerReporter = NonNullable<RuntimeManagerRuntimeOptions["reporter"]>;
-type LiveRunReporter = NonNullable<CreateLiveSnapshotWriterOptions["reporter"]>;
-type RunFinalizationReporter = NonNullable<FinalizeRunArtifactsOptions<FinalizedServiceResult>["reporter"]>;
-export type RunReporter = OrchestratorReporter & OperationProgressReporter & RuntimeManagerReporter & WorkerReporter & LiveRunReporter & RunFinalizationReporter;
-export interface RunOptions extends CollectSuitesOptions {
-    serviceFilter?: null | string;
-    allowEmpty?: boolean;
-    debug?: boolean;
-    fileNames?: readonly string[];
-    fileTimeoutSeconds?: null | number;
-    onEvent?: null | RunEventListener;
-    skipSchemaSourceVerify?: boolean;
-    taskConcurrency?: null | number;
-}
-export interface RunResult {
-    exitCode: number;
-    failure?: SerializedError;
-    results: FinalizedServiceResult[];
-    runArtifact: FinalizedRunArtifacts["runArtifact"];
-}
-export declare function runAll(configs: readonly NormalizedServiceConfig[], typeValues: readonly string[], suiteSelectors: readonly SuiteSelector[], opts: Readonly<RunOptions>, allConfigs?: readonly NormalizedServiceConfig[]): Promise<RunResult>;
-export declare function workerResultErrorsForOrchestrator(result: PromiseSettledResult<WorkerResult>): string[];
-export declare function resolveRunGateFailure(results: readonly FinalizedServiceResult[], allowEmpty?: boolean): null | string;
-export declare function resolveRunExecutionConfig(config: NormalizedServiceConfig | undefined, opts: Readonly<Pick<RunOptions, "fileTimeoutSeconds" | "taskConcurrency">>): NormalizedExecutionConfig;
-export declare function collectServicePlans(configs: readonly NormalizedServiceConfig[], configMap: ReadonlyMap<string, NormalizedServiceConfig>, typeValues: readonly string[], suiteSelectors: readonly SuiteSelector[], opts: Readonly<RunOptions>, execution: Readonly<NormalizedExecutionConfig>, reporter?: null | RunReporter): ServicePlan[];
-export {};

package/dist/app/run/planning-types.d.ts

@@ -1,68 +0,0 @@
-import type { SuiteSelector } from "../../domain/suite-selection.js";
-import type { EngineId, PublicTestType, RunnerProfileId } from "../../domain/identifiers.js";
-import type { DatabaseMaterializationInput } from "../../config/loader/index.js";
-import type { DatabaseBinding } from "../../config/loader/execution-model.js";
-export interface PlanningTask {
-    engineId: EngineId;
-    profileId: RunnerProfileId;
-    testType: PublicTestType;
-}
-export interface PlanningSuiteConfig {
-    engineId: EngineId;
-    files: readonly string[];
-    name: string;
-    profileId: RunnerProfileId;
-    testType: PublicTestType;
-    testkit?: {
-        weight?: null | number;
-    } | null;
-}
-export interface PlanningSkipSuiteRule {
-    reason: string;
-    selector: SuiteSelector;
-}
-export interface PlanningFileMetadata {
-    skipReason?: null | string;
-}
-export interface PlanningSkipConfig {
-    fileReasonByPath?: ReadonlyMap<string, string>;
-    suites?: readonly PlanningSkipSuiteRule[];
-}
-export interface PlanningServiceTestkitConfig {
-    database?: (DatabaseMaterializationInput & {
-        binding?: DatabaseBinding;
-    }) | null;
-    dependsOn?: readonly string[];
-    fileMetadataByPath?: ReadonlyMap<string, PlanningFileMetadata>;
-    runtime: {
-        instances: number;
-        maxConcurrentTasks: number;
-    };
-    skip?: PlanningSkipConfig | null;
-}
-export interface PlanningServiceConfig<Suite extends PlanningSuiteConfig = PlanningSuiteConfig> {
-    name: string;
-    suites: Readonly<Partial<Record<PublicTestType, readonly Suite[] | undefined>>>;
-    testkit: PlanningServiceTestkitConfig;
-}
-export type CollectedSuite<Suite extends PlanningSuiteConfig = PlanningSuiteConfig> = Omit<Suite, "files"> & {
-    files: readonly string[];
-    orderIndex: number;
-    skippedFiles: Array<{
-        path: string;
-        reason: string;
-    }>;
-    sortKey: string;
-    totalFileCount: number;
-    weight: number;
-};
-export interface PlanningServicePlan<Config extends PlanningServiceConfig = PlanningServiceConfig> {
-    assignedGraphKey?: string;
-    config: Config;
-    runtimeConfigs: readonly Config[];
-    runtimeKey: string;
-    runtimeNames: readonly string[];
-    skipped?: boolean;
-    suites?: readonly PlanningSuiteConfig[];
-}
-export type { RuntimeGraph } from "../../environment/planning-types.js";

package/dist/app/run/planning.d.ts

@@ -1,15 +0,0 @@
-import type { RuntimeGraph } from "../../environment/planning-types.js";
-import type { PlanningTask, PlanningSuiteConfig, PlanningServiceConfig, CollectedSuite, PlanningServicePlan } from "./planning-types.js";
-import { type SuiteSelector } from "../../domain/suite-selection.js";
-import { type PublicTestType } from "../../domain/identifiers.js";
-export interface CollectSuitesOptions {
-    ignoreSkipRules?: boolean;
-}
-export declare function taskNeedsLocalRuntime(task: Readonly<PlanningTask>): boolean;
-export declare function collectSuites<Suite extends PlanningSuiteConfig>(config: PlanningServiceConfig<Suite>, typeValues: readonly string[], suiteSelectors: readonly SuiteSelector[], fileNames?: readonly string[], opts?: Readonly<CollectSuitesOptions>): CollectedSuite<Suite>[];
-export declare function orderedTypes(types: readonly string[]): PublicTestType[];
-export declare function claimNextTask<Task extends {
-    graphKey?: unknown;
-}>(queue: Task[], preferredGraphKey: unknown, isRunnable?: (task: Task) => boolean): Task | null;
-export type { PlanningTask, PlanningSuiteConfig, PlanningSkipSuiteRule, PlanningFileMetadata, PlanningSkipConfig, PlanningServiceTestkitConfig, PlanningServiceConfig, CollectedSuite, PlanningServicePlan, RuntimeGraph, } from "./planning-types.js";
-export declare function buildRuntimeGraphs<Config extends PlanningServiceConfig>(servicePlans: readonly PlanningServicePlan<Config>[]): RuntimeGraph<Config>[];

package/dist/app/run/playwright-configuration.d.ts

@@ -1,2 +0,0 @@
-import { buildTemplateContext, type ExecutionEnvironmentConfig } from "../../steps/index.js";
-export declare function buildPlaywrightUiConfig(config: Readonly<ExecutionEnvironmentConfig>, baseUrl: string, lease: Readonly<Parameters<typeof buildTemplateContext>[1]>): unknown;

package/dist/app/run/playwright-configuration.js

@@ -1 +0,0 @@
-import{buildTemplateContext as l,finalizeSerializable as s}from"../../steps/index.js";export function buildPlaywrightUiConfig(t,e,n){const i=l(t,n),r=t.testkit.ui?s(t.testkit.ui,i):null,o=c(r)?{...r}:{};return a(e)&&(o.allowRemote=!0),o}function a(t){try{const e=new URL(t);return!u(e.hostname)}catch{return!1}}function u(t){const e=t.toLowerCase();return e==="localhost"||e==="::1"||e==="0.0.0.0"||e==="127.0.0.1"||e.endsWith(".localhost")||e.startsWith("127.")}function c(t){return t!==null&&typeof t=="object"&&!Array.isArray(t)}

package/dist/app/run/request.d.ts

@@ -1,30 +0,0 @@
-export interface RunRequestInput {
-    dir?: string;
-    service?: string;
-    taskConcurrency?: string;
-    workers?: string;
-    fileTimeoutSeconds?: string;
-    type?: readonly string[];
-    suite?: readonly string[];
-    file?: readonly string[];
-    allowEmpty: boolean;
-    ignoreSkipRules: boolean;
-    skipSchemaSourceVerify: boolean;
-}
-export declare function buildRunRequest(input: Readonly<RunRequestInput>, positionalType?: null | string, cwd?: string, invocationCwd?: string): Promise<{
-    allConfigs: import("../../config/loader/load.js").NormalizedServiceConfig[];
-    configs: import("../../config/loader/load.js").NormalizedServiceConfig[];
-    productDir: string;
-    typeValues: string[];
-    suiteSelectors: import("../../domain/suite-selection.js").SuiteSelector[];
-    runOptions: {
-        allowEmpty: boolean;
-        fileNames: string[];
-        taskConcurrency: number | null;
-        fileTimeoutSeconds: number | null;
-        serviceFilter: string | null;
-        ignoreSkipRules: boolean;
-        skipSchemaSourceVerify: boolean;
-    };
-}>;
-export type RunRequest = Awaited<ReturnType<typeof buildRunRequest>>;

package/dist/app/run/results.d.ts

@@ -1,161 +0,0 @@
-import type { RuntimeIsolationPolicy } from "../../config/loader/index.js";
-import type { TestOutcomeStatus } from "../../domain/test-outcomes.js";
-import { type NormalizedCheckDetail, type NormalizedFailureDetail } from "./failure-details.js";
-import type { CollectedSuite, PlanningServiceConfig } from "./planning.js";
-import type { PersistedArtifactReference, ReportingRecord, ReportingRuntimeBatch, ReportingRuntimeReset, RunArtifactFile, RunArtifactSuite, RunServiceResult } from "../../evidence/index.js";
-import type { CompletedRuntimeTaskResult } from "./runtime-task-types.js";
-import type { ScheduledTask } from "./scheduler/index.js";
-export type ResultServiceConfig = Pick<PlanningServiceConfig, "name"> & {
-    testkit: Pick<PlanningServiceConfig["testkit"], "database">;
-};
-export type ResultServicePlanSuite = Pick<CollectedSuite, "engineId" | "files" | "name" | "orderIndex" | "profileId" | "testType"> & Partial<Pick<CollectedSuite, "skippedFiles" | "totalFileCount">>;
-export interface ResultServicePlan {
-    config: ResultServiceConfig;
-    skipped?: boolean;
-    suites: readonly ResultServicePlanSuite[];
-}
-export type ResultTask = Pick<ScheduledTask, "engineId" | "file" | "profileId" | "serviceName" | "suiteKey" | "testType"> & Partial<Pick<ScheduledTask, "runtimeIsolation">>;
-export interface ResultGraph {
-    readonly targetNames: readonly string[];
-}
-export type ResultErrorClassification = "infra" | "product";
-export interface ResultErrorDetail extends ReportingRecord {
-    classification: ResultErrorClassification;
-    message: string;
-}
-export interface NormalizedRuntimeBatch extends ReportingRuntimeBatch {
-    fileCount: number;
-    files: string[];
-    id: string;
-    index: number;
-}
-export interface NormalizedRuntimeReset extends ReportingRuntimeReset {
-    position?: string;
-    reason?: string;
-    runtimeIsolation?: string;
-    trigger?: string;
-}
-type NormalizedCompletedTaskFields = Omit<CompletedRuntimeTaskResult<NormalizedFailureDetail, NormalizedCheckDetail>, "task">;
-export interface NormalizedTaskOutcome extends NormalizedCompletedTaskFields {
-    blockedByRuntime: boolean;
-    infraFailed: boolean;
-    reason: null | string;
-    runtimeBatch: null | NormalizedRuntimeBatch;
-    runtimeIsolation: null | RuntimeIsolationPolicy;
-    runtimeResets: NormalizedRuntimeReset[];
-}
-export type TaskOutcomeInput = Pick<NormalizedTaskOutcome, "status"> & Partial<NormalizedTaskOutcome>;
-export interface TrackedFileResult {
-    artifacts: PersistedArtifactReference[];
-    blockedByRuntime: boolean;
-    checkDetails: NormalizedCheckDetail[];
-    durationMs: number;
-    error: null | string;
-    failed: boolean;
-    failureDetails: NormalizedFailureDetail[];
-    infraFailed: boolean;
-    path: string;
-    reason: null | string;
-    runtimeBatch: null | NormalizedRuntimeBatch;
-    runtimeIsolation: null | RuntimeIsolationPolicy;
-    runtimeResets: NormalizedRuntimeReset[];
-    status: TestOutcomeStatus;
-}
-export interface ServiceSuiteTracker {
-    durationMs: number;
-    engineId: CollectedSuite["engineId"];
-    error: null | string;
-    failedFileSet: Set<string>;
-    failedFiles: string[];
-    fileResultsByPath: Map<string, TrackedFileResult>;
-    key: string;
-    name: string;
-    orderIndex: number;
-    profileId: CollectedSuite["profileId"];
-    testType: CollectedSuite["testType"];
-}
-export interface ServiceTracker {
-    dbBackend: "local" | null;
-    errorDetails: ResultErrorDetail[];
-    errorDetailSet: Set<string>;
-    errors: string[];
-    errorSet: Set<string>;
-    firstTaskAt: null | number;
-    lastTaskAt: null | number;
-    name: string;
-    skipped: boolean;
-    startedAt: number;
-    suiteCount: number;
-    suites: ServiceSuiteTracker[];
-    suitesByKey: Map<string, ServiceSuiteTracker>;
-    totalTaskDurationMs: number;
-}
-export type ServiceTrackerMap = Map<string, ServiceTracker>;
-export interface FinalizedFileResult extends RunArtifactFile {
-    artifacts?: PersistedArtifactReference[];
-    blockedByRuntime?: true;
-    checkDetails?: NormalizedCheckDetail[];
-    durationMs: number;
-    error: null | string;
-    failed: boolean;
-    failureDetails?: NormalizedFailureDetail[];
-    infraFailed?: true;
-    path: string;
-    reason: null | string;
-    runtimeBatch?: NormalizedRuntimeBatch;
-    runtimeIsolation?: RuntimeIsolationPolicy;
-    runtimeResets?: NormalizedRuntimeReset[];
-    status: TestOutcomeStatus;
-}
-export interface FinalizedSuiteResult extends RunArtifactSuite {
-    completedFileCount: number;
-    durationMs: number;
-    error: null | string;
-    failed: boolean;
-    failedFileCount: number;
-    failedFiles: string[];
-    fileCount: number;
-    files: FinalizedFileResult[];
-    engineId: CollectedSuite["engineId"];
-    name: string;
-    notRunFileCount: number;
-    passedFileCount: number;
-    profileId: CollectedSuite["profileId"];
-    skippedFileCount: number;
-    testType: CollectedSuite["testType"];
-}
-export interface FinalizedServiceResult extends RunServiceResult {
-    blockedByRuntime: boolean;
-    blockedByRuntimeFileCount?: number;
-    completedFileCount: number;
-    completedSuiteCount: number;
-    dbBackend?: null | string;
-    durationMs: number;
-    errorDetails: ResultErrorDetail[];
-    errors: string[];
-    failed: boolean;
-    failedFileCount: number;
-    failedSuiteCount: number;
-    infraFailed: boolean;
-    infraFailedFileCount?: number;
-    name: string;
-    notRunFileCount: number;
-    passedFileCount: number;
-    skipped: boolean;
-    skippedFileCount: number;
-    skippedSuiteCount: number;
-    suiteCount: number;
-    suites: FinalizedSuiteResult[];
-    totalFileCount: number;
-    totalTaskDurationMs: number;
-}
-export interface AddTrackerErrorOptions {
-    classification?: ResultErrorClassification;
-}
-export declare function buildServiceTrackers(servicePlans: readonly ResultServicePlan[], startedAt: number): ServiceTrackerMap;
-export declare function recordTaskOutcome(trackers: ReadonlyMap<string, ServiceTracker>, task: Readonly<ResultTask>, outcomeValue: Readonly<TaskOutcomeInput>, finishedAt?: number): void;
-export declare function recordGraphError(trackers: ReadonlyMap<string, ServiceTracker>, graph: null | Readonly<ResultGraph> | undefined, message: string, now?: number, options?: Readonly<AddTrackerErrorOptions>): void;
-export declare function addTrackerError(tracker: ServiceTracker, message: string, options?: Readonly<AddTrackerErrorOptions>): void;
-export declare function finalizeServiceResult(tracker: Readonly<ServiceTracker> | null | undefined, startedAt: number, finishedAt: number): FinalizedServiceResult;
-export declare function summarizeDbBackend(results: readonly Pick<RunServiceResult, "dbBackend">[]): null | string;
-export {};