bitfab 0.52.2 → 0.52.4

package/dist/replayCli.js

@@ -1,701 +1,32 @@
 #!/usr/bin/env node
 import {
-  BitfabError
-} from "./chunk-ESIEHZHQ.js";
-
-// src/replayCli.ts
-import { tsImport } from "tsx/esm/api";
-
-// src/codeChange.ts
-var NUL = String.fromCharCode(0);
-
-// src/serialize.ts
-import superjson from "superjson";
-
-// src/replay.ts
-var BITFAB_PROGRESS_PREFIX = "@@bitfab:progress ";
-function reportReplayProgress(progress) {
-  const stderr = typeof process !== "undefined" ? process.stderr : void 0;
-  if (!stderr) {
-    return;
-  }
-  try {
-    stderr.write(
-      `${BITFAB_PROGRESS_PREFIX}${JSON.stringify(progress, replayJsonReplacer)}
-`
-    );
-  } catch {
-  }
-}
-var ReplayError = class extends BitfabError {
-  constructor(message, items, testRunId, testRunUrl, cause) {
-    super(message, testRunUrl);
-    this.items = items;
-    this.testRunId = testRunId;
-    this.testRunUrl = testRunUrl;
-    this.cause = cause;
-    this.name = "ReplayError";
-  }
-};
-var DbBranchReplayError = class extends BitfabError {
-  constructor(code, message, originalTraceId, cause) {
-    super(message);
-    this.code = code;
-    this.originalTraceId = originalTraceId;
-    this.cause = cause;
-    this.name = "DbBranchReplayError";
-  }
-};
-function replayJsonReplacer(_key, value) {
-  if (value instanceof Error) {
-    const serialized = {
-      name: value.name,
-      message: value.message,
-      stack: value.stack
-    };
-    if (value instanceof DbBranchReplayError) {
-      serialized.code = value.code;
-      serialized.originalTraceId = value.originalTraceId;
-      if (value.cause !== void 0) {
-        serialized.cause = value.cause;
-      }
-    }
-    return serialized;
-  }
-  return value;
-}
-function serializeReplayResult(result) {
-  return JSON.stringify(result, replayJsonReplacer, 2);
-}
-
-// src/replayRegistry.ts
-var VALUE_FLAGS = /* @__PURE__ */ new Set([
-  "--limit",
-  "--attempts",
-  "--trace-ids",
-  "--name",
-  "--concurrency",
-  "--max-concurrency",
-  "--code-change",
-  "--experiment-group-id",
-  "--dataset-id",
-  "--dataset-ids",
-  "--grader-ids",
-  "--mock",
-  "--param",
-  "--params"
-]);
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
-  "--only-with-assertions",
-  "--db-branch",
-  "--no-db-branch",
-  "--no-code-change",
-  "--dry-run"
-]);
-var HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
-var MAX_ATTEMPTS = 100;
-var MAX_PINNED_TRACE_IDS = 100;
-async function pinnedDatasetMembers(client, datasetIds, limit) {
-  const members = /* @__PURE__ */ new Set();
-  for (const datasetId of datasetIds) {
-    const { traceIds } = await client.datasets.listTraces(datasetId);
-    for (const traceId of traceIds) {
-      members.add(traceId);
-    }
-  }
-  const ordered = [...members].sort();
-  if (limit >= ordered.length) {
-    return void 0;
-  }
-  if (limit > MAX_PINNED_TRACE_IDS) {
-    throw new BitfabError(
-      `Bounding a dataset replay to ${limit} names one trace ID per replayed item, and a replay accepts at most ${MAX_PINNED_TRACE_IDS}. Drop the limit to replay every selected dataset in full.`
-    );
-  }
-  return ordered.slice(0, limit);
-}
-function usage(registry) {
-  return `Usage: bitfab-replay --registry <path> <${Object.keys(registry).join("|")}> [options]
-
-Options:
-  --limit N (bounds a trace ID or dataset selection instead of replacing it)
-  --attempts N (replay each trace N times in this run, max ${MAX_ATTEMPTS})
-  --trace-ids id1,id2
-  --name NAME
-  --concurrency N, --max-concurrency N
-  --code-change PATH, --no-code-change
-  --experiment-group-id UUID
-  --dataset-ids uuid1,uuid2 (--dataset-id is the same flag)
-  --grader-ids id1,id2
-  --only-with-assertions (replay only traces carrying an assertion)
-  --mock none|all|marked
-  --db-branch, --no-db-branch
-  --dry-run (resolve inputs, run nothing)
-  --params PATH
-  --param name=value (repeatable)
-  -h, --help`;
-}
-var ReplayCliHelp = class extends Error {
-};
-function parseSeedCases(raw, path, run) {
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) {
-    throw new BitfabError(`Seed file '${path}' is empty.`);
-  }
-  const values = trimmed.startsWith("[") ? JSON.parse(trimmed) : trimmed.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => JSON.parse(line));
-  return values.map((value, index) => {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      throw new BitfabError(
-        `Seed case ${index} in '${path}' must be an object with an "input" array.`
-      );
-    }
-    const { input } = value;
-    if (!Array.isArray(input)) {
-      throw new BitfabError(
-        `Seed case ${index} in '${path}' is missing an "input" array. Wrap a single argument as [arg].`
-      );
-    }
-    if (run && "expected" in value) {
-      throw new BitfabError(
-        `Seed case ${index} in '${path}' carries "expected", which --run does not record: the case is run once and its output is what the run produced. Remove the field, or drop --run to record the case without running it.`
-      );
-    }
-    return value;
-  });
-}
-async function seedFromRegistry(registry, pipeline, cases, options = {}) {
-  const registration = registry[pipeline];
-  if (registration === void 0) {
-    throw new BitfabError(
-      `Unknown pipeline '${pipeline}'. Registered: ${Object.keys(registry).join(", ")}`
-    );
-  }
-  const traceFunctionKey = resolveTraceFunctionKey(registration);
-  if (options.run === true) {
-    const traceIds2 = [];
-    for (const seedCase of cases) {
-      traceIds2.push(
-        await registration.client.seedTrace(traceFunctionKey, registration.fn, {
-          args: seedCase.input,
-          metadata: seedCase.metadata,
-          sessionId: seedCase.sessionId
-        })
-      );
-    }
-    return { pipeline, traceFunctionKey, traceIds: traceIds2 };
-  }
-  const traceIds = cases.map(
-    (seedCase) => registration.client.seedTrace(traceFunctionKey, {
-      input: seedCase.input,
-      expected: seedCase.expected,
-      fn: registration.fn,
-      metadata: seedCase.metadata,
-      sessionId: seedCase.sessionId
-    })
-  );
-  const { flushTraces: flushTraces2 } = await import("./http-2NFFBFYV.js");
-  await flushTraces2(3e4);
-  return { pipeline, traceFunctionKey, traceIds };
-}
-var SEED_USAGE = 'Usage: bitfab-replay --registry <path> <pipeline> --seed <cases.jsonl> [--run]\n\nEach case is a JSON object with an "input" array, plus optional "expected", "metadata", and "sessionId". A JSON array of those objects works too.\n\nWithout --run, each case is written as a trace directly: "input" becomes the root span input and "expected" its output, and nothing executes.\n\nWith --run, each case is run once through the registered function with capture off and the execution is recorded, so the output is what the run produced. Cases carrying "expected" are rejected.';
-async function runSeedCli(registry, argv, io = {}) {
-  const stdout = io.stdout ?? console.log;
-  const stderr = io.stderr ?? console.error;
-  if (argv.some((value) => HELP_FLAGS.has(value))) {
-    throw new ReplayCliHelp(SEED_USAGE);
-  }
-  const pipeline = argv[0];
-  if (pipeline === void 0 || registry[pipeline] === void 0) {
-    throw new BitfabError(SEED_USAGE);
-  }
-  const seedIndex = argv.indexOf("--seed");
-  const casesPath = argv[seedIndex + 1];
-  if (casesPath === void 0 || casesPath.startsWith("--")) {
-    throw new BitfabError("--seed requires a path to a cases file.");
-  }
-  const run = argv.includes("--run");
-  const readFile = io.readFile ?? defaultReadFile;
-  const cases = parseSeedCases(await readFile(casesPath), casesPath, run);
-  stderr(
-    run ? `[seed] Running ${cases.length} case(s) through "${pipeline}"...` : `[seed] Seeding ${cases.length} case(s) into "${pipeline}"...`
-  );
-  const result = await seedFromRegistry(registry, pipeline, cases, { run });
-  stderr(
-    `[seed] ${run ? "Recorded" : "Wrote"} ${result.traceIds.length} trace(s) for "${result.traceFunctionKey}". Replay them with --trace-ids ${result.traceIds.slice(0, 3).join(",")}${result.traceIds.length > 3 ? ",..." : ""}`
-  );
-  stdout(JSON.stringify(result, null, 2));
-  return result;
-}
-function requirePositiveInteger(flag, raw, max) {
-  const value = Number(raw);
-  if (!Number.isInteger(value) || value < 1) {
-    throw new BitfabError(
-      `${flag} must be a positive integer (received '${raw}').`
-    );
-  }
-  if (max !== void 0 && value > max) {
-    throw new BitfabError(`${flag} must be at most ${max} (received '${raw}').`);
-  }
-  return value;
-}
-function commaSeparated(flag, raw) {
-  const values = raw.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
-  if (values.length === 0) {
-    throw new BitfabError(`${flag} must contain at least one value.`);
-  }
-  return values;
-}
-function parseReplayCliArgs(registry, argv) {
-  if (argv.some((value) => HELP_FLAGS.has(value))) {
-    throw new ReplayCliHelp(usage(registry));
-  }
-  const pipeline = argv[0];
-  if (pipeline === void 0 || registry[pipeline] === void 0) {
-    throw new BitfabError(usage(registry));
-  }
-  const parsed = { pipeline, params: [] };
-  for (let index = 1; index < argv.length; index += 1) {
-    const flag = argv[index];
-    if (BOOLEAN_FLAGS.has(flag)) {
-      switch (flag) {
-        case "--db-branch":
-          if (parsed.dbBranch === false) {
-            throw new BitfabError(
-              "--db-branch and --no-db-branch cannot be used together."
-            );
-          }
-          parsed.dbBranch = true;
-          break;
-        case "--no-db-branch":
-          if (parsed.dbBranch === true) {
-            throw new BitfabError(
-              "--db-branch and --no-db-branch cannot be used together."
-            );
-          }
-          parsed.dbBranch = false;
-          break;
-        case "--only-with-assertions":
-          parsed.onlyWithAssertions = true;
-          break;
-        case "--no-code-change":
-          parsed.noCodeChange = true;
-          break;
-        case "--dry-run":
-          parsed.dryRun = true;
-          break;
-      }
-      continue;
-    }
-    if (!VALUE_FLAGS.has(flag)) {
-      throw new BitfabError(
-        `Unknown replay option '${flag}'.
-${usage(registry)}`
-      );
-    }
-    const raw = argv[index + 1];
-    if (raw === void 0 || raw.startsWith("--")) {
-      throw new BitfabError(`${flag} requires a value.`);
-    }
-    index += 1;
-    switch (flag) {
-      case "--limit":
-        parsed.limit = requirePositiveInteger(flag, raw);
-        break;
-      case "--attempts":
-        parsed.attempts = requirePositiveInteger(flag, raw, MAX_ATTEMPTS);
-        break;
-      case "--trace-ids":
-        parsed.traceIds = commaSeparated(flag, raw);
-        break;
-      case "--name":
-        parsed.name = raw;
-        break;
-      case "--concurrency":
-      case "--max-concurrency":
-        parsed.maxConcurrency = requirePositiveInteger(flag, raw);
-        break;
-      case "--code-change":
-        parsed.codeChangePath = raw;
-        break;
-      case "--experiment-group-id":
-        parsed.experimentGroupId = raw;
-        break;
-      case "--dataset-id":
-      case "--dataset-ids":
-        parsed.datasetIds = commaSeparated(flag, raw);
-        break;
-      case "--grader-ids":
-        parsed.graderIds = commaSeparated(flag, raw);
-        break;
-      case "--mock":
-        if (raw !== "none" && raw !== "all" && raw !== "marked") {
-          throw new BitfabError(
-            `--mock must be one of: none, all, marked (received '${raw}').`
-          );
-        }
-        parsed.mock = raw;
-        break;
-      case "--params":
-        parsed.paramsPath = raw;
-        break;
-      case "--param":
-        parsed.params.push(raw);
-        break;
-    }
-  }
-  if (parsed.traceIds !== void 0 && parsed.datasetIds !== void 0) {
-    throw new BitfabError(
-      "--trace-ids and --dataset-ids select different replay sources and cannot be used together."
-    );
-  }
-  if (parsed.codeChangePath !== void 0 && parsed.noCodeChange === true) {
-    throw new BitfabError(
-      "--code-change and --no-code-change cannot be used together."
-    );
-  }
-  return parsed;
-}
-function resolveRegistrationDatasetIds(options) {
-  if (options.datasetId !== void 0 && options.datasetIds !== void 0) {
-    throw new BitfabError(
-      "Replay registry options datasetId and datasetIds are the same selector: set one of them."
-    );
-  }
-  if (options.datasetId !== void 0) {
-    return [options.datasetId];
-  }
-  return options.datasetIds;
-}
-function describeSelection(options) {
-  if (options.traceIds !== void 0) {
-    return `${options.traceIds.length} traces`;
-  }
-  if (options.limit !== void 0) {
-    return `${options.limit} traces`;
-  }
-  const datasetCount = options.datasetIds?.length ?? 1;
-  return datasetCount > 1 ? `${datasetCount} datasets' traces` : "dataset traces";
-}
-function resolveTraceFunctionKey(registration) {
-  const wrappedKey = registration.fn._bitfabTraceFunctionKey;
-  const key = registration.traceFunctionKey ?? wrappedKey;
-  if (key === void 0) {
-    throw new BitfabError(
-      "Replay registry entry uses a plain function. Set traceFunctionKey to the key its production handler records."
-    );
-  }
-  return key;
-}
-async function defaultReadFile(path) {
-  const fs = await import("fs/promises").catch(() => null);
-  if (fs === null) {
-    throw new BitfabError(
-      "--code-change requires a runtime that can read local files."
-    );
-  }
-  return fs.readFile(path, "utf8");
-}
-async function loadCodeChange(path, readFile) {
-  if (path === void 0) {
-    return void 0;
-  }
-  const value = JSON.parse(await readFile(path));
-  if (typeof value.description !== "string" || !Array.isArray(value.files)) {
-    throw new BitfabError(
-      `Invalid --code-change file '${path}': expected { description, files }.`
-    );
-  }
-  return { description: value.description, files: value.files };
-}
-function parseParameter(raw) {
-  const separator = raw.indexOf("=");
-  const key = raw.slice(0, separator).trim();
-  if (separator < 1 || key.length === 0) {
-    throw new BitfabError(
-      `Invalid --param '${raw}': expected a non-empty name=value pair.`
-    );
-  }
-  const value = raw.slice(separator + 1);
-  try {
-    return [key, JSON.parse(value)];
-  } catch {
-    return [key, value];
-  }
-}
-async function loadParameters(path, rawParameters, readFile) {
-  let params = {};
-  if (path !== void 0) {
-    const value = JSON.parse(await readFile(path));
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      throw new BitfabError(
-        `Invalid --params file '${path}': expected a JSON object.`
-      );
-    }
-    params = { ...value };
-  }
-  for (const raw of rawParameters) {
-    const [key, value] = parseParameter(raw);
-    params[key] = value;
-  }
-  return params;
-}
-function valuesEqual(left, right) {
-  try {
-    return JSON.stringify(left) === JSON.stringify(right);
-  } catch {
-    return Object.is(left, right);
-  }
-}
-function renderSummary(pipeline, result, stderr) {
-  let same = 0;
-  let changed = 0;
-  let matched = 0;
-  let missed = 0;
-  let errors = 0;
-  for (const item of result.items) {
-    if (item.error !== null) {
-      errors += 1;
-      continue;
-    }
-    const equal = valuesEqual(item.result, item.originalOutput);
-    if (item.ingestionType === "seeded") {
-      if (equal) {
-        matched += 1;
-      } else {
-        missed += 1;
-      }
-    } else if (equal) {
-      same += 1;
-    } else {
-      changed += 1;
-    }
-  }
-  stderr("\n\u2500\u2500\u2500 Summary \u2500\u2500\u2500");
-  stderr(`  Pipeline: ${pipeline}`);
-  stderr(`  Replayed: ${result.items.length}`);
-  if (result.attempts > 1) {
-    stderr(`  Attempts: ${result.attempts}`);
-  }
-  if (same > 0 || changed > 0 || matched + missed === 0) {
-    stderr(`  Same:     ${same}`);
-    stderr(`  Changed:  ${changed}`);
-  }
-  if (matched > 0 || missed > 0) {
-    stderr(`  Matched expected: ${matched}`);
-    stderr(`  Missed expected:  ${missed}`);
-  }
-  if (errors > 0) {
-    stderr(`  Errors:   ${errors}`);
-  }
-  stderr(`
-  ${result.testRunUrl}`);
-}
-function renderDryRun(pipeline, result, stderr) {
-  stderr("\n\u2500\u2500\u2500 Dry run \u2500\u2500\u2500");
-  stderr(`  Pipeline: ${pipeline}`);
-  stderr(`  Resolved: ${result.items.length} (nothing was executed)`);
-  for (const item of result.items) {
-    stderr(`
-  ${item.originalTraceId}`);
-    stderr(`    args: ${safeJson(item.input)}`);
-  }
-  stderr(`
-  ${result.testRunUrl}`);
-}
-function safeJson(value) {
-  try {
-    return JSON.stringify(value) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
-function reportReplayError(error, stderr) {
-  for (const item of error.items) {
-    stderr(
-      `${item.originalTraceId}: ${String(item.traceError ?? item.replayError ?? item.error)}`
-    );
-  }
-}
-async function runReplayCli(registry, argv = typeof process === "undefined" ? [] : process.argv.slice(2), io = {}) {
-  const stdout = io.stdout ?? console.log;
-  const stderr = io.stderr ?? console.error;
-  const args = parseReplayCliArgs(registry, argv);
-  const registration = registry[args.pipeline];
-  const traceFunctionKey = resolveTraceFunctionKey(registration);
-  const readFile = io.readFile ?? defaultReadFile;
-  const params = await loadParameters(args.paramsPath, args.params, readFile);
-  const dynamicOptions = await registration.optionsFactory?.({ params });
-  const registrationOptions = {
-    ...registration.options,
-    ...dynamicOptions
-  };
-  const registrationDatasetIds = resolveRegistrationDatasetIds(registrationOptions);
-  if (registrationOptions.traceIds !== void 0 && registrationDatasetIds !== void 0) {
-    throw new BitfabError(
-      "Replay registry options traceIds and datasetIds select different sources and cannot be used together."
-    );
-  }
-  const selectedDatasetIds = args.datasetIds ?? registrationDatasetIds;
-  const codeChange = await loadCodeChange(args.codeChangePath, readFile);
-  const options = {
-    ...registrationOptions,
-    ...args.name === void 0 ? {} : { name: args.name },
-    ...args.attempts === void 0 ? {} : { attempts: args.attempts },
-    ...args.maxConcurrency === void 0 ? {} : { maxConcurrency: args.maxConcurrency },
-    ...args.experimentGroupId === void 0 ? {} : { experimentGroupId: args.experimentGroupId },
-    datasetId: void 0,
-    datasetIds: selectedDatasetIds,
-    ...args.graderIds === void 0 ? {} : { graderIds: args.graderIds },
-    ...args.onlyWithAssertions === void 0 ? {} : { onlyWithAssertions: args.onlyWithAssertions },
-    ...args.mock === void 0 ? {} : { mock: args.mock },
-    ...args.dbBranch === void 0 ? {} : {
-      dbBranch: args.dbBranch && registrationOptions.dbBranch !== void 0 && registrationOptions.dbBranch !== false ? registrationOptions.dbBranch : args.dbBranch
-    },
-    ...args.noCodeChange === true ? { codeChangeDescription: null, codeChangeFiles: null } : {},
-    ...args.dryRun === true ? { dryRun: true } : {},
-    ...codeChange === void 0 ? {} : {
-      codeChangeDescription: codeChange.description,
-      codeChangeFiles: codeChange.files
-    },
-    onItemStart: reportReplayProgress,
-    onItemFinish: reportReplayProgress
-  };
-  if (args.traceIds !== void 0) {
-    options.traceIds = args.traceIds;
-    options.datasetIds = void 0;
-  } else if (args.datasetIds !== void 0) {
-    options.traceIds = void 0;
-  }
-  const bound = args.limit ?? registrationOptions.limit;
-  options.limit = void 0;
-  if (options.traceIds !== void 0) {
-    if (bound !== void 0) {
-      options.traceIds = options.traceIds.slice(0, bound);
-    }
-  } else if (options.datasetIds !== void 0) {
-    if (bound !== void 0) {
-      const pinned = await pinnedDatasetMembers(
-        registration.client,
-        options.datasetIds,
-        bound
-      );
-      if (pinned !== void 0) {
-        options.traceIds = pinned;
-      }
-    }
-  } else {
-    options.limit = bound ?? 10;
-  }
-  const attemptsSuffix = options.attempts !== void 0 && options.attempts > 1 ? ` (${options.attempts} attempts each)` : "";
-  stderr(
-    `[replay] ${args.dryRun === true ? "Resolving inputs for" : "Replaying"} ${describeSelection(options)} from "${traceFunctionKey}"${attemptsSuffix}...`
-  );
-  try {
-    const result = await registration.client.replay(
-      traceFunctionKey,
-      registration.fn,
-      options
-    );
-    if (args.dryRun === true) {
-      renderDryRun(args.pipeline, result, stderr);
-    } else {
-      renderSummary(args.pipeline, result, stderr);
-    }
-    stdout(serializeReplayResult(result));
-    if (result.items.length === 0) {
-      throw new BitfabError(
-        `No traces matched "${traceFunctionKey}", so nothing was replayed. Seed cases with --seed, or capture a trace first.`
-      );
-    }
-    return result;
-  } catch (error) {
-    if (error instanceof ReplayError) {
-      reportReplayError(error, stderr);
-    }
-    throw error;
-  }
-}
+  importRegistry,
+  parseRegistryCommandArgs,
+  resolveRegistry,
+  runIfEntrypoint,
+  runRegistryMain,
+  runReplayCli,
+  runSeedCli
+} from "./chunk-HKTODDFP.js";
+import "./chunk-IG3CPSRQ.js";
 
 // src/replayCli.ts
 var USAGE = "Usage: bitfab-replay --registry <path> <pipeline> [options]\n       bitfab-replay --registry <path> <pipeline> --seed <cases.jsonl> [--run]\nRun bitfab-replay --registry <path> --help to list replay options.";
-async function parseCommandArgs(argv) {
-  if (argv.some((value) => value === "--help" || value === "-h") && !argv.includes("--registry")) {
-    throw new ReplayCliHelp(USAGE);
-  }
-  const registryFlagIndex = argv.indexOf("--registry");
-  const registryPath = argv[registryFlagIndex + 1];
-  if (registryFlagIndex === -1 || registryPath === void 0 || registryPath.startsWith("--")) {
-    throw new BitfabError(USAGE);
-  }
-  const replayArgs = argv.filter(
-    (_value, index) => index !== registryFlagIndex && index !== registryFlagIndex + 1
-  );
-  if (replayArgs.length === 0) {
-    throw new BitfabError(USAGE);
-  }
-  const { resolve } = await import("path");
-  return { registryPath: resolve(registryPath), replayArgs };
-}
-async function importRegistry(path) {
-  const { pathToFileURL } = await import("url");
-  return tsImport(pathToFileURL(path).href, import.meta.url);
-}
-function resolveRegistry(moduleValue, path) {
-  if (typeof moduleValue !== "object" || moduleValue === null) {
-    throw new BitfabError(
-      `Replay registry '${path}' must export a default registry.`
-    );
-  }
-  const registry = moduleValue.default;
-  if (typeof registry !== "object" || registry === null) {
-    throw new BitfabError(
-      `Replay registry '${path}' must export a default registry.`
-    );
-  }
-  return registry;
-}
 async function runReplayCommand(argv, io = {}, importer = importRegistry) {
-  const { registryPath, replayArgs } = await parseCommandArgs(argv);
+  const { registryPath, commandArgs } = await parseRegistryCommandArgs(
+    argv,
+    USAGE
+  );
   const registry = resolveRegistry(await importer(registryPath), registryPath);
-  if (replayArgs.includes("--seed")) {
-    return runSeedCli(registry, replayArgs, io);
+  if (commandArgs.includes("--seed")) {
+    return runSeedCli(registry, commandArgs, io);
   }
-  return runReplayCli(registry, replayArgs, io);
+  return runReplayCli(registry, commandArgs, io);
 }
 async function runReplayMain(argv, io = {}) {
-  const stdout = io.stdout ?? console.log;
-  const stderr = io.stderr ?? console.error;
-  try {
-    await runReplayCommand(argv, io);
-    return 0;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (error instanceof ReplayCliHelp) {
-      stdout(message);
-      return 0;
-    }
-    stderr(message);
-    return 1;
-  }
+  return runRegistryMain(() => runReplayCommand(argv, io), io);
 }
-async function isEntrypoint() {
-  const executablePath = process.argv[1];
-  if (executablePath === void 0) {
-    return false;
-  }
-  const [{ realpath }, { fileURLToPath }] = await Promise.all([
-    import("fs/promises"),
-    import("url")
-  ]);
-  return await realpath(executablePath) === await realpath(fileURLToPath(import.meta.url));
-}
-void isEntrypoint().then((entrypoint) => {
-  if (entrypoint) {
-    void runReplayMain(process.argv.slice(2)).then((exitCode) => {
-      process.exitCode = exitCode;
-    });
-  }
-});
+runIfEntrypoint(import.meta.url, () => runReplayMain(process.argv.slice(2)));
 export {
   runReplayCommand,
   runReplayMain