@benchsdk/client 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,964 +15,35 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  BenchmarkApiError: () => BenchmarkApiError,
-  BenchmarkReporter: () => BenchmarkReporter,
-  claimBenchmarkReporter: () => claimBenchmarkReporter,
+  BenchmarkApiError: () => import_api.BenchmarkApiError,
+  BenchmarkReporter: () => import_worker2.BenchmarkReporter,
+  claimBenchmarkReporter: () => import_worker2.claimBenchmarkReporter,
   createBenchmarkClient: () => createBenchmarkClient,
-  createSystemMetricsCollector: () => createSystemMetricsCollector,
-  filterParticipantsByEnv: () => filterParticipantsByEnv,
-  selectParticipants: () => selectParticipants
+  createSystemMetricsCollector: () => import_worker2.createSystemMetricsCollector,
+  filterParticipantsByEnv: () => import_worker2.filterParticipantsByEnv,
+  runWorker: () => import_worker2.runWorker,
+  selectParticipants: () => import_worker2.selectParticipants
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/client.ts
-var DEFAULT_BASE_URL = "https://platform.computesdk.com/api/v1";
-var DEFAULT_BATCH_SIZE = 1e3;
-var DEFAULT_HEARTBEAT_INTERVAL_MS = 3e4;
-var DEFAULT_FLUSH_INTERVAL_MS = 3e4;
-var DEFAULT_READY_POLL_INTERVAL_MS = 1e3;
-var MAX_TASK_RESULT_RECORDS = 5e3;
-var MAX_TASK_RECORD_STEPS = 100;
-var MAX_HEARTBEAT_CONCURRENCY_SAMPLES = 20;
-var MAX_WORKER_LOG_LINES = 1e5;
-var BenchmarkApiError = class extends Error {
-  constructor(message, status, body) {
-    super(message);
-    this.status = status;
-    this.body = body;
-    this.name = "BenchmarkApiError";
-  }
-  status;
-  body;
-};
-function trimTrailingSlash(value) {
-  return value.replace(/\/+$/, "");
-}
-function encodePath(value) {
-  return encodeURIComponent(value);
-}
-function queryString(input) {
-  const params = new URLSearchParams();
-  for (const [key, value2] of Object.entries(input)) {
-    if (value2 !== void 0) params.set(key, String(value2));
-  }
-  const value = params.toString();
-  return value ? `?${value}` : "";
-}
-function getApiKey(input) {
-  return input ?? (typeof process !== "undefined" ? process.env.COMPUTESDK_ADMIN_API_KEY ?? process.env.COMPUTESDK_API_KEY : void 0);
-}
-function getErrorCode(error) {
-  if (error instanceof Error && "code" in error && typeof error.code === "string" && error.code) {
-    return error.code;
-  }
-  if (error instanceof Error && error.name) return error.name;
-  return "ERROR";
-}
-function toJsonObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  return value;
-}
-function mergeMeasures(measures, returned) {
-  const merged = { ...measures, ...returned ?? {} };
-  return Object.keys(merged).length > 0 ? merged : void 0;
-}
-function implicitTaskStep(record, measures) {
-  return {
-    name: "task",
-    status: record.status === "success" ? "success" : "error",
-    startedAt: record.startedAt,
-    completedAt: record.completedAt,
-    latencyMs: record.latencyMs,
-    errorCode: record.errorCode ?? null,
-    data: Object.keys(measures).length > 0 ? { ...measures } : void 0
-  };
-}
-function validateTaskResults(input) {
-  if (input.records.length > MAX_TASK_RESULT_RECORDS) {
-    throw new Error(`Benchmark task result batches are limited to ${MAX_TASK_RESULT_RECORDS} records.`);
-  }
-  for (const record of input.records) {
-    if ((record.steps?.length ?? 0) > MAX_TASK_RECORD_STEPS) {
-      throw new Error(`Benchmark task result records are limited to ${MAX_TASK_RECORD_STEPS} steps.`);
-    }
-  }
-}
-function validateHeartbeat(input) {
-  const concurrency = input.concurrency ?? [];
-  if (concurrency.length > MAX_HEARTBEAT_CONCURRENCY_SAMPLES) {
-    throw new Error(`Benchmark heartbeat concurrency is limited to ${MAX_HEARTBEAT_CONCURRENCY_SAMPLES} samples.`);
-  }
-  const steps = /* @__PURE__ */ new Set();
-  for (const sample of concurrency) {
-    if (steps.has(sample.step)) {
-      throw new Error(`Benchmark heartbeat concurrency step values must be unique per heartbeat.`);
-    }
-    steps.add(sample.step);
-  }
-}
-function validatePositiveInteger(name, value) {
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new Error(`Benchmark ${name} must be a positive integer.`);
-  }
-}
-function validateBatchSize(value) {
-  validatePositiveInteger("batchSize", value);
-  if (value > MAX_TASK_RESULT_RECORDS) {
-    throw new Error(`Benchmark batchSize must be at most ${MAX_TASK_RESULT_RECORDS}.`);
-  }
-}
-function normalizeArtifacts(data) {
-  return data.items ?? data.artifacts ?? [];
-}
-function bodySizeBytes(body) {
-  if (typeof body === "string") return new TextEncoder().encode(body).byteLength;
-  if (body instanceof Blob) return body.size;
-  if (body instanceof ArrayBuffer) return body.byteLength;
-  if (ArrayBuffer.isView(body)) return body.byteLength;
-  if (body instanceof URLSearchParams) return new TextEncoder().encode(body.toString()).byteLength;
-  return void 0;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function mapPool(items, concurrency, fn) {
-  let nextIndex = 0;
-  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
-    while (nextIndex < items.length) {
-      const item = items[nextIndex];
-      nextIndex += 1;
-      await fn(item);
-    }
-  });
-  await Promise.all(workers);
-}
+var import_api = require("@benchsdk/api");
+var import_worker = require("@benchsdk/worker");
 function createBenchmarkClient(config = {}) {
-  const baseUrl = trimTrailingSlash(config.baseUrl ?? DEFAULT_BASE_URL);
-  const apiKey = getApiKey(config.apiKey);
-  const fetchImpl = config.fetch ?? (typeof fetch !== "undefined" ? fetch : void 0);
-  if (!fetchImpl) {
-    throw new Error("fetch is not available");
-  }
-  const doFetch = fetchImpl;
-  async function request(method, path, body) {
-    const headers = { "Content-Type": "application/json" };
-    if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-    const response = await doFetch(`${baseUrl}${path}`, {
-      method,
-      headers,
-      body: body === void 0 ? void 0 : JSON.stringify(body)
-    });
-    const text = await response.text();
-    if (!response.ok) {
-      throw new BenchmarkApiError(
-        `Benchmark API request failed: ${response.status} ${response.statusText}`,
-        response.status,
-        text
-      );
-    }
-    return text ? JSON.parse(text) : {};
-  }
-  async function sendTaskResults(input) {
-    if (input.records.length === 0) {
-      return {};
-    }
-    validateTaskResults(input);
-    return request(
-      "POST",
-      `/benchmarks/${encodePath(input.benchmarkSlug)}/runs/${encodePath(input.runId)}/workers/${encodePath(input.workerId)}/events`,
-      {
-        type: "task_results",
-        attemptId: input.attemptId,
-        sequenceNumber: input.sequenceNumber,
-        isFinal: input.isFinal,
-        records: input.records
-      }
-    );
-  }
-  async function updateWorkerLifecycle(action, benchmarkSlug, runId, workerId, attemptId, extra) {
-    return request(
-      "POST",
-      `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/workers/${encodePath(workerId)}/${action}`,
-      { attemptId, ...extra ?? {} }
-    );
-  }
-  const client = {
-    async upsertBenchmark(slug, input) {
-      const data = await request("PUT", `/benchmarks/${encodePath(slug)}`, input);
-      return data.benchmark;
-    },
-    async getBenchmark(slug) {
-      const data = await request("GET", `/benchmarks/${encodePath(slug)}`);
-      return data.benchmark;
-    },
-    async updateBenchmark(slug, input) {
-      const data = await request("PATCH", `/benchmarks/${encodePath(slug)}`, input);
-      return data.benchmark;
-    },
-    async listBenchmarks() {
-      const data = await request("GET", "/benchmarks");
-      return data.items ?? data.benchmarks ?? [];
-    },
-    async createRun(benchmarkSlug, input) {
-      return request(
-        "POST",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs`,
-        input
-      );
-    },
-    async listRuns(benchmarkSlug) {
-      const data = await request("GET", `/benchmarks/${encodePath(benchmarkSlug)}/runs`);
-      return data.items;
-    },
-    async getRun(benchmarkSlug, runId) {
-      const data = await request("GET", `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}`);
-      return data.run;
-    },
-    async updateRun(benchmarkSlug, runId, input) {
-      const data = await request(
-        "PATCH",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}`,
-        input
-      );
-      return data.run;
-    },
-    async upsertParticipant(benchmarkSlug, runId, participantSlug, input = {}) {
-      const data = await request(
-        "PUT",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/participants/${encodePath(participantSlug)}`,
-        input
-      );
-      return data.participant;
-    },
-    async listParticipants(benchmarkSlug, runId) {
-      const data = await request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/participants`
-      );
-      return data.items ?? data.participants ?? [];
-    },
-    async getParticipant(benchmarkSlug, runId, participantSlug) {
-      const data = await request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/participants/${encodePath(participantSlug)}`
-      );
-      return data.participant;
-    },
-    async updateParticipant(benchmarkSlug, runId, participantSlug, input) {
-      const data = await request(
-        "PATCH",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/participants/${encodePath(participantSlug)}`,
-        input
-      );
-      return data.participant;
-    },
-    async getRunProgress(benchmarkSlug, runId) {
-      return request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/progress`
-      );
-    },
-    async listWorkers(benchmarkSlug, runId, participantSlug) {
-      const data = await request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/participants/${encodePath(participantSlug)}/workers`
-      );
-      return data.items ?? data.workers ?? [];
-    },
-    async planWorkers(benchmarkSlug, runId, participantSlug, input = {}) {
-      const data = await request(
-        "POST",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/participants/${encodePath(participantSlug)}/workers`,
-        input
-      );
-      return data.items ?? data.workers ?? [];
-    },
-    async getWorker(benchmarkSlug, runId, workerId) {
-      const data = await request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/workers/${encodePath(workerId)}`
-      );
-      return data.worker;
-    },
-    async updateWorker(benchmarkSlug, runId, workerId, input) {
-      const data = await request(
-        "PATCH",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/workers/${encodePath(workerId)}`,
-        input
-      );
-      return data.worker;
-    },
-    async claimWorker(benchmarkSlug, runId, participantSlug, input = {}) {
-      const data = await request(
-        "POST",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/participants/${encodePath(participantSlug)}/workers/claim`,
-        input
-      );
-      return data.assignment;
-    },
-    sendTaskResults,
-    async heartbeatWorker(benchmarkSlug, runId, workerId, input) {
-      validateHeartbeat(input);
-      const { attemptId, ...extra } = input;
-      if (extra.currentStep == null) {
-        delete extra.currentStep;
-      }
-      return updateWorkerLifecycle("heartbeat", benchmarkSlug, runId, workerId, attemptId, extra);
-    },
-    releaseWorker(benchmarkSlug, runId, workerId, attemptId) {
-      return updateWorkerLifecycle("release", benchmarkSlug, runId, workerId, attemptId);
-    },
-    completeWorker(benchmarkSlug, runId, workerId, attemptId) {
-      return updateWorkerLifecycle("complete", benchmarkSlug, runId, workerId, attemptId);
-    },
-    failWorker(benchmarkSlug, runId, workerId, attemptId, error) {
-      return updateWorkerLifecycle("fail", benchmarkSlug, runId, workerId, attemptId, {
-        errorCode: getErrorCode(error),
-        errorMessage: error instanceof Error ? error.message : String(error ?? "Unknown error")
-      });
-    },
-    async createWorkerArtifact(benchmarkSlug, runId, workerId, input) {
-      return request(
-        "POST",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/workers/${encodePath(workerId)}/artifacts`,
-        input
-      );
-    },
-    async uploadWorkerArtifact(benchmarkSlug, runId, workerId, input) {
-      const sizeBytes = bodySizeBytes(input.body);
-      const artifactInput = {
-        attemptId: input.attemptId,
-        kind: input.kind,
-        contentType: input.contentType,
-        name: input.name,
-        metadata: sizeBytes === void 0 ? input.metadata : { ...input.metadata, sizeBytes }
-      };
-      const response = await client.createWorkerArtifact(benchmarkSlug, runId, workerId, artifactInput);
-      const uploadUrl = response.uploadUrl ?? response.artifact?.uploadUrl;
-      if (!uploadUrl) {
-        throw new Error("Benchmark artifact upload URL is missing.");
-      }
-      const uploadResponse = await doFetch(uploadUrl, {
-        method: "PUT",
-        headers: input.contentType ? { "Content-Type": input.contentType } : void 0,
-        body: input.body
-      });
-      if (!uploadResponse.ok) {
-        const errorBody = await uploadResponse.text().catch(() => "");
-        throw new BenchmarkApiError(
-          `Benchmark artifact upload failed with ${uploadResponse.status}`,
-          uploadResponse.status,
-          errorBody
-        );
-      }
-      return response;
-    },
-    async listRunArtifacts(benchmarkSlug, runId) {
-      const data = await request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/artifacts`
-      );
-      return normalizeArtifacts(data);
-    },
-    async listWorkerArtifacts(benchmarkSlug, runId, workerId) {
-      const data = await request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/workers/${encodePath(workerId)}/artifacts`
-      );
-      return normalizeArtifacts(data);
-    },
-    async getBenchmarkResults(benchmarkSlug, input = {}) {
-      return request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/results${queryString({ limit: input.limit })}`
-      );
-    },
-    async getRunResults(benchmarkSlug, runId) {
-      return request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/results`
-      );
-    },
-    async getRunTaskResults(benchmarkSlug, runId, input = {}) {
-      return request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/results/tasks${queryString({ bucketSize: input.bucketSize, failureLimit: input.failureLimit })}`
-      );
-    },
-    async getRunTimeline(benchmarkSlug, runId, input = {}) {
-      return request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/results/timeline${queryString({ bucketMs: input.bucketMs })}`
-      );
-    },
-    async getRunImports(benchmarkSlug, runId) {
-      return request(
-        "GET",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/results/imports`
-      );
-    },
-    async submitRunSummary(benchmarkSlug, runId, input) {
-      await request(
-        "POST",
-        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/summary`,
-        input
-      );
-    },
-    async runWorker(options) {
-      if (options.concurrency !== void 0) validatePositiveInteger("concurrency", options.concurrency);
-      if (options.batchSize !== void 0) validateBatchSize(options.batchSize);
-      if (options.flushIntervalMs !== void 0) validatePositiveInteger("flushIntervalMs", options.flushIntervalMs);
-      const assignment = await client.claimWorker(options.benchmarkSlug, options.runId, options.participantSlug, {
-        processKind: options.processKind,
-        processKey: options.processKey
-      });
-      if (!assignment) return { assignment: null, records: [] };
-      const claimed = assignment;
-      let sequenceNumber = 0;
-      const records = [];
-      const pending = [];
-      const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
-      const workerConcurrency = options.concurrency ?? claimed.targetConcurrency;
-      validatePositiveInteger("concurrency", workerConcurrency);
-      const taskIndices = Array.from({ length: claimed.taskRange.count }, (_, index) => claimed.taskRange.start + index);
-      const activeByStep = /* @__PURE__ */ new Map();
-      const targetByStep = /* @__PURE__ */ new Map();
-      const readyWaitByStep = /* @__PURE__ */ new Map();
-      let doneCount = 0;
-      let errorCount = 0;
-      let inFlightCount = 0;
-      let flushChain = Promise.resolve();
-      function concurrencySamples() {
-        return Array.from(activeByStep.entries()).filter(([, active]) => active > 0).map(([step, active]) => ({
-          step,
-          active,
-          target: targetByStep.get(step) ?? workerConcurrency
-        })).sort((a, b) => b.active - a.active).slice(0, MAX_HEARTBEAT_CONCURRENCY_SAMPLES);
-      }
-      async function sendHeartbeat() {
-        const concurrency = concurrencySamples();
-        const step = concurrency[0]?.step ?? null;
-        await client.heartbeatWorker(options.benchmarkSlug, options.runId, claimed.workerId, {
-          attemptId: claimed.attemptId,
-          progressDone: doneCount,
-          progressInFlight: inFlightCount,
-          progressErrors: errorCount,
-          progressTotal: taskIndices.length,
-          ...step ? { currentStep: step } : {},
-          concurrency
-        });
-      }
-      let heartbeatInFlight = null;
-      let heartbeatRequested = false;
-      function requestHeartbeat() {
-        heartbeatRequested = true;
-        if (heartbeatInFlight) return;
-        heartbeatInFlight = (async () => {
-          while (heartbeatRequested) {
-            heartbeatRequested = false;
-            await sendHeartbeat().catch(() => {
-            });
-          }
-        })().finally(() => {
-          heartbeatInFlight = null;
-          if (heartbeatRequested) requestHeartbeat();
-        });
-      }
-      async function pollStepReady(stepName, stepOptions) {
-        const startedAt = Date.now();
-        const pollInterval = stepOptions.readyPollIntervalMs ?? options.readyPollIntervalMs ?? DEFAULT_READY_POLL_INTERVAL_MS;
-        while (true) {
-          const progress = await client.getRunProgress(options.benchmarkSlug, options.runId);
-          const participant = progress.participants.find((item) => item.slug === options.participantSlug);
-          const step = participant?.concurrency.find((item) => item.step === stepName);
-          if (step?.ready) return;
-          if (typeof stepOptions.readyTimeoutMs === "number" && Date.now() - startedAt >= stepOptions.readyTimeoutMs) {
-            throw new Error(`Timed out waiting for benchmark step "${stepName}" to become ready.`);
-          }
-          await sleep(pollInterval);
-        }
-      }
-      async function waitForStepReady(stepName, stepOptions) {
-        const existing = readyWaitByStep.get(stepName);
-        if (existing) return existing;
-        const wait = pollStepReady(stepName, stepOptions).finally(() => {
-          if (readyWaitByStep.get(stepName) === wait) readyWaitByStep.delete(stepName);
-        });
-        readyWaitByStep.set(stepName, wait);
-        return wait;
-      }
-      const heartbeat = setInterval(() => {
-        requestHeartbeat();
-      }, options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS);
-      heartbeat.unref?.();
-      async function flush(isFinal, force = false) {
-        flushChain = flushChain.then(async () => {
-          if (force && doneCount >= taskIndices.length) return;
-          while (pending.length >= batchSize || (isFinal || force) && pending.length > 0) {
-            const batch = pending.splice(0, batchSize);
-            await sendTaskResults({
-              benchmarkSlug: options.benchmarkSlug,
-              runId: options.runId,
-              workerId: claimed.workerId,
-              attemptId: claimed.attemptId,
-              sequenceNumber,
-              isFinal: isFinal && pending.length === 0,
-              records: batch
-            });
-            sequenceNumber += 1;
-          }
-        });
-        await flushChain;
-      }
-      const resultFlush = setInterval(() => {
-        if (doneCount < taskIndices.length) void flush(false, true).catch(() => {
-        });
-      }, options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS);
-      resultFlush.unref?.();
-      const workerLogLines = [];
-      let workerLogTruncated = false;
-      function appendWorkerLog(line) {
-        if (workerLogLines.length >= MAX_WORKER_LOG_LINES) {
-          if (!workerLogTruncated) {
-            workerLogTruncated = true;
-            workerLogLines.push("... (worker log truncated)");
-          }
-          return;
-        }
-        workerLogLines.push(line);
-      }
-      async function runFinishHook(status) {
-        await options.onFinish?.({
-          assignment: claimed,
-          records,
-          status,
-          client,
-          uploadArtifact(input) {
-            return client.uploadWorkerArtifact(options.benchmarkSlug, options.runId, claimed.workerId, {
-              ...input,
-              attemptId: claimed.attemptId
-            });
-          }
-        });
-      }
-      async function uploadWorkerLogArtifact() {
-        if (workerLogLines.length === 0) return;
-        try {
-          await client.uploadWorkerArtifact(options.benchmarkSlug, options.runId, claimed.workerId, {
-            attemptId: claimed.attemptId,
-            kind: "coordinator.log",
-            contentType: "text/plain",
-            name: "worker.log",
-            body: workerLogLines.join("\n") + "\n"
-          });
-        } catch {
-        }
-      }
-      try {
-        await sendHeartbeat().catch(() => {
-        });
-        await mapPool(taskIndices, workerConcurrency, async (taskIndex) => {
-          inFlightCount += 1;
-          const startedAtDate = /* @__PURE__ */ new Date();
-          const startedAtMs = Date.now();
-          const record = {
-            taskIndex,
-            status: "success",
-            startedAt: startedAtDate.toISOString()
-          };
-          const steps = [];
-          const taskMeasures = {};
-          let activeStep = null;
-          function measure(data) {
-            if (activeStep) {
-              activeStep.data = { ...activeStep.data ?? {}, ...data };
-            } else {
-              Object.assign(taskMeasures, data);
-            }
-          }
-          function log(message, meta) {
-            const suffix = meta && Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
-            appendWorkerLog(`${(/* @__PURE__ */ new Date()).toISOString()} [task ${taskIndex}] ${message}${suffix}`);
-          }
-          async function step(name, fn, stepOptions = {}) {
-            const stepStartedAtMs = Date.now();
-            const stepRecord = {
-              name,
-              status: "success",
-              startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-              completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-              latencyMs: 0
-            };
-            if (stepOptions.timeoutMs !== void 0) stepRecord.timeoutMs = stepOptions.timeoutMs;
-            if (stepOptions.stepConcurrency !== void 0) stepRecord.concurrency = stepOptions.stepConcurrency;
-            const shouldReportConcurrency = stepOptions.reportConcurrency ?? true;
-            if (shouldReportConcurrency) {
-              const stepConcurrency = stepOptions.concurrency ?? workerConcurrency;
-              validatePositiveInteger(`step "${name}" concurrency`, stepConcurrency);
-              targetByStep.set(name, stepConcurrency);
-              activeByStep.set(name, (activeByStep.get(name) ?? 0) + 1);
-              requestHeartbeat();
-            }
-            const previousStep = activeStep;
-            activeStep = stepRecord;
-            try {
-              if (stepOptions.readiness === "poll") {
-                await waitForStepReady(name, stepOptions);
-              }
-              const value = await fn();
-              appendWorkerLog(`${(/* @__PURE__ */ new Date()).toISOString()} [task ${taskIndex}] ${name}`);
-              return value;
-            } catch (error) {
-              stepRecord.status = "error";
-              stepRecord.errorCode = getErrorCode(error);
-              appendWorkerLog(`${(/* @__PURE__ */ new Date()).toISOString()} [task ${taskIndex}] ${name}`);
-              appendWorkerLog(`  error: ${error instanceof Error ? error.message : String(error)}`);
-              throw error;
-            } finally {
-              activeStep = previousStep;
-              stepRecord.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-              stepRecord.latencyMs = Date.now() - stepStartedAtMs;
-              steps.push(stepRecord);
-              if (shouldReportConcurrency) {
-                const nextActive = Math.max(0, (activeByStep.get(name) ?? 0) - 1);
-                if (nextActive === 0) {
-                  activeByStep.delete(name);
-                  targetByStep.delete(name);
-                } else {
-                  activeByStep.set(name, nextActive);
-                }
-                requestHeartbeat();
-              }
-            }
-          }
-          try {
-            const data = await options.task({ assignment: claimed, taskIndex, step, measure, log });
-            record.data = mergeMeasures(taskMeasures, toJsonObject(data));
-          } catch (error) {
-            record.status = "error";
-            record.errorCode = getErrorCode(error);
-            record.data = mergeMeasures(taskMeasures, { errorMessage: error instanceof Error ? error.message : String(error) });
-          } finally {
-            record.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-            record.latencyMs = Date.now() - startedAtMs;
-            if (steps.length === 0) {
-              steps.push(implicitTaskStep(record, taskMeasures));
-            }
-            record.steps = steps;
-            doneCount += 1;
-            inFlightCount = Math.max(0, inFlightCount - 1);
-            if (record.status !== "success") errorCount += 1;
-          }
-          records.push(record);
-          pending.push(record);
-          options.onResult?.(record);
-          if (pending.length >= batchSize) await flush(false);
-        });
-        await flush(true);
-        const hasErrors = records.some((record) => record.status !== "success");
-        try {
-          await runFinishHook(hasErrors ? "error" : "success");
-        } catch (error) {
-          if (!hasErrors) throw error;
-        }
-        if (hasErrors) {
-          await client.failWorker(options.benchmarkSlug, options.runId, claimed.workerId, claimed.attemptId, new Error("One or more tasks failed"));
-        } else {
-          await client.completeWorker(options.benchmarkSlug, options.runId, claimed.workerId, claimed.attemptId);
-        }
-        return { assignment: claimed, records };
-      } catch (error) {
-        await flush(true).catch(() => {
-        });
-        await runFinishHook("error").catch(() => {
-        });
-        await client.failWorker(options.benchmarkSlug, options.runId, claimed.workerId, claimed.attemptId, error).catch(() => {
-        });
-        throw error;
-      } finally {
-        await uploadWorkerLogArtifact();
-        clearInterval(heartbeat);
-        clearInterval(resultFlush);
-      }
-    }
-  };
-  return client;
-}
-
-// src/reporter.ts
-var DEFAULT_REPORTER_BATCH_SIZE = 500;
-var DEFAULT_READY_POLL_INTERVAL_MS2 = 1e3;
-var BenchmarkReporter = class _BenchmarkReporter {
-  client;
-  assignment;
-  cfg;
-  pending = [];
-  sequenceNumber = 0;
-  flushChain = Promise.resolve();
-  progress;
-  barrier = null;
-  constructor(client, cfg, assignment) {
-    this.client = client;
-    this.assignment = assignment;
-    this.cfg = {
-      benchmarkSlug: cfg.benchmarkSlug,
-      runId: cfg.runId,
-      participantSlug: cfg.participantSlug,
-      batchSize: cfg.batchSize ?? DEFAULT_REPORTER_BATCH_SIZE
-    };
-    this.progress = { done: 0, inFlight: 0, errors: 0, total: assignment.taskRange.count };
-  }
-  static async claim(cfg) {
-    const client = createBenchmarkClient(cfg);
-    try {
-      const assignment = await client.claimWorker(cfg.benchmarkSlug, cfg.runId, cfg.participantSlug, {
-        processKind: cfg.processKind,
-        processKey: cfg.processKey
-      });
-      return assignment ? new _BenchmarkReporter(client, cfg, assignment) : null;
-    } catch (error) {
-      console.warn(
-        `[benchsdk] failed to claim worker for ${cfg.benchmarkSlug}/${cfg.participantSlug}: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return null;
-    }
-  }
-  get workerAssignment() {
-    return this.assignment;
-  }
-  get taskCount() {
-    return this.assignment.taskRange.count;
-  }
-  get taskIndexStart() {
-    return this.assignment.taskRange.start;
-  }
-  setProgress(progress) {
-    this.progress = { ...progress, total: progress.total ?? this.assignment.taskRange.count };
-  }
-  recordResult(record) {
-    this.pending.push(record);
-    if (this.pending.length >= this.cfg.batchSize) void this.flush(false);
-  }
-  async heartbeat(input = {}) {
-    const barrier = this.barrier;
-    const currentStep = barrier?.step ?? input.currentStep;
-    const concurrency = barrier?.concurrency ?? input.concurrency;
-    await this.client.heartbeatWorker(this.cfg.benchmarkSlug, this.cfg.runId, this.assignment.workerId, {
-      attemptId: this.assignment.attemptId,
-      progressDone: this.progress.done,
-      progressInFlight: this.progress.inFlight,
-      progressErrors: this.progress.errors,
-      progressTotal: this.progress.total,
-      ...currentStep ? { currentStep } : {},
-      ...concurrency ? { concurrency } : {}
-    }).catch(() => {
-    });
-  }
-  async waitForStepReady(input) {
-    const startedAt = Date.now();
-    const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_READY_POLL_INTERVAL_MS2;
-    const concurrency = input.concurrency ?? [{
-      step: input.step,
-      active: input.active ?? this.assignment.taskRange.count,
-      target: input.target ?? this.assignment.taskRange.count
-    }];
-    this.barrier = { step: input.step, concurrency };
-    try {
-      while (true) {
-        await this.heartbeat({ currentStep: input.step, concurrency });
-        const progress = await this.client.getRunProgress(this.cfg.benchmarkSlug, this.cfg.runId).catch(() => null);
-        const participant = progress?.participants.find((item) => item.slug === this.cfg.participantSlug);
-        const step = participant?.concurrency.find((item) => item.step === input.step);
-        if (step?.ready) {
-          return {
-            active: step.active,
-            target: step.target,
-            ready: true,
-            measuredAt: progress?.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
-          };
-        }
-        if (input.timeoutMs !== void 0 && Date.now() - startedAt >= input.timeoutMs) {
-          throw new Error(`Timed out waiting for benchmark step "${input.step}" to become ready.`);
-        }
-        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-      }
-    } finally {
-      this.barrier = null;
-    }
-  }
-  uploadArtifact(input) {
-    return this.client.uploadWorkerArtifact(this.cfg.benchmarkSlug, this.cfg.runId, this.assignment.workerId, {
-      attemptId: this.assignment.attemptId,
-      kind: input.kind,
-      name: input.name,
-      contentType: input.contentType,
-      metadata: input.metadata,
-      body: input.body
-    }).catch((error) => {
-      console.warn(
-        `[benchsdk] failed to upload ${input.kind} artifact for worker ${this.assignment.workerId}: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return null;
-    });
-  }
-  flush(isFinal = false) {
-    this.flushChain = this.flushChain.then(async () => {
-      while (this.pending.length >= this.cfg.batchSize || isFinal && this.pending.length > 0) {
-        const batch = this.pending.slice(0, this.cfg.batchSize);
-        try {
-          await this.client.sendTaskResults({
-            benchmarkSlug: this.cfg.benchmarkSlug,
-            runId: this.cfg.runId,
-            workerId: this.assignment.workerId,
-            attemptId: this.assignment.attemptId,
-            sequenceNumber: this.sequenceNumber,
-            isFinal: isFinal && batch.length === this.pending.length,
-            records: batch
-          });
-        } catch (error) {
-          console.warn(
-            `[benchsdk] dropping ${this.pending.length} unsent task result(s) for worker ${this.assignment.workerId}: ${error instanceof Error ? error.message : String(error)}`
-          );
-          break;
-        }
-        this.pending.splice(0, batch.length);
-        this.sequenceNumber += 1;
-      }
-    });
-    return this.flushChain;
-  }
-  async finish(failed = false, error) {
-    await this.flush(true).catch(() => {
-    });
-    if (failed) {
-      await this.client.failWorker(
-        this.cfg.benchmarkSlug,
-        this.cfg.runId,
-        this.assignment.workerId,
-        this.assignment.attemptId,
-        error
-      ).catch(() => {
-      });
-      return;
-    }
-    await this.client.completeWorker(
-      this.cfg.benchmarkSlug,
-      this.cfg.runId,
-      this.assignment.workerId,
-      this.assignment.attemptId
-    ).catch(() => {
-    });
-  }
-};
-function claimBenchmarkReporter(config) {
-  return BenchmarkReporter.claim(config);
-}
-
-// src/metrics.ts
-var fs = __toESM(require("fs"), 1);
-var os = __toESM(require("os"), 1);
-var import_node_perf_hooks = require("perf_hooks");
-function readSockstat() {
-  try {
-    const data = fs.readFileSync("/proc/net/sockstat", "utf-8");
-    const out = {};
-    for (const line of data.split("\n")) {
-      const index = line.indexOf(":");
-      if (index < 0) continue;
-      const section = line.slice(0, index).trim().toLowerCase();
-      const parts = line.slice(index + 1).trim().split(/\s+/);
-      for (let i = 0; i + 1 < parts.length; i += 2) {
-        const value = Number.parseInt(parts[i + 1], 10);
-        if (!Number.isNaN(value)) out[`${section}_${parts[i]}`] = value;
-      }
-    }
-    return out;
-  } catch {
-    return null;
-  }
-}
-function countOpenFds() {
-  try {
-    return fs.readdirSync("/proc/self/fd").length;
-  } catch {
-    return null;
-  }
-}
-function createSystemMetricsCollector() {
-  const startedAt = Date.now();
-  const cpuBaseline = process.cpuUsage();
-  const eventLoop = (0, import_node_perf_hooks.monitorEventLoopDelay)({ resolution: 20 });
-  eventLoop.enable();
+  const apiClient = (0, import_api.createBenchmarkClient)(config);
   return {
-    sample() {
-      const cpu = process.cpuUsage(cpuBaseline);
-      const memory = process.memoryUsage();
-      const loadavg2 = os.loadavg();
-      const sample = {
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        uptimeMs: Date.now() - startedAt,
-        cpuUserUs: cpu.user,
-        cpuSystemUs: cpu.system,
-        memRssMb: Math.round(memory.rss / 1024 / 1024),
-        memHeapUsedMb: Math.round(memory.heapUsed / 1024 / 1024),
-        memHeapTotalMb: Math.round(memory.heapTotal / 1024 / 1024),
-        memExternalMb: Math.round(memory.external / 1024 / 1024),
-        eventLoopP50Ms: eventLoop.percentile(50) / 1e6,
-        eventLoopP99Ms: eventLoop.percentile(99) / 1e6,
-        eventLoopMaxMs: eventLoop.max / 1e6,
-        loadavg1m: loadavg2[0],
-        loadavg5m: loadavg2[1],
-        loadavg15m: loadavg2[2],
-        openFds: countOpenFds(),
-        sockstat: readSockstat()
-      };
-      eventLoop.reset();
-      return sample;
-    },
-    stop() {
-      eventLoop.disable();
-    }
+    ...apiClient,
+    runWorker: (options) => (0, import_worker.runWorker)(apiClient, options)
   };
 }
 
-// src/participants.ts
-function filterParticipantsByEnv(participants) {
-  const available = [];
-  const skipped = [];
-  for (const p of participants) {
-    const missing = p.requiredEnvVars.filter((v) => !process.env[v]);
-    if (missing.length > 0) {
-      skipped.push({ name: p.name, missing });
-    } else {
-      available.push(p);
-    }
-  }
-  return { available, skipped };
-}
-function selectParticipants(all, names) {
-  if (!names) return all;
-  const unknown = names.filter((n) => !all.some((p) => p.name === n));
-  if (unknown.length > 0) {
-    console.error(`Unknown participant(s): ${unknown.join(", ")}`);
-    console.error(`Available: ${all.map((p) => p.name).join(", ")}`);
-    process.exit(1);
-  }
-  return all.filter((p) => names.includes(p.name));
-}
+// src/index.ts
+var import_worker2 = require("@benchsdk/worker");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BenchmarkApiError,
@@ -983,6 +52,7 @@ function selectParticipants(all, names) {
   createBenchmarkClient,
   createSystemMetricsCollector,
   filterParticipantsByEnv,
+  runWorker,
   selectParticipants
 });
 //# sourceMappingURL=index.cjs.map