@benchsdk/client 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,727 @@
+type JsonValue = string | number | boolean | null | JsonObject | JsonValue[];
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+interface BenchmarkClientConfig {
+    /** API base URL. Defaults to https://platform.computesdk.com/api/v1. */
+    baseUrl?: string;
+    /** Bearer token. Defaults to process.env.COMPUTESDK_ADMIN_API_KEY, then process.env.COMPUTESDK_API_KEY. */
+    apiKey?: string;
+    /** Custom fetch implementation, mostly useful for tests. */
+    fetch?: typeof fetch;
+}
+interface BenchmarkResource {
+    id: string;
+    slug: string;
+    name: string;
+    kind?: string | null;
+    status?: string;
+    config?: JsonObject;
+    defaultRunConfig?: JsonObject;
+}
+type BenchmarkRunStatus = 'planned' | 'in_progress' | 'completed' | 'failed';
+type BenchmarkWorkerStatus = 'pending' | 'running' | 'completed' | 'failed';
+interface BenchmarkRun {
+    id: string;
+    benchmarkId: string;
+    name?: string | null;
+    status: BenchmarkRunStatus | string;
+    totalTasks: number;
+    workerCount: number;
+    config?: JsonObject;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface BenchmarkParticipant {
+    id: string;
+    benchmarkId: string;
+    runId: string;
+    slug: string;
+    label?: string | null;
+    provider?: string | null;
+    status: BenchmarkRunStatus | string;
+    totalTasks: number;
+    workerCount: number;
+    config?: JsonObject;
+}
+interface BenchmarkRunWorker {
+    id: string;
+    benchmarkId: string;
+    runId: string;
+    participantId: string;
+    workerIndex: number;
+    workerCount: number;
+    taskIndexStart: number;
+    taskIndexEnd: number;
+    targetConcurrency: number;
+    status: BenchmarkWorkerStatus | string;
+    progressDone?: number;
+    progressInFlight?: number;
+    progressErrors?: number;
+    progressTotal?: number;
+    currentStep?: string | null;
+    concurrency?: WorkerConcurrencySample[];
+}
+interface BenchmarkWorkerAttempt {
+    id: string;
+    benchmarkId: string;
+    runId: string;
+    participantId: string;
+    workerId: string;
+    attemptNumber: number;
+    status: string;
+}
+interface BenchmarkAssignment {
+    benchmarkId: string;
+    benchmarkSlug: string;
+    runId: string;
+    participantId: string;
+    participantSlug: string;
+    provider?: string | null;
+    workerId: string;
+    workerIndex: number;
+    workerCount: number;
+    attemptId: string;
+    attemptNumber: number;
+    taskRange: {
+        start: number;
+        end: number;
+        count: number;
+    };
+    targetConcurrency: number;
+    config?: JsonObject;
+}
+interface UpsertBenchmarkInput {
+    name: string;
+    kind?: string;
+    status?: string;
+    config?: JsonObject;
+    defaultRunConfig?: JsonObject;
+}
+interface UpdateBenchmarkInput {
+    name?: string;
+    kind?: string;
+    status?: string;
+    config?: JsonObject;
+    defaultRunConfig?: JsonObject;
+}
+interface CreateRunInput {
+    name?: string;
+    totalTasks: number;
+    workerCount: number;
+    participants?: string[];
+    config?: JsonObject;
+}
+interface UpdateRunInput {
+    name?: string;
+    status?: BenchmarkRunStatus;
+    config?: JsonObject;
+}
+interface UpsertParticipantInput {
+    label?: string;
+    provider?: string;
+    status?: string;
+    totalTasks?: number;
+    workerCount?: number;
+    config?: JsonObject;
+}
+type UpdateParticipantInput = UpsertParticipantInput;
+interface UpdateWorkerInput {
+    status?: BenchmarkWorkerStatus;
+    progressDone?: number;
+    progressInFlight?: number;
+    progressErrors?: number;
+    progressTotal?: number;
+}
+interface ClaimWorkerInput {
+    processKind?: string;
+    processKey?: string;
+}
+interface PlanWorkersInput {
+    workerCount?: number;
+    targetConcurrency?: number;
+    config?: JsonObject;
+}
+interface TaskResultRecord {
+    taskIndex: number;
+    status: string;
+    startedAt?: string;
+    completedAt?: string;
+    latencyMs?: number;
+    firstCommandMs?: number | null;
+    errorCode?: string | null;
+    steps?: TaskStepRecord[];
+    data?: JsonObject;
+}
+interface TaskStepRecord {
+    name: string;
+    status: 'success' | 'error';
+    startedAt?: string;
+    completedAt?: string;
+    latencyMs?: number;
+    errorCode?: string | null;
+    data?: JsonObject;
+}
+interface SendTaskResultsInput {
+    benchmarkSlug: string;
+    runId: string;
+    workerId: string;
+    attemptId: string;
+    sequenceNumber: number;
+    isFinal: boolean;
+    records: TaskResultRecord[];
+}
+interface TaskResultsResponse {
+    accepted?: number;
+    eventBatchId?: string;
+    queued?: boolean;
+    eventBatch?: unknown;
+    duplicate?: boolean;
+    queueMessageId?: string;
+}
+interface CreateWorkerArtifactInput {
+    attemptId: string;
+    kind: string;
+    contentType?: string;
+    name?: string;
+    metadata?: JsonObject;
+}
+interface UploadWorkerArtifactInput extends CreateWorkerArtifactInput {
+    body: BodyInit;
+}
+interface BenchmarkArtifact {
+    id?: string;
+    artifactId?: string;
+    benchmarkId?: string;
+    runId?: string;
+    participantId?: string;
+    participantSlug?: string;
+    workerId?: string;
+    attemptId?: string;
+    kind: string;
+    name?: string | null;
+    contentType?: string | null;
+    objectKey?: string;
+    uploadUrl?: string;
+    uploadUrlExpiresAt?: string;
+    metadata?: JsonObject;
+    createdAt?: string;
+}
+interface CreateWorkerArtifactResponse {
+    artifact?: BenchmarkArtifact;
+    artifactId?: string;
+    uploadUrl?: string;
+    uploadUrlExpiresAt?: string;
+    objectKey?: string;
+}
+interface BenchmarkResultLatencySummary {
+    min: number | null;
+    avg: number | null;
+    p50: number | null;
+    p95: number | null;
+    p99: number | null;
+    max: number | null;
+}
+interface BenchmarkResultSummary {
+    taskCount: number;
+    successCount: number;
+    errorCount: number;
+    otherCount: number;
+    latencyCount: number;
+    successRate: number;
+    latencyMs: BenchmarkResultLatencySummary;
+    firstStartedAt: string | null;
+    lastCompletedAt: string | null;
+}
+interface BenchmarkParticipantResultSummary extends BenchmarkResultSummary {
+    participantSlug: string;
+    provider: string | null;
+}
+interface BenchmarkStepResultSummary {
+    participantSlug: string;
+    provider: string | null;
+    stepName: string;
+    stepCount: number;
+    successCount: number;
+    errorCount: number;
+    otherCount: number;
+    latencyCount: number;
+    successRate: number;
+    latencyMs: BenchmarkResultLatencySummary;
+}
+interface BenchmarkResultsOverviewInput {
+    limit?: number;
+}
+type BenchmarkAnalyticsReadiness = 'ready' | 'complete' | 'partial' | 'pending' | 'unavailable' | 'failed';
+interface BenchmarkRunAnalyticsSummary {
+    status: BenchmarkAnalyticsReadiness;
+    eventBatches: number;
+    persisted: number;
+    queued: number;
+    failed: number;
+    imports: {
+        pending: number;
+        importing: number;
+        imported: number;
+        failed: number;
+        missing: number;
+    };
+}
+interface BenchmarkResultsOverviewAnalytics {
+    status: BenchmarkAnalyticsReadiness;
+    query: 'available' | 'unavailable';
+    error?: string;
+}
+interface BenchmarkResultsOverviewRun {
+    run: BenchmarkRun;
+    analytics: BenchmarkRunAnalyticsSummary;
+    participants: Array<BenchmarkParticipantResultSummary & {
+        runId: string;
+    }>;
+}
+interface BenchmarkResultsOverview {
+    benchmark: Pick<BenchmarkResource, 'id' | 'slug' | 'name' | 'kind'>;
+    generatedAt: string;
+    analytics: BenchmarkResultsOverviewAnalytics;
+    items: BenchmarkResultsOverviewRun[];
+}
+interface BenchmarkRunResults {
+    benchmark: Pick<BenchmarkResource, 'id' | 'slug' | 'name' | 'kind'>;
+    run: Pick<BenchmarkRun, 'id' | 'status' | 'totalTasks' | 'workerCount'>;
+    generatedAt: string;
+    overall: BenchmarkResultSummary;
+    participants: BenchmarkParticipantResultSummary[];
+    steps: BenchmarkStepResultSummary[];
+}
+interface BenchmarkRunTaskResultsInput {
+    bucketSize?: number;
+    failureLimit?: number;
+}
+interface BenchmarkTaskBucket {
+    participantSlug: string;
+    provider: string | null;
+    bucketStart: number;
+    bucketEnd: number;
+    taskIndexMidpoint: number;
+    taskCount: number;
+    successCount: number;
+    errorCount: number;
+    latencyMs: Pick<BenchmarkResultLatencySummary, 'p50' | 'p95' | 'max'>;
+}
+interface BenchmarkFailurePoint {
+    participantSlug: string;
+    provider: string | null;
+    taskIndex: number;
+    errorCode: string | null;
+}
+interface BenchmarkRunTaskResults {
+    run: {
+        id: string;
+    };
+    generatedAt: string;
+    bucketSize: number;
+    buckets: BenchmarkTaskBucket[];
+    failures: BenchmarkFailurePoint[];
+}
+interface BenchmarkRunTimelineInput {
+    bucketMs?: number;
+}
+interface BenchmarkEventRateBucket {
+    participantSlug: string;
+    provider: string | null;
+    tMs: number;
+    completed: number;
+    succeeded: number;
+    failed: number;
+}
+interface BenchmarkConcurrencyPoint {
+    participantSlug: string;
+    provider: string | null;
+    workerId: string;
+    recordedAt: string;
+    tMs: number;
+    step: string;
+    active: number;
+    target: number;
+}
+interface BenchmarkRunTimeline {
+    run: {
+        id: string;
+    };
+    generatedAt: string;
+    eventRate: {
+        bucketMs: number;
+        buckets: BenchmarkEventRateBucket[];
+    };
+    concurrency: {
+        firstRecordedAt: string | null;
+        heartbeatCount: number;
+        points: BenchmarkConcurrencyPoint[];
+    };
+}
+interface BenchmarkRunImportsSummary {
+    eventBatches: number;
+    persisted: number;
+    queued: number;
+    failed: number;
+    imports: {
+        pending: number;
+        importing: number;
+        imported: number;
+        failed: number;
+        missing: number;
+    };
+}
+interface BenchmarkRunImportItem {
+    eventBatchId: string;
+    batchType: string;
+    sequenceNumber: number;
+    batchStatus: string;
+    eventCount: number;
+    objectKey: string | null;
+    batchErrorMessage: string | null;
+    createdAt: string;
+    persistedAt: string | null;
+    sink: string | null;
+    importStatus: string | null;
+    importAttempts: number | null;
+    importedAt: string | null;
+    failedAt: string | null;
+    importErrorMessage: string | null;
+}
+interface BenchmarkRunImports {
+    run: {
+        id: string;
+    };
+    generatedAt: string;
+    summary: BenchmarkRunImportsSummary;
+    items: BenchmarkRunImportItem[];
+}
+interface WorkerConcurrencySample {
+    step: string;
+    active: number;
+    target: number;
+}
+interface WorkerHeartbeatInput {
+    attemptId: string;
+    progressDone?: number;
+    progressInFlight?: number;
+    progressErrors?: number;
+    progressTotal?: number;
+    currentStep?: string | null;
+    concurrency?: WorkerConcurrencySample[];
+}
+interface RunProgressConcurrency {
+    step: string;
+    active: number;
+    target: number;
+    ready: boolean;
+    freshWorkerCount: number;
+}
+type RunProgressStatus = 'planned' | 'in_progress' | 'completed' | 'failed';
+interface RunProgressWorkerCounts {
+    pending: number;
+    running: number;
+    completed: number;
+    failed: number;
+    stale: number;
+    total: number;
+}
+interface RunProgressTaskCounts {
+    done: number;
+    inFlight: number;
+    errors: number;
+    total: number;
+    completionRatio: number;
+}
+interface RunProgressParticipantCounts {
+    planned: number;
+    inProgress: number;
+    completed: number;
+    failed: number;
+    total: number;
+}
+interface RunProgressSummary {
+    status: RunProgressStatus;
+    started: boolean;
+    completed: boolean;
+    participants: RunProgressParticipantCounts;
+}
+interface RunProgressParticipant {
+    id: string;
+    slug: string;
+    provider?: string | null;
+    status: RunProgressStatus;
+    totalTasks: number;
+    workerCount: number;
+    workers: RunProgressWorkerCounts;
+    tasks: RunProgressTaskCounts;
+    concurrency: RunProgressConcurrency[];
+}
+interface RunProgress {
+    run: {
+        id: string;
+        status: string;
+        totalTasks: number;
+        workerCount: number;
+    };
+    summary: RunProgressSummary;
+    freshnessWindowSeconds: number;
+    generatedAt: string;
+    participants: RunProgressParticipant[];
+}
+interface RunWorkerContext {
+    assignment: BenchmarkAssignment;
+    taskIndex: number;
+    step<T>(name: string, fn: () => Promise<T> | T, options?: DefineStepOptions): Promise<T>;
+}
+interface WorkerFinishContext {
+    assignment: BenchmarkAssignment;
+    records: TaskResultRecord[];
+    status: 'success' | 'error';
+    client: BenchmarkClient;
+    uploadArtifact(input: Omit<UploadWorkerArtifactInput, 'attemptId'>): Promise<CreateWorkerArtifactResponse>;
+}
+interface StepContext<TState extends Record<string, unknown> = Record<string, unknown>> {
+    assignment: BenchmarkAssignment;
+    taskIndex: number;
+    state: TState;
+}
+type CleanupContext<TState extends Record<string, unknown> = Record<string, unknown>> = StepContext<TState>;
+interface DefineStepOptions {
+    /** Report this step as active in heartbeat concurrency samples. Defaults to true. */
+    reportConcurrency?: boolean;
+    /** Per-worker target for this step. Defaults to worker concurrency/assignment target. */
+    concurrency?: number;
+    /** Readiness coordination mode. Defaults to internal. */
+    readiness?: 'poll' | 'internal';
+    /** Poll interval while waiting for readiness. Defaults to 1000ms. */
+    readyPollIntervalMs?: number;
+    /** Maximum time to wait for readiness. Defaults to no timeout. */
+    readyTimeoutMs?: number;
+}
+interface DefinedStep<TState extends Record<string, unknown> = Record<string, unknown>> {
+    name: string;
+    options?: DefineStepOptions;
+    fn: (context: StepContext<TState>) => Promise<JsonObject | void> | JsonObject | void;
+}
+interface DefineTaskOptions<TState extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Runs after the task finishes, whether it succeeded or failed.
+     * Use this to tear down resources stored in task state.
+     */
+    cleanup?: (context: CleanupContext<TState>) => Promise<void> | void;
+}
+interface DefinedTask<TState extends Record<string, unknown> = Record<string, unknown>> {
+    name: string;
+    steps: DefinedStep<TState>[];
+    options?: DefineTaskOptions<TState>;
+}
+type TaskFunction = (context: RunWorkerContext) => Promise<JsonObject | void> | JsonObject | void;
+type WorkerTask = DefinedTask | TaskFunction;
+interface RunWorkerResult {
+    assignment: BenchmarkAssignment | null;
+    records: TaskResultRecord[];
+}
+interface RunWorkerOptions {
+    benchmarkSlug: string;
+    runId: string;
+    participantSlug: string;
+    processKind?: string;
+    processKey?: string;
+    concurrency?: number;
+    batchSize?: number;
+    flushIntervalMs?: number;
+    heartbeatIntervalMs?: number;
+    readyPollIntervalMs?: number;
+    onResult?: (record: TaskResultRecord) => void;
+    /** Runs once after final result flush and before worker completion/failure is reported. */
+    onFinish?: (context: WorkerFinishContext) => Promise<void> | void;
+    task: WorkerTask;
+}
+interface WorkerDefaults {
+    concurrency?: number;
+    batchSize?: number;
+    flushIntervalMs?: number;
+    heartbeatIntervalMs?: number;
+    readyPollIntervalMs?: number;
+}
+interface DefineWorkerOptions extends WorkerDefaults {
+    benchmarkSlug: string;
+    runId: string;
+    participantSlug: string;
+    processKind?: string;
+    processKey?: string;
+    client?: BenchmarkClient;
+    onFinish?: RunWorkerOptions['onFinish'];
+    task: WorkerTask;
+}
+interface BenchmarkWorker {
+    run(overrides?: Partial<WorkerDefaults>): Promise<RunWorkerResult>;
+}
+interface DefineBenchOptions extends WorkerDefaults {
+    slug: string;
+    participantSlug?: string;
+    client?: BenchmarkClient;
+    task: WorkerTask;
+}
+interface BenchDefinition {
+    slug: string;
+    task: WorkerTask;
+    defineWorker(options: Omit<DefineWorkerOptions, 'benchmarkSlug' | 'client' | 'task' | 'participantSlug'> & {
+        client?: BenchmarkClient;
+        participantSlug?: string;
+        task?: WorkerTask;
+    }): BenchmarkWorker;
+}
+interface BenchmarkClient {
+    upsertBenchmark(slug: string, input: UpsertBenchmarkInput): Promise<BenchmarkResource>;
+    updateBenchmark(slug: string, input: UpdateBenchmarkInput): Promise<BenchmarkResource>;
+    getBenchmark(slug: string): Promise<BenchmarkResource>;
+    listBenchmarks(): Promise<BenchmarkResource[]>;
+    createRun(benchmarkSlug: string, input: CreateRunInput): Promise<{
+        run: BenchmarkRun;
+        participants: BenchmarkParticipant[];
+    }>;
+    listRuns(benchmarkSlug: string): Promise<BenchmarkRun[]>;
+    getRun(benchmarkSlug: string, runId: string): Promise<BenchmarkRun>;
+    updateRun(benchmarkSlug: string, runId: string, input: UpdateRunInput): Promise<BenchmarkRun>;
+    upsertParticipant(benchmarkSlug: string, runId: string, participantSlug: string, input?: UpsertParticipantInput): Promise<BenchmarkParticipant>;
+    updateParticipant(benchmarkSlug: string, runId: string, participantSlug: string, input: UpdateParticipantInput): Promise<BenchmarkParticipant>;
+    listParticipants(benchmarkSlug: string, runId: string): Promise<BenchmarkParticipant[]>;
+    getParticipant(benchmarkSlug: string, runId: string, participantSlug: string): Promise<BenchmarkParticipant>;
+    listWorkers(benchmarkSlug: string, runId: string, participantSlug: string): Promise<BenchmarkRunWorker[]>;
+    planWorkers(benchmarkSlug: string, runId: string, participantSlug: string, input?: PlanWorkersInput): Promise<BenchmarkRunWorker[]>;
+    getWorker(benchmarkSlug: string, runId: string, workerId: string): Promise<BenchmarkRunWorker>;
+    updateWorker(benchmarkSlug: string, runId: string, workerId: string, input: UpdateWorkerInput): Promise<BenchmarkRunWorker>;
+    getRunProgress(benchmarkSlug: string, runId: string): Promise<RunProgress>;
+    claimWorker(benchmarkSlug: string, runId: string, participantSlug: string, input?: ClaimWorkerInput): Promise<BenchmarkAssignment | null>;
+    releaseWorker(benchmarkSlug: string, runId: string, workerId: string, attemptId: string): Promise<{
+        worker: BenchmarkRunWorker;
+        attempt: BenchmarkWorkerAttempt;
+    }>;
+    sendTaskResults(input: SendTaskResultsInput): Promise<TaskResultsResponse>;
+    heartbeatWorker(benchmarkSlug: string, runId: string, workerId: string, input: WorkerHeartbeatInput): Promise<{
+        worker: BenchmarkRunWorker;
+        attempt: BenchmarkWorkerAttempt;
+    }>;
+    completeWorker(benchmarkSlug: string, runId: string, workerId: string, attemptId: string): Promise<{
+        worker: BenchmarkRunWorker;
+        attempt: BenchmarkWorkerAttempt;
+    }>;
+    failWorker(benchmarkSlug: string, runId: string, workerId: string, attemptId: string, error?: unknown): Promise<{
+        worker: BenchmarkRunWorker;
+        attempt: BenchmarkWorkerAttempt;
+    }>;
+    createWorkerArtifact(benchmarkSlug: string, runId: string, workerId: string, input: CreateWorkerArtifactInput): Promise<CreateWorkerArtifactResponse>;
+    uploadWorkerArtifact(benchmarkSlug: string, runId: string, workerId: string, input: UploadWorkerArtifactInput): Promise<CreateWorkerArtifactResponse>;
+    listRunArtifacts(benchmarkSlug: string, runId: string): Promise<BenchmarkArtifact[]>;
+    listWorkerArtifacts(benchmarkSlug: string, runId: string, workerId: string): Promise<BenchmarkArtifact[]>;
+    getBenchmarkResults(benchmarkSlug: string, input?: BenchmarkResultsOverviewInput): Promise<BenchmarkResultsOverview>;
+    getRunResults(benchmarkSlug: string, runId: string): Promise<BenchmarkRunResults>;
+    getRunTaskResults(benchmarkSlug: string, runId: string, input?: BenchmarkRunTaskResultsInput): Promise<BenchmarkRunTaskResults>;
+    getRunTimeline(benchmarkSlug: string, runId: string, input?: BenchmarkRunTimelineInput): Promise<BenchmarkRunTimeline>;
+    getRunImports(benchmarkSlug: string, runId: string): Promise<BenchmarkRunImports>;
+    runWorker(options: RunWorkerOptions): Promise<RunWorkerResult>;
+}
+
+declare class BenchmarkApiError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(message: string, status: number, body: string);
+}
+declare function createBenchmarkClient(config?: BenchmarkClientConfig): BenchmarkClient;
+declare function runBenchmarkWorker(config: BenchmarkClientConfig, options: RunWorkerOptions): Promise<RunWorkerResult>;
+declare function defineStep<TState extends Record<string, unknown> = Record<string, unknown>>(name: string, optionsOrFn: DefineStepOptions | DefinedStep<TState>['fn'], maybeFn?: DefinedStep<TState>['fn']): DefinedStep<TState>;
+declare function defineTask<TState extends Record<string, unknown> = Record<string, unknown>>(name: string, steps: DefinedStep<TState>[], options?: DefineTaskOptions<TState>): DefinedTask<TState>;
+declare function defineWorker(options: DefineWorkerOptions): BenchmarkWorker;
+declare function defineBench(options: DefineBenchOptions): BenchDefinition;
+
+interface BenchmarkReporterConfig extends BenchmarkClientConfig {
+    benchmarkSlug: string;
+    runId: string;
+    participantSlug: string;
+    processKind?: string;
+    processKey?: string;
+    batchSize?: number;
+}
+interface BenchmarkReporterProgress {
+    done: number;
+    inFlight: number;
+    errors: number;
+    total?: number;
+}
+interface BenchmarkReporterArtifactInput {
+    kind: string;
+    name?: string;
+    contentType?: string;
+    body: BodyInit;
+    metadata?: JsonObject;
+}
+interface BenchmarkReporterHeartbeatInput {
+    currentStep?: string | null;
+    concurrency?: WorkerConcurrencySample[];
+}
+interface BenchmarkReporterBarrierInput {
+    step: string;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    active?: number;
+    target?: number;
+    concurrency?: WorkerConcurrencySample[];
+}
+interface BenchmarkReporterBarrierResult {
+    active: number | null;
+    target: number | null;
+    ready: boolean;
+    measuredAt: string;
+}
+declare class BenchmarkReporter {
+    private readonly client;
+    private readonly assignment;
+    private readonly cfg;
+    private pending;
+    private sequenceNumber;
+    private flushChain;
+    private progress;
+    private barrier;
+    private constructor();
+    static claim(cfg: BenchmarkReporterConfig): Promise<BenchmarkReporter | null>;
+    get workerAssignment(): BenchmarkAssignment;
+    get taskCount(): number;
+    get taskIndexStart(): number;
+    setProgress(progress: BenchmarkReporterProgress): void;
+    recordResult(record: TaskResultRecord): void;
+    heartbeat(input?: BenchmarkReporterHeartbeatInput): Promise<void>;
+    waitForStepReady(input: BenchmarkReporterBarrierInput): Promise<BenchmarkReporterBarrierResult>;
+    uploadArtifact(input: BenchmarkReporterArtifactInput): Promise<CreateWorkerArtifactResponse | null>;
+    flush(isFinal?: boolean): Promise<void>;
+    finish(failed?: boolean, error?: unknown): Promise<void>;
+}
+declare function claimBenchmarkReporter(config: BenchmarkReporterConfig): Promise<BenchmarkReporter | null>;
+
+interface BenchmarkSystemMetricsSample {
+    ts: string;
+    uptimeMs: number;
+    cpuUserUs: number;
+    cpuSystemUs: number;
+    memRssMb: number;
+    memHeapUsedMb: number;
+    memHeapTotalMb: number;
+    memExternalMb: number;
+    eventLoopP50Ms: number;
+    eventLoopP99Ms: number;
+    eventLoopMaxMs: number;
+    loadavg1m: number;
+    loadavg5m: number;
+    loadavg15m: number;
+    openFds: number | null;
+    sockstat: Record<string, number> | null;
+}
+interface BenchmarkSystemMetricsCollector {
+    sample(): BenchmarkSystemMetricsSample;
+    stop(): void;
+}
+declare function createSystemMetricsCollector(): BenchmarkSystemMetricsCollector;
+
+export { type BenchDefinition, type BenchmarkAnalyticsReadiness, BenchmarkApiError, type BenchmarkArtifact, type BenchmarkAssignment, type BenchmarkClient, type BenchmarkClientConfig, type BenchmarkConcurrencyPoint, type BenchmarkEventRateBucket, type BenchmarkFailurePoint, type BenchmarkParticipant, BenchmarkReporter, type BenchmarkReporterArtifactInput, type BenchmarkReporterBarrierInput, type BenchmarkReporterBarrierResult, type BenchmarkReporterConfig, type BenchmarkReporterHeartbeatInput, type BenchmarkReporterProgress, type BenchmarkResource, type BenchmarkResultLatencySummary, type BenchmarkResultSummary, type BenchmarkResultsOverview, type BenchmarkResultsOverviewAnalytics, type BenchmarkResultsOverviewInput, type BenchmarkResultsOverviewRun, type BenchmarkRun, type BenchmarkRunAnalyticsSummary, type BenchmarkRunImportItem, type BenchmarkRunImports, type BenchmarkRunImportsSummary, type BenchmarkRunResults, type BenchmarkRunStatus, type BenchmarkRunTaskResults, type BenchmarkRunTaskResultsInput, type BenchmarkRunTimeline, type BenchmarkRunTimelineInput, type BenchmarkRunWorker, type BenchmarkStepResultSummary, type BenchmarkSystemMetricsCollector, type BenchmarkSystemMetricsSample, type BenchmarkTaskBucket, type BenchmarkWorker, type BenchmarkWorkerAttempt, type BenchmarkWorkerStatus, type ClaimWorkerInput, type CreateRunInput, type CreateWorkerArtifactInput, type CreateWorkerArtifactResponse, type DefineBenchOptions, type DefineStepOptions, type DefineWorkerOptions, type DefinedStep, type DefinedTask, type JsonObject, type JsonValue, type PlanWorkersInput, type RunProgress, type RunProgressConcurrency, type RunProgressParticipant, type RunProgressParticipantCounts, type RunProgressStatus, type RunProgressSummary, type RunProgressTaskCounts, type RunProgressWorkerCounts, type RunWorkerContext, type RunWorkerOptions, type RunWorkerResult, type SendTaskResultsInput, type TaskFunction, type TaskResultRecord, type TaskResultsResponse, type TaskStepRecord, type UpdateBenchmarkInput, type UpdateParticipantInput, type UpdateRunInput, type UpdateWorkerInput, type UploadWorkerArtifactInput, type UpsertBenchmarkInput, type UpsertParticipantInput, type WorkerConcurrencySample, type WorkerFinishContext, type WorkerHeartbeatInput, type WorkerTask, claimBenchmarkReporter, createBenchmarkClient, createSystemMetricsCollector, defineBench, defineStep, defineTask, defineWorker, runBenchmarkWorker };