@benchsdk/client 0.2.1 → 0.4.0

package/dist/index.js

@@ -1,957 +1,31 @@
 // 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 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 && error.name) return error.name;
-  return "ERROR";
-}
-function toJsonObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  return value;
-}
-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 isDefinedTask(task) {
-  return typeof task === "object" && task !== null && Array.isArray(task.steps);
-}
-function mergeJsonObjects(target, source) {
-  if (!source) return;
-  Object.assign(target, source);
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function runWorkerTask(task, context) {
-  if (!isDefinedTask(task)) {
-    return task(context);
-  }
-  const state = {};
-  const data = { taskName: task.name };
-  try {
-    for (const definedStep of task.steps) {
-      const stepData = await context.step(
-        definedStep.name,
-        () => definedStep.fn({
-          assignment: context.assignment,
-          taskIndex: context.taskIndex,
-          state
-        }),
-        definedStep.options
-      );
-      mergeJsonObjects(data, stepData);
-    }
-  } catch (error) {
-    try {
-      await task.options?.cleanup?.({
-        assignment: context.assignment,
-        taskIndex: context.taskIndex,
-        state
-      });
-    } catch {
-    }
-    throw error;
-  }
-  await task.options?.cleanup?.({
-    assignment: context.assignment,
-    taskIndex: context.taskIndex,
-    state
-  });
-  return data;
-}
-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);
-}
+import { createBenchmarkClient as createApiClient, BenchmarkApiError } from "@benchsdk/api";
+import { runWorker } from "@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 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?.();
-      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
-            });
-          }
-        });
-      }
-      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 = [];
-          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
-            };
-            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();
-            }
-            try {
-              if (stepOptions.readiness === "poll") {
-                await waitForStepReady(name, stepOptions);
-              }
-              return await fn();
-            } catch (error) {
-              stepRecord.status = "error";
-              stepRecord.errorCode = getErrorCode(error);
-              throw error;
-            } finally {
-              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 runWorkerTask(options.task, { assignment: claimed, taskIndex, step });
-            record.data = toJsonObject(data);
-          } catch (error) {
-            record.status = "error";
-            record.errorCode = getErrorCode(error);
-            record.data = { errorMessage: error instanceof Error ? error.message : String(error) };
-          } finally {
-            record.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-            record.latencyMs = Date.now() - startedAtMs;
-            record.steps = steps.length > 0 ? steps : void 0;
-            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 {
-        clearInterval(heartbeat);
-        clearInterval(resultFlush);
-      }
-    }
-  };
-  return client;
-}
-async function runBenchmarkWorker(config, options) {
-  return createBenchmarkClient(config).runWorker(options);
-}
-function defineStep(name, optionsOrFn, maybeFn) {
-  if (name.trim() === "") {
-    throw new Error("Benchmark step name must be non-empty.");
-  }
-  const hasOptions = typeof optionsOrFn !== "function";
-  const fn = hasOptions ? maybeFn : optionsOrFn;
-  if (!fn) {
-    throw new Error("Benchmark step function is required.");
-  }
-  return { name, options: hasOptions ? optionsOrFn : void 0, fn };
-}
-function defineTask(name, steps, options) {
-  if (name.trim() === "") {
-    throw new Error("Benchmark task name must be non-empty.");
-  }
-  if (steps.length === 0) {
-    throw new Error("Benchmark task must define at least one step.");
-  }
-  const names = /* @__PURE__ */ new Set();
-  for (const step of steps) {
-    if (names.has(step.name)) {
-      throw new Error(`Benchmark task step names must be unique. Duplicate step: "${step.name}".`);
-    }
-    names.add(step.name);
-  }
-  return { name, steps, options };
-}
-function defineWorker(options) {
-  const client = options.client ?? createBenchmarkClient();
+  const apiClient = createApiClient(config);
   return {
-    run(overrides = {}) {
-      return client.runWorker({
-        benchmarkSlug: options.benchmarkSlug,
-        runId: options.runId,
-        participantSlug: options.participantSlug,
-        processKind: options.processKind,
-        processKey: options.processKey,
-        concurrency: overrides.concurrency ?? options.concurrency,
-        batchSize: overrides.batchSize ?? options.batchSize,
-        flushIntervalMs: overrides.flushIntervalMs ?? options.flushIntervalMs,
-        heartbeatIntervalMs: overrides.heartbeatIntervalMs ?? options.heartbeatIntervalMs,
-        readyPollIntervalMs: overrides.readyPollIntervalMs ?? options.readyPollIntervalMs,
-        onFinish: options.onFinish,
-        task: options.task
-      });
-    }
+    ...apiClient,
+    runWorker: (options) => runWorker(apiClient, options)
   };
 }
-function defineBench(options) {
-  return {
-    slug: options.slug,
-    task: options.task,
-    defineWorker(workerOptions) {
-      const participantSlug = workerOptions.participantSlug ?? options.participantSlug;
-      if (!participantSlug) {
-        throw new Error("Benchmark worker participantSlug is required.");
-      }
-      return defineWorker({
-        benchmarkSlug: options.slug,
-        runId: workerOptions.runId,
-        participantSlug,
-        processKind: workerOptions.processKind,
-        processKey: workerOptions.processKey,
-        concurrency: workerOptions.concurrency ?? options.concurrency,
-        batchSize: workerOptions.batchSize ?? options.batchSize,
-        flushIntervalMs: workerOptions.flushIntervalMs ?? options.flushIntervalMs,
-        heartbeatIntervalMs: workerOptions.heartbeatIntervalMs ?? options.heartbeatIntervalMs,
-        readyPollIntervalMs: workerOptions.readyPollIntervalMs ?? options.readyPollIntervalMs,
-        onFinish: workerOptions.onFinish,
-        client: workerOptions.client ?? options.client,
-        task: workerOptions.task ?? options.task
-      });
-    }
-  };
-}
-
-// 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 {
-      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(() => 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 {
-          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
-import * as fs from "fs";
-import * as os from "os";
-import { monitorEventLoopDelay } from "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 = monitorEventLoopDelay({ resolution: 20 });
-  eventLoop.enable();
-  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();
-    }
-  };
-}
+// src/index.ts
+import {
+  BenchmarkReporter,
+  claimBenchmarkReporter,
+  createSystemMetricsCollector,
+  filterParticipantsByEnv,
+  runWorker as runWorker2,
+  selectParticipants
+} from "@benchsdk/worker";
 export {
   BenchmarkApiError,
   BenchmarkReporter,
   claimBenchmarkReporter,
   createBenchmarkClient,
   createSystemMetricsCollector,
-  defineBench,
-  defineStep,
-  defineTask,
-  defineWorker,
-  runBenchmarkWorker
+  filterParticipantsByEnv,
+  runWorker2 as runWorker,
+  selectParticipants
 };
 //# sourceMappingURL=index.js.map