@benchsdk/client 0.2.1 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ComputeSDK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -10,77 +10,52 @@ This package talks to the platform-owned benchmark/run/participant/worker API. I
 npm install @benchsdk/client
 ```
 
-## Define A Worker
+> Higher-level benchmark authoring (`defineBenchmarkConfig` / `defineTask` and
+> the local orchestrator) lives in
+> [`@benchsdk/runner`](../benchsdk-runner). This package is REST transport plus
+> the worker engine only.
+
+## Run A Worker
 
 ```ts
-import { defineStep, defineTask, defineWorker } from '@benchsdk/client';
+import { createBenchmarkClient } from '@benchsdk/client';
 import { compute } from 'computesdk';
 
-const worker = defineWorker({
+const client = createBenchmarkClient({
+  apiKey: process.env.COMPUTESDK_ADMIN_API_KEY,
+});
+
+// `task` is a raw function; declare named steps imperatively via `step(...)`,
+// so values flow between steps with closures and cleanup runs in a `finally`.
+const { assignment, records } = await client.runWorker({
   benchmarkSlug: 'scale',
   runId: process.env.BENCHMARK_RUN_ID!,
   participantSlug: 'e2b',
   processKind: 'container',
   processKey: process.env.HOSTNAME,
   concurrency: 100,
-  task: defineTask('sandbox.lifecycle', [
-    defineStep('create', async ({ assignment, state }) => {
-      state.sandbox = await compute.sandbox.create({
-        provider: assignment.provider ?? 'e2b',
-      });
-    }),
-    defineStep('readiness', async ({ state }) => {
-      await (state.sandbox as any).runCommand('true');
-    }),
-    defineStep('exec.first-command', async ({ state }) => {
-      await (state.sandbox as any).runCommand('node -v');
-    }),
-    defineStep('pause', { readiness: 'poll' }, async () => {
-      // Every worker reports active pause concurrency and waits here until
-      // the platform reports the participant's pause step is ready.
-    }),
-    defineStep('destroy', async ({ state }) => {
-      await (state.sandbox as any).destroy();
-    }),
-  ]),
+  task: async ({ assignment, step }) => {
+    const sandbox = await step('create', () =>
+      compute.sandbox.create({ provider: assignment.provider ?? 'e2b' }),
+    );
+    try {
+      await step('readiness', () => sandbox.runCommand('true'), { readiness: 'internal' });
+      await step('exec.first-command', () => sandbox.runCommand('node -v'));
+      // A `readiness: 'poll'` step reports active concurrency and waits until
+      // the platform reports the participant's step is ready (a barrier).
+      await step('pause', () => {}, { readiness: 'poll' });
+      return { sandboxId: sandbox.id };
+    } finally {
+      await step('destroy', () => sandbox.destroy());
+    }
+  },
 });
-
-await worker.run();
 ```
 
-`worker.run()` claims the next pending platform assignment for the participant. If no work is available, it returns `{ assignment: null, records: [] }`.
+`client.runWorker(...)` claims the next pending platform assignment for the participant. If no work is available, it returns `{ assignment: null, records: [] }`.
 
 Task results are flushed to the platform in batches of 1,000 records by default. Set `batchSize` to tune this per worker; the SDK validates the platform limit of 5,000 records per batch. Workers also flush partial batches every 30 seconds by default via `flushIntervalMs`, and always flush pending records during final completion or shutdown.
 
-## Reuse A Bench Definition
-
-```ts
-import { defineBench, defineStep, defineTask } from '@benchsdk/client';
-
-const lifecycleTask = defineTask('sandbox.lifecycle', [
-  defineStep('create', async ({ state }) => {
-    state.sandboxId = 'sandbox_123';
-  }),
-  defineStep('exec.first-command', async ({ state }) => ({
-    sandboxId: String(state.sandboxId),
-  })),
-]);
-
-const bench = defineBench({
-  slug: 'scale',
-  participantSlug: 'e2b',
-  concurrency: 100,
-  task: lifecycleTask,
-});
-
-const worker = bench.defineWorker({
-  runId: process.env.BENCHMARK_RUN_ID!,
-  processKey: process.env.HOSTNAME,
-});
-
-await worker.run();
-```
-
 ## Create A Platform Run
 
 ```ts
@@ -92,7 +67,6 @@ const client = createBenchmarkClient({
 
 await client.upsertBenchmark('scale', {
   name: 'Scale',
-  kind: 'scale',
   config: { timeoutMs: 120_000 },
 });
 
@@ -110,55 +84,27 @@ await client.planWorkers('scale', run.id, 'modal');
 console.log(run.id);
 ```
 
-Workers must be planned before `worker.run()` can claim assignments.
+Workers must be planned before `client.runWorker(...)` can claim assignments.
 
 ## API
 
-### Definition Helpers
+### Worker Engine
 
 ```ts
-defineStep(name, fn)
-defineTask(name, steps)
-defineWorker(options)
-defineBench(options)
+client.runWorker(options)
 ```
 
-Step functions receive:
+The `task` function receives:
 
 | Field | Type | Description |
 |-------|------|-------------|
 | `assignment` | `BenchmarkAssignment` | Platform-owned assignment for this worker |
 | `taskIndex` | `number` | Deterministic task index within the benchmark run |
-| `state` | `Record<string, unknown>` | Mutable per-task state shared across steps |
-
-If a step returns a JSON object, it is merged into the task result `data` object. Defined tasks also include `taskName` in `data`.
-
-`defineTask(name, steps, options)` supports task cleanup:
+| `step` | `(name, fn, options?) => Promise<R>` | Runs `fn` as a named platform step and records its timing/outcome |
 
-| Option | Type | Description |
-|--------|------|-------------|
-| `cleanup` | `(context) => Promise<void> \| void` | Runs after the task finishes, whether steps succeeded or failed. Use shared `state` to tear down resources created by earlier steps. |
-
-```ts
-type SandboxState = {
-  sandbox?: Awaited<ReturnType<typeof compute.sandbox.create>>;
-};
-
-defineTask<SandboxState>('sandbox.lifecycle', [
-  defineStep<SandboxState>('create', async ({ state }) => {
-    state.sandbox = await compute.sandbox.create();
-  }),
-  defineStep<SandboxState>('exec', async ({ state }) => {
-    await state.sandbox.runCommand('node -v');
-  }),
-], {
-  cleanup: async ({ state }) => {
-    await state.sandbox?.destroy?.();
-  },
-});
-```
+If the task returns a JSON object, it is stored as the task result `data`.
 
-`defineStep(name, options, fn)` supports step-level progress coordination:
+`step(name, fn, options)` supports step-level progress coordination via `options`:
 
 | Option | Type | Description |
 |--------|------|-------------|
@@ -202,7 +148,7 @@ client.failWorker(benchmarkSlug, runId, workerId, attemptId, error)
 client.runWorker(options)
 ```
 
-For custom coordinators that do not fit `defineWorker`, use the best-effort reporter wrapper:
+For custom coordinators that do not fit `runWorker`, use the best-effort reporter wrapper:
 
 ```ts
 const reporter = await BenchmarkReporter.claim({
@@ -227,10 +173,10 @@ await reporter?.finish(false);
 
 `BenchmarkReporter` swallows platform telemetry failures for claim, heartbeat, result flushing, artifact upload, and finish calls. Benchmark work can continue even when reporting is temporarily unavailable.
 
-For `defineWorker` / `runWorker`, use `onFinish` to upload worker-level logs once, after final task results are flushed and before the worker attempt is completed or failed:
+For `runWorker`, use `onFinish` to upload worker-level logs once, after final task results are flushed and before the worker attempt is completed or failed:
 
 ```ts
-defineWorker({
+client.runWorker({
   benchmarkSlug: 'scale',
   runId,
   participantSlug: 'e2b',
@@ -269,7 +215,7 @@ console.log(participant?.tasks.completionRatio);
 console.log(participant?.concurrency.find((item) => item.step === 'pause')?.ready);
 ```
 
-Most workers should use `defineWorker(...).run()`.
+Most workers should use `client.runWorker(...)`.
 
 ## Task Result Shape
 
@@ -286,7 +232,6 @@ Most workers should use `defineWorker(...).run()`.
     { "name": "destroy", "status": "success", "startedAt": "...", "completedAt": "...", "latencyMs": 180 }
   ],
   "data": {
-    "taskName": "sandbox.lifecycle",
     "sandboxId": "..."
   }
 }

package/dist/index.cjs

@@ -35,11 +35,8 @@ __export(src_exports, {
   claimBenchmarkReporter: () => claimBenchmarkReporter,
   createBenchmarkClient: () => createBenchmarkClient,
   createSystemMetricsCollector: () => createSystemMetricsCollector,
-  defineBench: () => defineBench,
-  defineStep: () => defineStep,
-  defineTask: () => defineTask,
-  defineWorker: () => defineWorker,
-  runBenchmarkWorker: () => runBenchmarkWorker
+  filterParticipantsByEnv: () => filterParticipantsByEnv,
+  selectParticipants: () => selectParticipants
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -52,6 +49,7 @@ 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);
@@ -80,6 +78,9 @@ 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";
 }
@@ -87,6 +88,21 @@ 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.`);
@@ -132,53 +148,9 @@ function bodySizeBytes(body) {
   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 () => {
@@ -455,6 +427,13 @@ function createBenchmarkClient(config = {}) {
         `/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);
@@ -566,6 +545,18 @@ function createBenchmarkClient(config = {}) {
         });
       }, 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,
@@ -580,6 +571,19 @@ function createBenchmarkClient(config = {}) {
           }
         });
       }
+      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(() => {
         });
@@ -593,6 +597,19 @@ function createBenchmarkClient(config = {}) {
             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 = {
@@ -602,6 +619,8 @@ function createBenchmarkClient(config = {}) {
               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;
@@ -610,16 +629,23 @@ function createBenchmarkClient(config = {}) {
               activeByStep.set(name, (activeByStep.get(name) ?? 0) + 1);
               requestHeartbeat();
             }
+            const previousStep = activeStep;
+            activeStep = stepRecord;
             try {
               if (stepOptions.readiness === "poll") {
                 await waitForStepReady(name, stepOptions);
               }
-              return await fn();
+              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);
@@ -636,16 +662,19 @@ function createBenchmarkClient(config = {}) {
             }
           }
           try {
-            const data = await runWorkerTask(options.task, { assignment: claimed, taskIndex, step });
-            record.data = toJsonObject(data);
+            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 = { errorMessage: error instanceof Error ? error.message : String(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;
-            record.steps = steps.length > 0 ? steps : void 0;
+            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;
@@ -677,6 +706,7 @@ function createBenchmarkClient(config = {}) {
         });
         throw error;
       } finally {
+        await uploadWorkerLogArtifact();
         clearInterval(heartbeat);
         clearInterval(resultFlush);
       }
@@ -684,84 +714,6 @@ function createBenchmarkClient(config = {}) {
   };
   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();
-  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
-      });
-    }
-  };
-}
-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;
@@ -794,7 +746,10 @@ var BenchmarkReporter = class _BenchmarkReporter {
         processKey: cfg.processKey
       });
       return assignment ? new _BenchmarkReporter(client, cfg, assignment) : null;
-    } catch {
+    } catch (error) {
+      console.warn(
+        `[benchsdk] failed to claim worker for ${cfg.benchmarkSlug}/${cfg.participantSlug}: ${error instanceof Error ? error.message : String(error)}`
+      );
       return null;
     }
   }
@@ -869,7 +824,12 @@ var BenchmarkReporter = class _BenchmarkReporter {
       contentType: input.contentType,
       metadata: input.metadata,
       body: input.body
-    }).catch(() => null);
+    }).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 () => {
@@ -885,7 +845,10 @@ var BenchmarkReporter = class _BenchmarkReporter {
             isFinal: isFinal && batch.length === this.pending.length,
             records: batch
           });
-        } catch {
+        } 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);
@@ -987,6 +950,31 @@ function createSystemMetricsCollector() {
     }
   };
 }
+
+// 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));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BenchmarkApiError,
@@ -994,10 +982,7 @@ function createSystemMetricsCollector() {
   claimBenchmarkReporter,
   createBenchmarkClient,
   createSystemMetricsCollector,
-  defineBench,
-  defineStep,
-  defineTask,
-  defineWorker,
-  runBenchmarkWorker
+  filterParticipantsByEnv,
+  selectParticipants
 });
 //# sourceMappingURL=index.cjs.map